@cortexkit/opencode-magic-context 0.34.0 → 0.34.1

package/src/shared/rpc-utils.test.ts

@@ -0,0 +1,157 @@
+/// <reference types="bun-types" />
+
+import { afterEach, describe, expect, test } from "bun:test";
+import type { execFileSync } from "node:child_process";
+import type { readFileSync } from "node:fs";
+import {
+    __resetRpcIdentityTestHooks,
+    __setRpcIdentityTestHooks,
+    isPidIdentityPlausible,
+    type RpcPortFileRecord,
+} from "./rpc-utils";
+
+const PID = 1234;
+const NOW_MS = 2_000_000;
+const UPTIME_SECONDS = 1_000;
+
+function record(startedAt: number): RpcPortFileRecord {
+    return { port: 43123, pid: PID, started_at: startedAt };
+}
+
+function procStat(startTimeTicks: number): string {
+    // After the closing command-name parenthesis, field 3 is `state` and field
+    // 22 is the twentieth value in the suffix.
+    return `${PID} (opencode) S ${Array.from({ length: 18 }, () => "0").join(" ")} ${startTimeTicks}`;
+}
+
+function linuxFiles(files: Record<string, string | Error>): typeof readFileSync {
+    return ((path: string | URL) => {
+        const value = files[String(path)];
+        if (value instanceof Error) throw value;
+        if (value === undefined) throw new Error(`unexpected read: ${String(path)}`);
+        return value;
+    }) as typeof readFileSync;
+}
+
+function psOutput(output: string | Error): typeof execFileSync {
+    return (() => {
+        if (output instanceof Error) throw output;
+        return output;
+    }) as typeof execFileSync;
+}
+
+afterEach(() => {
+    __resetRpcIdentityTestHooks();
+});
+
+describe("isPidIdentityPlausible", () => {
+    test("rejects a reused Linux PID when proc start time is substantially newer", () => {
+        const readPaths: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: ((path: string | URL) => {
+                readPaths.push(String(path));
+                const files = {
+                    [`/proc/${PID}/stat`]: procStat(10_000),
+                    "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+                };
+                return files[String(path) as keyof typeof files];
+            }) as typeof readFileSync,
+            execFileSync: (() => {
+                throw new Error("ps must not run on Linux");
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidIdentityPlausible(record(500_000))).toBe(false);
+        expect(readPaths).toEqual([`/proc/${PID}/stat`, "/proc/uptime"]);
+    });
+
+    test("accepts a genuine Linux record when the process started no later than the record", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            nowMs: () => NOW_MS,
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: procStat(10_000),
+                "/proc/uptime": `${UPTIME_SECONDS}.0 0.0`,
+            }),
+        });
+
+        // The mocked process start is 1,100,000ms. The 120s tolerance is part of
+        // the contract because port-file creation follows process startup.
+        expect(isPidIdentityPlausible(record(1_000_000))).toBe(true);
+    });
+
+    test("treats an unreadable Linux start-time probe as live", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/stat`]: new Error("procfs unavailable"),
+            }),
+        });
+
+        expect(isPidIdentityPlausible(record(500_000))).toBe(true);
+    });
+
+    test("uses the legacy Linux command fallback and fails closed on probe errors", () => {
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: "/usr/sbin/opendkim --config /etc/opendkim.conf",
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: "/usr/local/bin/opencode serve",
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "linux",
+            readFileSync: linuxFiles({
+                [`/proc/${PID}/cmdline`]: new Error("procfs unavailable"),
+            }),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+    });
+
+    test("uses ps start time and command probes on non-Linux platforms", () => {
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("Mon Aug  7 00:00:00 1970"),
+        });
+        expect(
+            isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 121_000)),
+        ).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("Mon Aug  7 00:00:00 1970"),
+        });
+        expect(
+            isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 120_000)),
+        ).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("/usr/sbin/opendkim -f"),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(false);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput("/Applications/OpenCode.app/Contents/MacOS/opencode"),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+
+        __setRpcIdentityTestHooks({
+            platform: "darwin",
+            execFileSync: psOutput(new Error("ps unavailable")),
+        });
+        expect(isPidIdentityPlausible(record(0))).toBe(true);
+    });
+});

package/src/shared/rpc-utils.ts

@@ -1,4 +1,6 @@
+import { execFileSync } from "node:child_process";
 import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 export interface RpcPortFileRecord {
@@ -58,6 +60,141 @@ export function isPidAlive(pid: number): boolean {
     }
 }
 
+const RPC_IDENTITY_SKEW_TOLERANCE_MS = 120_000;
+const LINUX_CLOCK_TICKS_PER_SECOND = 100;
+const PS_PROBE_TIMEOUT_MS = 1_000;
+const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+
+let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
+let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
+let rpcIdentityPlatform: NodeJS.Platform = process.platform;
+let rpcIdentityNowMs: () => number = () => Date.now();
+
+function parseLinuxProcessStartTime(statContent: string, uptimeContent: string): number | null {
+    const closingCommandName = statContent.lastIndexOf(")");
+    if (closingCommandName < 0) return null;
+
+    // The fields after the command name begin at field 3 (`state`), so field 22
+    // (`starttime`) is index 19 in this suffix. The command name can contain ')',
+    // hence the last closing parenthesis rather than the first one is significant.
+    const statFields = statContent
+        .slice(closingCommandName + 1)
+        .trim()
+        .split(/\s+/);
+    const startTimeTicks = Number(statFields[19]);
+    const uptimeSeconds = Number(uptimeContent.trim().split(/\s+/)[0]);
+    if (
+        !Number.isFinite(startTimeTicks) ||
+        startTimeTicks < 0 ||
+        !Number.isFinite(uptimeSeconds) ||
+        uptimeSeconds < 0
+    ) {
+        return null;
+    }
+
+    const processStartTime =
+        rpcIdentityNowMs() -
+        uptimeSeconds * 1_000 +
+        (startTimeTicks / LINUX_CLOCK_TICKS_PER_SECOND) * 1_000;
+    return Number.isFinite(processStartTime) ? processStartTime : null;
+}
+
+function readLinuxProcessStartTime(pid: number): number | null {
+    try {
+        const statContent = String(rpcIdentityReadFileSync(`/proc/${pid}/stat`, "utf8"));
+        const uptimeContent = String(rpcIdentityReadFileSync("/proc/uptime", "utf8"));
+        return parseLinuxProcessStartTime(statContent, uptimeContent);
+    } catch {
+        return null;
+    }
+}
+
+function readPsProcessStartTime(pid: number): number | null {
+    try {
+        const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+        });
+        const processStartTime = Date.parse(String(output).trim());
+        return Number.isFinite(processStartTime) ? processStartTime : null;
+    } catch {
+        return null;
+    }
+}
+
+function readLinuxProcessCommand(pid: number): string | null {
+    try {
+        return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
+    } catch {
+        return null;
+    }
+}
+
+function readPsProcessCommand(pid: number): string | null {
+    try {
+        const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+        });
+        return String(output);
+    } catch {
+        return null;
+    }
+}
+
+function commandLooksLikeOpenCode(command: string): boolean {
+    const normalized = command.toLowerCase();
+    return OPEN_CODE_COMMAND_MARKERS.some((marker) => normalized.includes(marker));
+}
+
+/**
+ * Verify that a live PID still belongs to the process that wrote a port record.
+ *
+ * A PID can be reused after its original process exits. On Linux, procfs gives
+ * us a process start time without spawning a helper; other platforms use `ps`
+ * only on this cold database-open guard path. Legacy records without a start
+ * time use a weaker command-name check, and every probe failure stays live so
+ * this identity check cannot weaken the migration guard on uncertainty.
+ */
+export function isPidIdentityPlausible(record: RpcPortFileRecord): boolean {
+    if (!Number.isInteger(record.pid) || record.pid <= 0) return false;
+
+    if (Number.isFinite(record.started_at) && record.started_at > 0) {
+        const processStartTime =
+            rpcIdentityPlatform === "linux"
+                ? readLinuxProcessStartTime(record.pid)
+                : readPsProcessStartTime(record.pid);
+        if (processStartTime === null) return true;
+        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+    }
+
+    const command =
+        rpcIdentityPlatform === "linux"
+            ? readLinuxProcessCommand(record.pid)
+            : readPsProcessCommand(record.pid);
+    if (command === null) return true;
+    return commandLooksLikeOpenCode(command);
+}
+
+export function __setRpcIdentityTestHooks(hooks: {
+    readFileSync?: typeof readFileSync;
+    execFileSync?: typeof execFileSync;
+    platform?: NodeJS.Platform;
+    nowMs?: () => number;
+}): void {
+    rpcIdentityReadFileSync = hooks.readFileSync ?? readFileSync;
+    rpcIdentityExecFileSync = hooks.execFileSync ?? execFileSync;
+    rpcIdentityPlatform = hooks.platform ?? process.platform;
+    rpcIdentityNowMs = hooks.nowMs ?? (() => Date.now());
+}
+
+export function __resetRpcIdentityTestHooks(): void {
+    rpcIdentityReadFileSync = readFileSync;
+    rpcIdentityExecFileSync = execFileSync;
+    rpcIdentityPlatform = process.platform;
+    rpcIdentityNowMs = () => Date.now();
+}
+
 export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileRecord | null {
     const trimmed = content.trim();
     if (!trimmed) return null;

package/src/shared/tui-runtime-specifiers.ts

@@ -0,0 +1,32 @@
+/**
+ * The module specifiers the compiled TUI is allowed to resolve through OpenCode's
+ * process-wide OpenTUI runtime registry (`opentui:runtime-module:<encoded>`).
+ *
+ * Single source of truth, shared by `scripts/build-tui.ts` (which rewrites these
+ * specifiers during the Solid transform) and
+ * `src/tui/tui-compiled-runtime-imports.test.ts` (which verifies every emitted
+ * specifier names a real export). Keeping one list means the guard test cannot
+ * drift into skipping a specifier the build actually rewrites — a skipped
+ * specifier is exactly the silent hole the test exists to close.
+ *
+ * Lives in `src/shared/` rather than `src/tui/` on purpose: `build-tui.ts` copies
+ * every file under `src/tui/` into the shipped `src/tui-compiled/` bundle, and
+ * this list is build/test tooling that the runtime bundle must not carry.
+ */
+export const TUI_RUNTIME_SPECIFIERS = [
+    "@opentui/core",
+    "@opentui/core/testing",
+    "@opentui/solid",
+    "@opentui/solid/components",
+    "@opentui/solid/jsx-runtime",
+    "@opentui/solid/jsx-dev-runtime",
+    "solid-js",
+    "solid-js/store",
+] as const;
+
+export type TuiRuntimeSpecifier = (typeof TUI_RUNTIME_SPECIFIERS)[number];
+
+/** Virtual module id OpenCode registers for a runtime specifier. */
+export function runtimeModuleId(specifier: string): string {
+    return `opentui:runtime-module:${encodeURIComponent(specifier)}`;
+}

package/src/tui/slots/sidebar-content.tsx

@@ -1,5 +1,5 @@
 /** @jsxImportSource @opentui/solid */
-import { Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
+import { For, Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import packageJson from "../../../package.json"
 import { badgeTextColor } from '../badge-contrast';
@@ -763,6 +763,14 @@ const SidebarContent = (props: {
                 </box>
             )}
 
+            {s()?.dreamerProgress && (
+                <box marginTop={1} width="100%">
+                    <text fg={props.theme.warning}>
+                        Dreamer {s()!.dreamerProgress!.task}: {s()!.dreamerProgress!.processed}/{s()!.dreamerProgress!.total} processed
+                    </text>
+                </box>
+            )}
+
             {/* Token breakdown bar. In collapsed mode the header, bar and the
                 3 summary rows stack with no vertical padding for a compact look;
                 expanded mode keeps the 1-row gap above the bar. */}
@@ -817,6 +825,16 @@ const SidebarContent = (props: {
                                     <text fg={props.theme.textMuted}>idle</text>
                                 )}
                             </box>
+                            <Show when={s()?.dreamerProgress}>
+                                {(progress) => (
+                                    <box width="100%" flexDirection="row" justifyContent="space-between">
+                                        <text fg={props.theme.textMuted}>Dreamer</text>
+                                        <text fg={props.theme.warning}>
+                                            {progress().task} {progress().processed}/{progress().total}
+                                        </text>
+                                    </box>
+                                )}
+                            </Show>
                             <box width="100%" flexDirection="row" justifyContent="space-between">
                                 <text fg={props.theme.textMuted}>Memories</text>
                                 <text fg={props.theme.textMuted}>
@@ -953,15 +971,39 @@ const SidebarContent = (props: {
                 )}
 
             {/* Dreamer */}
-            {sections().dreamer && s()?.lastDreamerRunAt && (
+            {sections().dreamer && (s()?.lastDreamerRunAt || s()?.dreamerProgress) && (
                 <>
                     <SectionHeader theme={props.theme} title="Dreamer" />
-                    <StatRow
-                        theme={props.theme}
-                        label="Last run"
-                        value={relativeTime(s()!.lastDreamerRunAt!)}
-                        dim
-                    />
+                    <Show when={s()?.dreamerProgress}>
+                        {(progress) => (
+                            <StatRow
+                                theme={props.theme}
+                                label="Current"
+                                value={`${progress().task} ${progress().processed}/${progress().total}`}
+                                warning
+                            />
+                        )}
+                    </Show>
+                    <Show when={s()?.lastDreamerRunAt}>
+                        {(lastRunAt) => (
+                            <StatRow
+                                theme={props.theme}
+                                label="Last run"
+                                value={relativeTime(lastRunAt())}
+                                dim
+                            />
+                        )}
+                    </Show>
+                    <For each={Object.entries(s()?.dreamerBacklog ?? {})}>
+                        {([task, backlog]) => (
+                            <StatRow
+                                theme={props.theme}
+                                label={task}
+                                value={`${backlog.pending}/${backlog.total}`}
+                                dim
+                            />
+                        )}
+                    </For>
                 </>
             )}
 

package/src/tui/tui-compiled-runtime-imports.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, test } from "bun:test";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { TUI_RUNTIME_SPECIFIERS } from "../shared/tui-runtime-specifiers";
+
+/**
+ * Every `opentui:runtime-module:*` import in the compiled TUI bundle must name an
+ * export the target module actually has.
+ *
+ * The Solid transform routes ALL of its emitted imports — renderer helpers and
+ * control-flow builtins (`For`, `Show`, `Index`, `Switch`, `Match`, ...) alike —
+ * through the single `moduleName` that `scripts/build-tui.ts` passes it, which is
+ * `@opentui/solid`. But `@opentui/solid` only re-exports its own renderer
+ * helpers; the builtins live in `solid-js`. So a bundle built without the
+ * redirect in `build-tui.ts` contains
+ *
+ *     import { For as _$For } from "opentui:runtime-module:%40opentui%2Fsolid";
+ *
+ * and the host throws `Export named 'For' not found` while loading the plugin.
+ * OpenCode swallows that error, so the only visible symptom is a missing sidebar
+ * and missing /ctx-* commands — no crash and nothing on stderr.
+ *
+ * This test resolves each specifier against the real module export sets instead
+ * of a hardcoded list, so it keeps holding when OpenTUI changes which names it
+ * re-exports. It covers every specifier `build-tui.ts` rewrites (via the shared
+ * `TUI_RUNTIME_SPECIFIERS` list) and fails on any runtime module id outside that
+ * set, so a future import from e.g. `solid-js/store` cannot slip through
+ * unverified.
+ */
+describe("compiled TUI runtime imports", () => {
+    const COMPILED_ROOT = join(import.meta.dir, "..", "tui-compiled");
+    const IMPORT_PATTERN = /import \{([^}]+)\} from "opentui:runtime-module:([^"]+)"/g;
+
+    function compiledFiles(dir: string): string[] {
+        const found: string[] = [];
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            if (statSync(full).isDirectory()) {
+                found.push(...compiledFiles(full));
+            } else if (entry.endsWith(".ts") || entry.endsWith(".tsx")) {
+                found.push(full);
+            }
+        }
+        return found;
+    }
+
+    /** Export sets for EVERY specifier build-tui.ts rewrites, keyed by module id.
+     *  Built from the shared list so the test cannot cover fewer modules than the
+     *  build rewrites. */
+    async function loadExportSets(): Promise<Record<string, Set<string>>> {
+        const entries = await Promise.all(
+            TUI_RUNTIME_SPECIFIERS.map(
+                async (specifier) =>
+                    [specifier, new Set(Object.keys(await import(specifier)))] as const,
+            ),
+        );
+        return Object.fromEntries(entries);
+    }
+
+    test("every runtime specifier exists in the module it is imported from", async () => {
+        const exportSets = await loadExportSets();
+
+        const unresolved: string[] = [];
+        let checked = 0;
+
+        for (const file of compiledFiles(COMPILED_ROOT)) {
+            const source = readFileSync(file, "utf8");
+            for (const match of source.matchAll(IMPORT_PATTERN)) {
+                const moduleId = decodeURIComponent(match[2] ?? "");
+                const exports = exportSets[moduleId];
+                if (!exports) {
+                    // A runtime module id outside the rewritten set means the build
+                    // emitted something this guard does not know how to verify.
+                    // Failing is the only safe answer: skipping it silently is the
+                    // exact hole that let the `For` misroute ship.
+                    unresolved.push(
+                        `${file}: imports from unknown runtime module '${moduleId}' — ` +
+                            "add it to TUI_RUNTIME_SPECIFIERS so it can be verified",
+                    );
+                    continue;
+                }
+
+                for (const specifier of (match[1] ?? "").split(",")) {
+                    const importedName = specifier
+                        .trim()
+                        .split(/\s+as\s+/)[0]
+                        ?.trim();
+                    if (!importedName) continue;
+                    checked += 1;
+                    if (!exports.has(importedName)) {
+                        unresolved.push(
+                            `${file}: '${importedName}' is not exported by ${moduleId}`,
+                        );
+                    }
+                }
+            }
+        }
+
+        expect(checked).toBeGreaterThan(0);
+        expect(unresolved).toEqual([]);
+    });
+
+    test("every rewritten specifier resolves to a non-empty module", async () => {
+        // A specifier that stops resolving already fails loudly on its own: the
+        // dynamic import inside loadExportSets throws and takes the test with it.
+        // What that does NOT catch is a specifier that resolves to an empty module
+        // (a renamed or emptied subpath export), which would make the guard above
+        // report every import from it as unresolved for a misleading reason.
+        const exportSets = await loadExportSets();
+
+        const empty = TUI_RUNTIME_SPECIFIERS.filter(
+            (specifier) => (exportSets[specifier]?.size ?? 0) === 0,
+        );
+        expect(empty).toEqual([]);
+    });
+
+    test("TUI_RUNTIME_SPECIFIERS has no duplicates", () => {
+        // Object.fromEntries silently collapses duplicate keys, so a duplicated
+        // entry would shrink the export-set map without any other signal.
+        expect([...new Set(TUI_RUNTIME_SPECIFIERS)]).toEqual([...TUI_RUNTIME_SPECIFIERS]);
+    });
+
+    test("solid control-flow builtins are imported from solid-js, not @opentui/solid", async () => {
+        const openTuiExports = new Set(Object.keys(await import("@opentui/solid")));
+        const solidExports = new Set(Object.keys(await import("solid-js")));
+
+        // The builtins that belong to solid-js alone — the exact set the
+        // transform would otherwise misroute to @opentui/solid.
+        const misroutable = [...solidExports].filter((name) => !openTuiExports.has(name));
+
+        const violations: string[] = [];
+        for (const file of compiledFiles(COMPILED_ROOT)) {
+            const source = readFileSync(file, "utf8");
+            for (const match of source.matchAll(IMPORT_PATTERN)) {
+                if (decodeURIComponent(match[2] ?? "") !== "@opentui/solid") continue;
+                for (const specifier of (match[1] ?? "").split(",")) {
+                    const importedName = specifier
+                        .trim()
+                        .split(/\s+as\s+/)[0]
+                        ?.trim();
+                    if (importedName && misroutable.includes(importedName)) {
+                        violations.push(`${file}: '${importedName}' must come from solid-js`);
+                    }
+                }
+            }
+        }
+
+        expect(violations).toEqual([]);
+    });
+});