@opengsd/gsd-pi 1.0.2-dev.d55d5c9 → 1.0.2-dev.dbfb371

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -507,6 +507,21 @@ function initSessionNotifications(ctx: ExtensionContext): void {
   initNotificationWidget(ctx);
 }
 
+async function prepareWorkflowMcpForHookContext(
+  ctx: ExtensionContext,
+  basePath: string,
+): Promise<void> {
+  // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+  // already has .mcp.json from createAutoWorktree, and re-running the writer
+  // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+  // CLI path resolution), dirtying the tree and breaking the milestone merge.
+  const { isInAutoWorktree } = await import("../auto-worktree.js");
+  if (isInAutoWorktree(basePath)) return;
+
+  const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+  prepareWorkflowMcpForProject(ctx, basePath);
+}
+
 export function registerHooks(
   pi: ExtensionAPI,
   ecosystemHandlers: GSDEcosystemBeforeAgentStartHandler[],
@@ -532,12 +547,7 @@ export function registerHooks(
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
     await applyCompactionThresholdOverride(ctx);
-    // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
-    const { isInAutoWorktree } = await import("../auto-worktree.js");
-    if (!isInAutoWorktree(basePath)) {
-      const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-      prepareWorkflowMcpForProject(ctx, basePath);
-    }
+    await prepareWorkflowMcpForHookContext(ctx, basePath);
 
     // Apply show_token_cost preference (#1515)
     try {
@@ -563,15 +573,7 @@ export function registerHooks(
     await syncServiceTierStatus(ctx);
     await applyDisabledModelProviderPolicy(ctx);
     await applyCompactionThresholdOverride(ctx);
-    // Skip MCP auto-prep when running inside an auto-worktree. The worktree
-    // already has .mcp.json from createAutoWorktree, and re-running the writer
-    // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
-    // CLI path resolution), dirtying the tree and breaking the milestone merge.
-    const { isInAutoWorktree } = await import("../auto-worktree.js");
-    if (!isInAutoWorktree(basePath)) {
-      const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-      prepareWorkflowMcpForProject(ctx, basePath);
-    }
+    await prepareWorkflowMcpForHookContext(ctx, basePath);
     await loadToolApiKeysForSession();
     if (!isAutoActive()) {
       ctx.ui.setWidget("gsd-progress", undefined);
@@ -608,6 +610,11 @@ export function registerHooks(
     }
     clearDeferredApprovalGate(beforeAgentBasePath);
 
+    // session_start can fire before the active provider has settled. By
+    // before_agent_start, Claude Code CLI sessions should get the same
+    // project MCP config that /gsd mcp init would write.
+    await prepareWorkflowMcpForHookContext(ctx, beforeAgentBasePath);
+
     // GSD's own context injection (existing behavior — unchanged).
     const { buildBeforeAgentStartResult } = await import("./system-context.js");
     const gsdResult = await buildBeforeAgentStartResult(event, ctx);

package/src/resources/extensions/gsd/commands-handlers.ts

@@ -26,6 +26,7 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isPnpmInstall } from "../../shared/package-manager-detection.js";
 import {
   buildDoctorHealIssuePayload,
   buildDoctorHealSummary,
@@ -57,6 +58,7 @@ function isBunInstall(argv1: string | undefined = process.argv[1]): boolean {
 
 function resolveInstallCommand(pkg: string): string {
   if (isBunInstall()) return `bun add -g ${pkg}`;
+  if (isPnpmInstall()) return `pnpm add -g ${pkg}`;
   return `npm install -g ${pkg}`;
 }
 

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -344,6 +344,70 @@ describe("Custom engine loop integration", () => {
     );
   });
 
+  it("step mode stops after one custom workflow step", async () => {
+    _resetPendingResolve();
+
+    const runDir = makeTmpDir();
+    const graph = makeGraph([
+      makeStep({ id: "step-a" }),
+      makeStep({ id: "step-b", dependsOn: ["step-a"] }),
+      makeStep({ id: "step-c", dependsOn: ["step-b"] }),
+    ], "step-mode-custom");
+    writeGraph(runDir, graph);
+    writeDefinition(runDir, graph.steps, "step-mode-custom");
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const s = makeLoopSession({
+      activeEngineId: "custom",
+      activeRunDir: runDir,
+      basePath: runDir,
+      stepMode: true,
+    });
+
+    const deps = makeMockDeps({
+      stopAuto: async (_ctx, _pi, reason) => {
+        deps.callLog.push(`stopAuto:${reason ?? "no-reason"}`);
+        s.active = false;
+      },
+    });
+
+    const loopPromise = autoLoop(ctx, pi, s, deps);
+    await resolveNextAgentEnd();
+
+    let timeout: NodeJS.Timeout | undefined;
+    try {
+      await Promise.race([
+        loopPromise,
+        new Promise((_, reject) =>
+          timeout = setTimeout(() => {
+            s.active = false;
+            if (_hasPendingResolveForTest()) {
+              resolveAgentEnd({ messages: [{ role: "assistant" }] });
+            }
+            reject(new Error(
+              `step mode did not stop after one custom workflow step; calls=${pi.calls.length}; log=${deps.callLog.join(",")}`,
+            ));
+          }, 1_000),
+        ),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+
+    const finalGraph = readGraph(runDir);
+    assert.equal(pi.calls.length, 1, "step mode should dispatch exactly one custom step");
+    assert.equal(finalGraph.steps[0]?.status, "complete", "first step should complete");
+    assert.equal(finalGraph.steps[1]?.status, "pending", "second step should wait for the next /gsd next");
+    assert.equal(finalGraph.steps[2]?.status, "pending", "third step should wait for a later step");
+    assert.equal(
+      deps.callLog.some((e: string) => e.startsWith("stopAuto:")),
+      false,
+      "step-mode pause should not complete or stop the whole workflow",
+    );
+    assert.equal(s.preserveStepSurfaceAfterLoopExit, true);
+  });
+
   it("stops when engine reports isComplete on first derive", async () => {
     _resetPendingResolve();
 

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

@@ -1,6 +1,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { GSD_WORKFLOW_MCP_SERVER_NAME } from "../mcp-project-config.ts";
 import { prepareWorkflowMcpForProject, shouldAutoPrepareWorkflowMcp } from "../workflow-mcp-auto-prep.ts";
 
 test("shouldAutoPrepareWorkflowMcp enables prep for externalCli local transport", () => {
@@ -74,3 +79,58 @@ test("prepareWorkflowMcpForProject warns with /gsd mcp init guidance when prep f
   assert.equal(notifications[0].level, "warning");
   assert.match(notifications[0].message, /Please run \/gsd mcp init \./);
 });
+
+test("before_agent_start auto-prepares project workflow MCP for Claude Code CLI", async (t) => {
+  const projectRoot = mkdtempSync(join(tmpdir(), "gsd-mcp-before-agent-"));
+  const originalCwd = process.cwd();
+  const notifications: string[] = [];
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+    getActiveTools: () => [],
+    getAllTools: () => [],
+    setActiveTools() {},
+  };
+
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+
+  process.chdir(projectRoot);
+  registerHooks(pi as any, []);
+
+  const beforeAgentStart = handlers.get("before_agent_start")?.[0];
+  assert.ok(beforeAgentStart, "before_agent_start hook should be registered");
+
+  await beforeAgentStart(
+    { prompt: "hello", systemPrompt: "base" },
+    {
+      cwd: projectRoot,
+      model: { provider: "claude-code", baseUrl: "local://claude-code" },
+      modelRegistry: {
+        getProviderAuthMode: () => "externalCli",
+        isProviderRequestReady: () => true,
+      },
+      ui: {
+        notify(message: string) {
+          notifications.push(message);
+        },
+        setWidget() {},
+      },
+    },
+  );
+
+  const configPath = join(projectRoot, ".mcp.json");
+  assert.equal(existsSync(configPath), true, "Claude Code CLI turns should create project MCP config");
+
+  const parsed = JSON.parse(readFileSync(configPath, "utf-8")) as {
+    mcpServers?: Record<string, unknown>;
+  };
+  assert.ok(parsed.mcpServers?.[GSD_WORKFLOW_MCP_SERVER_NAME]);
+  assert.match(notifications.join("\n"), /Claude Code MCP prepared/);
+});

package/src/resources/shared/package-manager-detection.ts

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os'
+import { join, resolve as resolvePath, sep } from 'node:path'
+
+function hasPnpmPath(value: string | undefined): boolean {
+  if (!value) return false
+  const normalized = value.replace(/\\/g, '/').toLowerCase()
+  return (
+    normalized.includes('/.pnpm/') ||
+    normalized.endsWith('/pnpm') ||
+    normalized.endsWith('/pnpm.cjs') ||
+    normalized.endsWith('/pnpm.js')
+  )
+}
+
+function pathStartsWith(pathValue: string | undefined, dir: string): boolean {
+  if (!pathValue) return false
+  const resolvedPath = resolvePath(pathValue)
+  const resolvedDir = resolvePath(dir)
+  return resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep)
+}
+
+// Shared by update-check.ts and gsd command handlers. The JS installer keeps a
+// parallel copy because it runs before TypeScript output exists.
+export function isPnpmInstall(
+  argv1: string | undefined = process.argv[1],
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (env.npm_config_user_agent?.startsWith('pnpm/')) return true
+  if (hasPnpmPath(env.npm_execpath)) return true
+  if (hasPnpmPath(argv1)) return true
+  if (!argv1) return false
+
+  const pnpmBinDirs: string[] = []
+  if (env.PNPM_HOME) pnpmBinDirs.push(env.PNPM_HOME)
+  pnpmBinDirs.push(join(homedir(), 'Library', 'pnpm'))
+  pnpmBinDirs.push(join(homedir(), '.local', 'share', 'pnpm'))
+
+  return pnpmBinDirs.some((dir) => pathStartsWith(argv1, dir) || pathStartsWith(env.npm_execpath, dir))
+}