@lasso-ai/cli 1.4.5 → 2.0.0

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

@@ -0,0 +1,310 @@
+/**
+ * Lasso Runtime Client
+ *
+ * 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: {
+        projectId: string;
+        framework?: string;
+        hasTypeScript?: boolean;
+        hasReact?: boolean;
+        hasNext?: boolean;
+        hasVite?: boolean;
+        files?: string[];
+        currentRoute?: string;
+    };
+    model: {
+        provider: RuntimeProvider;
+        id: string;
+        name?: string;
+    };
+    selection?: {
+        element?: {
+            tag?: string;
+            text?: string;
+            source?: string;
+            attributes?: Record<string, string>;
+        };
+        viewport?: {
+            width: number;
+            height: number;
+            scrollY?: number;
+            scrollHeight?: number;
+        };
+        route?: string;
+        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;
+    phase: "understand" | "inspect" | "plan" | "execute" | "verify" | "recover" | "complete";
+    status: "running" | "waiting" | "completed" | "failed" | "cancelled";
+    iteration: number;
+    userPrompt: string;
+    conversation: Array<{
+        id: string;
+        role: "user" | "assistant" | "system" | "tool";
+        content: string;
+        timestamp: number;
+        metadata?: Record<string, unknown>;
+    }>;
+    observations: Array<{
+        id: string;
+        type: string;
+        summary: string;
+        data?: unknown;
+        timestamp: number;
+        phase?: string;
+        actionId?: string;
+    }>;
+    actions: Array<{
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    }>;
+    completedActions: Array<{
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    }>;
+    errors: Array<{
+        id: string;
+        type: string;
+        message: string;
+        phase: string;
+        actionId?: string;
+        timestamp: number;
+        recoverable: boolean;
+    }>;
+    plan?: {
+        id: string;
+        goal: string;
+        steps: Array<{
+            id: string;
+            description: string;
+            status: string;
+            actionCount?: number;
+        }>;
+        estimatedActions?: number;
+    };
+    selection?: RuntimeSessionInput["selection"];
+    project: RuntimeSessionInput["project"];
+    model: RuntimeSessionInput["model"];
+    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";
+    sessionId: string;
+    data: {};
+    timestamp: number;
+} | {
+    type: "agent_reasoning";
+    sessionId: string;
+    data: {
+        summary: string;
+    };
+    timestamp: number;
+} | {
+    type: "phase_changed";
+    sessionId: string;
+    data: {
+        from: string;
+        to: string;
+    };
+    timestamp: number;
+} | {
+    type: "tool_started";
+    sessionId: string;
+    data: {
+        actionType: string;
+    };
+    timestamp: number;
+} | {
+    type: "tool_completed";
+    sessionId: string;
+    data: {
+        actionType: string;
+        success: boolean;
+    };
+    timestamp: number;
+} | {
+    type: "observation";
+    sessionId: string;
+    data: {
+        observationType: string;
+        summary: string;
+    };
+    timestamp: number;
+} | {
+    type: "verification_started";
+    sessionId: string;
+    data: {
+        verificationType: string;
+    };
+    timestamp: number;
+} | {
+    type: "verification_completed";
+    sessionId: string;
+    data: {
+        verificationType: string;
+        success: boolean;
+    };
+    timestamp: number;
+} | {
+    type: "waiting_for_user";
+    sessionId: string;
+    data: {
+        question: string;
+    };
+    timestamp: number;
+} | {
+    type: "error";
+    sessionId: string;
+    data: Record<string, unknown>;
+    timestamp: number;
+} | {
+    type: "model_changed";
+    sessionId: string;
+    data: {
+        from: any;
+        to: any;
+    };
+    timestamp: number;
+} | {
+    type: "agent_completed";
+    sessionId: string;
+    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";
+    sessionId: string;
+} | {
+    type: "completed";
+    sessionId: string;
+};
+export type RuntimeEventHandler = (event: RuntimeEvent) => void | Promise<void>;
+export declare class RuntimeClient {
+    private serverUrl;
+    private apiKey?;
+    constructor(serverUrl: string, apiKey?: string);
+    /**
+     * Create a new runtime session
+     */
+    createSession(input: RuntimeSessionInput): Promise<RuntimeSession>;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): Promise<RuntimeSession>;
+    /**
+     * Run a session with SSE event streaming
+     */
+    runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal): Promise<void>;
+    /**
+     * Cancel a running session
+     */
+    cancelSession(sessionId: string): Promise<void>;
+    /**
+     * Switch model/backend for a session
+     */
+    switchModel(sessionId: string, model: {
+        provider: string;
+        id: string;
+        name?: string;
+    }, 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
+     */
+    deleteSession(sessionId: string): Promise<void>;
+}

