sailfork / t3code-github / apps/ server/ src/ mcp/ McpToolAccess.race.test.ts

import { assert, it } from "@effect/vitest";
import {
  CommandId,
  EnvironmentId,
  OrchestratorMcpFailure,
  ProjectId,
  ProviderDriverKind,
  ProviderInstanceId,
  ThreadId,
} from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Ref from "effect/Ref";
import * as Schema from "effect/Schema";
import { McpSchema, McpServer, Tool, Toolkit } from "effect/ai";

import * as SqlitePersistence from "../persistence/Sqlite.ts";
import { DispatchModeLimit } from "../orchestration-v2/DispatchModeLimit.ts";
import { CodexProviderCapabilitiesV2 } from "../orchestration-v2/Adapters/CodexAdapterV2.ts";
import * as CommandReceiptStore from "../orchestration-v2/CommandReceiptStore.ts";
import * as Orchestrator from "../orchestration-v2/Orchestrator.ts";
import * as ProjectionStore from "../orchestration-v2/ProjectionStore.ts";
import * as ProviderAdapterRegistry from "../orchestration-v2/ProviderAdapterRegistry.ts";
import * as ThreadManagement from "../orchestration-v2/ThreadManagementService.ts";
import * as ServerSettings from "../serverSettings.ts";
import * as ProviderReplayHarness from "../orchestration-v2/testkit/ProviderReplayHarness.ts";
import * as McpHttpServer from "./McpHttpServer.ts";
import * as McpInvocationContext from "./McpInvocationContext.ts";
import * as McpToolAccess from "./McpToolAccess.ts";
import type * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";

const instanceId = ProviderInstanceId.make("codex");
const adapter = {
  instanceId,
  driver: ProviderDriverKind.make("codex"),
  getCapabilities: () => Effect.succeed(CodexProviderCapabilitiesV2),
  planSelectionTransition: () => Effect.succeed({ type: "apply_on_next_turn" as const }),
  openSession: () => Effect.die("No provider process needed for metadata commands"),
} as ProviderAdapter.ProviderAdapterV2["Service"];
const layerDatabase = SqlitePersistence.layerMemory;
const layerOrchestrator = Layer.mergeAll(
  layerDatabase,
  ProjectionStore.layer.pipe(Layer.provide(layerDatabase)),
  ProviderReplayHarness.layerWithRegistry(
    { name: "mcp-mode-race" },
    ProviderAdapterRegistry.layerFromAdapters([adapter]),
    { databaseLayer: layerDatabase, runEffectWorker: false },
  ),
);

const RenameTool = Tool.make("rename", {
  parameters: Schema.Struct({ threadId: ThreadId }),
  success: Schema.Struct({ renamed: Schema.Boolean }),
  failure: OrchestratorMcpFailure,
  failureMode: "return",
  dependencies: [
    McpInvocationContext.McpInvocationContext,
    ThreadManagement.ThreadManagementService,
  ],
});
const RenameToolkit = Toolkit.make(RenameTool);

const supervisedClient: McpInvocationContext.McpInvocationScope = {
  environmentId: EnvironmentId.make("environment"),
  requestNamespace: "client:race",
  thread: undefined,
  client: { sessionId: "race", label: "Claude Code", access: "approval-required" },
  capabilities: new Set(["orchestration"]),
  issuedAt: 0,
};

const mcpClient = McpSchema.McpServerClient.of({
  clientId: 1,
  protocolVersion: "2025-06-18",
  clientCapabilities: {},
  clientInfo: { name: "mcp-race", version: "1" },
  initializePayload: {
    protocolVersion: "2025-06-18",
    capabilities: {},
    clientInfo: { name: "mcp-race", version: "1" },
  },
  getClient: Effect.die("unused"),
});

const decodeOutcome = Schema.decodeUnknownEffect(
  Schema.fromJsonString(
    Schema.Union([
      Schema.Struct({ renamed: Schema.Boolean }),
      Schema.Struct({ code: Schema.String }),
    ]),
  ),
);

const renameRacingTheUser = (threadId: ThreadId, userRaises: boolean) =>
  Effect.gen(function* () {
    const orchestrator = yield* Orchestrator.OrchestratorV2;
    const threads = yield* ThreadManagement.ThreadManagementService;
    const raised = yield* Ref.make(false);
    const handlers = McpToolAccess.toLayer(RenameToolkit, {
      rename: McpToolAccess.writesThreads(
        (input) => [input.threadId],
        (input) =>
          Effect.gen(function* () {
            if (userRaises) {
              yield* orchestrator
                .dispatch({
                  type: "thread.runtime-mode.set",
                  commandId: CommandId.make("user-raise"),
                  threadId: input.threadId,
                  runtimeMode: "full-access",
                })
                .pipe(Effect.provideService(DispatchModeLimit, undefined), Effect.orDie);
              yield* Ref.set(raised, true);
            }
            yield* threads
              .dispatch({
                type: "thread.metadata.update",
                commandId: CommandId.make(`agent-rename:${userRaises}`),
                threadId: input.threadId,
                title: "Renamed by the agent",
              })
              .pipe(
                Effect.mapError(
                  () =>
                    new OrchestratorMcpFailure({
                      code: "orchestration_error",
                      message: "The rename failed.",
                    }),
                ),
              );
            return { renamed: true };
          }),
      ),
    });
    const outcome = yield* McpServer.McpServer.pipe(
      Effect.flatMap((server) => server.callTool({ name: "rename", arguments: { threadId } })),
      Effect.flatMap(({ content }) =>
        decodeOutcome(content.map((part) => (part.type === "text" ? part.text : "")).join("")),
      ),
      Effect.provideService(McpInvocationContext.McpInvocationContext, supervisedClient),
      Effect.provideService(McpSchema.McpServerClient, mcpClient),
      Effect.provide(
        McpHttpServer.toolkitRegistration(RenameToolkit, handlers).pipe(
          Layer.provideMerge(McpHttpServer.layerInProcessMcpServer),
        ),
      ),
    );
    assert.equal(yield* Ref.get(raised), userRaises);
    return outcome;
  });

const createSupervisedThread = (threadId: ThreadId) =>
  Effect.gen(function* () {
    const orchestrator = yield* Orchestrator.OrchestratorV2;
    yield* orchestrator.dispatch({
      type: "thread.create",
      commandId: CommandId.make(`create:${threadId}`),
      threadId,
      projectId: ProjectId.make("project:mcp-race"),
      title: "Before",
      modelSelection: { instanceId, model: "gpt-5" },
      runtimeMode: "approval-required",
      interactionMode: "default",
      branch: null,
      worktreePath: null,
      createdBy: "user",
      creationSource: "web",
    });
  });

it.layer(layerOrchestrator)("writesThreads against a mode raise", (it) => {
  it.effect("refuses the write when the user raises the thread after the check", () =>
    Effect.gen(function* () {
      const projections = yield* ProjectionStore.ProjectionStoreV2;
      const threadId = ThreadId.make("thread:race-raised");
      yield* createSupervisedThread(threadId);
      const outcome = yield* renameRacingTheUser(threadId, true);
      assert.deepEqual(outcome, { code: "runtime_mode_escalation_denied" });
      const shell = yield* projections.getThreadShell(threadId);
      assert.equal(shell?.runtimeMode, "full-access");
      assert.equal(shell?.title, "Before");
    }).pipe(
      Effect.provide(
        ThreadManagement.layer.pipe(
          Layer.provide(ServerSettings.layerTest()),
          Layer.provide(CommandReceiptStore.layer.pipe(Layer.provide(layerDatabase))),
        ),
      ),
    ),
  );
});