@lasso-ai/cli 1.5.0 → 2.0.1

package/dist/cli/host/install.js

@@ -27,7 +27,18 @@ const AGENT_LABEL = "com.lasso.host";
 const LAUNCH_AGENT_FILE = node_path_1.default.join(node_os_1.default.homedir(), "Library", "LaunchAgents", `${AGENT_LABEL}.plist`);
 function cliEntry() {
     const entry = process.argv[1];
-    return entry && entry.endsWith(".js") ? entry : null;
+    if (!entry)
+        return null;
+    // Resolve symlinks (e.g. pnpm's global bin is extensionless) so the
+    // spawned child gets a real .js path.
+    let resolved = entry;
+    try {
+        resolved = node_fs_1.default.realpathSync(entry);
+    }
+    catch {
+        // keep the original if realpath fails
+    }
+    return resolved.endsWith(".js") ? resolved : null;
 }
 function spawnDaemon(env) {
     const port = (0, paths_1.hostProxyPort)(env);

package/dist/cli/local-runtime.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LocalRuntime — local coding agent execution on the user's machine.
+ *
+ * Implements the same session surface the CLI bridge uses for hosted
+ * sessions (RuntimeClient), but runs Claude Code / OpenCode / Codex CLI /
+ * Cursor Agent in THIS process: prompts, project context, and source code
+ * never travel through Lasso's server. Session state is in-memory (per CLI
+ * process) and the review-first workflow comes from the shared runtime core
+ * (LocalSessionRunner + WorkspaceGuard + VerificationEngine).
+ */
+import type { RuntimeSession, RuntimeSessionInput, RuntimeEventHandler, SessionVerificationResult, RuntimeFacade } from "./runtime-client.js";
+export declare class LocalRuntime implements RuntimeFacade {
+    private sessions;
+    private abortControllers;
+    createSession(input: RuntimeSessionInput): Promise<RuntimeSession>;
+    getSession(sessionId: string): Promise<RuntimeSession>;
+    runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal): Promise<void>;
+    verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
+    switchModel(sessionId: string, model: {
+        provider: string;
+        id: string;
+        name?: string;
+    }, _apiKey?: string, backendConfig?: RuntimeSessionInput["backendConfig"]): Promise<void>;
+    cancelSession(sessionId: string): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    private toSession;
+}
+export declare function getLocalRuntime(): LocalRuntime;

