@plannotator/pi-extension 0.27.10 → 0.27.11

package/generated/ai/providers/opencode-sdk.ts

@@ -2,10 +2,13 @@
 /**
  * OpenCode provider — bridges Plannotator's AI layer with OpenCode's agent server.
  *
- * Uses @opencode-ai/sdk to connect to an existing `opencode serve` first and
- * only spawns a new server when nothing is reachable. One server is shared
- * across all sessions. The user must have the `opencode` CLI installed and
- * authenticated.
+ * Uses @opencode-ai/sdk to spawn a dedicated `opencode serve` on an
+ * OS-assigned port. One server is shared across all sessions of this process,
+ * closed on dispose and on process exit. This provider deliberately never
+ * attaches to a server it did not spawn: an attached server cannot be cleaned
+ * up by us, and opencode's per-directory instances accumulate in it without
+ * eviction, so a shared long-lived server grows without bound. The user must
+ * have the `opencode` CLI installed and authenticated.
  */
 
 import type { OpencodeClient } from "@opencode-ai/sdk";
@@ -59,13 +62,19 @@ export class OpenCodeProvider implements AIProvider {
 	private server: { url: string; close: () => void } | null = null;
 	private client: OpencodeClient | null = null;
 	private startPromise: Promise<void> | null = null;
-	private lastAttachError: string | null = null;
+	private exitHandler: (() => void) | null = null;
+	/**
+	 * Bumped by dispose() to invalidate an in-flight doStart: a spawn that
+	 * completes after its epoch has passed reaps its own server instead of
+	 * resurrecting a provider the runtime already considers disposed.
+	 */
+	private startEpoch = 0;
 
 	constructor(config: OpenCodeConfig) {
 		this.config = config;
 	}
 
-	/** Attach to an existing OpenCode server or spawn one if needed. */
+	/** Spawn this process's OpenCode server if it is not already running. */
 	async ensureServer(): Promise<void> {
 		if (this.client) return;
 		this.startPromise ??= this.doStart().catch((err) => {
@@ -76,55 +85,63 @@ export class OpenCodeProvider implements AIProvider {
 	}
 
 	private async doStart(): Promise<void> {
-		this.lastAttachError = null;
+		const epoch = this.startEpoch;
 		const { createOpencodeServer, createOpencodeClient } = await getSDK();
-		const attachedClient = await this.tryAttachExistingServer(createOpencodeClient);
-		if (attachedClient) {
-			this.client = attachedClient;
-			return;
-		}
+		// port 0 asks opencode for an OS-assigned free port (the SDK reads the
+		// real URL back from the child's "listening" line), so every Plannotator
+		// process gets its own server instead of piling onto a shared default
+		// port. An explicitly configured port is still honored verbatim.
+		const server: { url: string; close: () => void } = await createOpencodeServer({
+			hostname: this.config.hostname ?? "127.0.0.1",
+			port: this.config.port ?? 0,
+			timeout: 15_000,
+		});
+		// A SIGINT/SIGTERM death is routed through process.exit() by the CLI, so
+		// an "exit" handler is what keeps Ctrl-C from orphaning the spawned
+		// `opencode serve` child (server.close() kills it synchronously). The
+		// closure captures ITS server — never `this.server`, which a failed
+		// retry could have replaced, leaving the first child unreachable by any
+		// cleanup. No SIGHUP listener: that would override the ignored
+		// disposition `nohup` depends on.
+		const exitHandler = () => {
+			try {
+				server.close();
+			} catch {
+				// Best effort — the process is exiting either way.
+			}
+		};
+		process.once("exit", exitHandler);
 
-		try {
-			this.server = await createOpencodeServer({
-				hostname: this.config.hostname ?? "127.0.0.1",
-				...(this.config.port != null && { port: this.config.port }),
-				timeout: 15_000,
-			});
-		} catch (err) {
-			const spawnMessage = err instanceof Error ? err.message : String(err);
-			if (this.lastAttachError) {
-				throw new Error(`${this.lastAttachError}\nFallback startup also failed: ${spawnMessage}`);
+		const reap = () => {
+			process.removeListener("exit", exitHandler);
+			try {
+				server.close();
+			} catch {
+				// Best effort — the child may already be gone.
 			}
-			throw err;
+		};
+
+		if (epoch !== this.startEpoch) {
+			// dispose() ran while the spawn was in flight: the runtime no longer
+			// wants this provider, so reap the just-spawned server instead of
+			// resurrecting a disposed provider with a live child.
+			reap();
+			throw new Error("OpenCode provider was disposed during startup.");
 		}
 
-		this.client = createOpencodeClient({
-			baseUrl: this.server!.url,
-			directory: this.config.cwd ?? process.cwd(),
-		});
-	}
-
-	private async tryAttachExistingServer(
-		createOpencodeClient: (config?: { baseUrl?: string; directory?: string }) => OpencodeClient,
-	): Promise<OpencodeClient | null> {
-		const cwd = this.config.cwd ?? process.cwd();
-		const baseUrl = `http://${this.config.hostname ?? "127.0.0.1"}:${this.config.port ?? 4096}`;
-		const client = createOpencodeClient({
-			baseUrl,
-			directory: cwd,
-		});
-
 		try {
-			await client.config.get({
-				throwOnError: true,
-				signal: AbortSignal.timeout(1_000),
+			this.client = createOpencodeClient({
+				baseUrl: server.url,
+				directory: this.config.cwd ?? process.cwd(),
 			});
-			return client;
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			this.lastAttachError = `Failed to attach to existing OpenCode server at ${baseUrl}: ${message}`;
-			return null;
+			// A post-spawn failure must not leak the child: close it and drop the
+			// handler so a retry starts from a clean slate.
+			reap();
+			throw err;
 		}
+		this.server = server;
+		this.exitHandler = exitHandler;
 	}
 
 	private getClient(): OpencodeClient {
@@ -199,6 +216,13 @@ export class OpenCodeProvider implements AIProvider {
 	}
 
 	dispose(): void {
+		// Invalidate any in-flight doStart so a spawn completing after this
+		// point reaps itself instead of resurrecting the provider.
+		this.startEpoch++;
+		if (this.exitHandler) {
+			process.removeListener("exit", this.exitHandler);
+			this.exitHandler = null;
+		}
 		if (this.server) {
 			this.server.close();
 			this.server = null;

package/generated/ai/types.ts

@@ -316,6 +316,6 @@ export interface OpenCodeConfig extends AIProviderConfig {
   type: "opencode-sdk";
   /** Hostname for the OpenCode server. Default: "127.0.0.1". */
   hostname?: string;
-  /** Port for the OpenCode server. Default: 4096. */
+  /** Port for the spawned OpenCode server. Default: 0 (OS-assigned free port). */
   port?: number;
 }

package/generated/config.ts

@@ -181,6 +181,16 @@ export interface PlannotatorConfig {
    * annotate sessions fully stateless. Default: true.
    */
   annotateHistory?: boolean;
+  /**
+   * Durably archive every submitted review under ~/.plannotator/feedback/
+   * (or PLANNOTATOR_DATA_DIR): one append-only JSONL record per submission
+   * plus a markdown sidecar for the ones that carry content. NOTE: this
+   * writes the user's own feedback text and the document/code excerpts it
+   * quotes to disk, and nothing prunes the directory. Set to false to never
+   * write. Default: true. Annotate-surface records additionally honor
+   * `annotateHistory`, so the stateless-annotate promise is unchanged.
+   */
+  feedbackHistory?: boolean;
   /**
    * Extra file extensions annotate treats as markdown (#1307), e.g.
    * [".livemd"] for Livebook notebooks. Listed extensions are accepted
@@ -648,6 +658,25 @@ export function resolveAnnotateHistory(config: PlannotatorConfig): boolean {
   return coerceConfigBoolean(config.annotateHistory, true);
 }
 
+/**
+ * Resolve whether submitted feedback is archived under feedback/.
+ *
+ * Priority (highest wins):
+ *   PLANNOTATOR_FEEDBACK_HISTORY env var  →  config.feedbackHistory  →  default true
+ *
+ * Deliberately a separate knob from annotateHistory: that one governs copying
+ * ANNOTATED CONTENT into the data dir, this one governs keeping the user's own
+ * SUBMISSIONS, and a code-review user must be able to control the second
+ * without touching the first. Annotate surfaces honor both.
+ */
+export function resolveFeedbackHistory(config: PlannotatorConfig): boolean {
+  const envVal = process.env.PLANNOTATOR_FEEDBACK_HISTORY;
+  if (envVal !== undefined) {
+    return envVal === "1" || envVal.toLowerCase() === "true";
+  }
+  return coerceConfigBoolean(config.feedbackHistory, true);
+}
+
 /**
  * Resolve whether successful Guided Reviews are persisted to disk.
  *