@lasso-ai/cli 2.1.15 → 2.1.16

package/dist/cli/bridge.d.ts

@@ -96,6 +96,11 @@ export type BridgeMessage = {
     type: "agent_prompt_response";
     taskId: string;
     response: string;
+} | {
+    type: "steer";
+    taskId: string;
+    queueId: string;
+    prompt: string;
 } | {
     type: "list_page_folders";
     path?: string;
@@ -221,6 +226,12 @@ export type ServerBridgeMessage = {
         kind: "permission" | "input" | "multiselect";
         options?: string[];
     };
+} | {
+    type: "steer_result";
+    taskId: string;
+    queueId: string;
+    success: boolean;
+    error?: string;
 } | {
     type: "page_folders";
     path: string;

package/dist/cli/bridge.js

@@ -900,6 +900,40 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
             message: "Agent stopped",
         }));
     }
+    /** Forward an overlay answer to the runtime's pending user question. */
+    async function handleAgentPromptResponse(message, socket) {
+        const session = activeSessions.get(message.taskId);
+        const facade = taskFacades.get(message.taskId);
+        if (!session || !facade) {
+            throw new Error("No active agent session is waiting for a response.");
+        }
+        if (!facade.respondToPrompt) {
+            throw new Error("This agent backend does not support interactive prompts.");
+        }
+        await facade.respondToPrompt(session.id, message.response);
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId: message.taskId,
+            status: "working",
+            message: "Continuing with your response…",
+        }));
+    }
+    /** Queue a prompt for the active runtime's next model turn. */
+    async function handleSteer(message, socket) {
+        const session = activeSessions.get(message.taskId);
+        const facade = taskFacades.get(message.taskId);
+        if (!session || !facade?.steerSession) {
+            socket.send(JSON.stringify({ type: "steer_result", taskId: message.taskId, queueId: message.queueId, success: false, error: "This agent backend does not support live steering." }));
+            return;
+        }
+        try {
+            await facade.steerSession(session.id, message.prompt);
+            socket.send(JSON.stringify({ type: "steer_result", taskId: message.taskId, queueId: message.queueId, success: true }));
+        }
+        catch (error) {
+            socket.send(JSON.stringify({ type: "steer_result", taskId: message.taskId, queueId: message.queueId, success: false, error: error instanceof Error ? error.message : "Failed to steer the agent." }));
+        }
+    }
     // Handler for switch_model
     async function handleSwitchModel(message, socket) {
         const { taskId, provider, modelId } = message;
@@ -1138,6 +1172,12 @@ async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort
                     case "stop":
                         await handleStop(msg, socket);
                         break;
+                    case "agent_prompt_response":
+                        await handleAgentPromptResponse(msg, socket);
+                        break;
+                    case "steer":
+                        await handleSteer(msg, socket);
+                        break;
                     case "switch_model":
                         await handleSwitchModel(msg, socket);
                         break;

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

@@ -157,6 +157,7 @@ export interface RuntimeFacade {
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal, opts?: {
         providerApiKey?: string;
         browserContextProvider?: BrowserContextProvider;
+        devServerUrl?: string;
     }): Promise<void>;
     getSession(sessionId: string): Promise<RuntimeSession>;
     verifySession(sessionId: string, projectPath: string): Promise<SessionVerificationResult>;
@@ -166,6 +167,8 @@ export interface RuntimeFacade {
         name?: string;
     }, apiKey?: string, backendConfig?: RuntimeSessionInput["backendConfig"]): Promise<void>;
     cancelSession(sessionId: string): Promise<void>;
