@cortexkit/opencode-magic-context 0.21.8 → 0.22.1

package/src/shared/rpc-server.ts

@@ -1,3 +1,4 @@
+import { randomBytes } from "node:crypto";
 import {
     mkdirSync,
     readdirSync,
@@ -20,6 +21,11 @@ export class MagicContextRpcServer {
     private portFilePath: string;
     private portDir: string;
     private startedAt = Date.now();
+    // Unguessable per-process bearer token, published in the (user-private) port
+    // file and required on every non-health RPC call. Defends side-effecting
+    // endpoints (recomp/upgrade/dismiss) against any local process or
+    // browser-origin script that merely discovers/guesses the port.
+    private readonly token = randomBytes(32).toString("hex");
 
     constructor(storageDir: string, directory: string) {
         this.portFilePath = rpcPortFilePath(storageDir, directory);
@@ -57,7 +63,15 @@ export class MagicContextRpcServer {
                 try {
                     this.warnIfOtherLiveInstance();
                     const dir = dirname(this.portFilePath);
-                    mkdirSync(dir, { recursive: true });
+                    // The port file holds the per-process bearer token that
+                    // gates side-effecting RPC endpoints (recomp/upgrade/
+                    // dismiss). Under the default umask 0o022 a plain write
+                    // lands at 0o644 in a 0o755 dir — world-readable, so any
+                    // local UID could read the token and drive those endpoints,
+                    // defeating the auth defense. Restrict both: dir 0o700,
+                    // file 0o600. renameSync preserves the tmp file's mode, so
+                    // the 0o600 on the write covers the final file.
+                    mkdirSync(dir, { recursive: true, mode: 0o700 });
                     const tmpPath = `${this.portFilePath}.tmp`;
                     writeFileSync(
                         tmpPath,
@@ -65,8 +79,9 @@ export class MagicContextRpcServer {
                             port: this.port,
                             pid: process.pid,
                             started_at: this.startedAt,
+                            token: this.token,
                         }),
-                        "utf-8",
+                        { encoding: "utf-8", mode: 0o600 },
                     );
                     renameSync(tmpPath, this.portFilePath);
                     log(`[rpc] server listening on 127.0.0.1:${this.port}`);
@@ -114,8 +129,10 @@ export class MagicContextRpcServer {
     private dispatch(req: IncomingMessage, res: ServerResponse): void {
         const url = req.url ?? "";
 
-        // CORS headers for same-origin fetch
-        res.setHeader("Access-Control-Allow-Origin", "*");
+        // No wildcard CORS: the only legitimate client is the in-process TUI
+        // client, which is not a browser origin. Omitting
+        // Access-Control-Allow-Origin makes browsers refuse to read responses,
+        // closing the CSRF-style read path a malicious local page could use.
 
         if (req.method === "GET" && url === "/health") {
             res.writeHead(200, { "Content-Type": "application/json" });
@@ -129,6 +146,18 @@ export class MagicContextRpcServer {
             return;
         }
 
+        // Require the per-process bearer token on every side-effecting call.
+        // The legitimate TUI client reads it from the same port file it used to
+        // discover the port; a process that only guessed the port cannot.
+        const auth = req.headers.authorization;
+        const presented = typeof auth === "string" ? auth.replace(/^Bearer\s+/i, "") : "";
+        if (presented !== this.token) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Unauthorized" }));
+            req.resume();
+            return;
+        }
+
         const method = url.slice(5); // strip "/rpc/"
         const handler = this.handlers.get(method);
         if (!handler) {

package/src/shared/rpc-types.ts

@@ -24,10 +24,23 @@ export interface SidebarSnapshot {
     compartmentTokens: number;
     factTokens: number;
     memoryTokens: number;
+    /**
+     * Token estimate of the injected <project-docs> block (root ARCHITECTURE.md
+     * + STRUCTURE.md) that lives in m[0] in v2. Part of the message stream, not
+     * conversation. Display layer shows this as "Docs".
+     */
+    docsTokens: number;
+    /**
+     * Token estimate of the injected <user-profile> block (promoted user
+     * memories) that lives in m[0] in v2. Part of the message stream, not
+     * conversation. Display layer shows this as "Profile".
+     */
+    profileTokens: 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".
+     * image parts) inside messages, excluding injected <session-history>,
+     * <project-docs>, and <user-profile> blocks. Display layer shows this as
+     * "Conversation".
      */
     conversationTokens: number;
     /**
@@ -57,6 +70,21 @@ export interface SidebarSnapshot {
     executeThreshold: number;
     newWorkTokens?: number | null;
     totalInputTokens?: number | null;
+    /**
+     * Live recomp / session-upgrade progress for this session, or null when no
+     * recomp is running (and no recent terminal state is being shown). Drives the
+     * sidebar "Recomp"/"Upgrade" progress bar and the /ctx-status dialog. Mirrors
+     * the runtime `RecompProgress` shape from compartment-runner-types.ts.
+     */
+    recompProgress?: {
+        phase: "recomp" | "migration" | "done" | "failed";
+        processedMessages: number;
+        totalMessages: number;
+        passCount: number;
+        compartmentsCreated: number;
+        message?: string;
+        note?: string;
+    } | null;
 }
 
 export interface StatusDetail extends SidebarSnapshot {

package/src/shared/rpc-utils.ts

@@ -5,6 +5,15 @@ export interface RpcPortFileRecord {
     port: number;
     pid: number;
     started_at: number;
+    /**
+     * Per-process bearer token. The server requires it on all non-health RPC
+     * calls so a random local process or browser-origin script that merely
+     * discovers/guesses the port cannot drive side-effecting endpoints
+     * (recomp/upgrade/dismiss). Optional in the type for forward/backward
+     * compatibility with port files written by older builds (treated as "no
+     * auth required" only when the server itself didn't set one).
+     */
+    token?: string;
 }
 
 /**
@@ -56,6 +65,7 @@ export function parseRpcPortFile(content: string, fallbackPid = 0): RpcPortFileR
                 port,
                 pid,
                 started_at: Number.isFinite(startedAt) ? startedAt : 0,
+                token: typeof parsed.token === "string" ? parsed.token : undefined,
             };
         } catch {
             return null;

package/src/shared/sqlite-helpers.ts

@@ -1,6 +1,6 @@
 /**
- * Cross-runtime helpers that smooth over the small bun:sqlite ↔ better-sqlite3
- * API differences without leaking either library into call sites.
+ * Cross-runtime helpers that smooth over the small bun:sqlite ↔ node:sqlite
+ * API differences without leaking either backend into call sites.
  */
 
 import type { Database } from "./sqlite";
@@ -8,17 +8,17 @@ import type { Database } from "./sqlite";
 /**
  * Close a database, ignoring errors.
  *
- * bun:sqlite supports `db.close(throwOnError = false)`. better-sqlite3 has
- * only `db.close()` and throws on already-closed databases. This helper
- * mirrors the bun "swallow errors" semantics for both runtimes — useful in
- * test teardown and `finally` blocks where the caller doesn't care whether
- * the close succeeded.
+ * bun:sqlite supports `db.close(throwOnError = false)`. node:sqlite has only
+ * `db.close()` and throws ("database is not open") on an already-closed
+ * handle. This helper mirrors the bun "swallow errors" semantics for both
+ * runtimes — useful in test teardown and `finally` blocks where the caller
+ * doesn't care whether the close succeeded.
  */
 export function closeQuietly(db: Database | null | undefined): void {
     if (!db) return;
     // Just attempt close and swallow errors. bun:sqlite has no `open` property,
-    // and better-sqlite3 throws TypeError on already-closed databases — both
-    // are handled by the bare try/catch.
+    // and node:sqlite throws on an already-closed handle — both are handled by
+    // the bare try/catch.
     try {
         db.close();
     } catch {

package/src/shared/sqlite.ts

@@ -3,33 +3,42 @@
  *
  * The same shipped plugin artifact must run under two different runtimes:
  *   - Bun (current OpenCode releases) → uses `bun:sqlite` (built-in, fast)
- *   - Node (OpenCode beta + future Pi plugin) → uses `better-sqlite3`
+ *   - Node / Electron (Pi plugin, OpenCode Desktop) → uses `node:sqlite`
+ *     (`DatabaseSync`, built into Node 22.5+ / Electron 41+, stable-enough and
+ *     flag-free since Node 22.13/23.4).
  *
- * Bun cannot load `better-sqlite3` (oven-sh/bun#4290), and Node has no
- * `bun:sqlite` module. Static imports of either would crash at parse time
- * in the wrong runtime, so we use dynamic imports gated by runtime detection.
+ * Bun has no `node:sqlite`, and Node/Electron have no `bun:sqlite`. Static
+ * imports of either would crash at parse time in the wrong runtime, so we use
+ * dynamic imports gated by runtime detection.
  *
- * The Function-constructor wrapper around `import()` defeats bundler static
- * analysis — without it, esbuild/bun build would try to resolve both modules
- * during the bundle step, including the one that doesn't exist in the build
- * runtime.
+ * Why `node:sqlite` instead of `better-sqlite3`: better-sqlite3 is a native
+ * module requiring per-ABI prebuilds, and Electron's ABI never matches the npm
+ * Node prebuild — which forced a runtime download of an Electron-matched
+ * `.node` binary (a supply-chain + maintenance liability). `node:sqlite` is
+ * built into the runtime, so there is NOTHING to download or rebuild. Both Pi
+ * (plain Node 24) and OpenCode Desktop (Electron 41 → Node 24.14.1) ship it.
  *
- * Both libraries expose ~95% API parity:
- *   - new Database(path, { readonly?: boolean })
+ * API surface we use (common across both backends, modulo the shims below):
+ *   - new Database(path, { readonly?: boolean })   ← we map readonly→readOnly
  *   - db.prepare(sql).run/get/all
  *   - db.exec(multistatement)
- *   - db.transaction(fn) → wrapped function
+ *   - db.transaction(fn) → wrapped function        ← shimmed for node:sqlite
  *   - db.close()
  *
- * The 5% that differs (db.query, db.run, db.close(boolean), Database.open)
- * is either rewritten to common-subset patterns or hidden behind the helpers
- * in `./sqlite-helpers.ts`.
+ * The two backend differences we bridge for node:sqlite:
+ *   1. node:sqlite has no `db.transaction(fn)` helper — we add a savepoint-aware
+ *      shim (below) that matches better-sqlite3/bun semantics.
+ *   2. node:sqlite's constructor option is `readOnly` (camel-case), not
+ *      better-sqlite3/bun's `readonly` — we translate it so call sites are
+ *      unchanged.
+ * Everything else (named params with bare keys, ATTACH under defensive mode,
+ * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
 
-// Type import only — better-sqlite3's runtime is loaded dynamically below.
-// @types/better-sqlite3 has richer definitions than @types/bun's bun:sqlite
-// types, and bun:sqlite is a structural superset for the API surface we use,
-// so calls typed against BetterSqlite3 work under both runtimes at runtime.
+// Type import only — runtime is loaded dynamically below. @types/better-sqlite3
+// has the richest definitions and is a structural superset of the API surface
+// we use, so calls typed against BetterSqlite3 work under bun:sqlite and
+// node:sqlite at runtime (both expose prepare/run/get/all/exec/close).
 import type BetterSqlite3 from "better-sqlite3";
 
 // Detect Bun via process.versions.bun. Both globalThis.Bun and
@@ -41,80 +50,90 @@ const isBun = typeof process !== "undefined" && typeof process.versions?.bun ===
 
 // IMPORTANT: bundler-evading dynamic imports.
 //
-// We can't write `await import("better-sqlite3")` directly because esbuild/bun
+// We can't write `await import("node:sqlite")` directly because esbuild/bun
 // would try to resolve both modules at build time, and one of them won't exist
-// in the build runtime (bun:sqlite is missing in Node, better-sqlite3 isn't
-// shipped in Bun-only environments). Earlier versions used
-// `new Function("p", "return import(p)")("modname")` to defeat static
-// analysis, but that breaks Pi's vm-based extension loader: a Function
-// constructed at runtime has no module record, so `import()` inside it has
-// no referrer module and Node throws "A dynamic import callback was not
+// in the build runtime (bun:sqlite is missing in Node, node:sqlite is missing
+// in Bun). Earlier versions used `new Function("p", "return import(p)")(...)`
+// to defeat static analysis, but that breaks Pi's vm-based extension loader: a
+// Function constructed at runtime has no module record, so `import()` inside it
+// has no referrer module and Node throws "A dynamic import callback was not
 // specified".
 //
 // The /* @vite-ignore */ + variable indirection pattern hides the specifier
 // from static analyzers while keeping a real referrer module for the
 // dynamic import — Pi's loader, esbuild, and bun build all accept it.
 const bunSpec = "bun:" + "sqlite";
-const betterSpec = "better-" + "sqlite3";
-
-// Under Electron, the npm-installed better-sqlite3 binary has the wrong ABI
-// (it's a Node prebuild but Electron embeds a different NODE_MODULE_VERSION).
-// resolveBetterSqliteNativeBinding() detects this and downloads + caches the
-// matching Electron prebuild, then returns its absolute path so we can pass
-// it to better-sqlite3 via the `nativeBinding` constructor option (a
-// documented public API). Returns null outside Electron OR when the on-disk
-// binary already matches the runtime ABI — in those cases the default
-// bindings() lookup just works.
-const electronNativeBinding = isBun
-    ? null
-    : await (async () => {
-          const mod = await import("./native-binding");
-          return mod.resolveBetterSqliteNativeBinding();
-      })();
+const nodeSpec = "node:" + "sqlite";
 
 const sqliteModule = isBun
     ? await import(/* @vite-ignore */ bunSpec)
-    : await import(/* @vite-ignore */ betterSpec);
+    : await import(/* @vite-ignore */ nodeSpec);
 
-// Different export shapes between the two libraries:
-//   - bun:sqlite     → named export `Database`
-//   - better-sqlite3 → default export
-const RawDatabaseImpl = isBun ? sqliteModule.Database : sqliteModule.default;
+// Different export shapes between the two backends:
+//   - bun:sqlite  → named export `Database` (has its own .transaction, accepts
+//     `{ readonly }`) — usable as-is.
+//   - node:sqlite → named export `DatabaseSync` (no .transaction, option is
+//     `readOnly`) — wrapped below.
+const DatabaseImpl: typeof BetterSqlite3 = isBun
+    ? (sqliteModule.Database as typeof BetterSqlite3)
+    : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
 
-// When we resolved a non-default Electron-compatible native binding above,
-// transparently inject it into every `new Database(...)` call. This is the
-// public `nativeBinding` constructor option that better-sqlite3 ships
-// specifically for cross-runtime extension scenarios — it makes
-// better-sqlite3 `require()` the binary at the supplied path directly,
-// bypassing the default bindings() resolver.
-//
-// Subclassing keeps the call sites untouched: existing
-// `new Database(filename, { readonly: true })` invocations work as-is.
-// Callers can still override `nativeBinding` explicitly if they need to.
-//
-// The TypeScript type intentionally references @types/better-sqlite3 because
-// its definitions are richer than @types/bun's bun:sqlite types and bun:sqlite
-// is a structural superset for the API surface we use. Calls written against
-// this type work correctly under both runtimes at runtime.
-//
-// @types/better-sqlite3 uses `export = Database` (CommonJS interop), which
-// surfaces in TypeScript as `import Database = require("better-sqlite3")`.
-// We capture the DatabaseConstructor type from the namespace re-export.
-const DatabaseImpl: typeof BetterSqlite3 =
-    electronNativeBinding == null
-        ? (RawDatabaseImpl as typeof BetterSqlite3)
-        : (class DatabaseWithElectronBinding extends (RawDatabaseImpl as typeof BetterSqlite3) {
-              constructor(filename?: string | Buffer, options?: BetterSqlite3.Options) {
-                  // Type narrowing: the surrounding ternary already proved
-                  // electronNativeBinding is non-null in this branch, but
-                  // TypeScript can't follow that across the class boundary.
-                  const fallback = electronNativeBinding as string;
-                  super(filename, {
-                      ...options,
-                      nativeBinding: options?.nativeBinding ?? fallback,
-                  });
-              }
-          } as typeof BetterSqlite3);
+/**
+ * Wrap node:sqlite's `DatabaseSync` so it presents the better-sqlite3/bun
+ * surface the rest of the codebase calls:
+ *   - translate the `{ readonly }` constructor option → node:sqlite's `readOnly`
+ *   - add a `transaction(fn)` helper that matches better-sqlite3 semantics,
+ *     using `db.isTransaction` to pick BEGIN (top-level) vs SAVEPOINT (nested),
+ *     so it composes correctly with manual `BEGIN IMMEDIATE` blocks too.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: node:sqlite has no shipped types here; the public export is cast to the better-sqlite3 shape.
+function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
+    // Single constant savepoint name is correct for arbitrary nesting depth:
+    // SQLite savepoints with the same name stack LIFO — RELEASE / ROLLBACK TO
+    // always target the most recent. node:sqlite is synchronous + single-process
+    // per connection, so there is no concurrent-savepoint hazard.
+    const SAVEPOINT = "mc_tx_sp";
+
+    class NodeSqliteDatabase extends DatabaseSync {
+        constructor(filename?: string | Buffer, options?: BetterSqlite3.Options) {
+            const translated: Record<string, unknown> = { ...options };
+            if (options && "readonly" in options) {
+                translated.readOnly = (options as { readonly?: boolean }).readonly;
+                delete translated.readonly;
+            }
+            super(typeof filename === "string" ? filename : ":memory:", translated);
+        }
+
+        // biome-ignore lint/suspicious/noExplicitAny: mirrors better-sqlite3's generic transaction(fn) signature.
+        transaction<F extends (...args: any[]) => any>(fn: F): F {
+            // biome-ignore lint/suspicious/noExplicitAny: faithful pass-through of this/args to fn.
+            const self = this as any;
+            const wrapped = function (this: unknown, ...args: unknown[]): unknown {
+                const nested = self.isTransaction === true;
+                self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : "BEGIN");
+                try {
+                    const result = fn.apply(this, args);
+                    self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
+                    return result;
+                } catch (error) {
+                    if (nested) {
+                        // ROLLBACK TO unwinds the savepoint's changes but leaves
+                        // it on the stack; RELEASE then pops it (better-sqlite3
+                        // does both).
+                        self.exec(`ROLLBACK TO ${SAVEPOINT}`);
+                        self.exec(`RELEASE ${SAVEPOINT}`);
+                    } else {
+                        self.exec("ROLLBACK");
+                    }
+                    throw error;
+                }
+            };
+            return wrapped as unknown as F;
+        }
+    }
+
+    return NodeSqliteDatabase as unknown as typeof BetterSqlite3;
+}
 
 export const Database: typeof BetterSqlite3 = DatabaseImpl;