@cortexkit/opencode-magic-context 0.29.0 → 0.29.1

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA+BmvK,CAAC;;;;;;;;;;;;qBAAjhE,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAggnC,CAAC;;;;;;EADh1tC"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BjF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;CACtC;;;;;;qBA2B28K,CAAC;;;;;;;;;;;;qBAAjhE,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAA20mC,CAAC;;;;;;EADn3tC"}

package/dist/plugin/rpc-handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,EACH,KAAK,eAAe,IAAI,QAAQ,EAGnC,MAAM,mCAAmC,CAAC;AAc3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAqBlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAe,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA0FtF,wBAAgB,oBAAoB,CAChC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,EAK9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,eAAe,CA2VjB;AAED,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,GAC/B,YAAY,CAyKd;AA4BD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CAyPN"}
+{"version":3,"file":"rpc-handlers.d.ts","sourceRoot":"","sources":["../../src/plugin/rpc-handlers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,OAAO,EACH,KAAK,eAAe,IAAI,QAAQ,EAGnC,MAAM,mCAAmC,CAAC;AAc3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AAqBlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,KAAK,EAAe,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA0FtF,wBAAgB,oBAAoB,CAChC,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,EAK9B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,eAAe,CAuVjB;AAED,wBAAgB,iBAAiB,CAC7B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,qBAAqB,CAAC,EAAE,MAAM,GAC/B,YAAY,CAyKd;AA4BD;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,IAAI,EAAE;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,kBAAkB,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,gBAAgB,CAAC;CACtC,GACF,IAAI,CAyPN"}

package/dist/shared/exit-abort-registry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Process-global registry of AbortControllers to abort on process exit, backed
+ * by a SINGLE `process.once("exit")` listener no matter how many controllers
+ * register.
+ *
+ * Why this exists: the plugin factory runs once per plugin instance, and
+ * OpenCode Desktop loads many instances in one Node process (one per open
+ * project). Registering a `process.once("exit")` per instance added one listener
+ * each, so past Node's default 10-listener cap it logged a
+ * `MaxListenersExceededWarning` ("11 exit listeners added to [process]"). One
+ * module-global listener that fans out to every registered controller keeps the
+ * count at one.
+ */
+/**
+ * Abort `controller` when the process exits. The underlying `process.once("exit")`
+ * listener is installed on the first call only; subsequent calls just add to the
+ * fan-out set.
+ */
+export declare function registerExitAbort(controller: AbortController): void;
+/**
+ * Stop tracking `controller` (e.g. when its plugin instance is disposed) so the
+ * set doesn't grow without bound as Desktop opens and closes projects.
+ */
+export declare function unregisterExitAbort(controller: AbortController): void;
+//# sourceMappingURL=exit-abort-registry.d.ts.map

package/dist/shared/exit-abort-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-abort-registry.d.ts","sourceRoot":"","sources":["../../src/shared/exit-abort-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAeH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAKnE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAErE"}

package/dist/shared/harness-provider-map.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Provider-id translation between the canonical (OpenCode) form stored in the
+ * shared magic-context config and Pi's harness-native provider ids.
+ *
+ * OpenCode and Pi now share ONE config, but a few auth-plugin providers were
+ * named differently on each side. The model id AFTER the slash is identical;
+ * only the provider prefix differs:
+ *
+ *   canonical (OpenCode)   Pi
+ *   --------------------   -------------------
+ *   openai/<model>         openai-codex/<model>
+ *   google/<model>         google-antigravity/<model>
+ *   anthropic/<model>      anthropic/<model>      (same; every other provider too)
+ *
+ * Canonical = OpenCode: the config always stores the OpenCode form. Pi
+ * translates at its edges:
+ *   - read:  canonical -> Pi when spawning a configured model (subagent-runner).
+ *   - write: Pi -> canonical in the Pi setup wizard, so a config written from
+ *            the Pi side stays readable by OpenCode.
+ *
+ * OpenCode needs no translation (canonical IS the OpenCode form).
+ */
+/** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
+ *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
+export declare function piModelRefToCanonical(ref: string): string;
+/** Canonical (OpenCode) `provider/model` -> Pi-native, for spawning a model on
+ *  Pi. Idempotent: normalizes any Pi-form prefix back to canonical first, so it
+ *  is safe on a config that already holds Pi-form ids (hand-edited or pre-fix). */
+export declare function resolveModelRefForPi(ref: string): string;
+//# sourceMappingURL=harness-provider-map.d.ts.map

package/dist/shared/harness-provider-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-provider-map.d.ts","sourceRoot":"","sources":["../../src/shared/harness-provider-map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAuBH;+EAC+E;AAC/E,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;mFAEmF;AACnF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/tools/ctx-note/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/tools/ctx-note/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,MAAM,qBAAqB,CAAC;AAYhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,QAAQ,CAAC;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;CACtD;AAoTD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAIxF"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/tools/ctx-note/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAQ,MAAM,qBAAqB,CAAC;AAYhE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAIpD,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,QAAQ,CAAC;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;CACtD;AAuTD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAIxF"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cortexkit/opencode-magic-context",
-	"version": "0.29.0",
+	"version": "0.29.1",
 	"type": "module",
 	"description": "OpenCode plugin for Magic Context — cross-session memory and context management",
 	"main": "dist/index.js",

package/src/shared/exit-abort-registry.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "bun:test";
+import { registerExitAbort, unregisterExitAbort } from "./exit-abort-registry";
+
+// Captured before any registration so we can isolate the ONE listener the
+// registry installs process-wide (it intentionally never removes it, mirroring
+// production, so the suite must not strip it either).
+const baseline = process.listenerCount("exit");
+
+/** The registry's single 'exit' listener (the first one added past baseline). */
+function registryListener(): () => void {
+    return process.listeners("exit").slice(baseline)[0] as () => void;
+}
+
+describe("exit-abort-registry", () => {
+    it("adds exactly ONE process exit listener no matter how many controllers register", () => {
+        registerExitAbort(new AbortController());
+        registerExitAbort(new AbortController());
+        registerExitAbort(new AbortController());
+        expect(process.listenerCount("exit") - baseline).toBe(1);
+    });
+
+    it("aborts every registered controller when the exit listener fires", () => {
+        const a = new AbortController();
+        const b = new AbortController();
+        registerExitAbort(a);
+        registerExitAbort(b);
+
+        // Invoke the registry's listener directly (emitting 'exit' would end the
+        // test process).
+        registryListener()();
+
+        expect(a.signal.aborted).toBe(true);
+        expect(b.signal.aborted).toBe(true);
+        // Still exactly one listener after firing.
+        expect(process.listenerCount("exit") - baseline).toBe(1);
+    });
+
+    it("does not abort a controller that was unregistered before exit", () => {
+        const keep = new AbortController();
+        const drop = new AbortController();
+        registerExitAbort(keep);
+        registerExitAbort(drop);
+        unregisterExitAbort(drop);
+
+        registryListener()();
+
+        expect(keep.signal.aborted).toBe(true);
+        expect(drop.signal.aborted).toBe(false);
+    });
+});

package/src/shared/exit-abort-registry.ts

@@ -0,0 +1,46 @@
+/**
+ * Process-global registry of AbortControllers to abort on process exit, backed
+ * by a SINGLE `process.once("exit")` listener no matter how many controllers
+ * register.
+ *
+ * Why this exists: the plugin factory runs once per plugin instance, and
+ * OpenCode Desktop loads many instances in one Node process (one per open
+ * project). Registering a `process.once("exit")` per instance added one listener
+ * each, so past Node's default 10-listener cap it logged a
+ * `MaxListenersExceededWarning` ("11 exit listeners added to [process]"). One
+ * module-global listener that fans out to every registered controller keeps the
+ * count at one.
+ */
+
+const controllers = new Set<AbortController>();
+let listenerRegistered = false;
+
+function abortAll(): void {
+    for (const controller of controllers) {
+        try {
+            controller.abort();
+        } catch {
+            // best-effort: the process is exiting anyway
+        }
+    }
+}
+
+/**
+ * Abort `controller` when the process exits. The underlying `process.once("exit")`
+ * listener is installed on the first call only; subsequent calls just add to the
+ * fan-out set.
+ */
+export function registerExitAbort(controller: AbortController): void {
+    controllers.add(controller);
+    if (listenerRegistered) return;
+    listenerRegistered = true;
+    process.once("exit", abortAll);
+}
+
+/**
+ * Stop tracking `controller` (e.g. when its plugin instance is disposed) so the
+ * set doesn't grow without bound as Desktop opens and closes projects.
+ */
+export function unregisterExitAbort(controller: AbortController): void {
+    controllers.delete(controller);
+}

package/src/shared/harness-provider-map.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { piModelRefToCanonical, resolveModelRefForPi } from "./harness-provider-map";
+
+describe("harness-provider-map", () => {
+    describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
+        it("maps the diverging auth-plugin providers, preserving the model id", () => {
+            expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google/antigravity-gemini-3.5-flash")).toBe(
+                "google-antigravity/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves anthropic and every other provider unchanged", () => {
+            expect(resolveModelRefForPi("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(resolveModelRefForPi("cerebras/gpt-oss-120b")).toBe("cerebras/gpt-oss-120b");
+            expect(resolveModelRefForPi("openrouter/openai/gpt-5.5")).toBe(
+                "openrouter/openai/gpt-5.5",
+            );
+        });
+
+        it("is idempotent: a config already in Pi form still resolves to Pi form", () => {
+            expect(resolveModelRefForPi("openai-codex/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google-antigravity/antigravity-gemini-3.1-pro")).toBe(
+                "google-antigravity/antigravity-gemini-3.1-pro",
+            );
+        });
+
+        it("preserves model ids that themselves contain slashes", () => {
+            expect(resolveModelRefForPi("openai/some/nested/id")).toBe(
+                "openai-codex/some/nested/id",
+            );
+        });
+
+        it("passes through malformed refs (no slash, empty provider) unchanged", () => {
+            expect(resolveModelRefForPi("gpt-5.5")).toBe("gpt-5.5");
+            expect(resolveModelRefForPi("/gpt-5.5")).toBe("/gpt-5.5");
+            expect(resolveModelRefForPi("")).toBe("");
+        });
+    });
+
+    describe("piModelRefToCanonical (Pi -> canonical, used by Pi setup write)", () => {
+        it("normalizes Pi-native provider ids to the OpenCode form", () => {
+            expect(piModelRefToCanonical("openai-codex/gpt-5.5")).toBe("openai/gpt-5.5");
+            expect(piModelRefToCanonical("google-antigravity/antigravity-gemini-3.5-flash")).toBe(
+                "google/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves already-canonical and unmapped providers unchanged", () => {
+            expect(piModelRefToCanonical("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(piModelRefToCanonical("openai/gpt-5.5")).toBe("openai/gpt-5.5");
+        });
+
+        it("round-trips with resolveModelRefForPi", () => {
+            const piForm = "openai-codex/gpt-5.5";
+            expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
+        });
+    });
+});

package/src/shared/harness-provider-map.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider-id translation between the canonical (OpenCode) form stored in the
+ * shared magic-context config and Pi's harness-native provider ids.
+ *
+ * OpenCode and Pi now share ONE config, but a few auth-plugin providers were
+ * named differently on each side. The model id AFTER the slash is identical;
+ * only the provider prefix differs:
+ *
+ *   canonical (OpenCode)   Pi
+ *   --------------------   -------------------
+ *   openai/<model>         openai-codex/<model>
+ *   google/<model>         google-antigravity/<model>
+ *   anthropic/<model>      anthropic/<model>      (same; every other provider too)
+ *
+ * Canonical = OpenCode: the config always stores the OpenCode form. Pi
+ * translates at its edges:
+ *   - read:  canonical -> Pi when spawning a configured model (subagent-runner).
+ *   - write: Pi -> canonical in the Pi setup wizard, so a config written from
+ *            the Pi side stays readable by OpenCode.
+ *
+ * OpenCode needs no translation (canonical IS the OpenCode form).
+ */
+
+const CANONICAL_TO_PI_PROVIDER: Record<string, string> = {
+    openai: "openai-codex",
+    google: "google-antigravity",
+};
+
+const PI_TO_CANONICAL_PROVIDER: Record<string, string> = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+};
+
+/** Remap only the provider prefix (text before the first "/"), preserving the
+ *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged. */
+function remapProviderPrefix(ref: string, map: Record<string, string>): string {
+    if (typeof ref !== "string") return ref;
+    const slash = ref.indexOf("/");
+    if (slash <= 0) return ref;
+    const provider = ref.slice(0, slash);
+    const mapped = map[provider];
+    return mapped ? `${mapped}${ref.slice(slash)}` : ref;
+}
+
+/** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
+ *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
+export function piModelRefToCanonical(ref: string): string {
+    return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+/** Canonical (OpenCode) `provider/model` -> Pi-native, for spawning a model on
+ *  Pi. Idempotent: normalizes any Pi-form prefix back to canonical first, so it
+ *  is safe on a config that already holds Pi-form ids (hand-edited or pre-fix). */
+export function resolveModelRefForPi(ref: string): string {
+    return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}

package/dist/hooks/is-anthropic-provider.d.ts

@@ -1,2 +0,0 @@
-export declare function isAnthropicProvider(providerID: string): boolean;
-//# sourceMappingURL=is-anthropic-provider.d.ts.map

package/dist/hooks/is-anthropic-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-anthropic-provider.d.ts","sourceRoot":"","sources":["../../src/hooks/is-anthropic-provider.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE/D"}

package/dist/shared/live-server-client.d.ts

@@ -1,50 +0,0 @@
-/**
- * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
- * user `<system-reminder>` delivered via `promptAsync`).
- *
- * WHY a separate client instead of the plugin-provided `input.client`:
- * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
- * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
- * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
- * observes an "idle" runner while the live turn is still running, `ensureRunning`
- * fails to coalesce, and OpenCode persists duplicate assistant children
- * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
- * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
- * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
- * message lands at the tail after the current assistant step.
- *
- * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
- * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
- * `/session/*`. We probe once at init and cache per `serverUrl`. When
- * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
- * remain the backstop) — MC deliberately does NOT fall back to the in-process
- * client because that would knowingly trigger #28202.
- */
-import { createOpencodeClient } from "@opencode-ai/sdk";
-export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
-/**
- * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
- * `(serverUrl, directory)`. One client is reused across deliveries.
- */
-export declare function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient;
-/**
- * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
- * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
- * (auth-protected listener still exists). `false` for 404 (plain TUI internal
- * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
- * Records the result + timestamp in the per-serverUrl cache.
- */
-export declare function probeServerReachable(serverUrl: string | undefined, timeoutMs?: number): Promise<boolean>;
-/** Record a probe result directly (test helper / explicit override). */
-export declare function setLiveServerWakeAvailable(serverUrl: string | undefined, available: boolean): void;
-/**
- * Should Channel 2 deliver through the live-server client for `serverUrl`?
- * Returns false when never probed or the last probe failed. A stale decision
- * (older than the TTL) returns false so the caller re-probes before delivering.
- */
-export declare function useLiveServerWake(serverUrl?: string): boolean;
-/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
-export declare function hasFreshProbe(serverUrl?: string): boolean;
-/** Test helper — reset both caches between cases. */
-export declare function __resetLiveServerClientForTests(): void;
-//# sourceMappingURL=live-server-client.d.ts.map

package/dist/shared/live-server-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"live-server-client.d.ts","sourceRoot":"","sources":["../../src/shared/live-server-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA0BvE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAY1F;AAcD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,SAAO,GACjB,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAED,wEAAwE;AACxE,wBAAgB,0BAA0B,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,OAAO,GACnB,IAAI,CAMN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAM7D;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAKzD;AAED,qDAAqD;AACrD,wBAAgB,+BAA+B,IAAI,IAAI,CAGtD"}

package/src/shared/live-server-client.ts

@@ -1,152 +0,0 @@
-/**
- * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
- * user `<system-reminder>` delivered via `promptAsync`).
- *
- * WHY a separate client instead of the plugin-provided `input.client`:
- * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
- * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
- * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
- * observes an "idle" runner while the live turn is still running, `ensureRunning`
- * fails to coalesce, and OpenCode persists duplicate assistant children
- * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
- * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
- * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
- * message lands at the tail after the current assistant step.
- *
- * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
- * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
- * `/session/*`. We probe once at init and cache per `serverUrl`. When
- * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
- * remain the backstop) — MC deliberately does NOT fall back to the in-process
- * client because that would knowingly trigger #28202.
- */
-
-import { createOpencodeClient } from "@opencode-ai/sdk";
-
-export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
-
-const clientCache = new Map<string, LiveServerClient>();
-
-function cacheKey(serverUrl: string, directory: string): string {
-    return `${serverUrl}|${directory}`;
-}
-
-function normalizeServerUrl(serverUrl: string): string {
-    try {
-        return new URL(serverUrl).toString();
-    } catch {
-        return serverUrl;
-    }
-}
-
-/** Basic-auth header OpenCode expects when `OPENCODE_SERVER_PASSWORD` is set. */
-function serverAuthHeaders(): Record<string, string> | undefined {
-    const password = process.env.OPENCODE_SERVER_PASSWORD;
-    if (!password) return undefined;
-    const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
-    return {
-        Authorization: `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`,
-    };
-}
-
-/**
- * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
- * `(serverUrl, directory)`. One client is reused across deliveries.
- */
-export function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient {
-    const key = cacheKey(serverUrl, directory);
-    const cached = clientCache.get(key);
-    if (cached) return cached;
-    const client = createOpencodeClient({
-        baseUrl: serverUrl,
-        directory,
-        headers: serverAuthHeaders(),
-        fetch: globalThis.fetch,
-    });
-    clientCache.set(key, client);
-    return client;
-}
-
-// Per-serverUrl wake decision + probe TTL. One plugin process can host multiple
-// OpenCode windows with different listener URLs, so the decision must be keyed.
-interface ProbeDecision {
-    reachable: boolean;
-    probedAt: number;
-}
-const wakeDecisionByServerUrl = new Map<string, ProbeDecision>();
-
-// Re-probe window: a transient 404/timeout shouldn't permanently disable
-// Channel 2 for the whole session lifetime (per council-r3).
-const PROBE_TTL_MS = 10 * 60_000;
-
-/**
- * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
- * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
- * (auth-protected listener still exists). `false` for 404 (plain TUI internal
- * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
- * Records the result + timestamp in the per-serverUrl cache.
- */
-export async function probeServerReachable(
-    serverUrl: string | undefined,
-    timeoutMs = 1500,
-): Promise<boolean> {
-    if (!serverUrl) return false;
-    const normalized = normalizeServerUrl(serverUrl);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    let reachable = false;
-    try {
-        const probeUrl = new URL("/session", serverUrl).toString();
-        const res = await globalThis.fetch(probeUrl, {
-            method: "GET",
-            headers: serverAuthHeaders(),
-            signal: controller.signal,
-        });
-        reachable = res.ok || res.status === 401 || res.status === 403;
-    } catch {
-        reachable = false;
-    } finally {
-        clearTimeout(timer);
-        wakeDecisionByServerUrl.set(normalized, { reachable, probedAt: Date.now() });
-    }
-    return reachable;
-}
-
-/** Record a probe result directly (test helper / explicit override). */
-export function setLiveServerWakeAvailable(
-    serverUrl: string | undefined,
-    available: boolean,
-): void {
-    if (!serverUrl) return;
-    wakeDecisionByServerUrl.set(normalizeServerUrl(serverUrl), {
-        reachable: available,
-        probedAt: Date.now(),
-    });
-}
-
-/**
- * Should Channel 2 deliver through the live-server client for `serverUrl`?
- * Returns false when never probed or the last probe failed. A stale decision
- * (older than the TTL) returns false so the caller re-probes before delivering.
- */
-export function useLiveServerWake(serverUrl?: string): boolean {
-    if (!serverUrl) return false;
-    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
-    if (!decision) return false;
-    if (Date.now() - decision.probedAt > PROBE_TTL_MS) return false;
-    return decision.reachable;
-}
-
-/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
-export function hasFreshProbe(serverUrl?: string): boolean {
-    if (!serverUrl) return false;
-    const decision = wakeDecisionByServerUrl.get(normalizeServerUrl(serverUrl));
-    if (!decision) return false;
-    return Date.now() - decision.probedAt <= PROBE_TTL_MS;
-}
-
-/** Test helper — reset both caches between cases. */
-export function __resetLiveServerClientForTests(): void {
-    clientCache.clear();
-    wakeDecisionByServerUrl.clear();
-}