package/dist/cli/local-runtime.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * LocalRuntime — local coding agent execution on the user's machine.
+ *
+ * Implements the same session surface the CLI bridge uses for hosted
+ * sessions (RuntimeClient), but runs Claude Code / OpenCode / Codex CLI /
+ * Cursor Agent in THIS process: prompts, project context, and source code
+ * never travel through Lasso's server. Session state is in-memory (per CLI
+ * process) and the review-first workflow comes from the shared runtime core
+ * (LocalSessionRunner + WorkspaceGuard + VerificationEngine).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRuntime = void 0;
+exports.getLocalRuntime = getLocalRuntime;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const index_js_1 = require("../runtime/index.js");
+class LocalRuntime {
+    sessions = new Map();
+    abortControllers = new Map();
+    async createSession(input) {
+        const backendConfig = input.backendConfig;
+        if (!(0, index_js_1.isLocalAgentConfig)(backendConfig)) {
+            throw new Error("LocalRuntime only accepts local_agent backend configs");
+        }
+        if (!backendConfig.projectPath) {
+            throw new Error("LocalRuntime requires backendConfig.projectPath");
+        }
+        const id = node_crypto_1.default.randomUUID();
+        const now = new Date();
+        const record = {
+            id,
+            phase: "execute",
+            status: "running",
+            iteration: 0,
+            userPrompt: input.userPrompt,
+            conversation: [
+                { id: node_crypto_1.default.randomUUID(), role: "user", content: input.userPrompt, timestamp: now.getTime() },
+            ],
+            observations: [],
+            actions: [],
+            completedActions: [],
+            errors: [],
+            selection: input.selection,
+            project: input.project,
+            model: input.model,
+            createdAt: now,
+            updatedAt: now,
+            metadata: { backendConfig },
+            backendConfig: { ...backendConfig, type: "local_agent" },
+            projectPath: backendConfig.projectPath,
+            input,
+            running: false,
+        };
+        this.sessions.set(id, record);
+        return this.toSession(record);
+    }
+    async getSession(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            throw new Error("Session not found");
+        return this.toSession(record);
+    }
+    async runSession(sessionId, projectPath, onEvent, signal) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            throw new Error("Session not found");
+        if (record.running)
+            throw new Error("Session is already running");
+        record.running = true;
+        record.status = "running";
+        record.phase = "execute";
+        record.updatedAt = new Date();
+        const controller = new AbortController();
+        this.abortControllers.set(sessionId, controller);
+        const onOuterAbort = () => controller.abort();
+        signal?.addEventListener("abort", onOuterAbort, { once: true });
+        const emit = (event) => {
+            void onEvent(event);
+        };
+        try {
+            // Fresh capture per run — corrective re-runs capture the post-apply state.
+            const guard = await index_js_1.WorkspaceGuard.capture(projectPath);
+            record.backend =
+                record.backend ||
+                    (await (0, index_js_1.createLocalAgentBackend)({ ...record.backendConfig, type: "local_agent", projectPath }));
+            const previousErrors = (record.errors || []);
+            const externalSessionId = typeof record.metadata.backendSessionId === "string" ? record.metadata.backendSessionId : undefined;
+            const runner = new index_js_1.LocalSessionRunner({
+                sessionId: record.id,
+                backend: record.backend,
+                guard,
+                emit,
+                phase: "execute",
+            });
+            const outcome = await runner.run({
+                taskId: record.id,
+                userPrompt: record.userPrompt,
+                project: {
+                    projectId: record.project.projectId || "local",
+                    framework: record.project.framework,
+                    hasTypeScript: Boolean(record.project.hasTypeScript),
+                    hasTailwind: false,
+                    hasReact: Boolean(record.project.hasReact),
+                    hasNext: Boolean(record.project.hasNext),
+                    hasVite: Boolean(record.project.hasVite),
+                    files: record.project.files || [],
+                },
+                selection: record.selection,
+                conversation: record.conversation.map((msg) => ({
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: msg.timestamp,
+                })),
+                previousObservations: [],
+                previousErrors,
+                currentPhase: "execute",
+                constraints: { safetyLevel: "standard" },
+                sessionRef: externalSessionId ? { id: externalSessionId } : undefined,
+            }, controller.signal);
+            // Persist review payload + normalized actions for the review flow.
+            record.actions = outcome.actions;
+            record.observations.push(...outcome.observations.map((obs) => ({
+                id: obs.id,
+                type: String(obs.type),
+                summary: obs.summary,
+                data: obs.data,
+                timestamp: obs.timestamp,
+                phase: String(obs.phase),
+            })));
+            record.errors = outcome.errors.map((err) => ({
+                id: err.id,
+                type: String(err.type),
+                message: err.message,
+                phase: String(err.phase),
+                timestamp: err.timestamp,
+                recoverable: err.recoverable,
+            }));
+            if (outcome.conversation.length > 0) {
+                record.conversation.push(...outcome.conversation.map((msg) => ({
+                    id: node_crypto_1.default.randomUUID(),
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: msg.timestamp,
+                })));
+            }
+            record.metadata = {
+                ...record.metadata,
+                ...outcome.metadata,
+                pendingChanges: outcome.changes,
+                binaryChanges: outcome.binaryPaths,
+            };
+            record.status =
+                outcome.status === "waiting" ? "waiting" : outcome.status === "completed" ? "completed" : "failed";
+            record.phase = "complete";
+            record.updatedAt = new Date();
+        }
+        catch (error) {
+            record.status = "failed";
+            record.errors = [
+                ...record.errors,
+                {
+                    id: node_crypto_1.default.randomUUID(),
+                    type: "execution",
+                    message: error instanceof Error ? error.message : "Local agent run failed",
+                    phase: "execute",
+                    timestamp: Date.now(),
+                    recoverable: false,
+                },
+            ];
+            record.updatedAt = new Date();
+            emit({
+                type: "error",
+                sessionId: record.id,
+                timestamp: Date.now(),
+                data: { error: error instanceof Error ? error.message : "Local agent run failed" },
+            });
+        }
+        finally {
+            signal?.removeEventListener("abort", onOuterAbort);
+            this.abortControllers.delete(sessionId);
+            record.running = false;
+        }
+    }
+    async verifySession(sessionId, projectPath) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            throw new Error("Session not found");
+        const engine = new index_js_1.VerificationEngine(projectPath);
+        const results = await engine.verifyAll("verify");
+        const observations = engine.getObservations(results);
+        const errors = engine.getErrors(results);
+        const passed = engine.allPassed(results);
+        // Keep verification errors so a corrective re-run receives them as context.
+        if (!passed) {
+            record.errors = [
+                ...record.errors,
+                ...errors.map((err) => ({
+                    id: err.id,
+                    type: String(err.type),
+                    message: err.message,
+                    phase: String(err.phase),
+                    timestamp: err.timestamp,
+                    recoverable: err.recoverable,
+                })),
+            ];
+        }
+        const command = results.map((r) => r.command).find((c) => typeof c === "string");
+        return { passed, errors, observations, command, requiresFix: !passed };
+    }
+    async switchModel(sessionId, model, _apiKey, backendConfig) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            throw new Error("Session not found");
+        if (!(0, index_js_1.isLocalAgentConfig)(backendConfig)) {
+            throw new Error("LocalRuntime.switchModel requires a local_agent backendConfig");
+        }
+        const nextBackend = await (0, index_js_1.createLocalAgentBackend)({ ...backendConfig, type: "local_agent" });
+        if (record.backend) {
+            await record.backend.switchBackend(nextBackend, {
+                taskId: record.id,
+                userPrompt: record.userPrompt,
+                project: {
+                    projectId: record.project.projectId || "local",
+                    hasTypeScript: Boolean(record.project.hasTypeScript),
+                    hasTailwind: false,
+                    hasReact: Boolean(record.project.hasReact),
+                    hasNext: Boolean(record.project.hasNext),
+                    hasVite: Boolean(record.project.hasVite),
+                    files: record.project.files || [],
+                },
+                conversation: [],
+                previousObservations: [],
+                previousErrors: [],
+                currentPhase: "execute",
+                constraints: {},
+                sessionRef: typeof record.metadata.backendSessionId === "string"
+                    ? { id: record.metadata.backendSessionId }
+                    : undefined,
+            });
+        }
+        record.backend = nextBackend;
+        record.backendConfig = { ...backendConfig, type: "local_agent" };
+        record.model = { provider: model.provider, id: model.id, name: model.name };
+        record.metadata = {
+            ...record.metadata,
+            backendConfig: record.backendConfig,
+            backendModel: model.id,
+        };
+        // Switching agents drops the previous agent's external session: context
+        // cannot be transferred across CLI agents.
+        delete record.metadata.backendSessionId;
+        record.updatedAt = new Date();
+    }
+    async cancelSession(sessionId) {
+        const controller = this.abortControllers.get(sessionId);
+        if (controller)
+            controller.abort();
+    }
+    async deleteSession(sessionId) {
+        this.sessions.delete(sessionId);
+        this.abortControllers.delete(sessionId);
+    }
+    toSession(record) {
+        return {
+            id: record.id,
+            phase: record.phase,
+            status: record.status,
+            iteration: record.iteration,
+            userPrompt: record.userPrompt,
+            conversation: record.conversation,
+            observations: record.observations,
+            actions: record.actions,
+            completedActions: record.completedActions,
+            errors: record.errors,
+            selection: record.selection,
+            project: record.project,
+            model: record.model,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+            metadata: record.metadata,
+        };
+    }
+}
+exports.LocalRuntime = LocalRuntime;
+/** Process-wide local runtime (sessions live for the CLI bridge lifetime). */
+let sharedLocalRuntime;
+function getLocalRuntime() {
+    if (!sharedLocalRuntime)
+        sharedLocalRuntime = new LocalRuntime();
+    return sharedLocalRuntime;
+}

