@wolfx/opencode-magic-context 0.21.8-patch.1

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

@@ -0,0 +1,161 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { MagicContextRpcClient } from "./rpc-client";
+import { rpcPortFilePath } from "./rpc-utils";
+
+interface TestServer {
+    port: number;
+    close: () => Promise<void>;
+}
+
+const tempDirs: string[] = [];
+let servers: TestServer[] = [];
+
+afterEach(async () => {
+    for (const server of servers.splice(0)) {
+        await server.close();
+    }
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+
+function makeTempDir(): string {
+    const dir = mkdtempSync(join(tmpdir(), "mc-rpc-client-"));
+    tempDirs.push(dir);
+    return dir;
+}
+
+function writePortFile(storageDir: string, directory: string, port: number): void {
+    const portFile = rpcPortFilePath(storageDir, directory);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(
+        portFile,
+        JSON.stringify({ port, pid: process.pid, started_at: Date.now() }),
+        "utf-8",
+    );
+}
+
+function writePortFileForPid(
+    storageDir: string,
+    directory: string,
+    port: number,
+    pid: number,
+    startedAt: number,
+): void {
+    const portFile = rpcPortFilePath(storageDir, directory, pid);
+    mkdirSync(dirname(portFile), { recursive: true });
+    writeFileSync(portFile, JSON.stringify({ port, pid, started_at: startedAt }), "utf-8");
+}
+
+async function startRpcServer(handler: (method: string) => Response | object): Promise<TestServer> {
+    const server = createServer(async (req, res) => {
+        if (req.method === "GET" && req.url === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+            return;
+        }
+
+        if (req.method === "POST" && req.url?.startsWith("/rpc/")) {
+            const method = req.url.slice("/rpc/".length);
+            const result = handler(method);
+            if (result instanceof Response) {
+                res.writeHead(result.status, { "Content-Type": "application/json" });
+                res.end(await result.text());
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+
+        res.writeHead(404);
+        res.end("Not Found");
+    });
+
+    await new Promise<void>((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const addr = server.address();
+    if (!addr || typeof addr === "string") throw new Error("failed to bind test server");
+
+    const testServer = {
+        port: addr.port,
+        close: () =>
+            new Promise<void>((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            }),
+    };
+    servers.push(testServer);
+    return testServer;
+}
+
+async function closeServer(server: TestServer): Promise<void> {
+    servers = servers.filter((s) => s !== server);
+    await server.close();
+}
+
+describe("MagicContextRpcClient", () => {
+    test("re-reads the port file after the cached server restarts on a new port", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const client = new MagicContextRpcClient(storageDir, directory);
+
+        const first = await startRpcServer(() => ({ value: "first" }));
+        writePortFile(storageDir, directory, first.port);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "first" });
+
+        await closeServer(first);
+        const second = await startRpcServer(() => ({ value: "second" }));
+        writePortFile(storageDir, directory, second.port);
+
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "second" });
+    });
+
+    test("gives up when the port file points at a dead server", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const dead = await startRpcServer(() => ({ ok: true }));
+        const port = dead.port;
+        await closeServer(dead);
+        writePortFile(storageDir, directory, port);
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        await expect(client.call("value")).rejects.toThrow(
+            "Magic Context RPC server not available",
+        );
+    }, 20_000);
+
+    test("re-resolves and retries transient 5xx responses", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        let calls = 0;
+        const server = await startRpcServer(() => {
+            calls++;
+            if (calls === 1) {
+                return new Response(JSON.stringify({ error: "warming up" }), { status: 503 });
+            }
+            return { value: "ok" };
+        });
+        writePortFile(storageDir, directory, server.port);
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "ok" });
+        expect(calls).toBe(2);
+    });
+
+    test("ignores newer stale pid files and discovers the latest live instance", async () => {
+        const storageDir = makeTempDir();
+        const directory = "/repo";
+        const live = await startRpcServer(() => ({ value: "live" }));
+        writePortFileForPid(storageDir, directory, 65535, 999_999_999, Date.now() + 10_000);
+        writePortFileForPid(storageDir, directory, live.port, process.pid, Date.now());
+
+        const client = new MagicContextRpcClient(storageDir, directory);
+        expect(await client.call<{ value: string }>("value")).toEqual({ value: "live" });
+    });
+});

