@lasso-ai/cli 1.5.0 → 2.0.0

package/dist/cli/bridge.js

@@ -18,6 +18,8 @@ const project_1 = require("./project");
 const auth_1 = require("./auth");
 const snapshot_1 = require("./snapshot");
 const runtime_client_1 = require("./runtime-client");
+const backends_1 = require("./backends");
+const local_runtime_1 = require("./local-runtime");
 exports.DEFAULT_BRIDGE_PORT = 3056;
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 async function restartBridge(port = exports.DEFAULT_BRIDGE_PORT) {
@@ -82,31 +84,50 @@ function detectProjectFramework(cwd) {
     catch { }
     return "unknown";
 }
-// Helper to extract SourceChange from runtime session
+// Helper to extract review changes from a runtime session.
+// Prefers the authoritative guard diff (session.metadata.pendingChanges) and
+// falls back to normalizing recorded actions (accepting filePath OR path).
 function extractChangesFromSession(session) {
     if (!session)
         return [];
+    const metadata = session.metadata;
+    const pending = metadata?.pendingChanges;
+    if (Array.isArray(pending) && pending.length > 0) {
+        return pending.map((change) => ({
+            filePath: change.filePath,
+            oldString: change.oldString ?? "",
+            newString: change.newString ?? "",
+            operation: change.operation || (change.oldString === "" && change.newString === "" ? "deleted" : change.oldString === "" ? "created" : "modified"),
+        }));
+    }
     const changes = [];
     for (const action of session.actions || []) {
-        if (action.type === "edit_file" && action.data) {
+        const data = (action.data || {});
+        const filePath = (data.filePath || data.path);
+        if (!filePath)
+            continue;
+        if (action.type === "edit_file") {
             changes.push({
-                filePath: action.data.filePath,
-                oldString: action.data.oldString,
-                newString: action.data.newString,
+                filePath,
+                oldString: data.oldString ?? "",
+                newString: data.newString ?? "",
+                operation: "modified",
             });
         }
-        else if (action.type === "create_file" && action.data) {
+        else if (action.type === "create_file") {
             changes.push({
-                filePath: action.data.filePath,
+                filePath,
                 oldString: "",
-                newString: action.data.content || "",
+                newString: data.content ?? "",
+                operation: "created",
             });
         }
-        else if (action.type === "delete_file" && action.data) {
+        else if (action.type === "delete_file") {
             changes.push({
-                filePath: action.data.filePath,
-                oldString: "(deleted)",
+                filePath,
+                oldString: data.oldContent ?? "(deleted)",
                 newString: "",
+                operation: "deleted",
             });
         }
     }
@@ -118,7 +139,11 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     let overlaySocket = null;
     const taskSnapshots = new Map();
     const activeSessions = new Map();
+    // Per-task runtime facade: LocalRuntime for local coding agents (executed
+    // in this process), RuntimeClient for hosted models (via Lasso server).
+    const taskFacades = new Map();
     const taskControllers = new Map();
+    const correctiveAttempts = new Map();
     const envRoots = [cwd, node_path_1.default.join(cwd, "web"), node_path_1.default.join(cwd, "server")];
     const fileEnv = envRoots.reduce((values, root) => ({
         ...values,
@@ -167,6 +192,27 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", provider: "google", locked: false },
         ];
     }
+    // Detect local coding agents (installed + authenticated) on this machine
+    const detectedBackends = await (0, backends_1.detectBackends)();
+    const BACKEND_LABELS = {
+        claude_code: "Claude Code",
+        opencode: "OpenCode",
+        codex_cli: "Codex CLI",
+        cursor: "Cursor",
+    };
+    for (const backend of detectedBackends) {
+        if (!backend.installed)
+            continue;
+        for (const option of backend.models) {
+            models.push({
+                id: option.id,
+                label: `${BACKEND_LABELS[backend.provider]} · ${option.label}`,
+                provider: backend.provider,
+                locked: !backend.authenticated,
+                lockedReason: backend.authenticated ? undefined : backend.error || `${BACKEND_LABELS[backend.provider]} is not authenticated.`,
+            });
+        }
+    }
     const pageIgnoredDirs = new Set(["node_modules", ".git", ".next", "dist", "build", ".turbo", "out", "coverage", ".vercel", ".cache"]);
     const resolveInsideProject = (root, relative) => {
         const target = node_path_1.default.resolve(root, relative && relative !== "." ? relative : "");
@@ -202,6 +248,128 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         res.writeHead(200, { "content-type": "application/json" });
         res.end(JSON.stringify({ ok: true }));
     });
+    // Shared runtime event handling for edit/ask, oneshot, and corrective runs.
+    // review=true opens the diff review on agent_completed (edit/ask flow).
+    function handleRuntimeEvent(event, socket, taskId, session, instruction, review) {
+        if (taskControllers.get(taskId)?.signal.aborted)
+            return;
+        switch (event.type) {
+            case "agent_started":
+            case "agent_reasoning":
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "thinking",
+                    message: event.data.summary || "Working...",
+                }));
+                break;
+            case "tool_started":
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "working",
+                    message: `Running ${event.data.tool || event.data.actionType || "tool"}...`,
+                }));
+                break;
+            case "tool_completed":
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "working",
+                    message: "Completed tool",
+                }));
+                break;
+            case "phase_changed": {
+                const phase = event.data.phase;
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "working",
+                    message: `Phase: ${phase}`,
+                }));
+                break;
+            }
+            case "verification_started":
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "review",
+                    message: "Verifying changes...",
+                }));
+                break;
+            case "verification_completed": {
+                const passed = event.data.success ?? event.data.passed;
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: passed ? "working" : "error",
+                    message: passed ? "Verification passed" : "Verification failed",
+                }));
+                break;
+            }
+            case "agent_completed":
+                if (!review)
+                    break;
+                void handleReviewReady(session, socket, taskId, instruction);
+                break;
+            case "error":
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "error",
+                    message: event.data.error || "Unknown error",
+                }));
+                break;
+            case "waiting_for_user":
+                socket.send(JSON.stringify({
+                    type: "agent_prompt",
+                    taskId,
+                    prompt: {
+                        message: event.data?.question || "Input required",
+                        kind: "input",
+                    },
+                }));
+                break;
+        }
+    }
+    // The server rolled the workspace back before review, so the current files
+    // are the originals: capture them for undo, then open the review panel.
+    async function handleReviewReady(session, socket, taskId, instruction) {
+        try {
+            const facade = taskFacades.get(taskId) || runtimeClient;
+            const finalSession = await facade.getSession(session.id);
+            const changes = extractChangesFromSession(finalSession);
+            if (changes.length > 0) {
+                taskSnapshots.set(taskId, changes.map((change) => {
+                    const abs = node_path_1.default.join(cwd, change.filePath);
+                    let content = null;
+                    try {
+                        content = node_fs_1.default.readFileSync(abs, "utf8");
+                    }
+                    catch {
+                        content = null; // did not exist before the task (created file)
+                    }
+                    return { filePath: change.filePath, content };
+                }));
+                (0, snapshot_1.createSnapshot)(cwd, taskId, instruction, changes.map((change) => change.filePath), undefined, session.id);
+            }
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "review",
+                message: changes.length > 0 ? "Review changes" : "No file changes were produced",
+                changes,
+            }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: error instanceof Error ? error.message : "Failed to load review changes",
+            }));
+        }
+    }
     // Handler for edit/ask - uses runtime
     async function handleEditOrAsk(message, socket, taskId, instruction, model, provider, context, element, messages) {
         taskControllers.get(taskId)?.abort();
@@ -214,6 +382,10 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             message: "Starting...",
         }));
         try {
+            const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
+            // Overlay model option ids are prefixed ("claude_code:sonnet") — the
+            // agent CLIs need the unprefixed/normalized form.
+            const backendModelId = (0, backends_1.modelIdForBackend)(model || "", provider || "");
             const sessionInput = {
                 userPrompt: instruction,
                 project: {
@@ -238,103 +410,21 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     route: context?.position?.route,
                     screenshot: context?.screenshots?.full,
                 } : undefined,
+                backendConfig: isLocalAgent ? {
+                    type: "local_agent",
+                    provider: provider,
+                    modelId: backendModelId,
+                    projectPath: cwd,
+                } : undefined,
             };
-            const session = await runtimeClient.createSession(sessionInput);
+            const facade = isLocalAgent ? (0, local_runtime_1.getLocalRuntime)() : runtimeClient;
+            const session = await facade.createSession(sessionInput);
             activeSessions.set(taskId, session);
-            // Create snapshot before changes
-            taskSnapshots.set(taskId, []);
-            // Note: Snapshot will be created after changes are extracted from session
-            await runtimeClient.runSession(session.id, cwd, (event) => {
-                if (controller.signal.aborted)
-                    return;
-                switch (event.type) {
-                    case "agent_started":
-                    case "agent_reasoning":
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "thinking",
-                            message: event.data.summary || "Working...",
-                        }));
-                        break;
-                    case "tool_started":
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "working",
-                            message: `Running ${event.data.tool || "tool"}...`,
-                        }));
-                        break;
-                    case "tool_completed":
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "working",
-                            message: "Completed tool",
-                        }));
-                        break;
-                    case "phase_changed":
-                        const phase = event.data.phase;
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "working",
-                            message: `Phase: ${phase}`,
-                        }));
-                        break;
-                    case "verification_started":
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "review",
-                            message: "Verifying changes...",
-                        }));
-                        break;
-                    case "verification_completed":
-                        const passed = event.data.passed;
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: passed ? "working" : "error",
-                            message: passed ? "Verification passed" : "Verification failed",
-                        }));
-                        break;
-                    case "agent_completed":
-                        runtimeClient.getSession(session.id).then((finalSession) => {
-                            const changes = extractChangesFromSession(finalSession);
-                            // Create snapshot with affected files
-                            const filePaths = changes.map(c => c.filePath);
-                            if (filePaths.length > 0) {
-                                (0, snapshot_1.createSnapshot)(cwd, taskId, `Runtime session: ${instruction}`, filePaths, undefined, session.id);
-                            }
-                            socket.send(JSON.stringify({
-                                type: "agent_status",
-                                taskId,
-                                status: "review",
-                                message: "Review changes",
-                                changes,
-                            }));
-                        });
-                        break;
-                    case "error":
-                        socket.send(JSON.stringify({
-                            type: "agent_status",
-                            taskId,
-                            status: "error",
-                            message: event.data.error || "Unknown error",
-                        }));
-                        break;
-                    case "waiting_for_user":
-                        socket.send(JSON.stringify({
-                            type: "agent_prompt",
-                            taskId,
-                            prompt: {
-                                message: event.data?.question || "Input required",
-                                kind: "input",
-                            },
-                        }));
-                        break;
-                }
+            taskFacades.set(taskId, facade);
+            // Originals are captured when the review is ready (the workspace was
+            // already rolled back at that point).
+            await facade.runSession(session.id, cwd, (event) => {
+                handleRuntimeEvent(event, socket, taskId, session, `Runtime session: ${instruction}`, true);
             }, controller.signal);
         }
         catch (error) {
@@ -346,55 +436,155 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             }));
         }
     }
