gsd-pi 2.67.0-dev.2142d3e → 2.67.0-dev.2367d7e

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -1,8 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
 import {
   buildWorkflowMcpServers,
@@ -43,13 +46,14 @@ test("detectWorkflowMcpLaunchConfig prefers explicit env override", () => {
     command: "node",
     args: ["dist/cli.js"],
     cwd: "/tmp/project",
-    env: {
-      FOO: "bar",
-      GSD_CLI_PATH: "/tmp/gsd",
-      GSD_PERSIST_WRITE_GATE_STATE: "1",
-      GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
-    },
+    env: launch?.env,
   });
+  assert.equal(launch?.env?.FOO, "bar");
+  assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd");
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
 });
 
 test("buildWorkflowMcpServers mirrors explicit launch config", () => {
@@ -62,12 +66,207 @@ test("buildWorkflowMcpServers mirrors explicit launch config", () => {
     "gsd-workflow": {
       command: "node",
       args: ["dist/cli.js"],
-      env: {
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: "/tmp/project",
-      },
+      env: servers?.["gsd-workflow"]?.env,
     },
   });
+  assert.equal((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match((servers?.["gsd-workflow"]?.env as Record<string, string> | undefined)?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_PROJECT_ROOT", () => {
+  const repoRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-root-"));
+  const worktreeRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-worktree-"));
+  const cliPath = join(repoRoot, "packages", "mcp-server", "dist", "cli.js");
+
+  mkdirSync(join(repoRoot, "packages", "mcp-server", "dist"), { recursive: true });
+  writeFileSync(cliPath, "#!/usr/bin/env node\n", "utf-8");
+
+  const launch = detectWorkflowMcpLaunchConfig(worktreeRoot, {
+    GSD_PROJECT_ROOT: repoRoot,
+  });
+
+  assert.deepEqual(launch, {
+    name: "gsd-workflow",
+    command: process.execPath,
+    args: [cliPath],
+    cwd: repoRoot,
+    env: launch?.env,
+  });
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, repoRoot);
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server from GSD_BIN_PATH ancestry", () => {
+  const repoRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-root-"));
+  const worktreeRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-worktree-"));
+  const cliPath = join(repoRoot, "packages", "mcp-server", "dist", "cli.js");
+  const devCliPath = join(repoRoot, "scripts", "dev-cli.js");
+
+  mkdirSync(join(repoRoot, "packages", "mcp-server", "dist"), { recursive: true });
+  mkdirSync(join(repoRoot, "scripts"), { recursive: true });
+  writeFileSync(cliPath, "#!/usr/bin/env node\n", "utf-8");
+  writeFileSync(devCliPath, "#!/usr/bin/env node\n", "utf-8");
+
+  const launch = detectWorkflowMcpLaunchConfig(worktreeRoot, {
+    GSD_BIN_PATH: devCliPath,
+  });
+
+  assert.deepEqual(launch, {
+    name: "gsd-workflow",
+    command: process.execPath,
+    args: [cliPath],
+    cwd: worktreeRoot,
+    env: launch?.env,
+  });
+  assert.equal(launch?.env?.GSD_CLI_PATH, devCliPath);
+  assert.equal(launch?.env?.GSD_PERSIST_WRITE_GATE_STATE, "1");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, worktreeRoot);
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the installed GSD package", () => {
+  const launch = detectWorkflowMcpLaunchConfig("/tmp/project", {
+    GSD_BIN_PATH: "/tmp/gsd-loader.js",
+  });
+
+  assert.equal(launch?.command, process.execPath);
+  assert.equal(launch?.cwd, "/tmp/project");
+  assert.equal(launch?.env?.GSD_CLI_PATH, "/tmp/gsd-loader.js");
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+  assert.equal(typeof launch?.args?.[0], "string");
+  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
+});
+
+test("detectWorkflowMcpLaunchConfig resolves the bundled server relative to the package without env hints", () => {
+  const launch = detectWorkflowMcpLaunchConfig("/tmp/project", {});
+
+  assert.equal(launch?.command, process.execPath);
+  assert.equal(launch?.cwd, "/tmp/project");
+  assert.equal(launch?.env?.GSD_CLI_PATH, undefined);
+  assert.equal(launch?.env?.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
+  assert.match(launch?.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "", /workflow-tool-executors\.(js|ts)$/);
+  assert.match(launch?.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "", /write-gate\.(js|ts)$/);
+  assert.equal(typeof launch?.args?.[0], "string");
+  assert.match(launch?.args?.[0] ?? "", /packages[\/\\]mcp-server[\/\\]dist[\/\\]cli\.js$/);
+});
+
+test("workflow MCP launch config reaches mutation tools over stdio", async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-workflow-transport-"));
+  mkdirSync(join(projectRoot, ".gsd"), { recursive: true });
+
+  const launch = detectWorkflowMcpLaunchConfig(projectRoot, {});
+  assert.ok(launch, "expected a workflow MCP launch config");
+  assert.match(
+    launch.env?.GSD_WORKFLOW_EXECUTORS_MODULE ?? "",
+    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]tools[\/\\]workflow-tool-executors\.js$/,
+  );
+  assert.match(
+    launch.env?.GSD_WORKFLOW_WRITE_GATE_MODULE ?? "",
+    /dist[\/\\]resources[\/\\]extensions[\/\\]gsd[\/\\]bootstrap[\/\\]write-gate\.js$/,
+  );
+
+  const client = new Client({ name: "workflow-mcp-transport-test", version: "1.0.0" });
+  const transport = new StdioClientTransport({
+    command: launch.command,
+    args: launch.args,
+    env: { ...process.env, ...launch.env } as Record<string, string>,
+    cwd: launch.cwd,
+    stderr: "pipe",
+  });
+
+  try {
+    await client.connect(transport, { timeout: 30_000 });
+
+    const tools = await client.listTools(undefined, { timeout: 30_000 });
+    assert.ok(
+      (tools.tools ?? []).some((tool) => tool.name === "gsd_plan_slice"),
+      "expected workflow MCP surface to expose gsd_plan_slice",
+    );
+
+    const milestoneResult = await client.callTool(
+      {
+        name: "gsd_plan_milestone",
+        arguments: {
+          projectDir: projectRoot,
+          milestoneId: "M001",
+          title: "Transport planning",
+          vision: "Verify stdio workflow MCP uses the executor bridge.",
+          slices: [
+            {
+              sliceId: "S01",
+              title: "Bridge path",
+              risk: "low",
+              depends: [],
+              demo: "Milestone planning succeeds over stdio MCP.",
+              goal: "Prove the executor bridge works in the spawned server.",
+              successCriteria: "gsd_plan_slice can write plan artifacts.",
+              proofLevel: "integration",
+              integrationClosure: "Stdio MCP client reaches the workflow executor bridge.",
+              observabilityImpact: "Regression test covers the spawned-server path.",
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+    assert.equal(milestoneResult.isError, undefined);
+    assert.match(
+      ((milestoneResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
+      /Planned milestone M001/,
+    );
+
+    const sliceResult = await client.callTool(
+      {
+        name: "gsd_plan_slice",
+        arguments: {
+          projectDir: projectRoot,
+          milestoneId: "M001",
+          sliceId: "S01",
+          goal: "Persist slice planning over the spawned MCP transport.",
+          tasks: [
+            {
+              taskId: "T01",
+              title: "Connect the bridge",
+              description: "Ensure the workflow executor bridge resolves in the child process.",
+              estimate: "10m",
+              files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
+              verify: "node --test",
+              inputs: ["M001-ROADMAP.md"],
+              expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
+            },
+          ],
+        },
+      },
+      undefined,
+      { timeout: 30_000 },
+    );
+    assert.equal(sliceResult.isError, undefined);
+    assert.match(
+      ((sliceResult.content as Array<{ text?: string }>)?.[0])?.text ?? "",
+      /Planned slice S01/,
+    );
+    assert.ok(
+      existsSync(join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md")),
+      "expected slice plan artifact to be written through stdio MCP",
+    );
+    assert.ok(
+      existsSync(
+        join(projectRoot, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-PLAN.md"),
+      ),
+      "expected task plan artifact to be written through stdio MCP",
+    );
+  } finally {
+    await client.close().catch(() => {});
+    rmSync(projectRoot, { recursive: true, force: true });
+  }
 });
 
 test("usesWorkflowMcpTransport matches local externalCli providers", () => {
@@ -93,7 +292,7 @@ test("transport compatibility passes when required tools fit current MCP surface
   assert.equal(error, null);
 });
 
-test("transport compatibility fails cleanly when MCP server is unavailable", () => {
+test("transport compatibility discovers the bundled MCP server without env overrides", () => {
   const error = getWorkflowTransportSupportError(
     "claude-code",
     ["gsd_task_complete"],
@@ -107,7 +306,7 @@ test("transport compatibility fails cleanly when MCP server is unavailable", ()
     },
   );
 
-  assert.match(error ?? "", /workflow MCP server is not configured or discoverable/);
+  assert.equal(error, null);
 });
 
 test("transport compatibility now allows auto execute-task over workflow MCP surface", () => {

package/src/resources/extensions/gsd/workflow-mcp.ts

@@ -1,6 +1,7 @@
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 export interface WorkflowMcpLaunchConfig {
   name: string;
@@ -66,6 +67,91 @@ function lookupCommand(command: string, platform: NodeJS.Platform = process.plat
   }
 }
 
+function findWorkflowCliFromAncestorPath(startPath: string): string | null {
+  let current = resolve(startPath);
+
+  while (true) {
+    const candidate = resolve(current, "packages", "mcp-server", "dist", "cli.js");
+    if (existsSync(candidate)) return candidate;
+
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return null;
+}
+
+function getBundledWorkflowMcpCliPath(env: NodeJS.ProcessEnv): string | null {
+  const envAnchors = [
+    env.GSD_BIN_PATH?.trim(),
+    env.GSD_CLI_PATH?.trim(),
+    env.GSD_WORKFLOW_PATH?.trim(),
+  ].filter((value): value is string => typeof value === "string" && value.length > 0);
+
+  for (const anchor of envAnchors) {
+    const candidate = findWorkflowCliFromAncestorPath(anchor);
+    if (candidate) return candidate;
+  }
+
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("../../../../../packages/mcp-server/dist/cli.js", import.meta.url))),
+  ];
+
+  for (const bundledCli of candidates) {
+    if (existsSync(bundledCli)) return bundledCli;
+  }
+
+  return null;
+}
+
+function getBundledWorkflowExecutorModulePath(): string | null {
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/tools/workflow-tool-executors.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./tools/workflow-tool-executors.ts", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function getBundledWorkflowWriteGateModulePath(): string | null {
+  const candidates = [
+    resolve(fileURLToPath(new URL("../../../../dist/resources/extensions/gsd/bootstrap/write-gate.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./bootstrap/write-gate.js", import.meta.url))),
+    resolve(fileURLToPath(new URL("./bootstrap/write-gate.ts", import.meta.url))),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function buildWorkflowLaunchEnv(
+  projectRoot: string,
+  gsdCliPath: string | undefined,
+  explicitEnv?: Record<string, string>,
+): Record<string, string> {
+  const executorModulePath = getBundledWorkflowExecutorModulePath();
+  const writeGateModulePath = getBundledWorkflowWriteGateModulePath();
+
+  return {
+    ...(explicitEnv ?? {}),
+    ...(gsdCliPath ? { GSD_CLI_PATH: gsdCliPath } : {}),
+    ...(executorModulePath ? { GSD_WORKFLOW_EXECUTORS_MODULE: executorModulePath } : {}),
+    ...(writeGateModulePath ? { GSD_WORKFLOW_WRITE_GATE_MODULE: writeGateModulePath } : {}),
+    GSD_PERSIST_WRITE_GATE_STATE: "1",
+    GSD_WORKFLOW_PROJECT_ROOT: projectRoot,
+  };
+}
+
 export function detectWorkflowMcpLaunchConfig(
   projectRoot = process.cwd(),
   env: NodeJS.ProcessEnv = process.env,
@@ -75,19 +161,17 @@ export function detectWorkflowMcpLaunchConfig(
   const explicitArgs = parseJsonEnv<unknown>(env, "GSD_WORKFLOW_MCP_ARGS");
   const explicitEnv = parseJsonEnv<Record<string, string>>(env, "GSD_WORKFLOW_MCP_ENV");
   const explicitCwd = env.GSD_WORKFLOW_MCP_CWD?.trim();
+  const gsdCliPath = env.GSD_CLI_PATH?.trim() || env.GSD_BIN_PATH?.trim();
   const workflowProjectRoot =
     explicitEnv?.GSD_WORKFLOW_PROJECT_ROOT?.trim() ||
     env.GSD_WORKFLOW_PROJECT_ROOT?.trim() ||
+    env.GSD_PROJECT_ROOT?.trim() ||
     explicitCwd ||
     projectRoot;
+  const resolvedWorkflowProjectRoot = resolve(workflowProjectRoot);
 
   if (explicitCommand) {
-    const launchEnv = {
-      ...(explicitEnv ?? {}),
-      ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-      GSD_PERSIST_WRITE_GATE_STATE: "1",
-      GSD_WORKFLOW_PROJECT_ROOT: resolve(workflowProjectRoot),
-    };
+    const launchEnv = buildWorkflowLaunchEnv(resolve(workflowProjectRoot), gsdCliPath, explicitEnv);
     return {
       name,
       command: explicitCommand,
@@ -97,18 +181,25 @@ export function detectWorkflowMcpLaunchConfig(
     };
   }
 
-  const distCli = resolve(projectRoot, "packages", "mcp-server", "dist", "cli.js");
+  const distCli = resolve(resolvedWorkflowProjectRoot, "packages", "mcp-server", "dist", "cli.js");
   if (existsSync(distCli)) {
     return {
       name,
       command: process.execPath,
       args: [distCli],
-      cwd: projectRoot,
-      env: {
-        ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: resolve(projectRoot),
-      },
+      cwd: resolvedWorkflowProjectRoot,
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
+    };
+  }
+
+  const bundledCli = getBundledWorkflowMcpCliPath(env);
+  if (bundledCli) {
+    return {
+      name,
+      command: process.execPath,
+      args: [bundledCli],
+      cwd: resolvedWorkflowProjectRoot,
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
     };
   }
 
@@ -117,11 +208,7 @@ export function detectWorkflowMcpLaunchConfig(
     return {
       name,
       command: binPath,
-      env: {
-        ...(env.GSD_CLI_PATH ? { GSD_CLI_PATH: env.GSD_CLI_PATH } : {}),
-        GSD_PERSIST_WRITE_GATE_STATE: "1",
-        GSD_WORKFLOW_PROJECT_ROOT: resolve(projectRoot),
-      },
+      env: buildWorkflowLaunchEnv(resolvedWorkflowProjectRoot, gsdCliPath),
     };
   }