@lasso-ai/cli 1.2.5 → 1.2.6

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- **One-shot generation no longer demands a provider API key when a local agent is
+  selected.** Picking Claude Code, Codex, OpenCode, or Cursor for a one-shot request
+  used to bail out with *"Please configure an AI provider API key or model in settings
+  to enable code generation."* Those agents authenticate themselves, so the request now
+  runs through the local CLI first. If the local CLI cannot run (not installed, not
+  signed in, out of credits) and a Lasso key is available, the request falls back to the
+  Lasso Agent Gateway with a hosted provider/model it understands (`claude-code`/`cursor`
+  → Anthropic, `codex` → OpenAI, `opencode` by model prefix). Without a key, the error
+  now names the CLI command and `lasso auth login` instead of pointing at settings.
+- **Local agents no longer hang on stdin.** `codex exec` and `opencode run` read stdin
+  until EOF, so every local-agent request stalled until the 5-minute timeout. Stdin is
+  closed as soon as the process spawns (none of these command lines are interactive).
+- **Ollama requests stay local.** One-shot requests for Ollama are no longer routed to
+  the gateway, which cannot reach the user's `localhost`.
+
 ### Changed
 
 - **`lasso init` registers against the Lasso API, not the realtime server.**

package/dist/cli/agent.d.ts

@@ -3,7 +3,7 @@ export type SourceChange = {
     oldString: string;
     newString: string;
 };
