codelocal 1.5.0-beta.1

package/dist/process-manager.js

@@ -0,0 +1,261 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+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;
+    }
+}
+function readBuffer(buffer, cursor) {
+    const requested = Math.max(cursor ?? buffer.baseOffset, buffer.baseOffset);
+    const relative = Math.max(0, requested - buffer.baseOffset);
+    return {
+        text: buffer.text.slice(relative),
+        cursor: buffer.totalBytes,
+        truncatedBeforeCursor: (cursor ?? buffer.baseOffset) < buffer.baseOffset,
+    };
+}
+async function loadNodePty() {
+    try {
+        const dynamicImport = new Function("m", "return import(m)");
+        return await dynamicImport("node-pty");
+    }
+    catch {
+        return null;
+    }
+}
+function hostShell(command, cwd) {
+    const shell = process.env.SHELL || (process.platform === "win32" ? "cmd.exe" : "/bin/zsh");
+    // Use the runtime's inherited environment without starting a login shell. This preserves
+    // PATH/credential helpers while avoiding arbitrary profile startup hooks on every command.
+    const args = process.platform === "win32" ? ["/d", "/s", "/c", command] : ["-c", command];
+    return { command: shell, args, cwd };
+}
+export class ProcessManager {
+    workspaceRoot;
+    workspaceKey;
+    onOutput;
+    onSettled;
+    records = new Map();
+    requestToProcess = new Map();
+    settledNotified = new Set();
+    constructor(workspaceRoot, workspaceKey, onOutput, onSettled) {
+        this.workspaceRoot = workspaceRoot;
+        this.workspaceKey = workspaceKey;
+        this.onOutput = onOutput;
+        this.onSettled = onSettled;
+    }
+    prune() {
+        const finished = [...this.records.values()].filter((x) => x.status !== "running").sort((a, b) => a.startedAt - b.startedAt);
+        while (this.records.size >= MAX_PROCESSES && finished.length) {
+            const victim = finished.shift();
+            this.records.delete(victim.processId);
+            this.settledNotified.delete(victim.processId);
+        }
+        if (this.records.size >= MAX_PROCESSES)
+            throw new Error(`Too many active CodeLocal processes (${MAX_PROCESSES}).`);
+    }
+    baseRecord(command, cwd, executionMode, ownerSessionId) {
+        return {
+            processId: randomUUID(),
+            workspaceKey: this.workspaceKey,
+            ownerSessionId,
+            pid: null,
+            command,
+            cwd,
+            startedAt: Date.now(),
+            lastActivityAt: Date.now(),
+            status: "running",
+            exitCode: null,
+            signal: null,
+            stdout: { text: "", baseOffset: 0, totalBytes: 0 },
+            stderr: { text: "", baseOffset: 0, totalBytes: 0 },
+            timeoutAt: null,
+            pty: false,
+            executionMode,
+        };
+    }
+    emit(record, stream, text) {
+        record.lastActivityAt = Date.now();
+        append(stream === "stdout" ? record.stdout : record.stderr, text);
+        this.onOutput?.(record, stream, text);
+    }
+    notifySettled(record) {
+        if (this.settledNotified.has(record.processId))
+            return;
+        this.settledNotified.add(record.processId);
+        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);
+        this.records.set(record.processId, record);
+        if (options.requestId)
+            this.requestToProcess.set(options.requestId, record.processId);
+        const wrap = async () => hostShell(command, options.cwd);
+        if (options.usePty) {
+            const nodePty = await loadNodePty();
+            if (nodePty) {
+                const wrapped = await wrap();
+                const terminal = nodePty.spawn(wrapped.command, wrapped.args, {
+                    name: process.env.TERM || "xterm-256color",
+                    cols: options.cols ?? 120,
+                    rows: options.rows ?? 36,
+                    cwd: wrapped.cwd,
+                    env: { ...process.env, PAGER: "cat", GIT_PAGER: "cat", CODELOCAL_EXECUTION_MODE: executionMode },
+                });
+                record.pty = true;
+                record.terminal = terminal;
+                record.pid = terminal.pid;
+                terminal.onData((data) => this.emit(record, "stdout", data));
+                terminal.onExit(({ exitCode, signal }) => {
+                    record.status = record.status === "cancelled" ? "cancelled" : "exited";
+                    record.exitCode = exitCode;
+                    record.signal = signal == null ? null : String(signal);
+                    record.lastActivityAt = Date.now();
+                    this.notifySettled(record);
+                });
+                this.scheduleTimeout(record, options.timeoutMs);
+                return this.snapshot(record.processId);
+            }
+        }
+        const wrapped = await wrap();
+        const child = spawn(wrapped.command, wrapped.args, {
+            cwd: wrapped.cwd,
+            env: { ...process.env, PAGER: "cat", GIT_PAGER: "cat", CI: process.env.CI ?? "1", CODELOCAL_EXECUTION_MODE: executionMode },
+            stdio: "pipe",
+        });
+        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.on("error", (error) => {
+            record.status = "failed";
+            record.exitCode = -1;
+            this.emit(record, "stderr", `\n[process error] ${error.message}\n`);
+        });
+        child.on("close", (code, signal) => {
+            if (record.status !== "cancelled" && record.status !== "failed")
+                record.status = "exited";
+            record.exitCode = code;
+            record.signal = signal ?? null;
+            record.lastActivityAt = Date.now();
+            this.notifySettled(record);
+        });
+        this.scheduleTimeout(record, options.timeoutMs);
+        return this.snapshot(record.processId);
+    }
+    scheduleTimeout(record, timeoutMs) {
+        if (!timeoutMs || timeoutMs <= 0)
+            return;
+        record.timeoutAt = Date.now() + timeoutMs;
+        setTimeout(() => {
+            const current = this.records.get(record.processId);
+            if (current?.status === "running")
+                this.cancel(record.processId, "timeout");
+        }, timeoutMs).unref?.();
+    }
+    snapshot(processId, cursors = {}) {
+        const record = this.records.get(processId);
+        if (!record)
+            throw new Error("Unknown processId.");
+        return {
+            processId: record.processId,
+            workspaceKey: record.workspaceKey,
+            ownerSessionId: record.ownerSessionId ?? null,
+            pid: record.pid,
+            command: record.command,
+            cwd: path.relative(this.workspaceRoot, record.cwd).split(path.sep).join("/") || ".",
+            startedAt: record.startedAt,
+            lastActivityAt: record.lastActivityAt,
+            status: record.status,
+            running: record.status === "running",
+            exitCode: record.exitCode,
+            signal: record.signal,
+            timeoutAt: record.timeoutAt,
+            pty: record.pty,
+            executionMode: record.executionMode,
+            stdout: readBuffer(record.stdout, cursors.stdout),
+            stderr: readBuffer(record.stderr, cursors.stderr),
+        };
+    }
+    list() {
+        return [...this.records.values()].map((record) => ({
+            processId: record.processId,
+            pid: record.pid,
+            command: record.command,
+            cwd: path.relative(this.workspaceRoot, record.cwd).split(path.sep).join("/") || ".",
+            status: record.status,
+            exitCode: record.exitCode,
+            signal: record.signal,
+            startedAt: record.startedAt,
+            lastActivityAt: record.lastActivityAt,
+            pty: record.pty,
+            executionMode: record.executionMode,
+        }));
+    }
+    write(processId, input) {
+        const record = this.records.get(processId);
+        if (!record || record.status !== "running")
+            throw new Error("Process not running.");
+        if (record.terminal)
+            record.terminal.write(input);
+        else if (record.child)
+            record.child.stdin.write(input);
+        else
+            throw new Error("Process stdin unavailable.");
+        record.lastActivityAt = Date.now();
+        return { written: Buffer.byteLength(input, "utf8") };
+    }
+    resize(processId, cols, rows) {
+        const record = this.records.get(processId);
+        if (!record?.terminal)
+            throw new Error("PTY resize is not available for this process.");
+        record.terminal.resize(cols, rows);
+        return { resized: true, cols, rows };
+    }
+    signal(processId, signal = "SIGTERM") {
+        const record = this.records.get(processId);
+        if (!record)
+            throw new Error("Unknown processId.");
+        if (record.status !== "running")
+            return { signalled: false, status: record.status };
+        if (record.terminal)
+            record.terminal.kill(signal);
+        else
+            record.child?.kill(signal);
+        record.signal = signal;
+        record.lastActivityAt = Date.now();
+        return { signalled: true, signal };
+    }
+    cancel(processId, reason = "cancelled") {
+        const record = this.records.get(processId);
+        if (!record)
+            throw new Error("Unknown processId.");
+        if (record.status === "running") {
+            record.status = "cancelled";
+            this.emit(record, "stderr", `\n[CodeLocal] ${reason}\n`);
+            if (record.terminal)
+                record.terminal.kill("SIGTERM");
+            else
+                record.child?.kill("SIGTERM");
+        }
+        return { cancelled: true, processId };
+    }
+    cancelRequest(requestId, reason = "tool request cancelled") {
+        const processId = this.requestToProcess.get(requestId);
+        if (!processId)
+            return { cancelled: false, reason: "no process associated with request" };
+        return this.cancel(processId, reason);
+    }
+}