+    respondToPrompt?(sessionId: string, response: string): Promise<void>;
+    steerSession?(sessionId: string, prompt: string): Promise<void>;
 }
 export type RuntimeEvent = {
     type: "agent_started";
@@ -315,6 +318,7 @@ export declare class RuntimeClient {
     runSession(sessionId: string, projectPath: string, onEvent: RuntimeEventHandler, signal?: AbortSignal, opts?: {
         providerApiKey?: string;
         browserContextProvider?: BrowserContextProvider;
+        devServerUrl?: string;
     }): Promise<void>;
     /** Parse and dispatch one complete SSE frame. */
     private processSseFrame;
@@ -326,6 +330,10 @@ export declare class RuntimeClient {
      * Cancel a running session
      */
     cancelSession(sessionId: string): Promise<void>;
+    /** Resume a hosted runtime that is waiting for an answer from the user. */
+    respondToPrompt(sessionId: string, response: string): Promise<void>;
+    /** Queue a prompt for the next turn of an active hosted runtime. */
+    steerSession(sessionId: string, prompt: string): Promise<void>;
     /**
      * Switch model/backend for a session
      */

package/dist/cli/runtime-client.js

@@ -83,7 +83,10 @@ class RuntimeClient {
         // pre-run workspace capture could not be established.
         const guard = await index_js_1.WorkspaceGuard.capture(projectPath);
         const executor = new index_js_1.ActionExecutor(projectPath, opts?.browserContextProvider);
-        const verifier = new index_js_1.VerificationEngine(projectPath);
+        const verifier = new index_js_1.VerificationEngine(projectPath, {
+            devServerUrl: opts?.devServerUrl || process.env.LASSO_DEV_SERVER_URL,
+            browserContextProvider: opts?.browserContextProvider,
+        });
         // Idempotent: called on agent_completed AND on stream failure, so the
         // diff is always cached before the safety-net restore wipes the edits.
         let finalized = false;
@@ -268,6 +271,36 @@ class RuntimeClient {
             throw new Error(`Failed to cancel session: ${response.statusText}`);
         }
     }
+    /** Resume a hosted runtime that is waiting for an answer from the user. */
+    async respondToPrompt(sessionId, response) {
+        const result = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/user-response`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
+            },
+            body: JSON.stringify({ response }),
+        });
+        if (!result.ok) {
+            const body = (await result.json().catch(() => ({})));
+            throw new Error(body.error || `Failed to submit agent response: ${result.statusText}`);
+        }
+    }
+    /** Queue a prompt for the next turn of an active hosted runtime. */
+    async steerSession(sessionId, prompt) {
+        const result = await fetch(`${this.serverUrl}/api/v1/agent-runtime/sessions/${sessionId}/steer`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
+            },
+            body: JSON.stringify({ prompt }),
+        });
+        if (!result.ok) {
+            const body = (await result.json().catch(() => ({})));
+            throw new Error(body.error || `Failed to queue steering prompt: ${result.statusText}`);
+        }
+    }
     /**
      * Switch model/backend for a session
      */

package/dist/overlay.js

@@ -11522,7 +11522,6 @@
       align-items: center;
       justify-content: space-between;
       padding: 6px 8px 8px;
-      border-bottom: 1px solid var(--lo-border-subtle);
       font-size: 11px;
       font-weight: 600;
       color: var(--lo-text-3);
@@ -11553,6 +11552,48 @@
       width: 100%;
     }
 
+    .lasso-command-history-load {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      min-width: 0;
+      flex: 1;
+      padding: 0;
+      border: 0;
+      background: transparent;
+      color: inherit;
+      cursor: pointer;
+      text-align: left;
+    }
+
+    .lasso-command-history-delete {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      flex: 0 0 auto;
+      width: 24px;
+      height: 24px;
+      padding: 0;
+      border: 0;
+      border-radius: 5px;
+      background: transparent;
+      color: var(--lo-text-3);
+      cursor: pointer;
+      opacity: 0;
+      transition: opacity 120ms ease, color 120ms ease, background 120ms ease;
+    }
+
+    .lasso-command-history-item:hover .lasso-command-history-delete,
+    .lasso-command-history-delete:focus-visible {
+      opacity: 1;
+    }
+
+    .lasso-command-history-delete:hover {
+      color: #fca5a5;
+      background: rgba(239, 68, 68, 0.14);
+    }
+
     .lasso-command-history-item:hover {
       background: var(--lo-surface-hover);
     }
@@ -19700,17 +19741,44 @@
     </div>
     ${conversationList.map(
       (conv) => `
-      <button class="lasso-command-history-item ${conv.id === activeConversationId ? "active" : ""}" type="button" data-conv-id="${conv.id}">
-        <span class="lasso-command-history-title" title="${escapeHtml4(conv.title || "Untitled Session")}">${escapeHtml4(conv.title || "Untitled Session")}</span>
-        <div class="lasso-command-history-meta">
-          <span class="lasso-command-history-scope ${conv.scope || "private"}">${conv.scope || "private"}</span>
-          <span>${formatDateAgo(conv.updatedAt)}</span>
-        </div>
-      </button>
+      <div class="lasso-command-history-item ${conv.id === activeConversationId ? "active" : ""}" data-conv-id="${escapeHtml4(conv.id)}">
+        <button class="lasso-command-history-load" type="button" title="Open session">
+          <span class="lasso-command-history-title" title="${escapeHtml4(conv.title || "Untitled Session")}">${escapeHtml4(conv.title || "Untitled Session")}</span>
+          <div class="lasso-command-history-meta">
+            <span class="lasso-command-history-scope ${conv.scope || "private"}">${conv.scope || "private"}</span>
+            <span>${formatDateAgo(conv.updatedAt)}</span>
+          </div>
+        </button>
+        <button class="lasso-command-history-delete" type="button" title="Delete session" aria-label="Delete session">
+          <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 6h18"/><path d="M8 6V4h8v2"/><path d="M19 6l-1 14H6L5 6"/><path d="M10 11v5M14 11v5"/></svg>
+        </button>
+      </div>
     `
     ).join("")}
   `;
   }
+  async function deleteConversation(convId) {
+    const conversation = conversationList.find((item) => item.id === convId);
+    if (!conversation) return;
+    if (!convId.startsWith("local-session-")) {
+      const deleted = await apiFetch(`/agent/conversations/${encodeURIComponent(convId)}`, { method: "DELETE" });
+      if (!deleted?.success) return;
+    }
+    try {
+      localStorage.removeItem(`lasso:session:${convId}`);
+      const key = getStorageProjectKey();
+      const list2 = JSON.parse(localStorage.getItem(key) || "[]");
+      localStorage.setItem(key, JSON.stringify(list2.filter((item) => item.id !== convId)));
+    } catch {
+    }
+    conversationList = conversationList.filter((item) => item.id !== convId);
+    if (activeConversationId === convId) {
+      activeConversationId = null;
+      commandMessages = [];
+      renderMessages();
+    }
+    renderHistoryPopover();
+  }
   async function switchConversation(convId) {
     if (activeThinkingInterval) {
       clearInterval(activeThinkingInterval);
@@ -20038,9 +20106,16 @@
     });
     commandHistoryPopover.addEventListener("click", async (event) => {
       event.stopPropagation();
-      const item = event.target.closest(".lasso-command-history-item");
+      const target = event.target;
+      const item = target.closest(".lasso-command-history-item");
       if (!item?.dataset.convId) return;
-      await switchConversation(item.dataset.convId);
+      if (target.closest(".lasso-command-history-delete")) {
+        await deleteConversation(item.dataset.convId);
+        return;
+      }
+      if (target.closest(".lasso-command-history-load")) {
+        await switchConversation(item.dataset.convId);
+      }
     });
     const setCommandModelMenuOpen = (open) => {
       if (!commandModelMenu || !commandModelBtn) return;
@@ -20194,6 +20269,19 @@
         }
         return;
       }
+      const steerBtn = target.closest(".lasso-command-steer-btn");
+      if (steerBtn) {
+        const msgId = steerBtn.closest(".lasso-command-msg")?.dataset.msgId;
+        const msg = commandMessages.find((m) => m.id === msgId);
+        if (msg?.queued && !msg.steering && activeTaskId && state.bridgeSocket?.readyState === WebSocket.OPEN) {
+          steerBtn.disabled = true;
+          steerBtn.textContent = "Steering\u2026";
+          msg.steering = true;
+          state.bridgeSocket.send(JSON.stringify({ type: "steer", taskId: activeTaskId, queueId: msg.id, prompt: msg.content }));
+          renderMessages();
+        }
+        return;
+      }
       const fileCheck = target.closest(".lasso-command-file-check");
       if (fileCheck) {
         const msgId = fileCheck.closest(".lasso-command-msg")?.dataset.msgId;
@@ -20405,6 +20493,21 @@ Please proceed directly with the implementation and code changes from this point
   async function handleSubmit() {
     if (!commandInput) return;
     if (activeTaskId) {
+      const queuedPrompt = commandInput.value.trim();
+      if (queuedPrompt) {
+        commandMessages.push({
+          id: `queued-${Date.now()}`,
+          role: "user",
+          content: queuedPrompt,
+          timestamp: Date.now(),
+          queued: true
+        });
+        commandInput.value = "";
+        autoResizeTextarea(commandInput);
+        renderMessages();
+        scrollToBottom();
+        return;
+      }
       if (state.bridgeSocket?.readyState === WebSocket.OPEN) {
         state.bridgeSocket.send(
           JSON.stringify({
@@ -20663,6 +20766,18 @@ Please proceed directly with the implementation and code changes from this point
       renderMessages();
     }
   }
+  function handleCommandBarSteerResult(message) {
+    const queued = commandMessages.find((msg) => msg.id === message.queueId);
+    if (!queued) return;
+    queued.steering = false;
+    if (message.success) {
+      queued.queued = false;
+      queued.steered = true;
+    } else {
+      queued.error = message.error || "The agent could not accept this steering prompt.";
+    }
+    renderMessages();
+  }
   function handleCommandBarPrompt(message) {
     const taskId2 = message.taskId;
     let targetMsg = commandMessages.find((m) => m.id === taskId2);
@@ -20716,6 +20831,7 @@ Please proceed directly with the implementation and code changes from this point
         html += `
         <div class="lasso-command-msg user" data-msg-id="${msg.id}">
           <div class="lasso-command-msg-bubble">${escapeHtml4(msg.content)}</div>
+          ${msg.queued ? `<button class="lasso-command-steer-btn" type="button"${msg.steering ? " disabled" : ""} style="margin-top: 6px; padding: 4px 9px; border: 1px solid rgba(96, 165, 250, 0.45); border-radius: 6px; background: rgba(59, 130, 246, 0.14); color: #bfdbfe; cursor: pointer;">${msg.steering ? "Steering\u2026" : "Steer"}</button>` : msg.steered ? `<span class="lasso-command-steered-label" style="display: inline-block; margin-top: 6px; color: #93c5fd; font-size: 12px;">Steered into next turn</span>` : ""}
         </div>
       `;
       } else {
@@ -21821,6 +21937,15 @@ Please proceed directly with the implementation and code changes from this point
             window.dispatchEvent(new CustomEvent("lasso-page-folder-created", { detail: { path: message.path || "", error: message.error } }));
             return;
           }
+          if (message.type === "steer_result" && message.taskId && message.queueId) {
+            handleCommandBarSteerResult({
+              taskId: message.taskId,
+              queueId: message.queueId,
+              success: Boolean(message.success),
+              error: message.error
+            });
+            return;
+          }
           if (message.type === "agent_status" && message.status && message.message) {
             const taskId2 = message.taskId;
             if (isCommandBarTaskId(taskId2)) {

package/dist/runtime/agent-runtime.d.ts

@@ -195,10 +195,12 @@ export interface LassoModelResponse {
         raw?: string;
     };
     decision: {
-        type: "inspect" | "plan" | "execute" | "verify" | "recover" | "ask_user";
+        type: "respond" | "inspect" | "plan" | "execute" | "verify" | "recover" | "ask_user";
         goal: string;
     };
     actions: AgentAction[];
+    /** Direct conversational answer when no project work is requested. */
+    reply?: string;
     expectedOutcome?: string;
 }
 export type AgentEventType = "agent_started" | "agent_reasoning" | "agent_completed" | "agent_failed" | "agent_cancelled" | "phase_changed" | "tool_started" | "tool_completed" | "tool_call" | "observation" | "plan_created" | "file_changed" | "verification_started" | "verification_completed" | "error" | "model_changed" | "waiting_for_user";

package/dist/runtime/verification-engine.d.ts

@@ -10,6 +10,14 @@ export interface VerificationConfig {
     buildTimeout: number;
     devServerTimeout: number;
     browserTimeout: number;
+    /** URL of the project's already-running dev server, if available. */
+    devServerUrl?: string;
+    /** Optional browser bridge used for DOM/runtime verification. */
+    browserContextProvider?: (action: {
+        id: string;
+        type: "browser_check";
+        data?: Record<string, unknown>;
+    }) => Promise<unknown>;
 }
 export interface VerificationResult {
     type: "typecheck" | "build" | "dev_server" | "browser";
@@ -68,4 +76,6 @@ export declare class VerificationEngine {
     private hasTypeScriptConfig;
     /** package.json with a non-empty build script. */
     private hasBuildScript;
+    /** Fetch a health URL with a portable timeout for supported Node versions. */
+    private fetchWithTimeout;
 }

package/dist/runtime/verification-engine.js

@@ -19,6 +19,8 @@ class VerificationEngine {
             buildTimeout: config?.buildTimeout || 120000,
             devServerTimeout: config?.devServerTimeout || 30000,
             browserTimeout: config?.browserTimeout || 60000,
+            devServerUrl: config?.devServerUrl,
+            browserContextProvider: config?.browserContextProvider,
         };
     }
     /**
@@ -43,7 +45,6 @@ class VerificationEngine {
         // Dev server health
         const devServerResult = await this.verifyDevServer(phase);
         results.push(devServerResult);
-        // Browser check (placeholder)
         const browserResult = await this.verifyBrowser(phase);
         results.push(browserResult);
         return results;
@@ -283,23 +284,48 @@ class VerificationEngine {
         const startTime = Date.now();
         const observations = [];
         const errors = [];
-        // TODO: Implement actual dev server health check
-        // For now, just check if a dev server is likely running
-        observations.push({
-            id: this.generateId(),
-            type: "build",
-            summary: "Dev server health check skipped (not implemented)",
-            data: { type: "dev_server", success: true },
-            timestamp: Date.now(),
-            phase,
-        });
-        return {
-            type: "dev_server",
-            success: true,
-            observations,
-            errors,
-            duration: Date.now() - startTime,
-        };
+        const url = this.config.devServerUrl;
+        if (!url) {
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary: "Dev server health check skipped (no devServerUrl configured)",
+                data: { type: "dev_server", success: true, skipped: true },
+                timestamp: Date.now(),
+                phase,
+            });
+            return { type: "dev_server", success: true, skipped: true, observations, errors, duration: Date.now() - startTime };
+        }
+        try {
+            const response = await this.fetchWithTimeout(url, this.config.devServerTimeout);
+            const success = response.status >= 200 && response.status < 400;
+            const summary = success ? `Dev server responded with HTTP ${response.status}` : `Dev server returned HTTP ${response.status}`;
+            observations.push({
+                id: this.generateId(),
+                type: "build",
+                summary,
+                data: { type: "dev_server", success, url, status: response.status },
+                timestamp: Date.now(),
+                phase,
+            });
+            if (!success) {
+                errors.push({
+                    id: this.generateId(),
+                    type: "verification",
+                    message: summary,
+                    phase,
+                    timestamp: Date.now(),
+                    recoverable: true,
+                });
+            }
+            return { type: "dev_server", success, command: `GET ${url}`, error: success ? undefined : summary, observations, errors, duration: Date.now() - startTime };
+        }
+        catch (error) {
+            const message = `Dev server health check failed: ${error?.message || String(error)}`;
+            observations.push({ id: this.generateId(), type: "build", summary: message, data: { type: "dev_server", success: false, url }, timestamp: Date.now(), phase });
+            errors.push({ id: this.generateId(), type: "verification", message, phase, timestamp: Date.now(), recoverable: true });
+            return { type: "dev_server", success: false, command: `GET ${url}`, error: message, observations, errors, duration: Date.now() - startTime };
+        }
     }
     /**
      * Verify browser/runtime state
@@ -308,23 +334,34 @@ class VerificationEngine {
         const startTime = Date.now();
         const observations = [];
         const errors = [];
-        // TODO: Implement actual browser checking via Puppeteer or similar
-        // For now, this is a placeholder
-        observations.push({
-            id: this.generateId(),
-            type: "browser",
-            summary: "Browser check skipped (not implemented)",
-            data: { type: "browser", success: true },
-            timestamp: Date.now(),
-            phase,
-        });
-        return {
-            type: "browser",
-            success: true,
-            observations,
-            errors,
-            duration: Date.now() - startTime,
-        };
+        const provider = this.config.browserContextProvider;
+        if (!provider) {
+            observations.push({
+                id: this.generateId(),
+                type: "browser",
+                summary: "Browser verification skipped (no browser bridge configured)",
+                data: { type: "browser", success: true, skipped: true },
+                timestamp: Date.now(),
+                phase,
+            });
+            return { type: "browser", success: true, skipped: true, observations, errors, duration: Date.now() - startTime };
+        }
+        try {
+            const result = await Promise.race([provider({ id: this.generateId(), type: "browser_check", data: { phase } }), new Promise((_, reject) => setTimeout(() => reject(new Error("Browser verification timed out")), this.config.browserTimeout))]);
+            const details = result && typeof result === "object" ? result : {};
+            const success = details.success !== false;
+            const summary = typeof details.summary === "string" ? details.summary : success ? "Browser check passed" : "Browser check failed";
+            observations.push({ id: this.generateId(), type: "browser", summary, data: { type: "browser", success, result }, timestamp: Date.now(), phase });
+            if (!success)
+                errors.push({ id: this.generateId(), type: "verification", message: summary, phase, timestamp: Date.now(), recoverable: true });
+            return { type: "browser", success, error: success ? undefined : summary, observations, errors, duration: Date.now() - startTime };
+        }
+        catch (error) {
+            const message = `Browser verification failed: ${error?.message || String(error)}`;
+            observations.push({ id: this.generateId(), type: "browser", summary: message, data: { type: "browser", success: false }, timestamp: Date.now(), phase });
+            errors.push({ id: this.generateId(), type: "verification", message, phase, timestamp: Date.now(), recoverable: true });
+            return { type: "browser", success: false, error: message, observations, errors, duration: Date.now() - startTime };
+        }
     }
     /**
      * Check if verification passed overall
@@ -370,5 +407,16 @@ class VerificationEngine {
             return false;
         }
     }
+    /** Fetch a health URL with a portable timeout for supported Node versions. */
+    async fetchWithTimeout(url, timeoutMs) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetch(url, { signal: controller.signal, redirect: "manual" });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
 }
 exports.VerificationEngine = VerificationEngine;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lasso-ai/cli",
-  "version": "2.1.15",
+  "version": "2.1.16",
   "description": "Select any part of your running app, describe a change, and let AI edit the real source code.",
   "type": "commonjs",
   "main": "dist/cli/index.js",