package/dist/cli/oneshot.js

@@ -138,7 +138,7 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
                     onProgress("review", "Verifying changes...");
                     break;
                 case "verification_completed":
-                    const passed = event.data.passed;
+                    const passed = event.data.success ?? event.data.passed;
                     onProgress(passed ? "working" : "error", passed ? "Verification passed" : "Verification failed");
                     break;
                 case "waiting_for_user":
@@ -173,27 +173,45 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
 function extractChangesFromSession(session) {
     if (!session)
         return [];
+    const pending = session.metadata?.pendingChanges;
+    if (Array.isArray(pending) && pending.length > 0) {
+        return pending.map((change) => ({
+            filePath: change.filePath ?? change.path,
+            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) {
+        if (!action.data)
+            continue;
+        const filePath = action.data.filePath ?? action.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: action.data.oldString ?? "",
+                newString: action.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 || "",
+                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: action.data.oldContent ?? "(deleted)",
                 newString: "",
+                operation: "deleted",
             });
         }
     }

package/dist/cli/runtime-client.d.ts

@@ -4,6 +4,7 @@
  * Client for the new Lasso Agentic Runtime
  * Uses SSE for real-time progress events
  */
+export type RuntimeProvider = "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
 export interface RuntimeSessionInput {
     userPrompt: string;
     project: {
@@ -17,7 +18,7 @@ export interface RuntimeSessionInput {
         currentRoute?: string;
     };
     model: {
-        provider: "anthropic" | "openai" | "google" | "nvidia" | "ollama";
+        provider: RuntimeProvider;
         id: string;
         name?: string;
     };
@@ -38,6 +39,12 @@ export interface RuntimeSessionInput {
         screenshot?: string;
     };
     conversationUid?: string;
+    backendConfig?: {
+        type: "hosted_model" | "local_agent";
+        provider: "claude_code" | "opencode" | "codex_cli" | "cursor";
+        modelId?: string;
+        projectPath?: string;
+    };
 }
 export interface RuntimeSession {
     id: string;
@@ -97,6 +104,44 @@ export interface RuntimeSession {
     conversationUid?: string;
     createdAt: Date;
     updatedAt: Date;
+    /** Runtime-owned metadata: pendingChanges, backendConfig, backendSessionId, … */
+    metadata?: Record<string, unknown>;
+}
+/** Result of post-apply verification (typecheck/build via VerificationEngine). */
+export interface SessionVerificationResult {
+    passed: boolean;
+    errors: Array<{
+        id: string;
+        type: string;
+        message: string;
+        phase: string;
+        timestamp: number;
+        recoverable: boolean;
+    }>;
+    observations: Array<{
+        id: string;
+        type: string;
+        summary: string;
+        timestamp: number;
+    }>;
+    command?: string;
+    requiresFix: boolean;
+}
+/**
+ * The session surface shared by RuntimeClient (hosted, via Lasso server) and
+ * LocalRuntime (local coding agents, executed in this process).
+ */
+export interface RuntimeFacade {
+    createSession(input: RuntimeSessionInput): Promise<RuntimeSession>;
+    runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal): Promise<void>;
+    getSession(sessionId: string): Promise<RuntimeSession>;
+    verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
+    switchModel(sessionId: string, model: {
+        provider: string;
+        id: string;
+        name?: string;
+    }, apiKey?: string, backendConfig?: RuntimeSessionInput["backendConfig"]): Promise<void>;
+    cancelSession(sessionId: string): Promise<void>;
 }
 export type RuntimeEvent = {
     type: "agent_started";
@@ -166,12 +211,7 @@ export type RuntimeEvent = {
 } | {
     type: "error";
     sessionId: string;
-    data: {
-        errorType: string;
-        message: string;
-        phase: string;
-        recoverable: boolean;
-    };
+    data: Record<string, unknown>;
     timestamp: number;
 } | {
     type: "model_changed";
@@ -184,7 +224,22 @@ export type RuntimeEvent = {
 } | {
     type: "agent_completed";
     sessionId: string;
-    data: {};
+    data: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "agent_cancelled";
+    sessionId: string;
+    data: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "agent_failed";
+    sessionId: string;
+    data: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "file_changed";
+    sessionId: string;
+    data: Record<string, unknown>;
     timestamp: number;
 } | {
     type: "started";
@@ -215,13 +270,39 @@ export declare class RuntimeClient {
      */
     cancelSession(sessionId: string): Promise<void>;
     /**
-     * Switch model for a session
+     * Switch model/backend for a session
      */
     switchModel(sessionId: string, model: {
         provider: string;
         id: string;
         name?: string;
-    }, apiKey?: string): Promise<void>;
+    }, apiKey?: string, backendConfig?: RuntimeSessionInput["backendConfig"]): Promise<void>;
+    /**
+     * Verify the workspace for a session (after reviewed changes were applied).
+     *
+     * Returns whether verification passed; on failure the session keeps the
+     * verification errors so a corrective re-run can fix them.
+     */
+    verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
+    /**
+     * List available backends from the server (hosted providers + local agents).
+     */
+    listBackends(projectPath?: string): Promise<{
+        backends: Array<{
+            provider: string;
+            type: string;
+            available: boolean;
+            authenticated: boolean;
+            installed?: boolean;
+            version?: string;
+            error?: string;
+            fixInstructions?: string;
+            models?: Array<{
+                id: string;
+                label: string;
+            }>;
+        }>;
+    }>;
     /**
      * Delete a session
      */

package/dist/cli/runtime-client.js

@@ -110,21 +110,56 @@ class RuntimeClient {
         }
     }
     /**
-     * Switch model for a session
+     * Switch model/backend for a session
      */
-    async switchModel(sessionId, model, apiKey) {
+    async switchModel(sessionId, model, apiKey, backendConfig) {
         const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/model`, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
                 ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
             },
-            body: JSON.stringify({ ...model, apiKey }),
+            body: JSON.stringify({ ...model, apiKey, backendConfig }),
         });
         if (!response.ok) {
             throw new Error(`Failed to switch model: ${response.statusText}`);
         }
     }
+    /**
+     * Verify the workspace for a session (after reviewed changes were applied).
+     *
+     * Returns whether verification passed; on failure the session keeps the
+     * verification errors so a corrective re-run can fix them.
+     */
+    async verifySession(sessionId, projectPath) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/verify`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+            body: JSON.stringify({ projectPath }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to verify session: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    /**
+     * List available backends from the server (hosted providers + local agents).
+     */
+    async listBackends(projectPath) {
+        const url = `${this.serverUrl}/api/v1/agent-runtime/backends${projectPath ? `?projectPath=${encodeURIComponent(projectPath)}` : ""}`;
+        const response = await fetch(url, {
+            headers: {
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list backends: ${response.statusText}`);
+        }
+        return (await response.json());
+    }
     /**
      * Delete a session
      */