package/dist/protocol.js

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto";
+export const PROTOCOL_VERSION = 2;
+export const MIN_PROTOCOL_VERSION = 1;
+export function requestId() {
+    return randomUUID();
+}
+export function normalizeError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    if (lower.includes("sensitive-path"))
+        return { errorCode: "SENSITIVE_PATH", errorMessage: message };
+    if (lower.includes("escapes project_root") || lower.includes("path escape") || lower.includes("unsafe patch path"))
+        return { errorCode: "PATH_ESCAPE", errorMessage: message };
+    if (lower.includes("changed since read") || lower.includes("hash mismatch") || lower.includes("conflict"))
+        return { errorCode: "CONFLICT", errorMessage: message };
+    if (lower.includes("approval") && (lower.includes("denied") || lower.includes("rejected")))
+        return { errorCode: "APPROVAL_DENIED", errorMessage: message };
+    if (lower.includes("blocked") || lower.includes("policy"))
+        return { errorCode: "POLICY_BLOCKED", errorMessage: message };
+    if (lower.includes("not found") || lower.includes("enoent") || lower.includes("unknown process"))
+        return { errorCode: "NOT_FOUND", errorMessage: message };
+    if (lower.includes("unsupported") || lower.includes("not available"))
+        return { errorCode: "UNSUPPORTED", errorMessage: message };
+    if (lower.includes("cancel"))
+        return { errorCode: "TOOL_CANCELLED", errorMessage: message };
+    return { errorCode: "TOOL_FAILED", errorMessage: message };
+}
+export function protocolCompatible(version) {
+    return typeof version === "number" && version >= MIN_PROTOCOL_VERSION && version <= PROTOCOL_VERSION;
+}
+export function isSideEffectingTool(tool) {
+    return new Set([
+        "write_file",
+        "edit_file",
+        "apply_patch",
+        "apply_edits",
+        "format_changed_files",
+        "run_command",
+        "exec_start",
+        "pty_start",
+        "process_write",
+        "process_kill",
+        "exec_cancel",
+        "git_stage",
+        "git_unstage",
+        "git_commit",
+        "git_push",
+        "approval_revoke",
+        "approval_reset",
+        "mcp_call",
+    ]).has(tool);
+}

