@lasso-ai/cli 1.4.5 → 2.0.0

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/host/next-host-entry.js

@@ -130,13 +130,11 @@ void (async () => {
         await waitForNext(nextPort, nextProcess);
     }
     catch (error) {
-        bridge.close();
         nextProcess.kill("SIGTERM");
         throw error;
     }
     server.listen(publicPort, "127.0.0.1");
     const shutdown = () => {
-        bridge.close();
         nextProcess.kill("SIGTERM");
         proxy.close();
         server.close(() => process.exit(0));

package/dist/cli/host/vite-host-entry.js

@@ -27,7 +27,7 @@ function lassoOverlayPlugin() {
     };
 }
 void (async () => {
-    const bridge = await (0, bridge_1.startBridge)(cwd, null, bridgePort);
+    await (0, bridge_1.startBridge)(cwd, null, bridgePort);
     const require = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
     const viteEntry = require.resolve("vite");
     const { createServer } = await import((0, node_url_1.pathToFileURL)(viteEntry).href);
@@ -49,11 +49,9 @@ void (async () => {
     });
     await server.listen();
     process.on("SIGTERM", () => {
-        bridge.close();
         void server.close().then(() => process.exit(0));
     });
     process.on("SIGINT", () => {
-        bridge.close();
         void server.close().then(() => process.exit(0));
     });
 })();

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;
+}