diff --git a/apps/server/src/kin/mcp/ScheduledTaskFence.test.ts b/apps/server/src/kin/mcp/ScheduledTaskFence.test.ts new file mode 100644 index 0000000000000..b056d75fc7423 --- /dev/null +++ b/apps/server/src/kin/mcp/ScheduledTaskFence.test.ts @@ -0,0 +1,290 @@ +import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; +import { describe, expect, it } from "@effect/vitest"; +import { + CommandId, + EnvironmentId, + ProjectId, + ProviderInstanceId, + type ScheduledTask, + ScheduledTaskId, + type ScheduledTaskUpsertInput, + ThreadId, +} from "@t3tools/contracts"; +import * as ConfigProvider from "effect/ConfigProvider"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; +import * as Ref from "effect/Ref"; +import { McpSchema, McpServer } from "effect/ai"; + +import * as ThreadLaunchService from "../../orchestration-v2/ThreadLaunchService.ts"; +import * as ThreadManagement from "../../orchestration-v2/ThreadManagementService.ts"; +import * as ThreadSearch from "../../orchestration-v2/ThreadSearch.ts"; +import * as ProviderAdapterRegistry from "../../orchestration-v2/ProviderAdapterRegistry.ts"; +import * as McpHttpServer from "../../mcp/McpHttpServer.ts"; +import * as McpInvocationContext from "../../mcp/McpInvocationContext.ts"; +import * as McpToolAccessTestkit from "../../mcp/McpToolAccess.testkit.ts"; +import * as PeerForwarding from "../../peer/PeerForwarding.ts"; +import * as PeerLinkRequests from "../../peer/PeerLinkRequests.ts"; +import * as PeerLinks from "../../peer/PeerLinks.ts"; +import * as RemoteDelegation from "../../peer/RemoteDelegation.ts"; +import * as ProjectService from "../../project/ProjectService.ts"; +import * as ProviderRegistry from "../../provider/ProviderRegistry.ts"; +import * as ScheduledTaskService from "../../scheduledTasks/ScheduledTaskService.ts"; +import * as SecretRequests from "../../secrets/SecretRequests.ts"; +import * as ServerSettings from "../../serverSettings.ts"; +import * as GitVcsDriver from "../../vcs/GitVcsDriver.ts"; +import * as ScheduledTaskFence from "./ScheduledTaskFence.ts"; + +const callerId = ThreadId.make("thread:kin-fence-caller"); +const caller = McpToolAccessTestkit.liveThreadShell(callerId); +const sameProject = caller.projectId; +const otherProject = ProjectId.make("project:kin-fence-other"); +const kinId = ScheduledTaskId.make("scheduled-task:kin:webhook:github-app"); +const plainId = ScheduledTaskId.make("scheduled-task:nightly"); + +const task = (id: ScheduledTaskId, projectId: ProjectId): ScheduledTask => ({ + id, + title: id, + prompt: "Check the build", + enabled: true, + schedule: { type: "interval", everyMs: 3_600_000 }, + projectId, + threadId: null, + workspaceStrategy: { type: "root" }, + modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "gpt-5" }, + runtimeMode: "approval-required", + interactionMode: "default", + createdBy: "system", + creationSource: "web", + createdAt: "2026-11-01T00:00:00.000Z", + updatedAt: "2026-11-01T00:00:00.000Z", + nextRunAt: null, + lastRunAt: null, + lastRunStatus: "never", + lastRunError: null, + runCount: 0, +}); + +const scope: McpInvocationContext.McpInvocationScope = { + environmentId: EnvironmentId.make("environment:kin-fence"), + requestNamespace: "provider:kin-fence", + thread: { + threadId: callerId, + providerSessionId: "provider:kin-fence", + providerInstanceId: caller.providerInstanceId, + }, + client: undefined, + issuedAt: 0, + capabilities: new Set(["orchestration"]), +}; + +const client = McpSchema.McpServerClient.of({ + clientId: 1, + protocolVersion: "2025-06-18", + clientCapabilities: {}, + clientInfo: { name: "kin-fence", version: "1" }, + initializePayload: { + protocolVersion: "2025-06-18", + capabilities: {}, + clientInfo: { name: "kin-fence", version: "1" }, + }, + getClient: Effect.die("unused"), +}); + +const declaredFailure = (result: McpSchema.CallToolResult) => { + const text = result.content[0]; + return result.isError === true && text?.type === "text" ? JSON.parse(text.text) : undefined; +}; + +const kinEnabled = (enabled: boolean) => + Layer.succeed( + ConfigProvider.ConfigProvider, + ConfigProvider.fromEnv({ env: { KIN_ENABLED: String(enabled) } }), + ); + +/** Records every write that reaches the real service. */ +const scheduledTasks = (tasks: ReadonlyArray, writes: Ref.Ref>) => { + const record = (write: string) => Ref.update(writes, (all) => [...all, write]); + const find = (id: ScheduledTaskId) => tasks.find((candidate) => candidate.id === id)!; + return Layer.mock(ScheduledTaskService.ScheduledTaskService)({ + list: () => Effect.succeed({ tasks }), + upsert: (input: ScheduledTaskUpsertInput) => { + const id = input.id ?? ScheduledTaskId.make(`scheduled-task:${input.commandId ?? "new"}`); + return record(`upsert ${id}`).pipe( + Effect.as({ task: { ...task(id, input.projectId), threadId: input.threadId ?? null } }), + ); + }, + setEnabled: (input) => + record(`setEnabled ${input.id}`).pipe(Effect.as({ task: find(input.id) })), + delete: (input) => record(`delete ${input.id}`).pipe(Effect.as({ id: input.id })), + runNow: (input) => + record(`runNow ${input.id}`).pipe(Effect.as({ task: find(input.id), threadId: null })), + rotateWebhookToken: (input) => + record(`rotate ${input.id}`).pipe(Effect.as({ task: find(input.id) })), + }); +}; + +const toolkits = (tasks: ReadonlyArray, writes: Ref.Ref>) => + Layer.mergeAll(McpHttpServer.layerOrchestratorToolkit, McpHttpServer.layerThreadToolkit).pipe( + Layer.provideMerge(McpHttpServer.layerInProcessMcpServer), + Layer.provide(NodeCrypto.layer), + Layer.provide(Layer.mock(ThreadLaunchService.ThreadLaunchService)({})), + Layer.provide( + Layer.mock(GitVcsDriver.GitVcsDriver)({ + resolvePrimaryRemoteName: () => Effect.succeed("origin"), + resolveDefaultBranchName: () => Effect.succeed("main"), + resolveCommit: () => Effect.succeed({ commitSha: "abc123" }), + }), + ), + Layer.provide( + Layer.mock(ThreadManagement.ThreadManagementService)({ + getThreadShell: () => Effect.succeed(caller), + getThreadRecords: () => + Effect.succeed(McpToolAccessTestkit.idleThreadProjection(caller) as never), + }), + ), + Layer.provide(Layer.mock(ThreadSearch.ThreadSearch)({})), + Layer.provide(ServerSettings.layerTest()), + Layer.provide( + Layer.mock(ProviderRegistry.ProviderRegistry)({ getProviders: Effect.succeed([]) }), + ), + Layer.provide( + Layer.mock(ProviderAdapterRegistry.ProviderAdapterRegistryV2)({ + list: () => Effect.succeed([]), + }), + ), + Layer.provide(scheduledTasks(tasks, writes)), + Layer.provide( + Layer.mock(ProjectService.ProjectService)({ + getById: (projectId) => + Effect.succeedSome({ + id: projectId, + workspaceRoot: "/repo", + defaultModelSelection: caller.modelSelection, + } as never), + }), + ), + Layer.provide(Layer.mock(SecretRequests.SecretRequests)({})), + Layer.provide(Layer.mock(PeerForwarding.PeerForwarding)({})), + Layer.provide(Layer.mock(PeerLinkRequests.PeerLinkRequests)({})), + Layer.provide(Layer.mock(PeerLinks.PeerLinks)({})), + Layer.provide(Layer.mock(RemoteDelegation.RemoteDelegation)({})), + ); + +const call = (name: string, args: Record) => + Effect.gen(function* () { + const server = yield* McpServer.McpServer; + return yield* server + .callTool({ name, arguments: args }) + .pipe( + Effect.provideService(McpInvocationContext.McpInvocationContext, scope), + Effect.provideService(McpSchema.McpServerClient, client), + ); + }); + +/** Every MCP write an agent could aim at an existing task. */ +const attempts = (id: ScheduledTaskId) => + [ + ["schedule_task", { scheduledTaskId: id, prompt: "Do something else" }], + ["schedule_task", { scheduledTaskId: id, enabled: false }], + ["delete_scheduled_task", { scheduledTaskId: id }], + ["run_scheduled_task_now", { taskId: id }], + ] as const; + +describe("Kin's scheduled tasks behind T3's MCP tools", () => { + it.effect.each([ + { caller: "in the same project", projectId: sameProject }, + { caller: "in another project", projectId: otherProject }, + ])("refuse an agent $caller while Kin is on", ({ projectId }) => + Effect.gen(function* () { + const writes = yield* Ref.make>([]); + yield* Effect.gen(function* () { + for (const [tool, args] of attempts(kinId)) { + expect(declaredFailure(yield* call(tool, args)), tool).toMatchObject({ + message: expect.stringContaining("is managed by Kin"), + }); + } + // A create can't land on a Kin id: the agent's key is scoped under its own session. + const created = yield* call("schedule_task", { + projectId, + prompt: "Check the build", + schedule: { type: "interval", everyMs: 3_600_000 }, + clientRequestId: "kin:webhook:github-app", + }); + expect(created.isError).toBe(false); + const listed = yield* call("list_scheduled_tasks", { projectId }); + expect(listed.isError).toBe(false); + for (const [tool, args] of attempts(plainId)) { + expect((yield* call(tool, args)).isError, tool).toBe(false); + } + }).pipe( + Effect.provide( + toolkits([task(kinId, projectId), task(plainId, projectId)], writes).pipe( + Layer.provide(kinEnabled(true)), + ), + ), + ); + const all = yield* Ref.get(writes); + expect(all.filter((write) => write.includes("kin:webhook"))).toEqual([]); + expect(all.filter((write) => write.endsWith(plainId))).toEqual([ + `upsert ${plainId}`, + `upsert ${plainId}`, + `delete ${plainId}`, + `runNow ${plainId}`, + ]); + }), + ); + + it.effect("change nothing while Kin is off", () => + Effect.gen(function* () { + const writes = yield* Ref.make>([]); + yield* Effect.gen(function* () { + for (const [tool, args] of attempts(kinId)) { + expect((yield* call(tool, args)).isError, tool).toBe(false); + } + }).pipe( + Effect.provide( + toolkits([task(kinId, otherProject)], writes).pipe(Layer.provide(kinEnabled(false))), + ), + ); + expect(yield* Ref.get(writes)).toEqual([ + `upsert ${kinId}`, + `upsert ${kinId}`, + `delete ${kinId}`, + `runNow ${kinId}`, + ]); + }), + ); + + it.effect.each([true, false])("the fenced service with KIN_ENABLED=%s", (enabled) => + Effect.gen(function* () { + const writes = yield* Ref.make>([]); + yield* Effect.gen(function* () { + const service = yield* ScheduledTaskService.ScheduledTaskService; + const results = yield* Effect.forEach( + [ + service.upsert({ + ...task(kinId, sameProject), + id: undefined, + commandId: CommandId.make("kin:webhook:github-app"), + }), + service.setEnabled({ id: kinId, enabled: false }), + service.rotateWebhookToken({ id: kinId }), + ], + Effect.exit, + ); + expect(results.map((exit) => exit._tag)).toEqual( + enabled ? ["Failure", "Failure", "Failure"] : ["Success", "Success", "Success"], + ); + }).pipe( + Effect.provide( + ScheduledTaskFence.layer.pipe( + Layer.provide(scheduledTasks([task(kinId, sameProject)], writes)), + Layer.provide(kinEnabled(enabled)), + ), + ), + ); + expect((yield* Ref.get(writes)).length).toBe(enabled ? 0 : 3); + }), + ); +}); diff --git a/apps/server/src/kin/mcp/ScheduledTaskFence.ts b/apps/server/src/kin/mcp/ScheduledTaskFence.ts new file mode 100644 index 0000000000000..e1679dc683348 --- /dev/null +++ b/apps/server/src/kin/mcp/ScheduledTaskFence.ts @@ -0,0 +1,56 @@ +import { ScheduledTaskError, ScheduledTaskId } from "@t3tools/contracts"; +import * as Effect from "effect/Effect"; +import * as Layer from "effect/Layer"; + +import * as ScheduledTasks from "../../scheduledTasks/ScheduledTaskService.ts"; +import * as KinEnabled from "../KinEnabled.ts"; + +// Upstream names a task created with a commandId `scheduled-task:${commandId}`. +const kinTaskPrefix = "scheduled-task:kin:"; + +const isKinTask = (id: string) => id.startsWith(kinTaskPrefix); + +const refuse = (taskId: ScheduledTaskId) => + Effect.fail( + new ScheduledTaskError({ + message: `Scheduled task ${taskId} is managed by Kin. Agents can list it but cannot change, run or delete it.`, + taskId, + }), + ); + +const guard = + ( + write: (input: I) => Effect.Effect, + ) => + (input: I) => + isKinTask(input.id) ? refuse(input.id) : write(input); + +/** + * The scheduled-task service T3's MCP tools see. While Kin is on, it refuses every + * write to a `kin:` task, so no agent can edit, pause, run, re-key or delete Kin's + * triggers, or claim one of their ids. Kin's own services and the client RPC use the + * unwrapped service. + */ +export const layer = Layer.effect( + ScheduledTasks.ScheduledTaskService, + Effect.gen(function* () { + const inner = yield* ScheduledTasks.ScheduledTaskService; + if (!(yield* KinEnabled.KinEnabled).enabled) return inner; + return ScheduledTasks.ScheduledTaskService.of({ + ...inner, + upsert: Effect.fn("KinScheduledTaskFence.upsert")(function* (input) { + const id = + input.id ?? + (input.commandId === undefined + ? undefined + : ScheduledTaskId.make(`scheduled-task:${input.commandId}`)); + if (id !== undefined && isKinTask(id)) return yield* refuse(id); + return yield* inner.upsert(input); + }), + setEnabled: guard(inner.setEnabled), + delete: guard(inner.delete), + runNow: guard(inner.runNow), + rotateWebhookToken: guard(inner.rotateWebhookToken), + }); + }), +).pipe(Layer.provide(KinEnabled.layer)); diff --git a/apps/server/src/mcp/McpHttpServer.ts b/apps/server/src/mcp/McpHttpServer.ts index 66fdd446fc991..80340a135d53e 100644 --- a/apps/server/src/mcp/McpHttpServer.ts +++ b/apps/server/src/mcp/McpHttpServer.ts @@ -1,3 +1,4 @@ +import * as KinScheduledTaskFence from "../kin/mcp/ScheduledTaskFence.ts"; import * as Cause from "effect/Cause"; import * as Clock from "effect/Clock"; import * as Context from "effect/Context"; @@ -1153,9 +1154,15 @@ export const layerPreviewToolkit = Layer.mergeAll( export const layerOrchestratorToolkit = toolkitRegistration( OrchestratorToolkit, OrchestratorHandlers.layer, -).pipe(Layer.provide(OrchestratorMcpService.layer), Layer.provide(ThreadMetadataMcpService.layer)); +).pipe( + Layer.provide(OrchestratorMcpService.layer), + Layer.provide(ThreadMetadataMcpService.layer), + Layer.provide(KinScheduledTaskFence.layer), +); -export const layerThreadToolkit = toolkitRegistration(ThreadToolkit, ThreadHandlers.layer); +export const layerThreadToolkit = toolkitRegistration(ThreadToolkit, ThreadHandlers.layer).pipe( + Layer.provide(KinScheduledTaskFence.layer), +); const layerWorktreeToolkitRegistration = toolkitRegistration( WorktreeToolkit,