package/dist/runtime-daemon.js

@@ -0,0 +1,162 @@
+import { spawn } from "node:child_process";
+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";
+function deviceHeaders(credential) {
+    return {
+        "content-type": "application/json",
+        "x-codelocal-credential-id": credential.credentialId,
+        authorization: `Device ${credential.credentialSecret}`,
+    };
+}
+function registrySignature(workspaces) {
+    return JSON.stringify(workspaces.map((workspace) => [workspace.workspaceId, workspace.workspaceName]).sort((a, b) => String(a[0]).localeCompare(String(b[0]))));
+}
+export class RuntimeDaemon {
+    options;
+    registry = new WorkspaceRegistry();
+    children = new Map();
+    stopped = false;
+    workspaces = [];
+    syncedSignature = "";
+    constructor(options) {
+        this.options = options;
+    }
+    stopUnauthorizedChildren(workspaces) {
+        const allowed = new Set(workspaces.map((workspace) => workspace.workspaceId));
+        for (const [workspaceId, child] of this.children) {
+            if (allowed.has(workspaceId))
+                continue;
+            if (child.exitCode == null && !child.killed)
+                child.kill("SIGTERM");
+            this.children.delete(workspaceId);
+            terminalStatus("warn", "Workspace", `${workspaceId} deactivated · authorization removed`);
+        }
+    }
+    async syncRegistry(force = false) {
+        const workspaces = await this.registry.list();
+        this.stopUnauthorizedChildren(workspaces);
+        const signature = registrySignature(workspaces);
+        this.workspaces = workspaces;
+        if (!force && signature === this.syncedSignature)
+            return workspaces;
+        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 })) }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (response.status === 401 || response.status === 403)
+            throw new Error("Stored CodeLocal device credential is no longer valid.");
+        if (!response.ok)
+            throw new Error(`Unable to sync authorized workspaces (${response.status}).`);
+        this.syncedSignature = signature;
+        return workspaces;
+    }
+    async childFor(workspace) {
+        const existing = this.children.get(workspace.workspaceId);
+        if (existing && existing.exitCode == null && !existing.killed)
+            return existing;
+        const entry = fileURLToPath(new URL("./client-entry-v2.js", import.meta.url));
+        const child = spawn(process.execPath, [entry], {
+            env: {
+                ...process.env,
+                PROJECT_ROOT: workspace.localPath,
+                SERVER_URL: this.options.serverUrl,
+                CODELOCAL_WORKSPACE_ID: workspace.workspaceId,
+                CODELOCAL_WORKSPACE_NAME: workspace.workspaceName,
+                CODELOCAL_ALLOW_SHELL: process.env.CODELOCAL_ALLOW_SHELL ?? "1",
+                CODELOCAL_APPROVAL_MODE: process.env.CODELOCAL_APPROVAL_MODE ?? "prompt",
+                CODELOCAL_LOG_FORMAT: process.env.CODELOCAL_LOG_FORMAT ?? "pretty",
+                CODELOCAL_DAEMON_CHILD: "1",
+            },
+            stdio: "inherit",
+            shell: false,
+        });
+        this.children.set(workspace.workspaceId, child);
+        child.once("exit", () => {
+            if (this.children.get(workspace.workspaceId) === child)
+                this.children.delete(workspace.workspaceId);
+        });
+        await this.registry.markActivated(workspace.workspaceId);
+        return child;
+    }
+    async activate(workspaceId) {
+        const workspace = await this.registry.get(workspaceId);
+        if (!workspace)
+            throw new Error(`Workspace is not authorized on this machine: ${workspaceId}`);
+        await this.childFor(workspace);
+        return workspace;
+    }
+    async revokeWorkspace(workspaceId) {
+        const workspace = await this.registry.get(workspaceId);
+        const removed = await this.registry.revoke(workspaceId);
+        if (!removed)
+            return false;
+        const child = this.children.get(workspaceId);
+        if (child && child.exitCode == null && !child.killed)
+            child.kill("SIGTERM");
+        this.children.delete(workspaceId);
+        await this.syncRegistry(true);
+        terminalStatus("warn", "Workspace", `${workspace?.workspaceName ?? workspaceId} removed`);
+        return true;
+    }
+    async pollOnce() {
+        const response = await fetch(`${this.options.baseUrl}/api/client/runtime/poll`, {
+            method: "POST",
+            headers: deviceHeaders(this.options.credential),
+            body: JSON.stringify({ workspaceIds: this.workspaces.map((workspace) => workspace.workspaceId) }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (response.status === 401 || response.status === 403)
+            throw new Error("CodeLocal runtime device authorization was revoked.");
+        if (!response.ok)
+            throw new Error(`Runtime poll failed (${response.status}).`);
+        return await response.json();
+    }
+    async run() {
+        const workspaces = await this.syncRegistry(true);
+        terminalHeader();
+        terminalStatus("success", "Runtime", "Online");
+        terminalStatus("success", "Cloud", "Connected");
+        terminalStatus("info", "Workspaces", `${workspaces.length} authorized`);
+        if (!workspaces.length)
+            terminalStatus("warn", "Workspace", "None granted · run codelocal grant /path/to/project");
+        terminalStatus("muted", "Status", "Waiting for ChatGPT…");
+        if (this.options.initialWorkspaceId) {
+            const activated = await this.activate(this.options.initialWorkspaceId);
+            terminalStatus("accent", "Workspace", `${activated.workspaceName} active`);
+        }
+        while (!this.stopped) {
+            try {
+                await this.syncRegistry();
+                const message = await this.pollOnce();
+                if (message.revocation?.workspaceId) {
+                    await this.revokeWorkspace(message.revocation.workspaceId);
+                    continue;
+                }
+                if (message.activation?.workspaceId) {
+                    const workspace = await this.activate(message.activation.workspaceId);
+                    terminalStatus("accent", "ChatGPT", `Activated ${workspace.workspaceName}`);
+                }
+            }
+            catch (error) {
+                if (this.stopped)
+                    break;
+                terminalStatus("error", "Runtime", error instanceof Error ? error.message : String(error));
+                await sleep(Math.max(1500, this.options.pollMs ?? 2500));
+            }
+            if (!this.stopped)
+                await sleep(this.options.pollMs ?? 2500);
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        for (const child of this.children.values()) {
+            if (child.exitCode == null && !child.killed)
+                child.kill("SIGTERM");
+        }
+        this.children.clear();
+    }
+}