package/src/shared/rpc-client.ts

@@ -0,0 +1,183 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+    isPidAlive,
+    legacyRpcPortFilePath,
+    parseRpcPortFile,
+    type RpcPortFileRecord,
+    rpcPortDir,
+} from "./rpc-utils";
+
+const MAX_RETRIES = 10;
+const RETRY_DELAY_MS = 500;
+const REQUEST_TIMEOUT_MS = 5000;
+const MAX_RERESOLVE_ATTEMPTS = 3;
+const NON_RETRYABLE_RPC_ERROR = Symbol("nonRetryableRpcError");
+type NonRetryableRpcError = Error & { [NON_RETRYABLE_RPC_ERROR]: true };
+
+export class MagicContextRpcClient {
+    private port: number | null = null;
+    private portDir: string;
+    private legacyPortFilePath: string;
+    private healthChecked = false;
+
+    constructor(storageDir: string, directory: string) {
+        this.portDir = rpcPortDir(storageDir, directory);
+        this.legacyPortFilePath = legacyRpcPortFilePath(storageDir, directory);
+    }
+
+    /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
+    async call<T = Record<string, unknown>>(
+        method: string,
+        params: Record<string, unknown> = {},
+    ): Promise<T> {
+        let lastError: unknown = null;
+
+        for (let attempt = 0; attempt < MAX_RERESOLVE_ATTEMPTS; attempt++) {
+            const port = await this.resolvePort();
+            if (!port) {
+                lastError = new Error("Magic Context RPC server not available");
+                this.reset();
+                continue;
+            }
+
+            try {
+                const response = await this.fetchWithTimeout(
+                    `http://127.0.0.1:${port}/rpc/${method}`,
+                    {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify(params),
+                    },
+                );
+
+                if (!response.ok) {
+                    const text = await response.text();
+                    const error = new Error(`RPC ${method} failed (${response.status}): ${text}`);
+                    if (response.status >= 500) {
+                        lastError = error;
+                        this.reset();
+                        continue;
+                    }
+                    (error as NonRetryableRpcError)[NON_RETRYABLE_RPC_ERROR] = true;
+                    throw error;
+                }
+
+                return (await response.json()) as T;
+            } catch (err) {
+                if (isNonRetryableRpcError(err)) {
+                    throw err;
+                }
+                lastError = err;
+                this.reset();
+            }
+        }
+
+        if (lastError instanceof Error) {
+            throw lastError;
+        }
+        throw new Error("Magic Context RPC server not available");
+    }
+
+    /** Check if the RPC server is reachable. */
+    async isAvailable(): Promise<boolean> {
+        try {
+            const port = await this.resolvePort();
+            return port !== null;
+        } catch {
+            return false;
+        }
+    }
+
+    private async resolvePort(): Promise<number | null> {
+        if (this.port && this.healthChecked) {
+            return this.port;
+        }
+
+        if (this.port) {
+            const alive = await this.healthCheck(this.port);
+            if (alive) {
+                this.healthChecked = true;
+                return this.port;
+            }
+            this.port = null;
+            this.healthChecked = false;
+        }
+
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const port = this.readPortFile();
+            if (port) {
+                const alive = await this.healthCheck(port);
+                if (alive) {
+                    this.port = port;
+                    this.healthChecked = true;
+                    return port;
+                }
+            }
+
+            if (attempt < MAX_RETRIES - 1) {
+                await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+            }
+        }
+
+        return null;
+    }
+
+    private readPortFile(): number | null {
+        const records: RpcPortFileRecord[] = [];
+
+        try {
+            for (const entry of readdirSync(this.portDir)) {
+                if (!entry.startsWith("port-") || !entry.endsWith(".json")) continue;
+                const record = parseRpcPortFile(readFileSync(join(this.portDir, entry), "utf-8"));
+                if (!record || !isPidAlive(record.pid)) continue;
+                records.push(record);
+            }
+        } catch {
+            // Directory may not exist yet. Fall back to the legacy file below.
+        }
+
+        if (records.length > 0) {
+            records.sort((a, b) => b.started_at - a.started_at);
+            return records[0].port;
+        }
+
+        try {
+            const record = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
+            if (record?.pid && !isPidAlive(record.pid)) return null;
+            return record?.port ?? null;
+        } catch {
+            return null;
+        }
+    }
+
+    private async healthCheck(port: number): Promise<boolean> {
+        try {
+            const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+                method: "GET",
+            });
+            return response.ok;
+        } catch {
+            return false;
+        }
+    }
+
+    private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            return await fetch(url, { ...options, signal: controller.signal });
+        } finally {
+            clearTimeout(timeout);
+        }
+    }
+
+    reset(): void {
+        this.port = null;
+        this.healthChecked = false;
+    }
+}
+
+function isNonRetryableRpcError(err: unknown): err is NonRetryableRpcError {
+    return typeof err === "object" && err !== null && NON_RETRYABLE_RPC_ERROR in err;
+}

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

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import { drainNotifications, pushNotification } from "./rpc-notifications";
+
+describe("rpc notifications", () => {
+    test("keeps messages queued until the client acks their id", () => {
+        const initial = drainNotifications(Number.MAX_SAFE_INTEGER);
+        expect(initial).toEqual([]);
+
+        pushNotification("one", { ok: true }, "ses_1");
+        const firstPoll = drainNotifications();
+        expect(firstPoll).toHaveLength(1);
+        expect(firstPoll[0].type).toBe("one");
+
+        const retryPoll = drainNotifications();
+        expect(retryPoll.map((m) => m.id)).toEqual(firstPoll.map((m) => m.id));
+
+        const lastReceivedId = Math.max(...firstPoll.map((m) => m.id));
+        expect(drainNotifications(lastReceivedId)).toEqual([]);
+    });
+});

