opencode-codex-memory 0.6.5 → 0.7.0

package/dist/src/v2/service.js

@@ -0,0 +1,173 @@
+/**
+ * The supported OpenCode 2 connection boundary.
+ *
+ * Server plugins do not receive the complete public client. The registered
+ * local service does: the XDG `service.json` file is the discovery contract
+ * (read-only — never Service.ensure()). Auth headers are preserved, and
+ * GET /api/status pid must match this process. 2.0.5 dropped JSON
+ * /api/health (404 HTML/empty); 2.0.3 Service.discover() still probes that
+ * path and throws on a non-object body, so this module never calls it.
+ */
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+let testDependencies = null;
+let clientPromise = null;
+const SERVICE_REQUEST_TIMEOUT_MS = 1_000;
+/** Test seam: replace discovery without changing the production connection path. */
+export function setV2ServiceDependenciesForTest(dependencies) {
+    testDependencies = dependencies;
+    clientPromise = null;
+}
+/** Forget a cached endpoint after a service restart or failed request. */
+export function invalidateOwnService() {
+    clientPromise = null;
+}
+export function parseReadyStatus(body) {
+    const record = unwrapStatusRecord(body);
+    if (!record)
+        return null;
+    const pid = record.pid;
+    const version = record.version;
+    if (typeof pid !== "number" || !Number.isFinite(pid) || typeof version !== "string" || version.length === 0) {
+        return null;
+    }
+    if ("healthy" in record && record.healthy !== true)
+        return null;
+    return { pid, version };
+}
+function unwrapStatusRecord(body) {
+    if (!body || typeof body !== "object")
+        return null;
+    const record = body;
+    if (record.data && typeof record.data === "object" && !Array.isArray(record.data)) {
+        return record.data;
+    }
+    return record;
+}
+async function withServiceTimeout(request, timeoutMs, controller) {
+    request.catch(() => { });
+    let timer;
+    try {
+        return await Promise.race([
+            request,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller?.abort();
+                    reject(new Error(`OpenCode service request timed out after ${timeoutMs}ms`));
+                }, timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function registrationPath() {
+    return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
+}
+export async function readRegisteredEndpoint(file = registrationPath()) {
+    const text = await readFile(file, "utf8").catch(() => undefined);
+    if (text === undefined)
+        return undefined;
+    let info;
+    try {
+        info = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (!info || typeof info !== "object")
+        return undefined;
+    const record = info;
+    if (typeof record.url !== "string" || record.url.length === 0)
+        return undefined;
+    const password = record.password;
+    return {
+        url: record.url,
+        ...(typeof password === "string" && password.length > 0
+            ? { auth: { type: "basic", username: "opencode", password } }
+            : {}),
+    };
+}
+async function fetchJson(url, headers, signal) {
+    const response = await fetch(url, { headers, signal });
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function fetchServiceStatus(endpoint, headers, signal) {
+    const statusBody = await fetchJson(new URL("/api/status", endpoint.url), headers, signal);
+    const fromStatus = parseReadyStatus(statusBody);
+    if (fromStatus)
+        return fromStatus;
+    const healthBody = await fetchJson(new URL("/api/health", endpoint.url), headers, signal);
+    const fromHealth = parseReadyStatus(healthBody);
+    if (fromHealth)
+        return fromHealth;
+    throw new Error("registered OpenCode service is not healthy");
+}
+async function productionDependencies() {
+    const { Service } = await import("@opencode/client/service");
+    const { OpenCode } = await import("@opencode/client");
+    return {
+        service: {
+            discover: () => readRegisteredEndpoint(),
+            headers: (endpoint) => Service.headers(endpoint),
+        },
+        make: (options) => OpenCode.make(options),
+        probe: (endpoint, signal) => fetchServiceStatus(endpoint, Service.headers(endpoint), signal),
+    };
+}
+async function probeEndpoint(deps, endpoint, client, signal) {
+    if (deps.probe)
+        return deps.probe(endpoint, signal);
+    if (client.health?.get) {
+        const raw = await client.health.get({ signal });
+        const parsed = parseReadyStatus(raw);
+        if (parsed)
+            return parsed;
+        throw new Error("registered OpenCode service is not healthy");
+    }
+    return fetchServiceStatus(endpoint, deps.service.headers(endpoint), signal);
+}
+/**
+ * Find a ready, registered OpenCode service without starting or replacing one.
+ * A missing service is a normal unavailable result; a PID mismatch is a
+ * safety failure because it would make global memory operate on another host.
+ */
+export async function discoverOwnService(dependencies, timeoutMs = SERVICE_REQUEST_TIMEOUT_MS) {
+    const deps = dependencies ?? testDependencies ?? (await productionDependencies());
+    const endpoint = await withServiceTimeout(deps.service.discover(), timeoutMs);
+    if (!endpoint)
+        return null;
+    const client = deps.make({ baseUrl: endpoint.url, headers: deps.service.headers(endpoint) });
+    const controller = new AbortController();
+    const health = await withServiceTimeout(probeEndpoint(deps, endpoint, client, controller.signal), timeoutMs, controller);
+    if (health.pid !== process.pid) {
+        throw new Error(`registered OpenCode service PID ${String(health.pid)} does not match plugin host PID ${process.pid}`);
+    }
+    return { endpoint, client, health };
+}
+/** Resolve the registered client once per live service; never start a service. */
+export async function ownServiceClient() {
+    if (!clientPromise) {
+        const request = discoverOwnService().then((found) => found?.client ?? null).catch((err) => {
+            console.warn("[opencode-codex-memory] registered OpenCode service unavailable:", err);
+            return null;
+        });
+        clientPromise = request;
+        const result = await request;
+        if (!result)
+            clientPromise = null;
+        return result;
+    }
+    return clientPromise;
+}

package/dist/src/v2/shim.d.ts

@@ -0,0 +1,47 @@
+/**
+ * opencode2 host-compatibility shim.
+ *
+ * V2 intentionally reuses the V1 pipeline (phase1/phase2/capture/llm/store/…
+ * run byte-identical) by presenting a V1-shaped client façade backed by the
+ * V2 plugin context. Only genuinely missing V2 surfaces are adapted:
+ *
+ * - session list/discovery → the authenticated public service client
+ *   discovered through the registered local service.
+ * - session.prompt agent/system/model/format/variant → V2 create-time
+ *   agent/model (via switchAgent/switchModel) + generate.text for the
+ *   json_schema extraction path (V2 prompts carry text only).
+ * - session.messages → public message.list with V1-shaped row adaptation.
+ * - session.delete → public session.remove, with a released-set fallback so
+ *   the V1 shutdown/liveness logic keeps working across hosts.
+ * - config.get → public service config documents adapted for the V1 resolver;
+ *   callers fall back to session defaults if the service is unavailable.
+ * - provider.list → catalog.model.list adapted to the V1 catalog shape for
+ *   reasoning-variant mapping.
+ * - mcp.status → mcp.list adapted to the V1 status map.
+ *
+ * Nothing in this file changes V1 behavior: V1 hosts never load it.
+ */
+import type { Plugin } from "@opencode/plugin";
+export type V2Context = Plugin.Context;
+export declare function setV2Context(ctx: V2Context | null): void;
+export declare function isReleasedSubSession(id: string): boolean;
+/** Stable synthetic id for extraction helpers (see create below). */
+export declare const EXTRACT_STUB_SESSION_ID = "codex-memory-extract-stub";
+/** Test seam. */
+export declare function resetV2ShimStateForTest(): void;
+/**
+ * V2 public transcript messages → V1 session.messages rows
+ * ({info:{role}, parts:[...]}) consumed by capture.ts extractText.
+ */
+export declare function adaptV2Messages(msgs: unknown): Array<{
+    info?: {
+        role?: string;
+    };
+    parts?: unknown[];
+}>;
+/** V2 catalog.model.list → V1 provider-list shape for catalogVariantKeys. */
+export declare function adaptProviderCatalog(v2: unknown): unknown;
+/** V2 mcp.list → V1 mcp.status map shape. */
+export declare function adaptMcpStatus(v2: unknown): unknown;
+/** Build the V1-shaped client. Passed to setPluginInput() by V2 setup(). */
+export declare function buildV1ClientShim(): unknown;