-    // Handler for apply - applies pending changes
+    // Handler for apply - applies approved pending changes, then runs server-side
+    // verification. On failure a corrective run is started automatically.
     async function handleApply(message, socket, cwd) {
         const { taskId, changes } = message;
         const session = activeSessions.get(taskId);
-        const snapshot = taskSnapshots.get(taskId) || [];
-        // Create snapshot before applying changes
         const filePaths = changes.map((c) => c.filePath);
+        // The server rolled the workspace back before review, so the disk still
+        // holds the originals — capture them now (if the review didn't already).
+        if (filePaths.length > 0 && (!taskSnapshots.has(taskId) || (taskSnapshots.get(taskId) || []).length === 0)) {
+            taskSnapshots.set(taskId, changes.map((change) => {
+                const abs = node_path_1.default.join(cwd, change.filePath);
+                let content = null;
+                try {
+                    content = node_fs_1.default.readFileSync(abs, "utf8");
+                }
+                catch {
+                    content = null;
+                }
+                return { filePath: change.filePath, content };
+            }));
+        }
         if (filePaths.length > 0) {
             (0, snapshot_1.createSnapshot)(cwd, taskId, `Apply changes for task ${taskId}`, filePaths, undefined, session?.id);
         }
+        const applyError = applyChanges(changes, cwd);
+        if (applyError) {
+            // Roll back partial application so the project stays consistent
+            const originals = taskSnapshots.get(taskId) || [];
+            for (const item of originals) {
+                try {
+                    const abs = node_path_1.default.join(cwd, item.filePath);
+                    if (item.content === null) {
+                        if (node_fs_1.default.existsSync(abs))
+                            node_fs_1.default.unlinkSync(abs);
+                    }
+                    else {
+                        node_fs_1.default.mkdirSync(node_path_1.default.dirname(abs), { recursive: true });
+                        node_fs_1.default.writeFileSync(abs, item.content);
+                    }
+                }
+                catch { }
+            }
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: applyError,
+            }));
+            return;
+        }
+        // Post-apply verification (inconclusive when the engine can't run —
+        // never reported as a failure of the changes themselves).
+        let validation;
+        const facade = taskFacades.get(taskId) || runtimeClient;
+        if (session) {
+            try {
+                const result = await facade.verifySession(session.id, cwd);
+                validation = {
+                    passed: result.passed,
+                    errors: result.errors.map((e) => e.message),
+                    command: result.command || "verification",
+                };
+            }
+            catch {
+                validation = undefined;
+            }
+        }
+        socket.send(JSON.stringify({
+            type: "applied",
+            taskId,
+            message: "Changes applied successfully",
+            ...(validation ? { validation } : {}),
+        }));
+        if (validation && !validation.passed && session) {
+            await runCorrectiveFix(session, facade, taskId, socket);
+        }
+    }
+    /** Apply approved changes to disk. Returns an error message or null. */
+    function applyChanges(changes, cwd) {
         for (const change of changes) {
             const filePath = node_path_1.default.join(cwd, change.filePath);
             const dir = node_path_1.default.dirname(filePath);
+            const oldString = typeof change.oldString === "string" ? change.oldString : "";
+            const newString = typeof change.newString === "string" ? change.newString : "";
+            const operation = change.operation ||
+                (oldString === "" && newString === "" ? "deleted" : oldString === "" ? "created" : "modified");
             try {
                 if (!node_fs_1.default.existsSync(dir)) {
                     node_fs_1.default.mkdirSync(dir, { recursive: true });
                 }
-                if (change.oldString === "" && change.newString === "") {
-                    // Delete file
+                if (operation === "deleted") {
                     if (node_fs_1.default.existsSync(filePath)) {
                         node_fs_1.default.unlinkSync(filePath);
                     }
                 }
-                else if (change.oldString === "") {
-                    // Create file
-                    node_fs_1.default.writeFileSync(filePath, change.newString);
+                else if (operation === "created" || (oldString === "" && operation !== "modified")) {
+                    node_fs_1.default.writeFileSync(filePath, newString);
                 }
                 else {
-                    // Edit file
+                    // Full-content replacement; split/join avoids String.replace's
+                    // special $-pattern handling in the replacement text.
                     const content = node_fs_1.default.readFileSync(filePath, "utf8");
-                    const newContent = content.replace(change.oldString, change.newString);
-                    node_fs_1.default.writeFileSync(filePath, newContent);
+                    let next;
+                    if (content === oldString) {
+                        next = newString;
+                    }
+                    else if (oldString && content.includes(oldString)) {
+                        next = content.split(oldString).join(newString);
+                    }
+                    else {
+                        return `Cannot apply ${change.filePath}: the file changed since the diff was generated.`;
+                    }
+                    node_fs_1.default.writeFileSync(filePath, next);
                 }
             }
             catch (error) {
-                socket.send(JSON.stringify({
-                    type: "agent_status",
-                    taskId,
-                    status: "error",
-                    message: `Failed to apply ${change.filePath}: ${error instanceof Error ? error.message : "Unknown error"}`,
-                }));
-                return;
+                return `Failed to apply ${change.filePath}: ${error instanceof Error ? error.message : "Unknown error"}`;
             }
         }
+        return null;
+    }
+    // Automatic corrective run after failed post-apply verification (bounded).
+    async function runCorrectiveFix(session, facade, taskId, socket) {
+        const attempts = correctiveAttempts.get(taskId) || 0;
+        if (attempts >= 2)
+            return;
+        correctiveAttempts.set(taskId, attempts + 1);
+        taskControllers.get(taskId)?.abort();
+        const controller = new AbortController();
+        taskControllers.set(taskId, controller);
         socket.send(JSON.stringify({
-            type: "applied",
+            type: "agent_status",
             taskId,
-            message: "Changes applied successfully",
+            status: "thinking",
+            message: "Fixing verification errors...",
         }));
+        try {
+            await facade.runSession(session.id, cwd, (event) => {
+                handleRuntimeEvent(event, socket, taskId, session, "Corrective run", true);
+            }, controller.signal);
+        }
+        catch (error) {
+            socket.send(JSON.stringify({
+                type: "agent_status",
+                taskId,
+                status: "error",
+                message: error instanceof Error ? error.message : "Corrective run failed",
+            }));
+        }
     }
     // Handler for undo - restores snapshot
     async function handleUndo(message, socket, cwd) {
@@ -424,13 +614,24 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
         const { taskId } = message;
         if (taskId) {
             taskControllers.get(taskId)?.abort();
+            const session = activeSessions.get(taskId);
+            const facade = taskFacades.get(taskId);
+            if (session && facade)
+                void facade.cancelSession(session.id).catch(() => { });
             activeSessions.delete(taskId);
+            taskFacades.delete(taskId);
         }
         else {
             for (const controller of taskControllers.values())
                 controller.abort();
             taskControllers.clear();
+            for (const [id, session] of activeSessions) {
+                const facade = taskFacades.get(id);
+                if (facade)
+                    void facade.cancelSession(session.id).catch(() => { });
+            }
             activeSessions.clear();
+            taskFacades.clear();
         }
         socket.send(JSON.stringify({
             type: "agent_status",
@@ -453,10 +654,19 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             return;
         }
         try {
-            await runtimeClient.switchModel(session.id, {
+            const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
+            const facade = taskFacades.get(taskId) || runtimeClient;
+            await facade.switchModel(session.id, {
                 provider: provider,
                 id: modelId,
-            });
+            }, undefined, isLocalAgent
+                ? {
+                    type: "local_agent",
+                    provider: provider,
+                    modelId: (0, backends_1.modelIdForBackend)(modelId || "", provider || ""),
+                    projectPath: cwd,
+                }
+                : undefined);
             socket.send(JSON.stringify({
                 type: "agent_status",
                 taskId,
@@ -487,6 +697,8 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             message: "Starting oneshot...",
         }));
         try {
+            const isLocalAgent = ["claude_code", "opencode", "codex_cli", "cursor"].includes(provider || "");
+            const backendModelId = (0, backends_1.modelIdForBackend)(model || "", provider || "");
             const sessionInput = {
                 userPrompt: prompt,
                 project: {
@@ -500,32 +712,26 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     provider: (provider || "anthropic"),
                     id: model || "claude-3-5-sonnet-20241022",
                 },
+                backendConfig: isLocalAgent ? {
+                    type: "local_agent",
+                    provider: provider,
+                    modelId: backendModelId,
+                    projectPath: cwd,
+                } : undefined,
             };
-            const session = await runtimeClient.createSession(sessionInput);
+            const facade = isLocalAgent ? (0, local_runtime_1.getLocalRuntime)() : runtimeClient;
+            const session = await facade.createSession(sessionInput);
             activeSessions.set(taskId, session);
-            await runtimeClient.runSession(session.id, cwd, (event) => {
-                if (controller.signal.aborted)
-                    return;
+            taskFacades.set(taskId, facade);
+            await facade.runSession(session.id, cwd, (event) => {
+                // Oneshot results are reviewed exactly like edit/ask: the workspace is
+                // rolled back and only approval re-applies the changes.
+                handleRuntimeEvent(event, socket, taskId, session, `Oneshot: ${instruction}`, true);
                 if (event.type === "agent_completed") {
-                    runtimeClient.getSession(session.id).then((finalSession) => {
-                        const changes = extractChangesFromSession(finalSession);
-                        const filePaths = changes.map(c => c.filePath);
-                        if (filePaths.length > 0) {
-                            (0, snapshot_1.createSnapshot)(cwd, taskId, `Oneshot: ${instruction}`, filePaths, undefined, session.id);
-                        }
-                        socket.send(JSON.stringify({
-                            type: "assistant_message",
-                            taskId,
-                            message: "Oneshot completed",
-                        }));
-                    });
-                }
-                else if (event.type === "error") {
                     socket.send(JSON.stringify({
-                        type: "agent_status",
+                        type: "assistant_message",
                         taskId,
-                        status: "error",
-                        message: event.data.error || "Runtime error",
+                        message: "Oneshot completed",
                     }));
                 }
             }, controller.signal);
@@ -543,7 +749,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     async function handleRestoreSnapshot(message, socket, cwd) {
         const { snapshotId } = message;
         try {
-            await (0, snapshot_1.restoreSnapshot)(snapshotId, cwd);
+            await (0, snapshot_1.restoreSnapshot)(cwd, snapshotId);
             socket.send(JSON.stringify({
                 type: "agent_status",
                 status: "working",
@@ -579,7 +785,7 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
     async function handleDeleteSnapshot(message, socket, cwd) {
         const { snapshotId } = message;
         try {
-            await (0, snapshot_1.deleteSnapshot)(snapshotId, cwd);
+            await (0, snapshot_1.deleteSnapshot)(cwd, snapshotId);
             socket.send(JSON.stringify({
                 type: "agent_status",
                 status: "working",