package/src/shared/rpc-notifications.ts

@@ -0,0 +1,53 @@
+/**
+ * In-memory notification queue for server→TUI push.
+ * Replaces SQLite plugin_messages table.
+ *
+ * Also tracks whether a TUI client is actively connected (polling).
+ * The server plugin cannot use `process.env.OPENCODE_CLIENT` to detect TUI
+ * because the server runs in a separate process from the TUI client.
+ */
+
+export interface RpcNotification {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}
+
+let queue: RpcNotification[] = [];
+let nextNotificationId = 1;
+// Timestamp of last drain — used to detect if TUI is actively polling.
+// The TUI polls every 500ms; we consider it connected if it polled within
+// the last 3 seconds (6× the poll interval, tolerates transient delays).
+let lastDrainAt = 0;
+const TUI_CONNECTED_WINDOW_MS = 3_000;
+
+/** Push a notification for TUI to pick up via polling. */
+export function pushNotification(
+    type: string,
+    payload: Record<string, unknown>,
+    sessionId?: string,
+): void {
+    queue.push({ id: nextNotificationId++, type, payload, sessionId });
+    // Cap queue size to prevent unbounded growth if TUI is not polling
+    if (queue.length > 100) {
+        queue = queue.slice(-50);
+    }
+}
+
+/** Return pending notifications after acking the client's last received id.
+ *  Updates lastDrainAt so isTuiConnected() reflects recent activity. */
+export function drainNotifications(lastReceivedId = 0): RpcNotification[] {
+    lastDrainAt = Date.now();
+    if (lastReceivedId > 0) {
+        queue = queue.filter((notification) => notification.id > lastReceivedId);
+    }
+    return [...queue];
+}
+
+/** Whether a TUI client is actively polling for notifications.
+ *  Returns true only if the TUI has drained within the last 3 seconds.
+ *  This prevents stale-connected state after TUI closes or disconnects. */
+export function isTuiConnected(): boolean {
+    return lastDrainAt > 0 && Date.now() - lastDrainAt < TUI_CONNECTED_WINDOW_MS;
+}

package/src/shared/rpc-server.ts

