@nurix/nustack 0.10.0-dev.8 → 0.11.0

package/dist/lib/lanes/supervisor.js

@@ -1,247 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { createInterface } from "node:readline";
-import { ClaudeLane } from "./claudeAdapter.js";
-import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
-import { createLaneWorktree, lanesHome } from "./worktree.js";
-function defaultProbeClaude(env) {
-    return new Promise((resolve) => {
-        execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
-            if (error)
-                resolve({ found: false, version: null });
-            else
-                resolve({ found: true, version: stdout.trim() });
-        });
-    });
-}
-export class LaneSupervisor {
-    options;
-    env;
-    lanes = new Map();
-    closingLanes = new Set();
-    shuttingDown = false;
-    resolveDone = null;
-    lines = null;
-    registryWrites = Promise.resolve();
-    constructor(options) {
-        this.options = options;
-        this.env = options.env ?? process.env;
-    }
-    emit(frame) {
-        this.options.output.write(serializeFrame(frame));
-    }
-    status(laneId, status, message = null) {
-        this.emit({ v: FRAME_VERSION, type: "lane.status", laneId, status, message });
-    }
-    error(laneId, code, message) {
-        this.emit({ v: FRAME_VERSION, type: "lane.error", laneId, code, message });
-    }
-    registryPath() {
-        return path.join(lanesHome(this.env), "registry.json");
-    }
-    async boundWorkspaceOf(projectPath) {
-        try {
-            const parsed = JSON.parse(await readFile(path.join(projectPath, ".nustack", "workspace.json"), "utf8"));
-            const id = parsed?.workspaceId;
-            return typeof id === "string" && id.trim() ? id.trim() : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async moveLaneSession(record, to) {
-        const client = this.options.sessions;
-        if (!client || !record.workspaceId)
-            return;
-        try {
-            await client.transitionSession(record.workspaceId, record.laneId, to);
-        }
-        catch {
-        }
-    }
-    async updateRegistry(mutate) {
-        const run = async () => {
-            const file = this.registryPath();
-            let lanes = [];
-            try {
-                const parsed = JSON.parse(await readFile(file, "utf8"));
-                if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.lanes)) {
-                    lanes = parsed.lanes;
-                }
-            }
-            catch {
-            }
-            await mkdir(path.dirname(file), { recursive: true });
-            await writeFile(file, JSON.stringify({ v: 1, lanes: mutate(lanes) }, null, 2) + "\n", "utf8");
-        };
-        this.registryWrites = this.registryWrites.then(run, run);
-        return this.registryWrites;
-    }
-    async run() {
-        const probe = this.options.probeClaude ?? (() => defaultProbeClaude(this.env));
-        const claude = await probe();
-        this.emit({ v: FRAME_VERSION, type: "engine.hello", engineVersion: this.options.engineVersion, claude });
-        const lines = createInterface({ input: this.options.input });
-        this.lines = lines;
-        lines.on("line", (line) => {
-            if (line.trim() === "")
-                return;
-            const parsed = parseInboundFrame(line);
-            if (!parsed.ok) {
-                this.error(null, parsed.error.code, parsed.error.message);
-                return;
-            }
-            void this.handle(parsed.frame);
-        });
-        await new Promise((resolve) => {
-            this.resolveDone = resolve;
-            lines.on("close", () => void this.shutdown());
-        });
-    }
-    async handle(frame) {
-        switch (frame.type) {
-            case "engine.shutdown":
-                await this.shutdown();
-                return;
-            case "lane.open":
-                await this.openLane(frame.laneId, frame.projectPath, frame.permissionMode, frame.isolated, frame.resumeSessionId);
-                return;
-            case "lane.turn": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.sendTurn(frame.text);
-                this.status(frame.laneId, "running");
-                return;
-            }
-            case "lane.approval": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.respondApproval(frame.requestId, frame.verdict);
-                return;
-            }
-            case "lane.interrupt": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                lane.adapter.interrupt();
-                return;
-            }
-            case "lane.close": {
-                const lane = this.lanes.get(frame.laneId);
-                if (!lane)
-                    return this.error(frame.laneId, "LANE_UNKNOWN", `no open lane ${frame.laneId}`);
-                this.closingLanes.add(frame.laneId);
-                lane.adapter.stop();
-                return;
-            }
-        }
-    }
-    async openLane(laneId, projectPath, permissionMode, isolated, resumeSessionId) {
-        if (this.lanes.has(laneId))
-            return this.error(laneId, "LANE_ALREADY_OPEN", `lane ${laneId} is already open`);
-        this.status(laneId, "starting");
-        const worktree = await createLaneWorktree(projectPath, laneId, this.env, isolated === true);
-        const record = {
-            laneId,
-            projectPath,
-            worktreePath: worktree.worktreePath,
-            branch: worktree.branch,
-            provider: "claude-code",
-            providerSessionId: null,
-            createdAt: new Date().toISOString(),
-            status: "open",
-            workspaceId: await this.boundWorkspaceOf(projectPath),
-        };
-        const adapterOptions = {
-            cwd: worktree.worktreePath,
-            permissionMode,
-            resumeSessionId,
-            env: this.env,
-            onEvent: (event) => {
-                this.emit({ v: FRAME_VERSION, type: "lane.event", laneId, event });
-                if (typeof event === "object" && event !== null && event.type === "result") {
-                    this.status(laneId, "ready");
-                }
-            },
-            onApprovalRequest: (request) => {
-                this.emit({
-                    v: FRAME_VERSION,
-                    type: "lane.approvalRequest",
-                    laneId,
-                    requestId: request.requestId,
-                    toolName: request.toolName,
-                    displayName: request.displayName,
-                    toolInput: request.toolInput,
-                    description: request.description,
-                });
-            },
-            onProtocolError: (code, message) => this.error(laneId, code, message),
-            onSessionId: (sessionId) => {
-                record.providerSessionId = sessionId;
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, providerSessionId: sessionId } : row)));
-                const client = this.options.sessions;
-                if (client && record.workspaceId) {
-                    void client.setVendorSessionId(record.workspaceId, laneId, sessionId).catch(() => undefined);
-                }
-            },
-            onExit: (code) => {
-                const wasExpected = this.closingLanes.delete(laneId) || this.shuttingDown;
-                this.lanes.delete(laneId);
-                if (!wasExpected)
-                    this.error(laneId, "ADAPTER_FAILED", `claude exited unexpectedly (code ${String(code)})`);
-                this.emit({ v: FRAME_VERSION, type: "lane.closed", laneId });
-                void this.updateRegistry((lanes) => lanes.map((row) => (row.laneId === laneId ? { ...row, status: "closed" } : row)));
-                void this.moveLaneSession(record, wasExpected ? "done" : "failed");
-            },
-        };
-        const create = this.options.createAdapter ?? ((opts) => new ClaudeLane(opts));
-        let adapter;
-        try {
-            adapter = create(adapterOptions);
-        }
-        catch (error) {
-            return this.error(laneId, "ADAPTER_FAILED", error instanceof Error ? error.message : String(error));
-        }
-        this.lanes.set(laneId, { adapter, record });
-        await this.updateRegistry((lanes) => [...lanes.filter((row) => row.laneId !== laneId), record]);
-        if (this.options.sessions && record.workspaceId) {
-            try {
-                await this.options.sessions.createSession(record.workspaceId, {
-                    id: laneId,
-                    startedBy: "person",
-                    substrate: "device",
-                    mode: "synchronous",
-                    origin: "inside",
-                    vendor: "claude_code",
-                    renderer: "claude_transcript",
-                    status: "created",
-                });
-            }
-            catch {
-            }
-        }
-        this.emit({
-            v: FRAME_VERSION,
-            type: "lane.opened",
-            laneId,
-            projectPath,
-            worktreePath: worktree.worktreePath,
-            branch: worktree.branch,
-            isolated: worktree.isolated,
-        });
-        this.status(laneId, "ready");
-    }
-    async shutdown() {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        for (const [, lane] of this.lanes)
-            lane.adapter.stop();
-        this.lanes.clear();
-        this.lines?.close();
-        this.resolveDone?.();
-    }
-}