package/dist/cli/runtime-client.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Lasso Runtime Client
+ *
+ * Client for the new Lasso Agentic Runtime
+ * Uses SSE for real-time progress events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeClient = void 0;
+class RuntimeClient {
+    serverUrl;
+    apiKey;
+    constructor(serverUrl, apiKey) {
+        this.serverUrl = serverUrl;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Create a new runtime session
+     */
+    async createSession(input) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+            body: JSON.stringify(input),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to create session: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * Get a session by ID
+     */
+    async getSession(sessionId) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}`, {
+            headers: {
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get session: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * Run a session with SSE event streaming
+     */
+    async runSession(sessionId, projectPath, onEvent, signal) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/run`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+            body: JSON.stringify({ projectPath }),
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to run session: ${response.statusText}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error("No response body");
+        }
+        const decoder = new TextDecoder();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value);
+                const lines = chunk.split("\n");
+                for (const line of lines) {
+                    if (!line.trim() || !line.startsWith("data: "))
+                        continue;
+                    const data = line.slice(6);
+                    if (data === "[DONE]")
+                        continue;
+                    try {
+                        const event = JSON.parse(data);
+                        await onEvent(event);
+                    }
+                    catch (error) {
+                        console.error("Failed to parse SSE event:", error);
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Cancel a running session
+     */
+    async cancelSession(sessionId) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/cancel`, {
+            method: "POST",
+            headers: {
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to cancel session: ${response.statusText}`);
+        }
+    }
+    /**
+     * Switch model/backend for a session
+     */
+    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, 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
+     */
+    async deleteSession(sessionId) {
+        const response = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}`, {
+            method: "DELETE",
+            headers: {
+                ...(this.apiKey && { "Authorization": `Bearer ${this.apiKey}` }),
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to delete session: ${response.statusText}`);
+        }
+    }
+}
+exports.RuntimeClient = RuntimeClient;

package/dist/cli/snapshot.d.ts

@@ -7,6 +7,7 @@ export type FileSnapshot = {
 export type TimelineSnapshot = {
     id: string;
     taskId: string;
+    sessionId?: string;
     summary: string;
     files: FileSnapshot[];
     createdAt: string;
@@ -19,7 +20,7 @@ export type ConflictInfo = {
     originalContent: string;
     currentContent: string;
 };
-export declare function createSnapshot(cwd: string, taskId: string, summary: string, filePaths: string[], parentSnapshotId?: string): TimelineSnapshot;
+export declare function createSnapshot(cwd: string, taskId: string, summary: string, filePaths: string[], parentSnapshotId?: string, sessionId?: string): TimelineSnapshot;
 export declare function restoreSnapshot(cwd: string, snapshotId: string): boolean;
 export declare function detectConflicts(cwd: string, expectedFiles: Array<{
     filePath: string;
@@ -30,4 +31,5 @@ export declare function getTimeline(cwd: string, limit?: number): TimelineSnapsh
 export declare function deleteSnapshot(cwd: string, snapshotId: string): boolean;
 export declare function clearSnapshots(cwd: string): void;
 export declare function getSnapshotByTaskId(cwd: string, taskId: string): TimelineSnapshot | undefined;
+export declare function getSnapshotBySessionId(cwd: string, sessionId: string): TimelineSnapshot | undefined;
 export declare function getLatestSnapshot(cwd: string): TimelineSnapshot | undefined;

package/dist/cli/snapshot.js

@@ -10,6 +10,7 @@ exports.getTimeline = getTimeline;
 exports.deleteSnapshot = deleteSnapshot;
 exports.clearSnapshots = clearSnapshots;
 exports.getSnapshotByTaskId = getSnapshotByTaskId;
+exports.getSnapshotBySessionId = getSnapshotBySessionId;
 exports.getLatestSnapshot = getLatestSnapshot;
 // src/cli/snapshot.ts
 // Local history snapshot system for safe concurrent edits
@@ -59,7 +60,7 @@ function saveTimeline(cwd, timeline) {
     }
 }
 // Create a snapshot of current file states
-function createSnapshot(cwd, taskId, summary, filePaths, parentSnapshotId) {
+function createSnapshot(cwd, taskId, summary, filePaths, parentSnapshotId, sessionId) {
     ensureSnapshotsDir(cwd);
     const snapshotId = generateSnapshotId();
     const files = [];
@@ -87,6 +88,7 @@ function createSnapshot(cwd, taskId, summary, filePaths, parentSnapshotId) {
     const snapshot = {
         id: snapshotId,
         taskId,
+        sessionId,
         summary,
         files,
         createdAt: timestamp,
@@ -218,6 +220,11 @@ function getSnapshotByTaskId(cwd, taskId) {
     const timeline = loadTimeline(cwd);
     return timeline.find((s) => s.taskId === taskId);
 }
+// Get snapshot by session ID
+function getSnapshotBySessionId(cwd, sessionId) {
+    const timeline = loadTimeline(cwd);
+    return timeline.find((s) => s.sessionId === sessionId);
+}
 // Get latest snapshot
 function getLatestSnapshot(cwd) {
     const timeline = loadTimeline(cwd);