opencode-codex-memory 0.6.5 → 0.7.1

package/dist/src/v2/shim.js

@@ -0,0 +1,591 @@
+import { memoryRoot } from "../paths.js";
+import { invalidateOwnService, lastServiceFailure, ownServiceClient } from "./service.js";
+let v2ctx = null;
+export function setV2Context(ctx) {
+    v2ctx = ctx;
+}
+function ctx() {
+    if (!v2ctx)
+        throw new Error("v2 context not initialized");
+    return v2ctx;
+}
+/** Unwrap {data} vs direct payloads (client shape varies by call). */
+function und(v) {
+    const r = v;
+    if (r && typeof r === "object" && "data" in r)
+        return r.data;
+    return v;
+}
+function isNotFoundError(e) {
+    if (!e || typeof e !== "object")
+        return String(e ?? "").includes("404");
+    const r = e;
+    if (r.status === 404)
+        return true;
+    for (const f of [r._tag, r.name, r.message]) {
+        if (typeof f === "string" && /notfound|404/i.test(f))
+            return true;
+    }
+    return false;
+}
+async function sessionGoneOnService(client, sessionID) {
+    if (typeof client.session.get !== "function")
+        return false;
+    try {
+        const info = await client.session.get({ sessionID });
+        if (info?.error && isNotFoundError(info.error)) {
+            return true;
+        }
+        const data = und(info);
+        return !data || typeof data !== "object";
+    }
+    catch (e) {
+        return isNotFoundError(e);
+    }
+}
+/** Sub-session ids released via delete(): report 404 from get(). */
+const releasedSubSessions = new Set();
+const RELEASED_CAP = 500;
+function markReleased(id) {
+    releasedSubSessions.add(id);
+    if (releasedSubSessions.size > RELEASED_CAP) {
+        const oldest = releasedSubSessions.values().next().value;
+        if (oldest !== undefined)
+            releasedSubSessions.delete(oldest);
+    }
+}
+export function isReleasedSubSession(id) {
+    return releasedSubSessions.has(id);
+}
+/** Stable synthetic id for extraction helpers (see create below). */
+export const EXTRACT_STUB_SESSION_ID = "codex-memory-extract-stub";
+/** Test seam. */
+export function resetV2ShimStateForTest() {
+    releasedSubSessions.clear();
+    invalidateOwnService();
+}
+// ---------------------------------------------------------------------------
+// Shape adapters
+// ---------------------------------------------------------------------------
+function joinTextParts(content) {
+    if (!Array.isArray(content))
+        return "";
+    const out = [];
+    for (const p of content) {
+        if (p && typeof p === "object" && p.type === "text" && typeof p.text === "string") {
+            out.push(p.text);
+        }
+        else if (typeof p === "string") {
+            out.push(p);
+        }
+    }
+    return out.join("\n");
+}
+/**
+ * V2 public transcript messages → V1 session.messages rows
+ * ({info:{role}, parts:[...]}) consumed by capture.ts extractText.
+ */
+export function adaptV2Messages(msgs) {
+    if (!Array.isArray(msgs))
+        return [];
+    const rows = [];
+    for (const m of msgs) {
+        if (!m || typeof m !== "object")
+            continue;
+        if (m.type === "user") {
+            rows.push({ info: { role: "user" }, parts: [{ type: "text", text: m.text }] });
+            continue;
+        }
+        if (m.type === "system") {
+            rows.push({ info: { role: "system" }, parts: [{ type: "system", text: m.text }] });
+            continue;
+        }
+        if (m.type === "assistant") {
+            const parts = [];
+            for (const p of m.content ?? []) {
+                if (!p || typeof p !== "object")
+                    continue;
+                if (p.type === "text")
+                    parts.push({ type: "text", text: p.text });
+                else if (p.type === "reasoning")
+                    parts.push({ type: "reasoning" });
+                else if (p.type === "tool") {
+                    // The codemode `execute` wrapper runs code that calls the real
+                    // tools; expand its toolCalls so the transcript keeps V1's
+                    // per-tool granularity ([tool: name] input/output).
+                    const calls = p.state?.metadata?.toolCalls ?? p?.metadata?.toolCalls;
+                    if (p.name === "execute" && Array.isArray(calls) && calls.length > 0) {
+                        const outputText = joinTextParts(p.state?.content);
+                        for (const c of calls) {
+                            parts.push({
+                                type: "tool",
+                                tool: c.tool ?? "execute",
+                                state: {
+                                    input: c.input ?? p.state?.input,
+                                    ...(outputText ? { output: outputText } : {}),
+                                },
+                            });
+                        }
+                    }
+                    else {
+                        const st = p.state ?? {};
+                        const outputText = joinTextParts(st.content);
+                        parts.push({
+                            type: "tool",
+                            tool: p.name ?? "unknown",
+                            state: {
+                                ...(st.input !== undefined ? { input: st.input } : {}),
+                                ...(outputText ? { output: outputText } : {}),
+                                ...(typeof st.error === "string" ? { error: st.error } : {}),
+                            },
+                        });
+                    }
+                }
+            }
+            rows.push({ info: { role: "assistant" }, parts });
+            continue;
+        }
+        // synthetic/skill/shell/compaction/…: keep visible text, if any.
+        if (typeof m.text === "string") {
+            rows.push({ info: { role: m.type }, parts: [{ type: "text", text: m.text }] });
+        }
+        else {
+            rows.push({ info: { role: m.type }, parts: [] });
+        }
+    }
+    return rows;
+}
+/** V2 catalog.model.list → V1 provider-list shape for catalogVariantKeys. */
+export function adaptProviderCatalog(v2) {
+    const items = und(v2);
+    const list = Array.isArray(items) ? items : items?.data ?? [];
+    const providers = new Map();
+    for (const m of list) {
+        if (!m || typeof m !== "object")
+            continue;
+        const providerID = m.providerID;
+        const modelID = m.modelID ?? m.id;
+        if (typeof providerID !== "string" || typeof modelID !== "string")
+            continue;
+        if (!providers.has(providerID))
+            providers.set(providerID, {});
+        const variants = {};
+        for (const v of m.variants ?? []) {
+            if (v && typeof v === "object" && typeof v.id === "string") {
+                variants[v.id] = { ...(typeof v.disabled === "boolean" ? { disabled: v.disabled } : {}) };
+            }
+        }
+        ;
+        providers.get(providerID)[modelID] = { variants };
+    }
+    return { all: [...providers.entries()].map(([id, models]) => ({ id, models })) };
+}
+/** V2 mcp.list → V1 mcp.status map shape. */
+export function adaptMcpStatus(v2) {
+    const items = und(v2);
+    const list = Array.isArray(items) ? items : [];
+    const out = {};
+    for (const s of list) {
+        if (!s || typeof s !== "object" || typeof s.name !== "string")
+            continue;
+        const st = s.status;
+        out[s.name] = { status: typeof st === "string" ? st : (st?.status ?? "unknown") };
+    }
+    return out;
+}
+function parseModelRef(ref) {
+    const slash = ref.indexOf("/");
+    if (slash <= 0 || slash === ref.length - 1)
+        return null;
+    return { providerID: ref.slice(0, slash), modelID: ref.slice(slash + 1) };
+}
+function responseRows(response) {
+    const payload = und(response);
+    if (Array.isArray(payload))
+        return payload;
+    if (payload && typeof payload === "object" && Array.isArray(payload.data)) {
+        return payload.data;
+    }
+    return null;
+}
+function responseNextCursor(response) {
+    const payload = und(response);
+    const direct = response?.cursor?.next;
+    const next = direct ?? payload?.cursor?.next;
+    return typeof next === "string" && next.length > 0 ? next : undefined;
+}
+function adaptV2SessionRow(row) {
+    if (!row || typeof row !== "object")
+        return row;
+    const record = row;
+    const location = record.location;
+    const directory = typeof record.directory === "string"
+        ? record.directory
+        : location && typeof location === "object" && typeof location.directory === "string"
+            ? location.directory
+            : undefined;
+    return directory === undefined ? row : { ...record, directory };
+}
+// ---------------------------------------------------------------------------
+// The façade: V1-shaped client over the V2 context
+// ---------------------------------------------------------------------------
+async function v2promptWithWait(sessionID, body, signal) {
+    const c = ctx();
+    const text = body.parts.map((p) => p.text ?? "").join("\n");
+    // Structured-output extraction: V2 prompts carry text only, so run the
+    // turn through generate.text (inherently tool-less, like the V1
+    // memorize-extract sandbox) with the system prompt prepended. The caller
+    // falls back to JSON text parsing (hostStructuredOutput finds nothing).
+    if (body.format) {
+        const prompt = body.system ? `${body.system}\n\n---\n\n${text}` : text;
+        const parsed = body.model ? parseModelRef(`${body.model.providerID}/${body.model.modelID}`) : null;
+        const payload = {
+            prompt,
+            ...(parsed || body.variant
+                ? {
+                    model: {
+                        ...(parsed ? { providerID: parsed.providerID, id: parsed.modelID } : {}),
+                        ...(body.variant ? { variant: body.variant } : {}),
+                    },
+                }
+                : {}),
+        };
+        if (signal?.aborted)
+            throw new Error("sub-agent prompt cancelled");
+        const publicClient = await ownServiceClient();
+        if (typeof publicClient?.generate?.text === "function") {
+            const gen = await publicClient.generate.text(payload, signal ? { signal } : undefined);
+            const outText = typeof gen?.text === "string" ? gen.text : JSON.stringify(gen);
+            return { data: { parts: [{ type: "text", text: outText }] } };
+        }
+        // ctx.generate.text ignores request-option signals. Race AbortSignal.
+        const genP = c.generate.text(payload);
+        const gen = signal
+            ? await Promise.race([
+                genP,
+                new Promise((_, reject) => {
+                    signal.addEventListener("abort", () => reject(new Error("sub-agent prompt cancelled")), { once: true });
+                }),
+            ])
+            : await genP;
+        const outText = typeof gen?.text === "string" ? gen.text : JSON.stringify(gen);
+        return { data: { parts: [{ type: "text", text: outText }] } };
+    }
+    // Agentic turn (consolidation): the agent/model must be set at CREATE time
+    // in V2, so switch the fresh helper session first, then prompt + wait to
+    // preserve V1's "prompt resolves after the turn" semantics.
+    if (body.agent) {
+        await c.session.switchAgent({ sessionID, agent: body.agent });
+    }
+    if (body.model) {
+        await c.session.switchModel({
+            sessionID,
+            model: {
+                providerID: body.model.providerID,
+                id: body.model.modelID,
+                ...(body.variant ? { variant: body.variant } : {}),
+            },
+        });
+    }
+    const posted = await c.session.prompt({ sessionID, text });
+    const waitP = c.session.wait({ sessionID });
+    if (signal) {
+        if (signal.aborted) {
+            await c.session.interrupt({ sessionID }).catch(() => { });
+            await waitP.catch(() => { });
+            throw new Error("sub-agent prompt cancelled");
+        }
+        await Promise.race([
+            waitP,
+            new Promise((_, reject) => {
+                signal.addEventListener("abort", () => reject(new Error("sub-agent prompt cancelled")), { once: true });
+            }),
+        ]).catch(async (e) => {
+            await c.session.interrupt({ sessionID }).catch(() => { });
+            await waitP.catch(() => { });
+            throw e;
+        });
+    }
+    else {
+        await waitP;
+    }
+    return { data: { posted } };
+}
+/** Build the V1-shaped client. Passed to setPluginInput() by V2 setup(). */
+export function buildV1ClientShim() {
+    async function serviceOrThrow() {
+        const client = await ownServiceClient();
+        if (!client) {
+            throw new Error(lastServiceFailure() ?? "no healthy registered OpenCode 2 service for global memory operations");
+        }
+        return client;
+    }
+    async function paginateSessionList(listFn, limit, cursor, search) {
+        const pageSize = Math.min(Math.max(limit, 1), 5000);
+        const out = [];
+        const seenCursors = new Set();
+        const timestampCursor = typeof cursor === "number" ? cursor : undefined;
+        let next = typeof cursor === "string" ? cursor : undefined;
+        while (out.length < limit) {
+            const response = (await listFn({
+                limit: pageSize,
+                order: "desc",
+                parentID: null,
+                ...(search ? { search } : {}),
+                ...(next ? { cursor: next } : {}),
+            }));
+            const rawRows = responseRows(response);
+            if (!rawRows)
+                throw new Error("registered service returned an invalid session list");
+            const rows = rawRows
+                .map(adaptV2SessionRow)
+                .filter((row) => {
+                if (!row || typeof row !== "object")
+                    return false;
+                const record = row;
+                const time = record.time;
+                const updated = time && typeof time === "object" ? time.updated : undefined;
+                if (timestampCursor !== undefined && (typeof updated !== "number" || updated >= timestampCursor))
+                    return false;
+                if (!search)
+                    return true;
+                const title = typeof record.title === "string" ? record.title : "";
+                const id = typeof record.id === "string" ? record.id : "";
+                return `${id}\n${title}`.toLowerCase().includes(search.toLowerCase());
+            });
+            out.push(...rows);
+            const candidate = responseNextCursor(response);
+            if (!candidate || seenCursors.has(candidate) || rawRows.length === 0)
+                break;
+            seenCursors.add(candidate);
+            next = candidate;
+        }
+        return { data: out.slice(0, limit) };
+    }
+    async function listGlobalSessions(limit, cursor, search) {
+        const localList = v2ctx ? v2ctx.session.list : undefined;
+        if (typeof localList === "function") {
+            return paginateSessionList((input) => localList(input), limit, cursor, search);
+        }
+        const client = await serviceOrThrow();
+        if (typeof client.session.list !== "function")
+            throw new Error("registered service does not support session.list");
+        return paginateSessionList((input) => client.session.list(input), limit, cursor, search);
+    }
+    const session = {
+        create: async (opts) => {
+            try {
+                // Extraction turns run through generate.text (see prompt below) and
+                // never touch a session, so hand out a stable synthetic id instead
+                // of creating a server row per extraction (without this each
+                // extraction would litter one dead
+                // `codex-memory-extract-*` session). Skip/tracking logic keys off
+                // the id string only, so behavior is unchanged.
+                if (opts?.body?.title?.startsWith("codex-memory-extract-")) {
+                    releasedSubSessions.delete(EXTRACT_STUB_SESSION_ID);
+                    return { data: { id: EXTRACT_STUB_SESSION_ID } };
+                }
+                const res = await ctx().session.create({
+                    ...(opts?.body?.title ? { title: opts.body.title } : {}),
+                    ...(opts?.body?.metadata ? { metadata: opts.body.metadata } : {}),
+                    location: { directory: opts?.query?.directory ?? memoryRoot() },
+                });
+                return { data: { id: und(res)?.id } };
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+        prompt: async (opts) => {
+            try {
+                return await v2promptWithWait(opts.path.id, opts.body, opts.signal);
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+        messages: async (opts) => {
+            try {
+                if (isReleasedSubSession(opts.path.id))
+                    throw Object.assign(new Error("SessionNotFound"), { _tag: "SessionNotFoundError" });
+                const client = await serviceOrThrow();
+                if (typeof client.message?.list !== "function")
+                    throw new Error("registered service does not support message.list");
+                const messages = [];
+                const seenCursors = new Set();
+                let cursor;
+                while (true) {
+                    const response = await client.message.list(cursor ? { sessionID: opts.path.id, cursor } : { sessionID: opts.path.id, order: "asc" });
+                    const rows = responseRows(response);
+                    if (!rows)
+                        throw new Error("registered service returned an invalid message list");
+                    messages.push(...rows);
+                    const next = responseNextCursor(response);
+                    if (!next || seenCursors.has(next))
+                        break;
+                    seenCursors.add(next);
+                    cursor = next;
+                }
+                return { data: adaptV2Messages(messages) };
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+        delete: async (opts) => {
+            let shutdownError;
+            try {
+                const client = await serviceOrThrow();
+                if (typeof client.session.remove !== "function")
+                    throw new Error("registered service does not support session.remove");
+                const result = await client.session.remove({ sessionID: opts.path.id }, opts.signal ? { signal: opts.signal } : undefined);
+                if (result?.error)
+                    throw result.error;
+                if (await sessionGoneOnService(client, opts.path.id)) {
+                    markReleased(opts.path.id);
+                    return {};
+                }
+                throw new Error("session still exists after remove");
+            }
+            catch (error) {
+                shutdownError = error;
+            }
+            try {
+                const session = ctx().session;
+                const interrupt = await session.interrupt({ sessionID: opts.path.id });
+                if (interrupt?.error)
+                    throw interrupt.error;
+                if (typeof session.wait === "function")
+                    await session.wait({ sessionID: opts.path.id });
+            }
+            catch (interruptError) {
+                return { error: shutdownError ?? interruptError };
+            }
+            try {
+                const client = await ownServiceClient();
+                if (!client?.session?.get)
+                    return { error: shutdownError ?? new Error("session still exists after interrupt") };
+                const info = await client.session.get({ sessionID: opts.path.id });
+                if (info?.error && isNotFoundError(info.error)) {
+                    markReleased(opts.path.id);
+                    return {};
+                }
+                const data = und(info);
+                if (data && typeof data === "object") {
+                    return { error: shutdownError ?? new Error("session still exists after interrupt") };
+                }
+                return { error: shutdownError ?? new Error("session still exists after interrupt") };
+            }
+            catch (e) {
+                if (isNotFoundError(e)) {
+                    markReleased(opts.path.id);
+                    return {};
+                }
+                return { error: shutdownError ?? e };
+            }
+        },
+        get: async (opts) => {
+            try {
+                if (isReleasedSubSession(opts.path.id)) {
+                    return { response: { status: 404 }, error: { _tag: "SessionNotFoundError" } };
+                }
+                const client = await serviceOrThrow();
+                const info = und(await client.session.get?.({ sessionID: opts.path.id }));
+                return { data: info };
+            }
+            catch (e) {
+                if (isNotFoundError(e))
+                    return { response: { status: 404 }, error: e };
+                return { error: e };
+            }
+        },
+        abort: async (opts) => {
+            try {
+                const client = await serviceOrThrow();
+                if (typeof client.session.interrupt !== "function")
+                    throw new Error("registered service does not support session.interrupt");
+                const result = await client.session.interrupt({ sessionID: opts.path.id });
+                if (!result?.error)
+                    return {};
+            }
+            catch {
+                // Fall through to the context-local interrupt below.
+            }
+            try {
+                await ctx().session.interrupt({ sessionID: opts.path.id });
+            }
+            catch {
+                // Best-effort, mirrors V1.
+            }
+            return {};
+        },
+    };
+    const config = {
+        get: async () => {
+            try {
+                const client = await serviceOrThrow();
+                const response = await client.config?.get({ location: { directory: ctx().location.directory } });
+                const documents = und(response);
+                const candidates = Array.isArray(documents) ? documents : documents?.type === "document" ? [documents] : [];
+                let info = {};
+                let found = false;
+                for (const entry of candidates) {
+                    if (!entry || typeof entry !== "object" || entry.type !== "document")
+                        continue;
+                    if (!entry.info || typeof entry.info !== "object" || Array.isArray(entry.info))
+                        continue;
+                    info = { ...info, ...entry.info };
+                    found = true;
+                }
+                if (!found)
+                    return { data: {} };
+                const model = info.model;
+                let normalizedModel = model;
+                const modelRecord = model && typeof model === "object" ? model : null;
+                if (typeof modelRecord?.providerID === "string" && typeof modelRecord.model === "string") {
+                    normalizedModel = `${modelRecord.providerID}/${modelRecord.model}`;
+                }
+                return { data: { ...info, ...(normalizedModel !== undefined ? { model: normalizedModel } : {}) } };
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+    };
+    const provider = {
+        list: async () => {
+            try {
+                const res = await ctx().catalog.model.list();
+                return { data: adaptProviderCatalog(res) };
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+    };
+    const mcp = {
+        status: async () => {
+            try {
+                const res = await ctx().mcp.list();
+                return { data: adaptMcpStatus(res) };
+            }
+            catch (e) {
+                return { error: e };
+            }
+        },
+    };
+    const _client = {
+        get: async (opts) => {
+            if (opts.url === "/experimental/session") {
+                const q = opts.query ?? {};
+                const cursor = typeof q.cursor === "number" || typeof q.cursor === "string" ? q.cursor : undefined;
+                return listGlobalSessions(typeof q.limit === "number" ? q.limit : 5000, cursor, typeof q.search === "string" ? q.search : undefined);
+            }
+            if (opts.url === "/provider") {
+                return provider.list();
+            }
+            return { error: { message: `unsupported shim route ${opts.url}` } };
+        },
+    };
+    return { session, config, provider, mcp, _client };
+}