package/dist/lib/lanes/worktree.js

@@ -1,33 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-export const LANE_BRANCH_PREFIX = "nustack/lane-";
-export function lanesHome(env = process.env) {
-    const override = env.NUSTACK_LANES_HOME;
-    if (override && override !== "")
-        return override;
-    return path.join(os.homedir(), ".nustack", "lanes");
-}
-function git(args, cwd) {
-    return new Promise((resolve) => {
-        execFile("git", args, { cwd, timeout: 15_000 }, (error, stdout) => {
-            resolve(error ? null : stdout.trim());
-        });
-    });
-}
-export async function createLaneWorktree(projectPath, laneId, env = process.env, isolate = false) {
-    const inPlace = { worktreePath: projectPath, branch: null, isolated: false };
-    if (!isolate)
-        return inPlace;
-    const isRepo = await git(["rev-parse", "--is-inside-work-tree"], projectPath);
-    if (isRepo !== "true")
-        return inPlace;
-    const branch = `${LANE_BRANCH_PREFIX}${laneId}`;
-    const worktreePath = path.join(lanesHome(env), "worktrees", laneId);
-    await mkdir(path.dirname(worktreePath), { recursive: true });
-    const added = await git(["worktree", "add", worktreePath, "-b", branch], projectPath);
-    if (added === null)
-        return inPlace;
-    return { worktreePath, branch, isolated: true };
-}

