Fix daemon session lifecycle and scoped callers

Author: backnotprop

.github/workflows/release.yml

@@ -170,22 +170,29 @@ jobs:
             local ok=0
 
             for _ in $(seq 1 60); do
-              if curl -sf "http://127.0.0.1:${port}${endpoint}" -o /dev/null 2>/dev/null; then
-                ok=1
-                break
+              local sessions
+              sessions="$(curl -sf "http://127.0.0.1:${port}/daemon/sessions" 2>/dev/null || true)"
+              if [ -n "$sessions" ]; then
+                local session_url
+                session_url="$(python3 -c 'import json,sys; data=json.load(sys.stdin); sessions=data.get("sessions") or []; print(sessions[0].get("url","") if sessions else "")' <<< "$sessions")"
+                if [ -n "$session_url" ] && curl -sf "${session_url}${endpoint}" -o /dev/null 2>/dev/null; then
+                  ok=1
+                  break
+                fi
               fi
               sleep 0.5
             done
 
             kill "$pid" 2>/dev/null || true
             wait "$pid" 2>/dev/null || true
+            PLANNOTATOR_PORT="$port" "$BINARY" daemon stop >/dev/null 2>&1 || true
 
             if [ "$ok" = "0" ]; then
-              echo "FAIL: ${label} did not respond on :${port}${endpoint}"
+              echo "FAIL: ${label} did not expose a daemon-scoped ${endpoint}"
               exit 1
             fi
 
-            echo "OK: ${label} responded on :${port}${endpoint}"
+            echo "OK: ${label} exposed daemon-scoped ${endpoint}"
           }
 
           # 2. review: exercises server startup, bundled HTML, git diff, and HTTP.
@@ -232,9 +239,14 @@ jobs:
             try {
               for ($i = 0; $i -lt 60; $i++) {
                 try {
-                  Invoke-WebRequest -Uri "http://127.0.0.1:$Port$Endpoint" -UseBasicParsing -TimeoutSec 1 | Out-Null
-                  $ok = $true
-                  break
+                  $sessionsResponse = Invoke-WebRequest -Uri "http://127.0.0.1:$Port/daemon/sessions" -UseBasicParsing -TimeoutSec 1
+                  $sessionsBody = $sessionsResponse.Content | ConvertFrom-Json
+                  if ($sessionsBody.sessions.Count -gt 0) {
+                    $sessionUrl = $sessionsBody.sessions[0].url
+                    Invoke-WebRequest -Uri "$sessionUrl$Endpoint" -UseBasicParsing -TimeoutSec 1 | Out-Null
+                    $ok = $true
+                    break
+                  }
                 } catch {
                   if ($process.HasExited) {
                     break
@@ -247,6 +259,7 @@ jobs:
                 Stop-Process -Id $process.Id -Force
                 Wait-Process -Id $process.Id -ErrorAction SilentlyContinue
               }
+              & $binary daemon stop *> $null
               Remove-Item Env:\PLANNOTATOR_PORT -ErrorAction SilentlyContinue
             }
 
@@ -255,10 +268,10 @@ jobs:
               Get-Content $stdout -ErrorAction SilentlyContinue
               Write-Host "stderr:"
               Get-Content $stderr -ErrorAction SilentlyContinue
-              throw "FAIL: $Label did not respond on :$Port$Endpoint"
+              throw "FAIL: $Label did not expose a daemon-scoped $Endpoint"
             }
 
-            Write-Host "OK: $Label responded on :$Port$Endpoint"
+            Write-Host "OK: $Label exposed daemon-scoped $Endpoint"
           }
 
           # 2. review: exercises server startup, bundled HTML, git diff, and HTTP.

apps/hook/server/index.ts

