pi-ast-sgrep 1.3.2 → 2.0.0

package/dist/codemode/runner.js

@@ -0,0 +1,242 @@
+import { Worker } from "node:worker_threads";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_CODE_CHARS = 32_000;
+const MAX_BRIDGE_CALLS = 256;
+const MAX_BRIDGE_REQUEST_CHARS = 64_000;
+const MAX_BRIDGE_RESPONSE_CHARS = 4 * 1024 * 1024;
+const MAX_ERROR_CHARS = 8_192;
+const MAX_LOG_LINES = 100;
+const MAX_LOG_CHARS = 64_000;
+const MAX_LOG_LINE_CHARS = 4_096;
+const MAX_RESULT_JSON_CHARS = 1_000_000;
+const RESULT_SERIALIZE_TIMEOUT_MS = 1_000;
+const MAX_TIMER_MS = 2_147_483_647;
+/** Strip markdown fences and normalize to an async IIFE expression. */
+export function normalizeCode(raw) {
+    let code = raw.trim();
+    if (code.startsWith("```")) {
+        code = code.replace(/^```(?:javascript|js|typescript|ts)?\s*/i, "").replace(/\s*```$/, "").trim();
+    }
+    if (/^async\s*\(/.test(code) || /^async\s+function\b/.test(code)) {
+        return `(${code.endsWith(";") ? code.slice(0, -1) : code})()`;
+    }
+    return `(async () => {\n${code}\n})()`;
+}
+/**
+ * Run model-generated JavaScript against the typed `asgrep` connector.
+ *
+ * Model-generated code is not trusted with the extension host's ambient Node
+ * authority. A dedicated worker contains CPU/microtask denial of service; its
+ * VM hides `process`, module loading, and host constructors, with a JSON bridge
+ * as the only exposed capability. This is not an OS sandbox, so deployments
+ * requiring adversarial-code isolation should still restrict the Pi process.
+ */
+export async function runCodemode(rawCode, asgrep, options = {}) {
+    const requestedTimeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = Number.isFinite(requestedTimeout)
+        ? Math.min(MAX_TIMER_MS, Math.max(1, Math.trunc(requestedTimeout)))
+        : DEFAULT_TIMEOUT_MS;
+    const wall0 = Date.now();
+    if (rawCode.length > MAX_CODE_CHARS) {
+        return resultErr(`code exceeds ${MAX_CODE_CHARS} characters`, [], rawCode.slice(0, 200), wall0, options.stats);
+    }
+    if (options.signal?.aborted) {
+        return resultErr("codemode aborted", [], rawCode.slice(0, 200), wall0, options.stats);
+    }
+    const code = normalizeCode(rawCode);
+    const runController = new AbortController();
+    const hostMethods = {
+        search: asgrep.search.bind(asgrep),
+        semantic: asgrep.semantic.bind(asgrep),
+        chain: asgrep.chain.bind(asgrep),
+        defs: asgrep.defs.bind(asgrep),
+        callers: asgrep.callers.bind(asgrep),
+        imports: asgrep.imports.bind(asgrep),
+        indexStatus: asgrep.indexStatus.bind(asgrep),
+        indexRepo: asgrep.indexRepo.bind(asgrep),
+        catalogSearch: asgrep.catalogSearch.bind(asgrep),
+        catalogDescribe: asgrep.catalogDescribe.bind(asgrep),
+    };
+    const workerUrl = new URL(import.meta.url.endsWith(".ts") ? "./sandbox-worker.ts" : "./sandbox-worker.js", import.meta.url);
+    let worker;
+    try {
+        worker = new Worker(workerUrl, {
+            workerData: {
+                code,
+                timeoutMs,
+                limits: {
+                    bridgeCalls: MAX_BRIDGE_CALLS,
+                    bridgeRequestChars: MAX_BRIDGE_REQUEST_CHARS,
+                    errorChars: MAX_ERROR_CHARS,
+                    logLines: MAX_LOG_LINES,
+                    logChars: MAX_LOG_CHARS,
+                    logLineChars: MAX_LOG_LINE_CHARS,
+                    resultJsonChars: MAX_RESULT_JSON_CHARS,
+                    serializeTimeoutMs: RESULT_SERIALIZE_TIMEOUT_MS,
+                },
+            },
+            resourceLimits: {
+                maxOldGenerationSizeMb: 64,
+                maxYoungGenerationSizeMb: 16,
+                stackSizeMb: 4,
+            },
+        });
+    }
+    catch (cause) {
+        return resultErr(cause instanceof Error ? cause.message : String(cause), [], code, wall0, options.stats);
+    }
+    return new Promise((resolve) => {
+        let active = true;
+        const receivedCallIds = new Set();
+        const finish = (outcome) => {
+            if (!active)
+                return;
+            active = false;
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            // Cancel host work that the disposable worker was awaiting or abandoned.
+            runController.abort();
+            void worker.terminate().catch(() => undefined).then(() => {
+                outcome.wallMs = Date.now() - wall0;
+                resolve(outcome);
+            });
+        };
+        const fail = (error, logs = []) => {
+            finish(resultErr(error, logs, code, wall0, options.stats));
+        };
+        const onAbort = () => fail("codemode aborted");
+        const timer = setTimeout(() => fail(`codemode timeout after ${timeoutMs}ms`), timeoutMs);
+        worker.on("message", (message) => {
+            if (!active)
+                return;
+            if (!isSandboxMessage(message)) {
+                fail("codemode worker sent an invalid message");
+                return;
+            }
+            if (message.type === "done") {
+                if (message.ok) {
+                    finish(resultOk(message.result, message.logs, code, wall0, options.stats));
+                }
+                else {
+                    fail(message.error ?? "codemode worker failed", message.logs);
+                }
+                return;
+            }
+            for (const call of message.calls) {
+                if (call.id >= MAX_BRIDGE_CALLS || receivedCallIds.has(call.id)) {
+                    fail("codemode worker exceeded its bridge call allowance");
+                    return;
+                }
+                receivedCallIds.add(call.id);
+            }
+            for (const call of message.calls)
+                void handleSandboxCall(call);
+        });
+        worker.once("error", (error) => fail(error.message));
+        worker.once("exit", (code) => {
+            if (active)
+                fail(`codemode worker exited ${code}`);
+        });
+        const handleSandboxCall = async (call) => {
+            if (!active)
+                return;
+            let payload;
+            try {
+                if (call.payload.length > MAX_BRIDGE_REQUEST_CHARS) {
+                    throw new Error(`codemode call arguments exceed ${MAX_BRIDGE_REQUEST_CHARS} characters`);
+                }
+                if (!Object.hasOwn(hostMethods, call.method)) {
+                    throw new Error(`unknown asgrep method: ${call.method}`);
+                }
+                const input = JSON.parse(call.payload);
+                const methodCall = hostMethods[call.method];
+                const value = await methodCall(input, { signal: runController.signal });
+                payload = stringifyBounded({ ok: true, value }, MAX_BRIDGE_RESPONSE_CHARS, "codemode call result");
+            }
+            catch (cause) {
+                payload = JSON.stringify({
+                    ok: false,
+                    error: safeErrorMessage(cause).slice(0, MAX_ERROR_CHARS),
+                });
+            }
+            if (active)
+                worker.postMessage({ type: "callResult", id: call.id, payload });
+        };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+    });
+}
+function isSandboxMessage(message) {
+    if (typeof message !== "object" || message === null || !("type" in message))
+        return false;
+    if (message.type === "calls") {
+        return "calls" in message
+            && Array.isArray(message.calls)
+            && message.calls.length > 0
+            && message.calls.length <= MAX_BRIDGE_CALLS
+            && message.calls.every((call) => isSandboxCall(call));
+    }
+    if (message.type !== "done"
+        || !("ok" in message)
+        || typeof message.ok !== "boolean"
+        || !("logs" in message)
+        || !Array.isArray(message.logs)
+        || message.logs.length > MAX_LOG_LINES
+        || !message.logs.every((line) => typeof line === "string" && line.length <= MAX_LOG_LINE_CHARS)
+        || message.logs.reduce((total, line) => total + line.length, 0) > MAX_LOG_CHARS) {
+        return false;
+    }
+    return !("error" in message)
+        || message.error === undefined
+        || (typeof message.error === "string" && message.error.length <= MAX_ERROR_CHARS);
+}
+function isSandboxCall(call) {
+    return typeof call === "object"
+        && call !== null
+        && "id" in call
+        && typeof call.id === "number"
+        && Number.isSafeInteger(call.id)
+        && call.id >= 0
+        && "method" in call
+        && typeof call.method === "string"
+        && "payload" in call
+        && typeof call.payload === "string";
+}
+function safeErrorMessage(cause) {
+    try {
+        return String(cause instanceof Error ? cause.message : cause);
+    }
+    catch {
+        return "codemode call failed";
+    }
+}
+function stringifyBounded(value, maxBytes, label) {
+    let remaining = maxBytes;
+    const payload = JSON.stringify(value, (key, item) => {
+        remaining -= Buffer.byteLength(key) + 8;
+        if (typeof item === "string")
+            remaining -= Buffer.byteLength(item);
+        if (remaining < 0)
+            throw new Error(`${label} exceeds ${maxBytes} bytes`);
+        return item;
+    });
+    if (payload === undefined || Buffer.byteLength(payload) > maxBytes) {
+        throw new Error(`${label} exceeds ${maxBytes} bytes`);
+    }
+    return payload;
+}
+function resultOk(result, logs, code, wall0, statsFn) {
+    const out = { ok: true, result, logs, code, wallMs: Date.now() - wall0 };
+    const stats = statsFn?.();
+    if (stats)
+        out.stats = stats;
+    return out;
+}
+function resultErr(error, logs, code, wall0, statsFn) {
+    const out = { ok: false, result: null, logs, error, code, wallMs: Date.now() - wall0 };
+    const stats = statsFn?.();
+    if (stats)
+        out.stats = stats;
+    return out;
+}

package/dist/codemode/sandbox-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codemode/sandbox-worker.js

@@ -0,0 +1,204 @@
+import vm from "node:vm";
+import { parentPort, workerData } from "node:worker_threads";
+const port = (() => {
+    if (!parentPort)
+        throw new Error("codemode sandbox requires a parent port");
+    return parentPort;
+})();
+const data = workerData;
+const pending = new Map();
+const outgoing = [];
+let nextCallId = 0;
+let flushScheduled = false;
+port.on("message", (message) => {
+    if (message.type !== "callResult")
+        return;
+    const resolve = pending.get(message.id);
+    if (!resolve)
+        return;
+    pending.delete(message.id);
+    resolve(message.payload);
+});
+const bridge = (method, payload) => new Promise((resolve) => {
+    if (nextCallId >= data.limits.bridgeCalls) {
+        resolve(JSON.stringify({
+            ok: false,
+            error: `codemode exceeds ${data.limits.bridgeCalls} host calls`,
+        }));
+        return;
+    }
+    const id = nextCallId++;
+    pending.set(id, resolve);
+    outgoing.push({ id, method, payload });
+    if (!flushScheduled) {
+        flushScheduled = true;
+        queueMicrotask(() => {
+            flushScheduled = false;
+            const calls = outgoing.splice(0);
+            if (calls.length > 0)
+                port.postMessage({ type: "calls", calls });
+        });
+    }
+});
+void run();
+async function run() {
+    const logs = [];
+    let logChars = 0;
+    const logBridge = (line) => {
+        if (logs.length >= data.limits.logLines || logChars >= data.limits.logChars)
+            return;
+        const remaining = data.limits.logChars - logChars;
+        const bounded = line.length <= remaining
+            ? line
+            : `${line.slice(0, Math.max(0, remaining - 1))}…`;
+        logs.push(bounded);
+        logChars += bounded.length;
+    };
+    Object.setPrototypeOf(bridge, null);
+    Object.setPrototypeOf(logBridge, null);
+    Object.freeze(bridge);
+    Object.freeze(logBridge);
+    try {
+        const globals = Object.create(null);
+        globals.__asgrepBridge = bridge;
+        globals.__asgrepLog = logBridge;
+        const context = vm.createContext(globals, {
+            codeGeneration: { strings: false, wasm: false },
+        });
+        new vm.Script(bootstrap(data.limits), {
+            filename: "asgrep-codemode-bootstrap.js",
+        }).runInContext(context, { timeout: Math.min(data.timeoutMs, 1_000) });
+        const script = new vm.Script(data.code, { filename: "asgrep-codemode.js" });
+        const value = await Promise.resolve(script.runInContext(context, {
+            displayErrors: true,
+            timeout: data.timeoutMs,
+        }));
+        const setResult = context.__asgrepSetResult;
+        if (typeof setResult !== "function") {
+            throw new Error("codemode result bridge is unavailable");
+        }
+        setResult(value);
+        const serialized = new vm.Script("globalThis.__asgrepSerializeResult()", {
+            filename: "asgrep-codemode-result.js",
+        }).runInContext(context, {
+            displayErrors: true,
+            timeout: Math.min(data.timeoutMs, data.limits.serializeTimeoutMs),
+        });
+        const result = serialized === undefined ? undefined : JSON.parse(serialized);
+        finish({ type: "done", ok: true, result, logs });
+    }
+    catch (cause) {
+        finish({
+            type: "done",
+            ok: false,
+            error: safeErrorMessage(cause).slice(0, data.limits.errorChars),
+            logs,
+        });
+    }
+}
+function safeErrorMessage(cause) {
+    try {
+        return String(cause instanceof Error ? cause.message : cause);
+    }
+    catch {
+        return "codemode worker failed";
+    }
+}
+function finish(message) {
+    port.postMessage(message);
+    port.close();
+}
+function bootstrap(limits) {
+    return `
+  {
+    const hostCall = globalThis.__asgrepBridge;
+    const hostLog = globalThis.__asgrepLog;
+    delete globalThis.__asgrepBridge;
+    delete globalThis.__asgrepLog;
+
+    let resultValue;
+    const setResult = (value) => { resultValue = value; };
+    const stringify = JSON.stringify;
+    const stringifyBounded = (value, maxChars, label) => {
+      let remaining = maxChars;
+      const serialized = stringify(value, (key, item) => {
+        remaining -= key.length + 8;
+        if (typeof item === "string") remaining -= item.length;
+        if (remaining < 0) throw new Error(\`codemode \${label} exceeds \${maxChars} characters\`);
+        return item;
+      });
+      if (serialized !== undefined && serialized.length > maxChars) {
+        throw new Error(\`codemode \${label} exceeds \${maxChars} characters\`);
+      }
+      return serialized;
+    };
+    const serializeResult = () => stringifyBounded(resultValue, ${limits.resultJsonChars}, "result");
+    Object.freeze(setResult);
+    Object.freeze(serializeResult);
+    Object.defineProperty(globalThis, "__asgrepSetResult", {
+      value: setResult, configurable: false, writable: false,
+    });
+    Object.defineProperty(globalThis, "__asgrepSerializeResult", {
+      value: serializeResult, configurable: false, writable: false,
+    });
+
+    // Worker heap limits do not reliably account for backing stores. Code Mode
+    // exchanges JSON, so raw-memory and WebAssembly APIs add risk without utility.
+    for (const name of [
+      "ArrayBuffer", "SharedArrayBuffer", "DataView", "Atomics", "WebAssembly",
+      "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array",
+      "Int32Array", "Uint32Array", "Float32Array", "Float64Array",
+      "BigInt64Array", "BigUint64Array",
+    ]) {
+      Object.defineProperty(globalThis, name, {
+        value: undefined, configurable: false, writable: false,
+      });
+    }
+
+    const invoke = async (method, args = {}) => {
+      const payload = stringifyBounded(args, ${limits.bridgeRequestChars}, "call arguments");
+      const response = JSON.parse(await hostCall(method, payload));
+      if (!response.ok) throw new Error(response.error || \`asgrep.\${method} failed\`);
+      return response.value;
+    };
+    const api = Object.create(null);
+    for (const method of [
+      "search", "semantic", "chain", "defs", "callers", "imports",
+      "indexStatus", "indexRepo", "catalogSearch", "catalogDescribe",
+    ]) {
+      Object.defineProperty(api, method, {
+        enumerable: true,
+        value: (args = {}) => invoke(method, args),
+      });
+    }
+    Object.freeze(api);
+
+    const formatLog = (value) => {
+      if (typeof value === "string") return value.slice(0, ${limits.logLineChars});
+      try { return stringifyBounded(value, ${limits.logLineChars}, "log line"); }
+      catch { return "[unserializable or oversized log value]"; }
+    };
+    const consoleApi = Object.create(null);
+    for (const level of ["log", "info", "warn", "error", "debug"]) {
+      Object.defineProperty(consoleApi, level, {
+        enumerable: true,
+        value: (...args) => {
+          let line = "";
+          for (const arg of args) {
+            const part = formatLog(arg);
+            const prefix = line.length === 0 ? "" : " ";
+            const remaining = ${limits.logLineChars} - line.length;
+            if (remaining <= 0) break;
+            line += (prefix + part).slice(0, remaining);
+          }
+          hostLog(line);
+        },
+      });
+    }
+    Object.freeze(consoleApi);
+
+    Object.defineProperty(globalThis, "asgrep", { value: api, configurable: false, writable: false });
+    Object.defineProperty(globalThis, "console", { value: consoleApi, configurable: false, writable: false });
+  }
+  `;
+}

package/dist/codemode/session-pool.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session-scoped native Code Mode sessions.
+ *
+ * Primary path: in-process NAPI (`CodeModeSession` inside Node) — same model as
+ * MCP linking core. Zero CLI spawn.
+ *
+ * Fallback: sticky `codemode-serve` child only when the `.node` addon is missing
+ * (unsupported host / incomplete install). Doctor reports that as degraded.
+ */
+import type { MachineEnvelope } from "../runtime.js";
+import { type StickyWorker } from "./dispatch.js";
+import { type StickyWorkerOptions } from "./worker.js";
+export type SessionPoolOptions = {
+    /** Required only for CLI sticky fallback. */
+    binary?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    root?: string;
+    indexPath?: string;
+    useEmbed?: boolean;
+    limit?: number;
+};
+export type StickyStarter = (options: StickyWorkerOptions) => Promise<StickyWorker>;
+export declare class NativeSessionPool {
+    #private;
+    constructor(startFn?: StickyStarter);
+    configure(options: SessionPoolOptions): void;
+    configured(): boolean;
+    /** Active backend after first successful acquire. */
+    backend(): "napi" | "cli" | "none";
+    acquire(root: string): Promise<StickyWorker | null>;
+    call(root: string, tool: string, args?: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<MachineEnvelope>;
+    invalidate(root: string): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/** Singleton for advanced hosts; tools registration uses a local pool. */
+export declare const sharedNativePool: NativeSessionPool;