package/dist/lib/local_store/workspace_events_cache.js

@@ -1,54 +0,0 @@
-export const DEFAULT_WORKSPACE_EVENT_KEEP_COUNT = 500;
-function mapRow(row) {
-    return {
-        bindingId: row.binding_id,
-        workspaceSequence: row.workspace_sequence,
-        eventType: row.event_type,
-        payloadJson: row.payload_json ?? null,
-        appliedAtMs: row.applied_at_ms ?? null,
-        createdAtMs: row.created_at_ms,
-    };
-}
-export function cacheWorkspaceEvents(store, bindingId, events) {
-    const now = Date.now();
-    const insert = store.db.prepare(`INSERT INTO cached_workspace_events (
-            binding_id, workspace_sequence, event_type, payload_json, applied_at_ms, created_at_ms
-        ) VALUES (
-            :binding_id, :workspace_sequence, :event_type, :payload_json, :applied_at_ms, :created_at_ms
-        )
-        ON CONFLICT(binding_id, workspace_sequence) DO NOTHING`);
-    for (const event of events) {
-        insert.run({
-            binding_id: bindingId,
-            workspace_sequence: event.workspaceSequence,
-            event_type: event.eventType,
-            payload_json: event.payloadJson ?? null,
-            applied_at_ms: event.appliedAtMs ?? null,
-            created_at_ms: now,
-        });
-    }
-}
-export function latestCachedSequence(store, bindingId) {
-    const row = store.db
-        .prepare("SELECT MAX(workspace_sequence) AS latest FROM cached_workspace_events WHERE binding_id = :binding_id")
-        .get({ binding_id: bindingId });
-    return row?.latest ?? null;
-}
-export function listCachedWorkspaceEvents(store, bindingId) {
-    const rows = store.db
-        .prepare("SELECT * FROM cached_workspace_events WHERE binding_id = :binding_id ORDER BY workspace_sequence ASC")
-        .all({ binding_id: bindingId });
-    return rows.map(mapRow);
-}
-export function pruneWorkspaceEvents(store, bindingId, keepCount = DEFAULT_WORKSPACE_EVENT_KEEP_COUNT) {
-    store.db
-        .prepare(`DELETE FROM cached_workspace_events
-             WHERE binding_id = :binding_id
-               AND workspace_sequence NOT IN (
-                   SELECT workspace_sequence FROM cached_workspace_events
-                   WHERE binding_id = :binding_id
-                   ORDER BY workspace_sequence DESC
-                   LIMIT :keep
-               )`)
-        .run({ binding_id: bindingId, keep: keepCount });
-}