@@ -61,7 +61,7 @@ import {
 import {
   handleAnnotateServerReady,
 } from "@plannotator/server/annotate";
-import { loadConfig } from "@plannotator/shared/config";
+import { loadConfig, resolveUseJina } from "@plannotator/shared/config";
 import { parseReviewArgs } from "@plannotator/shared/review-args";
 import { statSync, existsSync } from "fs";
 import {
@@ -72,7 +72,7 @@ import {
   buildPlanFileRule,
 } from "@plannotator/shared/prompts";
 import { openBrowser } from "@plannotator/server/browser";
-import { cleanupDaemonState, discoverDaemon } from "@plannotator/server/daemon/client";
+import { cleanupDaemonState, discoverDaemon, waitForDaemonShutdown } from "@plannotator/server/daemon/client";
 import { startDaemonRuntime } from "@plannotator/server/daemon/runtime";
 import { createDaemonSessionFactory } from "@plannotator/server/daemon/session-factory";
 import { getDaemonStartCommand } from "@plannotator/server/daemon/start-command";
@@ -127,6 +127,7 @@ const reviewHtmlContent = reviewHtml as unknown as string;
 
 // Check for subcommand
 const args = process.argv.slice(2);
+const launcherCwd = process.cwd();
 
 // Global flag: --browser <name>
 const browserIdx = args.indexOf("--browser");
@@ -282,6 +283,13 @@ async function runDaemonCommand(): Promise<void> {
       process.exit(1);
     }
     const result = await daemon.client.shutdown();
+    if ("ok" in result && result.ok) {
+      const stopped = await waitForDaemonShutdown(daemon.state);
+      if (!stopped) {
+        console.log(JSON.stringify({ ok: false, code: "daemon-stop-timeout", message: "Timed out waiting for the Plannotator daemon to stop." }));
+        process.exit(1);
+      }
+    }
     console.log(JSON.stringify(result));
     process.exit("ok" in result && result.ok ? 0 : 1);
   }
@@ -300,7 +308,7 @@ async function runDaemonCommand(): Promise<void> {
     }
 
     if (!foreground) {
-      const child = Bun.spawn(getDaemonStartCommand(), {
+      const child = Bun.spawn(getDaemonStartCommand(process.argv, process.execPath, launcherCwd), {
         cwd: getInvocationCwd(),
         stdin: "ignore",
         stdout: "ignore",
@@ -449,7 +457,7 @@ async function ensureDaemonClient(options: { pluginError?: boolean } = {}) {
     fail(`daemon-${existing.code}`, existing.message);
   }
 
-  const command = getDaemonStartCommand();
+  const command = getDaemonStartCommand(process.argv, process.execPath, launcherCwd);
   const child = Bun.spawn(command, {
     cwd: getInvocationCwd(),
     stdin: "ignore",
@@ -523,6 +531,8 @@ async function runDaemonSessionRequest(request: PluginRequest, options: { plugin
   };
   if (created.session.remoteShare) {
     process.stderr.write(formatRemoteShareNotice(created.session.remoteShare));
+  } else if (daemon.state.isRemote) {
+    process.stderr.write(`\n  Open this forwarded Plannotator session URL:\n  ${created.session.url}\n\n`);
   }
   if (options.pluginError) {
     emitPluginSessionReady(session);
@@ -597,11 +607,14 @@ async function runPluginArchiveCommand(): Promise<void> {
 async function runPluginAnnotateCommand(defaultMode: "annotate" | "annotate-last" = "annotate"): Promise<void> {
   const request = await readPluginRequest<PluginAnnotateRequest>();
   const origin = getPluginOrigin(request);
+  const useJina = resolveUseJina(request.noJina === true, loadConfig());
   await runDaemonBackedPluginRequest({
     ...request,
     action: defaultMode,
     origin,
     cwd: resolvePluginCwd(request),
+    useJina,
+    jinaApiKey: process.env.JINA_API_KEY,
   });
 }
 
@@ -754,6 +767,8 @@ if (args[0] === "sessions") {
     cwd: getInvocationCwd(),
     args: rawFilePath,
     noJina: cliNoJina,
+    useJina: resolveUseJina(cliNoJina, loadConfig()),
+    jinaApiKey: process.env.JINA_API_KEY,
     gate: gateFlag,
     renderHtml: renderHtmlFlag,
     sharingEnabled,

apps/opencode-plugin/binary-client.test.ts

@@ -260,6 +260,27 @@ describe("OpenCode binary client", () => {
     ]);
   });
 
+  test("includes the command timeout in plugin requests", async () => {
+    const response = createPluginSuccessResponse({ approved: true });
+    let inputBody: unknown;
+    const run: CommandRunner = (_command, _args, input) => {
+      inputBody = JSON.parse(input ?? "{}");
+      return { exitCode: 0, stdout: JSON.stringify(response), stderr: "" };
+    };
+
+    await runPluginPlan(
+      "/bin/plannotator",
+      {
+        origin: "opencode",
+        plan: "# Plan",
+      },
+      run,
+      { timeoutMs: 12_000 },
+    );
+
+    expect(inputBody).toMatchObject({ timeoutMs: 12_000 });
+  });
+
   test("turns malformed plugin plan output into a protocol error", async () => {
     const result = await runPluginPlan(
       "/bin/plannotator",

apps/vscode-extension/src/editor-annotations.ts

@@ -13,6 +13,7 @@ import * as http from "http";
 // ── State ──────────────────────────────────────────────────────────
 
 let activeProxyPort: number | null = null;
+let activeProxySessionPath = "";
 let commentController: vscode.CommentController | null = null;
 let annotationDecorationType: vscode.TextEditorDecorationType | null = null;
 
@@ -24,11 +25,13 @@ const decoratedRanges = new Map<string, vscode.Range[]>();
 
 // ── Public API ─────────────────────────────────────────────────────
 
-export function setActiveProxyPort(port: number | null): void {
+export function setActiveProxyPort(port: number | null, sessionPath = ""): void {
   activeProxyPort = port;
+  activeProxySessionPath = /^\/s\/[^/]+$/.test(sessionPath) ? sessionPath : "";
   if (port !== null) {
     createController();
   } else {
+    activeProxySessionPath = "";
     disposeAllThreads();
     clearAllDecorations();
     if (commentController) {
@@ -300,7 +303,7 @@ function requestProxy(
     }
 
     const req = http.request(
-      { hostname: "127.0.0.1", port, path: urlPath, method, headers },
+      { hostname: "127.0.0.1", port, path: scopedProxyPath(urlPath), method, headers },
       (res) => {
         let data = "";
         res.on("data", (chunk: string) => (data += chunk));
@@ -318,3 +321,10 @@ function requestProxy(
     req.end();
   });
 }
+
+function scopedProxyPath(urlPath: string): string {
+  if (activeProxySessionPath && urlPath.startsWith("/api/")) {
+    return `${activeProxySessionPath}${urlPath}`;
+  }
+  return urlPath;
+}

apps/vscode-extension/src/extension.ts

@@ -63,8 +63,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
       },
     });
 
+    const parsedUrl = new URL(url);
     const panel = await panelManager.open(proxy.rewriteUrl(url));
-    setActiveProxyPort(proxy.port);
+    setActiveProxyPort(proxy.port, parsedUrl.pathname);
 
     // Auto-close this specific panel when plannotator signals completion
     proxy.events.on("close", () => panel.dispose());

packages/server/daemon/client.test.ts

@@ -95,6 +95,37 @@ describe("DaemonClient", () => {
     expect(existsSync(paths.lockPath)).toBe(false);
   });
 
+  test("waits for accepted shutdown before removing daemon files", async () => {
+    const baseDir = tempBase();
+    const paths = getDaemonPaths({ baseDir });
+    const daemonState = state();
+    writeDaemonState(daemonState, { baseDir });
+    writeFileSync(paths.lockPath, "123\n", "utf-8");
+    let statusCalls = 0;
+    let stateFileExistedDuringPoll = false;
+
+    await cleanupDaemonState(daemonState, {
+      baseDir,
+      isAlive: () => true,
+      fetch: async (input) => {
+        const url = String(input);
+        if (url.endsWith("/daemon/shutdown")) return Response.json({ ok: true });
+        if (url.endsWith("/daemon/status")) {
+          statusCalls += 1;
+          stateFileExistedDuringPoll = stateFileExistedDuringPoll || existsSync(paths.statePath);
+          if (statusCalls === 1) return Response.json({ ...daemonState, ok: true });
+          throw new Error("gone");
+        }
+        throw new Error(`unexpected request: ${url}`);
+      },
+    });
+
+    expect(statusCalls).toBe(2);
+    expect(stateFileExistedDuringPoll).toBe(true);
+    expect(existsSync(paths.statePath)).toBe(false);
+    expect(existsSync(paths.lockPath)).toBe(false);
+  });
+
   test("does not signal recorded PID when endpoint shutdown fails", async () => {
     const baseDir = tempBase();
     const paths = getDaemonPaths({ baseDir });

packages/server/daemon/client.ts

@@ -15,6 +15,7 @@ import { readDaemonState, removeDaemonFiles, type DaemonState, type DaemonStateO
 export interface DaemonClientOptions extends DaemonStateOptions {
   fetch?: typeof fetch;
   validateEnvironment?: boolean;
+  shutdownTimeoutMs?: number;
 }
 
 export type DaemonDiscoveryResult =
@@ -92,21 +93,68 @@ function stateBaseUrl(state: unknown): string | undefined {
   return typeof baseUrl === "string" ? baseUrl : undefined;
 }
 
+function statePid(state: unknown): number | undefined {
+  const pid = (state as { pid?: unknown } | null)?.pid;
+  return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+
+export async function waitForDaemonShutdown(
+  state: unknown,
+  options: DaemonClientOptions = {},
+): Promise<boolean> {
+  const fetchImpl = options.fetch ?? fetch;
+  const baseUrl = stateBaseUrl(state);
+  const pid = statePid(state);
+  const isAlive = options.isAlive ?? ((targetPid: number) => {
+    try {
+      process.kill(targetPid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const deadline = Date.now() + (options.shutdownTimeoutMs ?? 3_000);
+
+  while (Date.now() < deadline) {
+    if (pid && !isAlive(pid)) return true;
+    if (!baseUrl) return true;
+    try {
+      const res = await fetchImpl(`${baseUrl}/daemon/status`);
+      const status = await res.json().catch(() => null) as { pid?: unknown } | null;
+      if (!res.ok) return true;
+      if (pid && status?.pid !== pid) return true;
+    } catch {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  return false;
+}
+
 export async function cleanupDaemonState(state: unknown, options: DaemonClientOptions = {}): Promise<void> {
   const fetchImpl = options.fetch ?? fetch;
   const baseUrl = stateBaseUrl(state);
+  let shutdownAccepted = false;
   if (baseUrl) {
     try {
-      await fetchImpl(`${baseUrl}/daemon/shutdown`, {
+      const res = await fetchImpl(`${baseUrl}/daemon/shutdown`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: "{}",
       });
+      shutdownAccepted = res.ok;
     } catch {
       // Best effort only. Do not signal the recorded PID here; stale daemon
       // state can outlive the process and the PID may now belong to something else.
     }
   }
+  if (shutdownAccepted) {
+    const stopped = await waitForDaemonShutdown(state, options);
+    if (!stopped) {
+      throw new Error("Timed out waiting for the existing Plannotator daemon to stop.");
+    }
+  }
   removeDaemonFiles(options);
 }
 

packages/server/daemon/server.test.ts

@@ -48,7 +48,7 @@ describe("daemon HTTP router", () => {
   });
 
   test("reports daemon status with active session count", async () => {
-    const { handler } = makeHandler();
+    const { handler, store } = makeHandler();
     await handler(new Request("http://127.0.0.1:4321/daemon/sessions", {
       method: "POST",
       headers: { "content-type": "application/json" },
@@ -60,6 +60,11 @@ describe("daemon HTTP router", () => {
     expect(body.endpoint.baseUrl).toBe("http://localhost:4321");
     expect(body.activeSessionCount).toBe(1);
     expect(body.sessionCount).toBe(1);
+    store.complete("s1", { approved: true });
+    const afterComplete = await handler(new Request("http://127.0.0.1:4321/daemon/status"));
+    const afterCompleteBody = await afterComplete.json();
+    expect(afterCompleteBody.activeSessionCount).toBe(0);
+    expect(afterCompleteBody.sessionCount).toBe(1);
   });
 
   test("creates and lists sessions", async () => {
@@ -92,6 +97,7 @@ describe("daemon HTTP router", () => {
     expect(html).toContain("apiBase=\"/s/s1/api\"");
     expect(html).toContain("window.fetch");
     expect(html).toContain("window.EventSource");
+    expect(html).toContain("window.EventSource.OPEN=OriginalEventSource.OPEN");
     expect(html.indexOf("window.__PLANNOTATOR_API_BASE__")).toBeGreaterThan(html.indexOf("const literal"));
     expect(html.indexOf("window.__PLANNOTATOR_API_BASE__")).toBeLessThan(html.indexOf("<body>"));
   });