@@ -0,0 +1,174 @@
+import {
+    mkdirSync,
+    readdirSync,
+    readFileSync,
+    renameSync,
+    unlinkSync,
+    writeFileSync,
+} from "node:fs";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { dirname } from "node:path";
+import { log } from "./logger";
+import { isPidAlive, parseRpcPortFile, rpcPortDir, rpcPortFilePath } from "./rpc-utils";
+
+type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+
+export class MagicContextRpcServer {
+    private server: Server | null = null;
+    private port = 0;
+    private handlers = new Map<string, RpcHandler>();
+    private portFilePath: string;
+    private portDir: string;
+    private startedAt = Date.now();
+
+    constructor(storageDir: string, directory: string) {
+        this.portFilePath = rpcPortFilePath(storageDir, directory);
+        this.portDir = rpcPortDir(storageDir, directory);
+    }
+
+    /** Register an RPC method handler. */
+    handle(method: string, handler: RpcHandler): void {
+        this.handlers.set(method, handler);
+    }
+
+    /** Start the server on a random port, write port to disk. */
+    async start(): Promise<number> {
+        return new Promise((resolve, reject) => {
+            const server = createServer((req, res) => this.dispatch(req, res));
+
+            server.on("error", (err) => {
+                log(`[rpc] server error: ${err.message}`);
+                reject(err);
+            });
+
+            server.listen(0, "127.0.0.1", () => {
+                const addr = server.address();
+                if (!addr || typeof addr === "string") {
+                    reject(new Error("Failed to get server address"));
+                    return;
+                }
+                this.port = addr.port;
+                this.server = server;
+
+                // Write a per-process port file atomically. Multi-instance
+                // OpenCode is supported: TUI discovery scans all live pid files
+                // and picks the most recent instead of cross-wiring via one
+                // shared project file.
+                try {
+                    this.warnIfOtherLiveInstance();
+                    const dir = dirname(this.portFilePath);
+                    mkdirSync(dir, { recursive: true });
+                    const tmpPath = `${this.portFilePath}.tmp`;
+                    writeFileSync(
+                        tmpPath,
+                        JSON.stringify({
+                            port: this.port,
+                            pid: process.pid,
+                            started_at: this.startedAt,
+                        }),
+                        "utf-8",
+                    );
+                    renameSync(tmpPath, this.portFilePath);
+                    log(`[rpc] server listening on 127.0.0.1:${this.port}`);
+                } catch (err) {
+                    log(`[rpc] failed to write port file: ${err}`);
+                }
+
+                resolve(this.port);
+            });
+
+            // Don't keep the process alive just for the RPC server
+            server.unref();
+        });
+    }
+
+    private warnIfOtherLiveInstance(): void {
+        try {
+            for (const entry of readdirSync(this.portDir)) {
+                if (!entry.startsWith("port-") || !entry.endsWith(".json")) continue;
+                const record = parseRpcPortFile(readFileSync(`${this.portDir}/${entry}`, "utf-8"));
+                if (!record || record.pid === process.pid || !isPidAlive(record.pid)) continue;
+                log(
+                    `[rpc] another Magic Context RPC server is active for this project (pid ${record.pid}, port ${record.port}); starting separate instance on a new port`,
+                );
+                return;
+            }
+        } catch {
+            // No discovery directory yet, or unreadable stale file. Not fatal.
+        }
+    }
+
+    /** Stop the server and clean up port file. */
+    stop(): void {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        try {
+            unlinkSync(this.portFilePath);
+        } catch {
+            // Intentional: port file may already be gone
+        }
+    }
+
+    private dispatch(req: IncomingMessage, res: ServerResponse): void {
+        const url = req.url ?? "";
+
+        // CORS headers for same-origin fetch
+        res.setHeader("Access-Control-Allow-Origin", "*");
+
+        if (req.method === "GET" && url === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true, pid: process.pid }));
+            return;
+        }
+
+        if (req.method !== "POST" || !url.startsWith("/rpc/")) {
+            res.writeHead(404);
+            res.end("Not Found");
+            return;
+        }
+
+        const method = url.slice(5); // strip "/rpc/"
+        const handler = this.handlers.get(method);
+        if (!handler) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Unknown method: ${method}` }));
+            return;
+        }
+
+        let body = "";
+        req.on("data", (chunk: Buffer) => {
+            body += chunk.toString();
+            if (body.length > 1_048_576) {
+                res.writeHead(413);
+                res.end("Request too large");
+                req.destroy();
+            }
+        });
+
+        req.on("end", () => {
+            let params: Record<string, unknown> = {};
+            try {
+                if (body.length > 0) {
+                    params = JSON.parse(body);
+                }
+            } catch {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid JSON" }));
+                return;
+            }
+
+            handler(params)
+                .then((result) => {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(result));
+                })
+                .catch((err) => {
+                    log(`[rpc] handler error: ${method} => ${err}`);
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: String(err) }));
+                });
+        });
+    }
+}

package/src/shared/rpc-types.ts

@@ -0,0 +1,104 @@
+/**
+ * Shared types for RPC between server and TUI plugins.
+ * Both sides import these — no SQLite dependency.
+ */
+
+export interface SidebarSnapshot {
+    sessionId: string;
+    usagePercentage: number;
+    inputTokens: number;
+    contextLimit: number;
+    systemPromptTokens: number;
+    compartmentCount: number;
+    factCount: number;
+    memoryCount: number;
+    memoryBlockCount: number;
+    pendingOpsCount: number;
+    historianRunning: boolean;
+    compartmentInProgress: boolean;
+    sessionNoteCount: number;
+    readySmartNoteCount: number;
+    cacheTtl: string;
+    lastDreamerRunAt: number | null;
+    projectIdentity: string | null;
+    compartmentTokens: number;
+    factTokens: number;
+    memoryTokens: number;
+    /**
+     * Token estimate of real user/assistant discussion (text + reasoning +
+     * image parts) inside messages, excluding injected <session-history>
+     * blocks. Display layer shows this as "Conversation".
+     */
+    conversationTokens: number;
+    /**
+     * Token estimate of tool call I/O inside messages (tool_use, tool_result,
+     * tool, tool-invocation parts). Actionable — users can reduce via
+     * ctx_reduce. Display layer shows this as "Tool Calls".
+     */
+    toolCallTokens: number;
+    /**
+     * Measured token cost of tool schemas (description + JSON-schema
+     * parameters) OpenCode sends in the request `tools` parameter. Populated
+     * by the `tool.definition` plugin hook, keyed by
+     * `{providerID, modelID, agentName}`. Zero until the first turn after
+     * plugin startup measures the current agent's tool set. Display layer
+     * shows this as "Tool Definitions".
+     */
+    toolDefinitionTokens: number;
+    /**
+     * Effective execute-threshold percentage for this session's active model,
+     * after per-model resolution and the tokens→percentage conversion (when
+     * `execute_threshold_tokens` applies). Surfaces in the sidebar / status
+     * dialog header alongside `usagePercentage` so users can see how close
+     * the session is to triggering compaction. Defaults to `65` when no live
+     * model is known yet — matches the runtime fallback used by the
+     * scheduler and transform paths.
+     */
+    executeThreshold: number;
+    newWorkTokens?: number | null;
+    totalInputTokens?: number | null;
+}
+
+export interface StatusDetail extends SidebarSnapshot {
+    tagCounter: number;
+    activeTags: number;
+    droppedTags: number;
+    totalTags: number;
+    activeBytes: number;
+    lastResponseTime: number;
+    lastNudgeTokens: number;
+    lastNudgeBand: string;
+    lastTransformError: string | null;
+    isSubagent: boolean;
+    pendingOps: Array<{ tagId: number; operation: string }>;
+    contextLimit: number;
+    cacheTtlMs: number;
+    cacheRemainingMs: number;
+    cacheExpired: boolean;
+    executeThreshold: number;
+    /**
+     * Which config source produced `executeThreshold`. "tokens" means
+     * execute_threshold_tokens matched for this session's model and was
+     * converted to a percentage. "percentage" means percentage config was used.
+     */
+    executeThresholdMode: "percentage" | "tokens";
+    /**
+     * When `executeThresholdMode === "tokens"`, the absolute clamped token value
+     * (≤ 80% × contextLimit) that will trigger execute. Undefined in percentage mode.
+     */
+    executeThresholdTokens?: number;
+    protectedTagCount: number;
+    nudgeInterval: number;
+    historyBudgetPercentage: number;
+    nextNudgeAfter: number;
+    historyBlockTokens: number;
+    compressionBudget: number | null;
+    compressionUsage: string | null;
+}
+
+export interface RpcNotificationMessage {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId?: string;
+}