codelocal 1.5.0-beta.2 → 1.5.0-beta.4

package/dist/client-v2.js

@@ -1,4 +1,5 @@
-import { promises as fs } from "node:fs";
+import { createReadStream, promises as fs } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
 import path from "node:path";
 import os from "node:os";
 import { spawn } from "node:child_process";
@@ -21,6 +22,7 @@ import { EditingEngine } from "./editing-engine.js";
 import { VerificationEngine } from "./verification.js";
 import { defaultDeviceIdentity, loadLocalCredential } from "./identity.js";
 import { McpHub } from "./mcp-hub.js";
+import { VERSION } from "./version.js";
 const SERVER_URL = process.env.SERVER_URL;
 const PROJECT_ROOT = process.env.PROJECT_ROOT;
 const LEGACY_DEVICE_TOKEN = process.env.DEVICE_TOKEN;
@@ -32,6 +34,8 @@ const MAX_READ_BYTES = Number(process.env.CODELOCAL_MAX_READ_BYTES ?? 2 * 1024 *
 const MAX_BATCH_BYTES = Number(process.env.CODELOCAL_MAX_BATCH_BYTES ?? 8 * 1024 * 1024);
 const MAX_LIST_ENTRIES = Number(process.env.CODELOCAL_MAX_LIST_ENTRIES ?? 10000);
 const MAX_OUTPUT_BYTES = Number(process.env.CODELOCAL_MAX_OUTPUT_BYTES ?? 2 * 1024 * 1024);
+const WORKSPACE_IDLE_MS = Math.max(60_000, Number(process.env.CODELOCAL_WORKSPACE_IDLE_MS ?? 20 * 60_000) || 20 * 60_000);
+const DAEMON_CHILD = process.env.CODELOCAL_DAEMON_CHILD === "1";
 if (!SERVER_URL || !PROJECT_ROOT) {
     console.error("Required: SERVER_URL and PROJECT_ROOT. Pairing credential or DEVICE_TOKEN is also required for registration.");
     process.exit(1);
@@ -53,10 +57,8 @@ const approvalMemory = new ApprovalMemory();
 const chatApproval = new ChatApprovalBroker();
 const terminalHistory = new TerminalHistory();
 const journal = new IdempotencyJournal();
-let mcpConnectAuthorized = false;
 const mcpHub = new McpHub(root, async () => {
-    if (!mcpConnectAuthorized)
-        throw new Error("Starting an installed MCP runtime requires approval in ChatGPT. Call mcp_call and approve it there.");
+    throw new Error("Starting an installed MCP runtime requires approval in ChatGPT. Call mcp_call and approve it there.");
 });
 const processManager = new ProcessManager(root, WORKSPACE_KEY, (_record, stream, text) => {
     if (MIRROR_PROCESS_OUTPUT)
@@ -72,6 +74,9 @@ let ignoreMatcher = ignore();
 let metadataEpoch = 0;
 let reconnectDelay = 1000;
 let activeSocket = null;
+let lastToolActivityAt = Date.now();
+let shuttingDown = false;
+let idleTimer = null;
 function isInsideRoot(candidate) {
     return candidate === root || candidate.startsWith(rootPrefix);
 }
@@ -138,28 +143,70 @@ function isIgnored(relativePath) {
 function hashBuffer(buf) {
     return createHash("sha256").update(buf).digest("hex");
 }
+function bufferLooksBinary(buf) {
+    const limit = Math.min(buf.length, 8192);
+    for (let i = 0; i < limit; i++)
+        if (buf[i] === 0)
+            return true;
+    return false;
+}
 async function isBinary(file) {
     const handle = await fs.open(file, "r");
     try {
         const buf = Buffer.alloc(8192);
         const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
-        for (let i = 0; i < bytesRead; i++)
-            if (buf[i] === 0)
-                return true;
-        return false;
+        return bufferLooksBinary(buf.subarray(0, bytesRead));
     }
     finally {
         await handle.close();
     }
 }
-async function fileMeta(file) {
-    const stat = await fs.stat(file);
+async function fileMeta(file, options = {}) {
+    const stat = options.stat ?? await fs.stat(file);
     const relative = rel(file);
     if (isSensitivePath(relative))
         throw new Error(`Access blocked by sensitive-path policy: ${relative}`);
-    const hash = stat.isFile() && stat.size <= MAX_READ_BYTES * 4 ? hashBuffer(await fs.readFile(file)) : null;
+    const hash = options.hash !== undefined
+        ? options.hash
+        : stat.isFile() && stat.size <= MAX_READ_BYTES * 4
+            ? hashBuffer(options.buffer ?? await fs.readFile(file))
+            : null;
     return { path: relative, size: stat.size, mtimeMs: stat.mtimeMs, hash, ignored: isIgnored(relative), isFile: stat.isFile(), isDirectory: stat.isDirectory() };
 }
+async function streamTextRange(file, stat, startLine, endLine) {
+    const from = Math.max(1, startLine);
+    const requestedTo = endLine == null ? Number.POSITIVE_INFINITY : Math.max(0, endLine);
+    const selected = [];
+    const decoder = new StringDecoder("utf8");
+    const digest = stat.size <= MAX_READ_BYTES * 4 ? createHash("sha256") : null;
+    let carry = "";
+    let line = 0;
+    const consume = (text) => {
+        const parts = `${carry}${text}`.split(/\r?\n/);
+        carry = parts.pop() ?? "";
+        for (const value of parts) {
+            line++;
+            if (line >= from && line <= requestedTo)
+                selected.push(value);
+        }
+    };
+    const stream = createReadStream(file);
+    for await (const raw of stream) {
+        const chunk = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        digest?.update(chunk);
+        consume(decoder.write(chunk));
+    }
+    const tail = `${carry}${decoder.end()}`;
+    carry = "";
+    const finalParts = tail.split(/\r?\n/);
+    for (const value of finalParts) {
+        line++;
+        if (line >= from && line <= requestedTo)
+            selected.push(value);
+    }
+    const to = Math.min(line, Number.isFinite(requestedTo) ? requestedTo : line);
+    return { from, to, totalLines: line, content: selected.join("\n"), hash: digest?.digest("hex") ?? null };
+}
 async function readOne(requestedPath, startLine, endLine) {
     const file = await safeExistingPath(requestedPath);
     const stat = await fs.stat(file);
@@ -167,13 +214,20 @@ async function readOne(requestedPath, startLine, endLine) {
         throw new Error(`${requestedPath}: not a file.`);
     if (stat.size > MAX_READ_BYTES && startLine == null)
         throw new Error(`${requestedPath}: exceeds read limit; use read_file_range.`);
+    if (stat.size <= MAX_READ_BYTES) {
+        const buffer = await fs.readFile(file);
+        if (bufferLooksBinary(buffer))
+            return { ...(await fileMeta(file, { stat, buffer })), binary: true, content: null };
+        const text = buffer.toString("utf8");
+        const lines = text.split(/\r?\n/);
+        const from = Math.max(1, startLine ?? 1);
+        const to = Math.min(lines.length, endLine ?? lines.length);
+        return { ...(await fileMeta(file, { stat, buffer })), binary: false, startLine: from, endLine: to, totalLines: lines.length, content: lines.slice(from - 1, to).join("\n") };
+    }
     if (await isBinary(file))
-        return { ...(await fileMeta(file)), binary: true, content: null };
-    const text = await fs.readFile(file, "utf8");
-    const lines = text.split(/\r?\n/);
-    const from = Math.max(1, startLine ?? 1);
-    const to = Math.min(lines.length, endLine ?? lines.length);
-    return { ...(await fileMeta(file)), binary: false, startLine: from, endLine: to, totalLines: lines.length, content: lines.slice(from - 1, to).join("\n") };
+        return { ...(await fileMeta(file, { stat, hash: null })), binary: true, content: null };
+    const ranged = await streamTextRange(file, stat, Math.max(1, startLine ?? 1), endLine);
+    return { ...(await fileMeta(file, { stat, hash: ranged.hash })), binary: false, startLine: ranged.from, endLine: ranged.to, totalLines: ranged.totalLines, content: ranged.content };
 }
 async function listFiles(startRelative = ".", maxDepth = 4, includeIgnored = false) {
     const start = await safeExistingPath(startRelative);
@@ -454,8 +508,8 @@ async function gitWrite(operation, detail, args, requestId, approvalToken) {
     return { exitCode: result.exitCode, output: result.stdout + result.stderr };
 }
 async function callInstalledMcp(server, tool, args, requestId, approvalToken) {
-    const info = await mcpHub.toolInfo(server, tool);
-    const readOnlyHint = info.annotations?.readOnlyHint === true;
+    const cachedInfo = await mcpHub.cachedToolInfo(server, tool);
+    const readOnlyHint = cachedInfo?.annotations?.readOnlyHint === true;
     const rule = `mcp:${server}:${tool}`;
     const decision = {
         riskLevel: "REVIEW",
@@ -478,9 +532,8 @@ async function callInstalledMcp(server, tool, args, requestId, approvalToken) {
     }
     await audit({ event: "mcp.chat_approved", requestId, workspaceKey: WORKSPACE_KEY, riskLevel: decision.riskLevel, status: "approved", detail: { server, tool, rule } });
     const startedAt = Date.now();
-    mcpConnectAuthorized = true;
     try {
-        const result = await mcpHub.callTool(server, tool, args);
+        const result = await mcpHub.callTool(server, tool, args, { authorizeConnect: true });
         await audit({ event: "mcp.call", requestId, workspaceKey: WORKSPACE_KEY, tool: `${server}.${tool}`, status: "ok", detail: { durationMs: Date.now() - startedAt } });
         return result;
     }
@@ -488,9 +541,6 @@ async function callInstalledMcp(server, tool, args, requestId, approvalToken) {
         await audit({ event: "mcp.call", requestId, workspaceKey: WORKSPACE_KEY, tool: `${server}.${tool}`, status: "failed", detail: { durationMs: Date.now() - startedAt, error: error instanceof Error ? error.message : String(error) } });
         throw error;
     }
-    finally {
-        mcpConnectAuthorized = false;
-    }
 }
 async function handleTool(tool, args, request) {
     if (tool === "project_info") {
@@ -773,12 +823,24 @@ const watcher = chokidar.watch(root, {
 watcher.on("all", (event, changed) => {
     const relative = rel(changed);
     semantic.invalidate();
-    context.invalidate();
+    context.noteChange(relative);
     metadataEpoch++;
     if (relative === ".gitignore")
         void reloadIgnore();
     log("debug", "workspace.changed", { event, path: relative, metadataEpoch });
 });
+if (DAEMON_CHILD) {
+    const sweepMs = Math.min(60_000, Math.max(10_000, Math.floor(WORKSPACE_IDLE_MS / 4)));
+    idleTimer = setInterval(() => {
+        if (shuttingDown || Date.now() - lastToolActivityAt < WORKSPACE_IDLE_MS)
+            return;
+        if (processManager.list().some((record) => record.status === "running"))
+            return;
+        log("info", "workspace.idle_sleep", { workspaceId: WORKSPACE_ID, idleMs: Date.now() - lastToolActivityAt });
+        void shutdown().finally(() => process.exit(0));
+    }, sweepMs);
+    idleTimer.unref?.();
+}
 async function clientCapabilities() {
     const semanticInfo = await semantic.info();
     let pty = false;
@@ -837,6 +899,7 @@ async function connect() {
         ws.send(JSON.stringify({
             type: "register",
             protocolVersion: PROTOCOL_VERSION,
+            clientVersion: VERSION,
             token: localCredential ? undefined : LEGACY_DEVICE_TOKEN,
             credentialId: localCredential?.credentialId,
             credentialSecret: localCredential?.credentialSecret,
@@ -873,6 +936,7 @@ async function connect() {
         }
         if (message.type !== "tool_call")
             return;
+        lastToolActivityAt = Date.now();
         const requestId = String(message.requestId ?? message.id ?? "");
         const startedAt = Date.now();
         const trace = {
@@ -897,20 +961,31 @@ async function connect() {
         }
     });
     ws.on("close", (code, reason) => {
-        log("warn", "client.disconnected", { code, reason: reason.toString(), reconnectInMs: reconnectDelay });
+        log("warn", "client.disconnected", { code, reason: reason.toString(), reconnectInMs: shuttingDown ? null : reconnectDelay });
         if (activeSocket === ws)
             activeSocket = null;
+        if (shuttingDown)
+            return;
         const jitter = Math.floor(Math.random() * Math.min(1000, reconnectDelay / 2));
-        setTimeout(() => void connect(), reconnectDelay + jitter);
+        setTimeout(() => { if (!shuttingDown)
+            void connect(); }, reconnectDelay + jitter);
         reconnectDelay = Math.min(reconnectDelay * 2, 30_000);
     });
     ws.on("error", (error) => log("error", "client.socket_error", { error }));
 }
 async function shutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    if (idleTimer) {
+        clearInterval(idleTimer);
+        idleTimer = null;
+    }
+    processManager.stopAll();
     await Promise.allSettled([semantic.shutdown(), mcpHub.shutdown(), watcher.close()]);
     activeSocket?.close();
 }
 process.on("SIGINT", async () => { await shutdown(); process.exit(0); });
 process.on("SIGTERM", async () => { await shutdown(); process.exit(0); });
-log("info", "client.started", { version: "1.5.0-beta.2", protocolVersion: PROTOCOL_VERSION, deviceId: DEVICE_ID, workspaceId: WORKSPACE_ID, projectRoot: root, shell: ALLOW_SHELL, approvalMode: APPROVAL_MODE, terminalApproval: "chat-mediated", networkPolicy: NETWORK_POLICY, hostname: os.hostname() });
+log("info", "client.started", { version: VERSION, protocolVersion: PROTOCOL_VERSION, deviceId: DEVICE_ID, workspaceId: WORKSPACE_ID, projectRoot: root, shell: ALLOW_SHELL, approvalMode: APPROVAL_MODE, terminalApproval: "chat-mediated", networkPolicy: NETWORK_POLICY, hostname: os.hostname() });
 void connect();

package/dist/mcp-hub.js

@@ -5,11 +5,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { audit } from "./audit.js";
 const REGISTRY_VERSION = 1;
 const CATALOG_VERSION = 1;
 const MAX_CATALOG_TOOLS = Number(process.env.CODELOCAL_MCP_MAX_TOOLS ?? 5000);
 const MAX_STDERR_TAIL = 16 * 1024;
+const MCP_SESSION_IDLE_MS = Math.max(60_000, Number(process.env.CODELOCAL_MCP_SESSION_IDLE_MS ?? 10 * 60_000) || 10 * 60_000);
 const NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
 function normalizeRoot(value) {
     return path.resolve(value);
@@ -196,29 +196,24 @@ function safeConnectDetail(config) {
         return `http ${config.name}`;
     }
 }
-function defaultRuntimeConnectGuard(workspaceRoot) {
-    if (!process.env.SERVER_URL || !process.env.PROJECT_ROOT || process.env.CODELOCAL_MCP_START_APPROVAL === "0")
-        return undefined;
-    return async (config) => {
-        await audit({
-            event: "policy.mcp_runtime_start_blocked",
-            workspaceKey: workspaceRoot,
-            riskLevel: "REVIEW",
-            status: "blocked",
-            detail: { server: config.name, transport: config.transport, rule: `mcp-runtime:${config.name}` },
-        });
-        throw new Error(`Starting installed MCP runtime requires chat-mediated approval. Use mcp_call from ChatGPT: ${config.name}`);
-    };
-}
 export class McpHub {
     workspaceRoot;
     beforeConnect;
     sessions = new Map();
+    connecting = new Map();
+    idleTimer;
     constructor(workspaceRoot = process.cwd(), beforeConnect) {
         this.workspaceRoot = workspaceRoot;
         this.beforeConnect = beforeConnect;
         this.workspaceRoot = normalizeRoot(workspaceRoot);
-        this.beforeConnect ??= defaultRuntimeConnectGuard(this.workspaceRoot);
+        const sweepMs = Math.min(60_000, Math.max(10_000, Math.floor(MCP_SESSION_IDLE_MS / 4)));
+        this.idleTimer = setInterval(() => { void this.pruneIdleSessions(); }, sweepMs);
+        this.idleTimer.unref?.();
+    }
+    async pruneIdleSessions() {
+        const cutoff = Date.now() - MCP_SESSION_IDLE_MS;
+        const stale = [...this.sessions.entries()].filter(([, session]) => session.lastUsedAt < cutoff).map(([name]) => name);
+        await Promise.allSettled(stale.map((name) => this.disconnect(name)));
     }
     async registry() {
         const value = await readJson(mcpStatePaths().registry, { version: REGISTRY_VERSION, servers: [] });
@@ -299,9 +294,9 @@ export class McpHub {
             tools: catalog.tools.filter((tool) => tool.serverKey === key),
         };
     }
-    async probe(name) {
+    async probe(name, authorizeConnect = false) {
         const config = await this.resolveServer(name);
-        const client = await this.getOrConnect(config);
+        const client = await this.getOrConnect(config, authorizeConnect);
         const tools = await this.fetchAllTools(client);
         await this.replaceCatalogForServer(config, tools);
         return {
@@ -349,24 +344,26 @@ export class McpHub {
             recommendation: ranked.length ? "Call mcp_tool_info before mcp_call when you need the exact input schema." : "Probe a newly installed MCP with explicit local approval, then search again.",
         };
     }
-    async toolInfo(server, tool) {
+    async cachedToolInfo(server, tool) {
         const config = await this.resolveServer(server);
         const key = configKey(config);
-        let catalog = await this.catalogFile();
-        let found = catalog.tools.find((item) => item.serverKey === key && item.name === tool);
+        const catalog = await this.catalogFile();
+        return catalog.tools.find((item) => item.serverKey === key && item.name === tool) ?? null;
+    }
+    async toolInfo(server, tool, authorizeConnect = false) {
+        let found = await this.cachedToolInfo(server, tool);
         if (!found) {
-            await this.probe(server);
-            catalog = await this.catalogFile();
-            found = catalog.tools.find((item) => item.serverKey === key && item.name === tool);
+            await this.probe(server, authorizeConnect);
+            found = await this.cachedToolInfo(server, tool);
         }
         if (!found)
             throw new Error(`MCP tool not found: ${server}.${tool}`);
         return found;
     }
-    async callTool(server, tool, args = {}) {
+    async callTool(server, tool, args = {}, options = {}) {
         const config = await this.resolveServer(server);
-        const info = await this.toolInfo(server, tool);
-        const client = await this.getOrConnect(config);
+        const info = await this.toolInfo(server, tool, options.authorizeConnect === true);
+        const client = await this.getOrConnect(config, options.authorizeConnect === true);
         const session = this.sessions.get(server);
         if (session)
             session.lastUsedAt = Date.now();
@@ -386,6 +383,8 @@ export class McpHub {
         await session.client.close().catch(() => undefined);
     }
     async shutdown() {
+        clearInterval(this.idleTimer);
+        await Promise.allSettled([...this.connecting.values()]);
         await Promise.all([...this.sessions.keys()].map((name) => this.disconnect(name)));
     }
     publicServer(server) {
@@ -417,13 +416,28 @@ export class McpHub {
             throw new Error(`MCP server is disabled: ${name}`);
         return config;
     }
-    async getOrConnect(config) {
+    async getOrConnect(config, authorizeConnect = false) {
         const existing = this.sessions.get(config.name);
-        if (existing)
+        if (existing) {
+            existing.lastUsedAt = Date.now();
             return existing.client;
-        await this.beforeConnect?.(config);
+        }
+        if (!authorizeConnect)
+            await this.beforeConnect?.(config);
+        const inFlight = this.connecting.get(config.name);
+        if (inFlight)
+            return inFlight;
+        const connecting = this.connectNew(config).finally(() => {
+            if (this.connecting.get(config.name) === connecting)
+                this.connecting.delete(config.name);
+        });
+        this.connecting.set(config.name, connecting);
+        return connecting;
+    }
+    async connectNew(config) {
         const client = new Client({ name: "codelocal-mcp-hub", version: "1.0.0" });
         let transport;
+        let session;
         if (config.transport === "stdio") {
             const cwd = config.cwd ? (path.isAbsolute(config.cwd) ? config.cwd : path.resolve(config.scope === "workspace" ? this.workspaceRoot : process.cwd(), config.cwd)) : (config.scope === "workspace" ? this.workspaceRoot : undefined);
             const stdio = new StdioClientTransport({
@@ -434,26 +448,24 @@ export class McpHub {
                 stderr: "pipe",
             });
             transport = stdio;
-            const session = { client, transport, connectedAt: Date.now(), lastUsedAt: Date.now(), stderrTail: "" };
+            session = { client, transport, connectedAt: Date.now(), lastUsedAt: Date.now(), stderrTail: "" };
             stdio.stderr?.on("data", (chunk) => {
                 session.stderrTail = (session.stderrTail + String(chunk)).slice(-MAX_STDERR_TAIL);
             });
-            this.sessions.set(config.name, session);
         }
         else {
             const headers = materializeHeaders(config.headers);
             transport = new StreamableHTTPClientTransport(new URL(config.url), headers ? { requestInit: { headers } } : undefined);
-            this.sessions.set(config.name, { client, transport, connectedAt: Date.now(), lastUsedAt: Date.now(), stderrTail: "" });
+            session = { client, transport, connectedAt: Date.now(), lastUsedAt: Date.now(), stderrTail: "" };
         }
         try {
             await client.connect(transport);
+            this.sessions.set(config.name, session);
             return client;
         }
         catch (error) {
-            const session = this.sessions.get(config.name);
-            this.sessions.delete(config.name);
             await client.close().catch(() => undefined);
-            const stderr = session?.stderrTail.trim();
+            const stderr = session.stderrTail.trim();
             throw new Error(`Failed to connect MCP ${config.name}: ${error instanceof Error ? error.message : String(error)}${stderr ? `\nMCP stderr:\n${stderr}` : ""}`);
         }
     }

package/dist/process-manager.js

@@ -4,22 +4,24 @@ import path from "node:path";
 const MAX_BUFFER_BYTES = Number(process.env.CODELOCAL_MAX_PROCESS_BUFFER_BYTES ?? 2 * 1024 * 1024);
 const MAX_PROCESSES = Number(process.env.CODELOCAL_MAX_PROCESSES ?? 64);
 function append(buffer, value) {
-    const bytes = Buffer.byteLength(value, "utf8");
-    buffer.totalBytes += bytes;
-    buffer.text += value;
-    const currentBytes = Buffer.byteLength(buffer.text, "utf8");
-    if (currentBytes > MAX_BUFFER_BYTES) {
-        const keep = buffer.text.slice(-MAX_BUFFER_BYTES);
-        const keptBytes = Buffer.byteLength(keep, "utf8");
-        buffer.baseOffset += currentBytes - keptBytes;
-        buffer.text = keep;
-    }
+    const chunk = Buffer.from(value, "utf8");
+    buffer.totalBytes += chunk.length;
+    buffer.data = buffer.data.length ? Buffer.concat([buffer.data, chunk]) : chunk;
+    if (buffer.data.length <= MAX_BUFFER_BYTES)
+        return;
+    let start = buffer.data.length - MAX_BUFFER_BYTES;
+    while (start < buffer.data.length && (buffer.data[start] & 0xc0) === 0x80)
+        start++;
+    buffer.baseOffset += start;
+    buffer.data = buffer.data.subarray(start);
 }
 function readBuffer(buffer, cursor) {
     const requested = Math.max(cursor ?? buffer.baseOffset, buffer.baseOffset);
-    const relative = Math.max(0, requested - buffer.baseOffset);
+    let relative = Math.max(0, Math.min(buffer.data.length, requested - buffer.baseOffset));
+    while (relative < buffer.data.length && (buffer.data[relative] & 0xc0) === 0x80)
+        relative++;
     return {
-        text: buffer.text.slice(relative),
+        text: buffer.data.subarray(relative).toString("utf8"),
         cursor: buffer.totalBytes,
         truncatedBeforeCursor: (cursor ?? buffer.baseOffset) < buffer.baseOffset,
     };
@@ -64,11 +66,12 @@ export class ProcessManager {
         if (this.records.size >= MAX_PROCESSES)
             throw new Error(`Too many active CodeLocal processes (${MAX_PROCESSES}).`);
     }
-    baseRecord(command, cwd, executionMode, ownerSessionId) {
+    baseRecord(command, cwd, executionMode, ownerSessionId, requestId) {
         return {
             processId: randomUUID(),
             workspaceKey: this.workspaceKey,
             ownerSessionId,
+            requestId,
             pid: null,
             command,
             cwd,
@@ -77,8 +80,8 @@ export class ProcessManager {
             status: "running",
             exitCode: null,
             signal: null,
-            stdout: { text: "", baseOffset: 0, totalBytes: 0 },
-            stderr: { text: "", baseOffset: 0, totalBytes: 0 },
+            stdout: { data: Buffer.alloc(0), baseOffset: 0, totalBytes: 0 },
+            stderr: { data: Buffer.alloc(0), baseOffset: 0, totalBytes: 0 },
             timeoutAt: null,
             pty: false,
             executionMode,
@@ -93,12 +96,19 @@ export class ProcessManager {
         if (this.settledNotified.has(record.processId))
             return;
         this.settledNotified.add(record.processId);
+        if (record.timeoutTimer) {
+            clearTimeout(record.timeoutTimer);
+            record.timeoutTimer = undefined;
+        }
+        if (record.requestId && this.requestToProcess.get(record.requestId) === record.processId) {
+            this.requestToProcess.delete(record.requestId);
+        }
         Promise.resolve(this.onSettled?.(record)).catch(() => undefined);
     }
     async start(command, options) {
         this.prune();
         const executionMode = "host-policy";
-        const record = this.baseRecord(command, options.cwd, executionMode, options.ownerSessionId);
+        const record = this.baseRecord(command, options.cwd, executionMode, options.ownerSessionId, options.requestId);
         this.records.set(record.processId, record);
         if (options.requestId)
             this.requestToProcess.set(options.requestId, record.processId);
@@ -137,8 +147,10 @@ export class ProcessManager {
         });
         record.child = child;
         record.pid = child.pid ?? null;
-        child.stdout.on("data", (d) => this.emit(record, "stdout", d.toString()));
-        child.stderr.on("data", (d) => this.emit(record, "stderr", d.toString()));
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (d) => this.emit(record, "stdout", String(d)));
+        child.stderr.on("data", (d) => this.emit(record, "stderr", String(d)));
         child.on("error", (error) => {
             record.status = "failed";
             record.exitCode = -1;
@@ -159,11 +171,12 @@ export class ProcessManager {
         if (!timeoutMs || timeoutMs <= 0)
             return;
         record.timeoutAt = Date.now() + timeoutMs;
-        setTimeout(() => {
+        record.timeoutTimer = setTimeout(() => {
             const current = this.records.get(record.processId);
             if (current?.status === "running")
                 this.cancel(record.processId, "timeout");
-        }, timeoutMs).unref?.();
+        }, timeoutMs);
+        record.timeoutTimer.unref?.();
     }
     snapshot(processId, cursors = {}) {
         const record = this.records.get(processId);
@@ -258,4 +271,15 @@ export class ProcessManager {
             return { cancelled: false, reason: "no process associated with request" };
         return this.cancel(processId, reason);
     }
+    stopAll(reason = "runtime shutdown") {
+        let cancelled = 0;
+        for (const record of this.records.values()) {
+            if (record.status !== "running")
+                continue;
+            this.cancel(record.processId, reason);
+            cancelled++;
+        }
+        this.requestToProcess.clear();
+        return { cancelled };
+    }
 }

package/dist/runtime-daemon.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from "node:url";
 import { setTimeout as sleep } from "node:timers/promises";
 import { terminalHeader, terminalStatus } from "./log.js";
 import { WorkspaceRegistry } from "./workspace-registry.js";
+import { VERSION } from "./version.js";
 function deviceHeaders(credential) {
     return {
         "content-type": "application/json",
@@ -44,7 +45,7 @@ export class RuntimeDaemon {
         const response = await fetch(`${this.options.baseUrl}/api/client/workspaces/sync`, {
             method: "POST",
             headers: deviceHeaders(this.options.credential),
-            body: JSON.stringify({ workspaces: workspaces.map(({ workspaceId, workspaceName, grantedAt, lastActivatedAt }) => ({ workspaceId, workspaceName, grantedAt, lastActivatedAt })) }),
+            body: JSON.stringify({ clientVersion: VERSION, workspaces: workspaces.map(({ workspaceId, workspaceName, grantedAt, lastActivatedAt }) => ({ workspaceId, workspaceName, grantedAt, lastActivatedAt })) }),
             signal: AbortSignal.timeout(10_000),
         });
         if (response.status === 401 || response.status === 403)

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = "1.5.0-beta.3";

package/dist/workspace-index.js

@@ -129,6 +129,8 @@ export class WorkspaceIntelligenceIndex {
     dirty = true;
     scanPromise = null;
     cacheLoaded = false;
+    pendingPaths = new Set();
+    fullRescanNeeded = true;
     cacheDir;
     cacheFile;
     constructor(root, maxEntries = Math.max(1000, Number(process.env.CODELOCAL_INDEX_MAX_FILES ?? 12000) || 12000), maxDepth = Math.max(2, Number(process.env.CODELOCAL_INDEX_MAX_DEPTH ?? 8) || 8), maxReadBytes = Math.max(16_384, Number(process.env.CODELOCAL_INDEX_MAX_FILE_BYTES ?? 384 * 1024) || 384 * 1024), freshnessMs = Math.max(500, Number(process.env.CODELOCAL_INDEX_FRESHNESS_MS ?? 1500) || 1500)) {
@@ -143,15 +145,20 @@ export class WorkspaceIntelligenceIndex {
     }
     invalidate(paths) {
         this.dirty = true;
-        if (paths?.length)
+        if (paths?.length) {
             for (const file of paths)
                 this.noteChange(file);
+            return;
+        }
+        this.fullRescanNeeded = true;
+        this.pendingPaths.clear();
     }
     noteChange(relativePath) {
         const normalized = normalizeRelative(relativePath);
         if (!normalized || normalized === "." || normalized.startsWith("../"))
             return;
         this.recentChanges.set(normalized, Date.now());
+        this.pendingPaths.add(normalized);
         this.dirty = true;
     }
     async loadCache() {
@@ -255,6 +262,69 @@ export class WorkspaceIntelligenceIndex {
         const tokens = [...new Set([...tokenize(meta.path), ...symbols.flatMap(tokenize), ...imports.flatMap(tokenize), ...(packageName ? tokenize(packageName) : [])])].slice(0, 800);
         return { ...meta, language, kind, imports, symbols, tokens, packageName, changedAt };
     }
+    async scanChanged() {
+        await this.loadCache();
+        const changed = [...this.pendingPaths];
+        this.pendingPaths.clear();
+        let requiresFullScan = false;
+        for (const relative of changed) {
+            if (!relative || relative === "." || relative.startsWith("../") || isSensitivePath(relative)) {
+                this.files.delete(relative);
+                continue;
+            }
+            const segments = relative.split("/");
+            if (segments.some((segment) => SKIP_DIRS.has(segment)) || segments.length - 1 > this.maxDepth) {
+                this.files.delete(relative);
+                continue;
+            }
+            const absolute = path.join(this.root, relative);
+            let stat;
+            try {
+                stat = await fs.lstat(absolute);
+            }
+            catch {
+                const prefix = `${relative}/`;
+                if ([...this.files.keys()].some((file) => file.startsWith(prefix))) {
+                    requiresFullScan = true;
+                    break;
+                }
+                this.files.delete(relative);
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                this.files.delete(relative);
+                continue;
+            }
+            if (stat.isDirectory()) {
+                requiresFullScan = true;
+                break;
+            }
+            if (!stat.isFile()) {
+                this.files.delete(relative);
+                continue;
+            }
+            if (!this.files.has(relative) && this.files.size >= this.maxEntries) {
+                requiresFullScan = true;
+                break;
+            }
+            this.files.set(relative, await this.indexOne({ path: relative, size: stat.size, mtimeMs: stat.mtimeMs }, this.files.get(relative)));
+        }
+        if (requiresFullScan) {
+            this.fullRescanNeeded = true;
+            await this.scan();
+            return;
+        }
+        this.rebuildGraphMetadata();
+        this.builtAt = Date.now();
+        this.lastScanAt = this.builtAt;
+        this.dirty = false;
+        this.fullRescanNeeded = false;
+        const cutoff = Date.now() - 10 * 60_000;
+        for (const [file, at] of this.recentChanges)
+            if (at < cutoff)
+                this.recentChanges.delete(file);
+        await this.persistCache();
+    }
     async scan() {
         await this.loadCache();
         const discovered = await this.discover();
@@ -267,6 +337,8 @@ export class WorkspaceIntelligenceIndex {
                 this.recentChanges.set(oldPath, Date.now());
         }
         this.files = next;
+        this.pendingPaths.clear();
+        this.fullRescanNeeded = false;
         this.rebuildGraphMetadata();
         this.builtAt = Date.now();
         this.lastScanAt = this.builtAt;
@@ -322,7 +394,8 @@ export class WorkspaceIntelligenceIndex {
         if (!force && this.dirty && this.lastScanAt > 0 && now - this.lastScanAt < Math.min(this.freshnessMs, 750))
             return this.summary();
         if (!this.scanPromise) {
-            this.scanPromise = this.scan().finally(() => { this.scanPromise = null; });
+            const incremental = !force && !this.fullRescanNeeded && this.pendingPaths.size > 0 && this.pendingPaths.size <= 256;
+            this.scanPromise = (incremental ? this.scanChanged() : this.scan()).finally(() => { this.scanPromise = null; });
         }
         await this.scanPromise;
         return this.summary();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codelocal",
-  "version": "1.5.0-beta.2",
+  "version": "1.5.0-beta.4",
   "description": "CodeLocal local code intelligence and execution runtime for ChatGPT.",
   "license": "UNLICENSED",
   "type": "module",