-type AgentInput = {
+export type AgentInput = {
     taskId?: string;
     instruction: string;
     model: string;
@@ -97,6 +97,7 @@ export type AgentStepAction = {
     changes: SourceChange[];
 };
 export declare function parseAgentAction(text: string): AgentStepAction;
+export declare function runLocalAgentPrompt(cwd: string, config: AgentConfig, prompt: string, signal?: AbortSignal, onProgress?: AgentProgress, taskId?: string, onPrompt?: AgentPromptHandler): Promise<string>;
 export declare function proposeChanges(cwd: string, input: AgentInput, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress, onPrompt?: AgentPromptHandler): Promise<{
     summary: string;
     packages?: string[];
@@ -104,4 +105,3 @@ export declare function proposeChanges(cwd: string, input: AgentInput, config: A
 }>;
 export declare function answerQuestion(cwd: string, input: AgentAnswer, config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress, onPrompt?: AgentPromptHandler): Promise<string>;
 export declare function generateCommitMessage(cwd: string, status: string[], config: AgentConfig, signal?: AbortSignal, onProgress?: AgentProgress): Promise<string>;
-export {};

package/dist/cli/agent.js

@@ -10,6 +10,7 @@ exports.executeWebSearch = executeWebSearch;
 exports.executeAgentCommand = executeAgentCommand;
 exports.detectLocalAgents = detectLocalAgents;
 exports.parseAgentAction = parseAgentAction;
+exports.runLocalAgentPrompt = runLocalAgentPrompt;
 exports.proposeChanges = proposeChanges;
 exports.answerQuestion = answerQuestion;
 exports.generateCommitMessage = generateCommitMessage;
@@ -755,6 +756,12 @@ function localCommand(provider, model, prompt) {
 function runLocalCommand(cwd, command, args, provider, signal, onProgress, taskId, onPrompt) {
     return new Promise((resolve, reject) => {
         const child = (0, node_child_process_1.spawn)(command, args, { cwd, stdio: ["pipe", "pipe", "pipe"] });
+        // Headless invocations: codex/opencode/cursor read stdin until EOF and otherwise hang
+        // until our timeout, so close stdin right away. Prompt answers can no longer be piped
+        // back in, which is fine — none of these command lines are interactive. Swallow the
+        // EPIPE that a late write would raise so it cannot crash the CLI.
+        child.stdin?.on("error", () => { });
+        child.stdin?.end();
         const label = provider === "opencode" ? "OpenCode" : provider === "codex" ? "Codex" : provider === "cursor" ? "Cursor" : "Claude Code";
         let stdout = "";
         let stderr = "";
@@ -882,6 +889,16 @@ async function proposeWithLocalAgent(cwd, instruction, context, config, signal,
         throw new Error(localAgentError(command, result.stderr, result.exitCode));
     return extractLocalAgentProposal(result.stdout, config.provider);
 }
+// Runs a local coding-agent CLI (claude/codex/opencode/cursor) and returns its final text.
+// The CLI authenticates itself (its own login), so no provider API key is required.
+async function runLocalAgentPrompt(cwd, config, prompt, signal, onProgress, taskId, onPrompt) {
+    const provider = config.provider;
+    const local = localCommand(provider, config.model, prompt);
+    const result = await runLocalCommand(cwd, local.command, local.args, provider, signal, onProgress, taskId, onPrompt);
+    if (result.exitCode !== 0)
+        throw new Error(localAgentError(local.command, result.stderr, result.exitCode));
+    return extractLocalAgentText(result.stdout, provider);
+}
 async function proposeChanges(cwd, input, config, signal, onProgress, onPrompt) {
     const context = await contextFor(cwd, input.element);
     const runtimeErrors = input.context?.runtimeErrors || [];
@@ -1176,11 +1193,7 @@ async function answerQuestion(cwd, input, config, signal, onProgress, onPrompt)
     const history = input.messages?.map((message) => `${message.role}: ${message.content}`).join("\n") || "None";
     const prompt = `Answer the user's question conversationally and directly. Do not propose file changes and do not return JSON. If the question is about the selected UI, use the selection and source context below.\n\nUser question:\n${input.question}\n\nSelected element:\n${JSON.stringify(input.element, null, 2)}\n\nVisual context:\n${JSON.stringify({ ...input.context, screenshots: undefined }, null, 2)}\n\nConversation:\n${history}\n\nRelevant source context:\n${context || "No matching source context was found."}`;
     if (config.provider === "claude-code" || config.provider === "codex" || config.provider === "opencode" || config.provider === "cursor") {
-        const local = localCommand(config.provider, config.model, prompt);
-        const result = await runLocalCommand(cwd, local.command, local.args, config.provider, signal, onProgress, input.taskId, onPrompt);
-        if (result.exitCode !== 0)
-            throw new Error(localAgentError(local.command, result.stderr, result.exitCode));
-        return extractLocalAgentText(result.stdout, config.provider).trim();
+        return (await runLocalAgentPrompt(cwd, config, prompt, signal, onProgress, input.taskId, onPrompt)).trim();
     }
     const callServerGatewayAnswer = async (gatewayKey) => {
         let serverUrl = config.serverUrl || process.env.LASSO_SERVER_URL || process.env.NEXT_PUBLIC_LASSO_SERVER_URL || "https://api.lasso.byorello.space";

package/dist/cli/bridge.js

@@ -556,7 +556,7 @@ function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = expo
                 taskControllers.set(msg.taskId, controller);
                 let selectedConfig;
                 if (localProvider) {
-                    selectedConfig = { provider: cliProvider, model: msg.model };
+                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
                 }
                 else {
                     const requestedProvider = (msg.provider || agentConfig.provider);
@@ -608,7 +608,7 @@ function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = expo
                 }
                 let selectedConfig;
                 if (localProvider) {
-                    selectedConfig = { provider: cliProvider, model: msg.model };
+                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
                 }
                 else {
                     const requestedProvider = (msg.provider || agentConfig.provider);
@@ -765,21 +765,23 @@ function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = expo
                 const provider = (msg.provider || agentConfig?.provider || "google");
                 const model = msg.model || agentConfig?.model || (provider === "nvidia" ? "nvidia/llama-3.1-nemotron-70b-instruct" : provider === "google" ? "gemini-2.5-flash" : "claude-3-7-sonnet");
                 const localKey = localProviderKeys[provider];
+                const serverUrl = collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv);
+                const targetApiUrl = (serverUrl.includes("collab.lasso.byorello.space") ? "https://api.lasso.byorello.space" : serverUrl).replace(/\/api\/v1\/?$/, "");
                 const selectedConfig = localProvider
-                    ? { provider: cliProvider, model: msg.model || "claude-code:sonnet" }
+                    ? { provider: cliProvider, model: msg.model || "claude-code:sonnet", lassoKey: resolvedLassoKey, serverUrl: targetApiUrl }
                     : {
                         ...(agentConfig || {}),
                         provider,
                         model,
                         apiKey: localKey || apiKey,
+                        lassoKey: resolvedLassoKey,
+                        serverUrl: targetApiUrl,
                         baseUrl: provider === "nvidia" ? "https://integrate.api.nvidia.com/v1" : provider === "ollama" ? `${(process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api").replace(/\/api\/?$/, "")}/v1` : undefined,
                     };
                 const controller = new AbortController();
                 taskControllers.set(taskId, controller);
                 socket.send(JSON.stringify({ type: "agent_status", taskId, status: "thinking", message: "Planning your request..." }));
                 const { runOneShotAgent } = await import("./oneshot.js");
-                const serverUrl = collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv);
-                const targetApiUrl = (serverUrl.includes("collab.lasso.byorello.space") ? "https://api.lasso.byorello.space" : serverUrl).replace(/\/api\/v1\/?$/, "");
                 runOneShotAgent(cwd, msg.prompt, msg.scope || "project", selectedConfig, controller.signal, (status, message, detail) => {
                     if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
                         socket.send(JSON.stringify({ type: "agent_status", taskId, status, message, detail }));

package/dist/cli/oneshot.js

@@ -9,7 +9,37 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
+const agent_1 = require("./agent");
 const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+const CLI_PROVIDERS = new Set(["claude-code", "codex", "opencode", "cursor"]);
+function isCliProvider(provider) {
+    return Boolean(provider && CLI_PROVIDERS.has(provider));
+}
+function cliLabel(provider) {
+    return provider === "claude-code" ? "Claude Code" : provider === "opencode" ? "OpenCode" : provider === "cursor" ? "Cursor" : provider === "codex" ? "Codex" : "CLI agent";
+}
+function cliCommand(provider) {
+    return provider === "claude-code" ? "claude" : provider || "the agent CLI";
+}
+// The Lasso Agent Gateway only understands hosted providers, so a CLI selection is
+// normalized to the closest hosted provider/model when we have to fall back to it.
+const GATEWAY_MODELS = {
+    anthropic: "claude-sonnet-4-5-20250929",
+    openai: "gpt-4.1",
+    google: "gemini-2.5-flash",
+};
+function gatewayTargetForCli(provider, model) {
+    const bare = model && model.includes(":") ? model.slice(model.indexOf(":") + 1) : model || "";
+    if (provider === "codex")
+        return { provider: "openai", model: GATEWAY_MODELS.openai };
+    if (provider === "cursor")
+        return bare.includes("gpt") ? { provider: "openai", model: GATEWAY_MODELS.openai } : { provider: "anthropic", model: GATEWAY_MODELS.anthropic };
+    if (bare.startsWith("openai/") || /^gpt/i.test(bare))
+        return { provider: "openai", model: GATEWAY_MODELS.openai };
+    if (bare.startsWith("google/") || /^gemini/i.test(bare))
+        return { provider: "google", model: GATEWAY_MODELS.google };
+    return { provider: "anthropic", model: GATEWAY_MODELS.anthropic };
+}
 function isConversationalPrompt(prompt) {
     const p = prompt.trim().toLowerCase().replace(/[!?.,;:]+$/, "");
     const greetings = [
@@ -39,7 +69,7 @@ function runtimeErrorObservation(pageContext) {
         return "- Console/Runtime Errors: None";
     return `- Console/Runtime Errors (the page is currently throwing these):\n${errors.map((e) => `  ! ${e}`).join("\n")}`;
 }
-async function generateConversationalReply(prompt, framework, config, signal, messages, pageContext) {
+async function generateConversationalReply(cwd, prompt, framework, config, signal, messages, pageContext, onProgress, taskId, onPrompt) {
     const history = messages?.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n\n") || "";
     let pageObservation = "";
     if (pageContext) {
@@ -68,13 +98,19 @@ Respond conversationally, concisely, and helpfully.
 ${pageContext ? "You have live access to the browser page context. When the user asks about the page, design, layout, or components, reference the actual headings, sections, buttons, and text rendered on screen. Provide concrete, expert design and UX feedback. Never claim the page has no content or components when rendered headings and sections are present." : ""}
 Do not output code changes, file patches, or JSON schemas — just talk to the developer naturally and offer assistance.`;
     const userPrompt = `${history ? `Conversation History:\n${history}\n\n` : ""}${pageObservation}\nUser message: ${prompt}`;
+    // CLI agents (Claude Code, Codex, OpenCode, Cursor) authenticate themselves, so no
+    // provider API key is needed. Failures are thrown so the caller can fall back.
+    if (isCliProvider(config.provider)) {
+        const text = await (0, agent_1.runLocalAgentPrompt)(cwd, config, `${systemPrompt}\n\n${userPrompt}`, signal, onProgress, taskId, onPrompt);
+        return text.trim() || "Hello! I'm Lasso, your AI pair programmer. You can ask me questions about your project or tell me what to build, modify, or fix.";
+    }
     if (!config.apiKey && config.provider !== "ollama") {
         if (pageContext && (prompt.toLowerCase().includes("landing page") || prompt.toLowerCase().includes("page"))) {
             const headings = (pageContext.domSummary?.headings || []).map((h) => `"${h.text}"`).join(", ");
             const sections = (pageContext.domSummary?.sections || []).map((s) => s.name).join(", ");
-            return `Looking at your current page ("${pageContext.title}" on ${pageContext.route}):\n\n- **Rendered Sections:** ${sections || "Standard container"}\n- **Key Headings:** ${headings || "None"}\n- **CTAs:** ${(pageContext.domSummary?.buttons || []).join(", ") || "None"}\n\nTo build or refine components, configure your AI API key in settings or ask me what to modify!`;
+            return `Looking at your current page ("${pageContext.title}" on ${pageContext.route}):\n\n- **Rendered Sections:** ${sections || "Standard container"}\n- **Key Headings:** ${headings || "None"}\n- **CTAs:** ${(pageContext.domSummary?.buttons || []).join(", ") || "None"}\n\nTo build or refine components, run \`lasso auth login\` or add an AI provider API key in settings, then ask me what to modify!`;
         }
-        return "Hello! I'm Lasso, your AI pair programmer. You can ask me questions about your project or tell me what to build, modify, or fix.";
+        return "Hello! I'm Lasso, your AI pair programmer. You can ask me questions about your project or tell me what to build, modify, or fix. Run `lasso auth login` (or add a provider API key in settings) to unlock AI replies.";
     }
     try {
         const model = config.model || (config.provider === "google" ? "gemini-2.5-flash" : config.provider === "openai" ? "gpt-4.1-mini" : config.provider === "ollama" ? "llama3.2" : config.provider === "nvidia" ? "nvidia/llama-3.1-nemotron-70b-instruct" : "claude-3-7-sonnet-latest");
@@ -179,21 +215,20 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
             rawServerUrl = rawServerUrl.replace("collab.lasso.byorello.space", "api.lasso.byorello.space");
         }
         const targetServerUrl = rawServerUrl.replace(/\/$/, "").replace(/\/api\/v1$/, "");
-        const isCliProvider = config.provider === "claude-code" ||
-            config.provider === "codex" ||
-            config.provider === "opencode" ||
-            config.provider === "cursor";
+        const useCliAgent = isCliProvider(config.provider);
+        const gatewayKey = apiKey || config.lassoKey || (config.apiKey && (config.apiKey.startsWith("lss_live_") || config.apiKey.startsWith("lss_")) ? config.apiKey : "") || process.env.LASSO_API_KEY || "";
         const hasLocalProviderKey = Boolean(config.apiKey &&
             config.apiKey !== "ollama" &&
             !config.apiKey.startsWith("lss_live_") &&
             !config.apiKey.startsWith("lss_"));
         // If the user does NOT have a local provider key in .env, route to Lasso Agent Gateway on server.
         // When they DO have a local key in .env, it runs locally to save server resources!
-        const shouldRouteToServer = !isCliProvider && !hasLocalProviderKey && Boolean(targetServerUrl);
-        if (shouldRouteToServer) {
+        // Ollama always runs locally (the server cannot reach the user's localhost).
+        const shouldRouteToServer = !useCliAgent && config.provider !== "ollama" && !hasLocalProviderKey && Boolean(targetServerUrl);
+        const callGateway = async (target) => {
             try {
                 if (!isConversational && !pageContext) {
-                    onProgress("thinking", "Connecting to Lasso Agent Gateway...", `Model: ${config.model || "claude-3-7-sonnet"}`);
+                    onProgress("thinking", "Connecting to Lasso Agent Gateway...", `Model: ${target.model || "claude-3-7-sonnet"}`);
                 }
                 const endpoint = `${targetServerUrl.replace(/\/$/, "")}/api/v1/agent/session`;
                 const headers = {
@@ -235,8 +270,8 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
                         prompt,
                         messages,
                         model: {
-                            id: config.model,
-                            provider: config.provider,
+                            id: target.model,
+                            provider: target.provider,
                         },
                         context: {
                             framework,
@@ -315,10 +350,100 @@ async function runOneShotAgent(cwd, prompt, scope, config, signal, onProgress, o
                     error: serverErr instanceof Error ? serverErr.message : "Failed to connect to Lasso Agent Gateway.",
                 };
             }
+            return { ok: false, error: "The agent session returned no result." };
+        };
+        const gatewayFallback = async (reason) => {
+            if (!gatewayKey || !targetServerUrl) {
+                return {
+                    ok: false,
+                    error: `${reason} — run \`${cliCommand(config.provider)}\` once to authenticate it, or run \`lasso auth login\` to use the Lasso gateway.`,
+                };
+            }
+            onProgress("thinking", `${cliLabel(config.provider)} is unavailable; using the Lasso Agent Gateway...`, reason);
+            const target = gatewayTargetForCli(config.provider, config.model);
+            const result = await callGateway({ provider: target.provider, model: target.model });
+            if (!result.ok && result.error) {
+                return { ok: false, error: `${reason} — gateway fallback failed: ${result.error}` };
+            }
+            return result;
+        };
+        // CLI agents (Claude Code, Codex, OpenCode, Cursor) authenticate themselves, so they run
+        // locally first instead of demanding a provider API key from settings.
+        if (useCliAgent && !isConversational) {
+            onProgress("thinking", `Running ${cliLabel(config.provider)}...`, `Local CLI agent · ${config.model || ""}`);
+            try {
+                const selectedElement = pageContext?.selectedElement;
+                const input = {
+                    taskId,
+                    instruction: prompt,
+                    model: config.model || "",
+                    messages,
+                    context: {
+                        runtimeErrors: pageContext?.runtimeErrors,
+                        screenshots: pageContext?.screenshot ? { full: pageContext.screenshot } : undefined,
+                        viewport: pageContext?.viewport,
+                    },
+                    element: {
+                        tag: selectedElement?.tag || "project",
+                        group: scope === "component" ? "component" : "workspace",
+                        label: selectedElement?.text || "project",
+                        html: selectedElement ? `<${selectedElement.tag}> ${selectedElement.text || ""}` : undefined,
+                    },
+                };
+                const proposal = await (0, agent_1.proposeChanges)(cwd, input, config, signal, (message, detail, level) => {
+                    onProgress(level === "error" ? "error" : "working", message, detail);
+                }, (agentPrompt) => {
+                    onPrompt({ question: agentPrompt.message, options: agentPrompt.options });
+                });
+                if (signal.aborted) {
+                    return { ok: false, error: "Operation was cancelled" };
+                }
+                if (!proposal.changes.length) {
+                    return { ok: true, summary: proposal.summary, changes: [], thinking: [], totalThinkingTimeMs: Date.now() - startTime };
+                }
+                onProgress("review", "Implementation complete", `${proposal.changes.length} files modified`);
+                return {
+                    ok: true,
+                    summary: proposal.summary,
+                    changes: proposal.changes,
+                    thinking: [
+                        { title: "Analyzed project structure", detail: `Detected ${framework} framework` },
+                        { title: `${cliLabel(config.provider)} generated a proposal`, detail: `${proposal.changes.length} file(s)` },
+                    ],
+                    totalThinkingTimeMs: Date.now() - startTime,
+                };
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    return { ok: false, error: "Operation was cancelled" };
+                }
+                return await gatewayFallback(err instanceof Error ? err.message : `${cliLabel(config.provider)} failed`);
+            }
+        }
+        if (useCliAgent && isConversational) {
+            try {
+                const reply = await generateConversationalReply(cwd, prompt, framework, config, signal, messages, pageContext, (message, detail) => onProgress("thinking", message, detail), taskId, (agentPrompt) => onPrompt({ question: agentPrompt.message, options: agentPrompt.options }));
+                return {
+                    ok: true,
+                    summary: reply,
+                    changes: [],
+                    thinking: [],
+                    totalThinkingTimeMs: Date.now() - startTime,
+                };
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    return { ok: false, error: "Operation was cancelled" };
+                }
+                return await gatewayFallback(err instanceof Error ? err.message : `${cliLabel(config.provider)} failed`);
+            }
+        }
+        if (shouldRouteToServer) {
+            return await callGateway({ provider: config.provider, model: config.model });
         }
         // If it's a conversational prompt and server was not used or failed, respond directly without modifying files!
         if (isConversational) {
-            const reply = await generateConversationalReply(prompt, framework, config, signal, messages, pageContext);
+            const reply = await generateConversationalReply(cwd, prompt, framework, config, signal, messages, pageContext);
             return {
                 ok: true,
                 summary: reply,
@@ -578,11 +703,11 @@ Existing code context (study these carefully before writing — especially the C
 ${fileSnippets || "No existing components found. Create appropriate files in src/."}
 
 Analyze the existing code structure, then respond in JSON:`;
-    if (!config.apiKey && config.provider !== "ollama") {
+    if (!config.apiKey && config.provider !== "ollama" && !isCliProvider(config.provider)) {
         return {
             steps: [],
             isConversational: true,
-            reply: "Please configure an AI provider API key or model in settings to enable code generation.",
+            reply: "I couldn't generate code because no AI provider is available. Run `lasso auth login` to use your Lasso account, or add an AI provider API key in settings, then try again.",
         };
     }
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lasso-ai/cli",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "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",