@lasso-ai/cli 1.4.4 → 1.5.0

package/dist/cli/bridge-old.js

@@ -0,0 +1,1350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BRIDGE_PORT = void 0;
+exports.restartBridge = restartBridge;
+exports.startBridge = startBridge;
+// src/cli/bridge.ts
+const ws_1 = require("ws");
+const node_http_1 = __importDefault(require("node:http"));
+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 chalk_1 = __importDefault(require("chalk"));
+const agent_1 = require("./agent");
+const project_1 = require("./project");
+const auth_1 = require("./auth");
+const snapshot_1 = require("./snapshot");
+exports.DEFAULT_BRIDGE_PORT = 3056;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function restartBridge(port = exports.DEFAULT_BRIDGE_PORT) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/__lasso/bridge/restart`, { method: "POST" });
+        const body = await response.json().catch(() => ({}));
+        if (!response.ok || !body.ok)
+            return { ok: false, error: body.error || "The bridge rejected the restart request." };
+        return { ok: true };
+    }
+    catch {
+        return { ok: false, error: `No Lasso bridge is listening on 127.0.0.1:${port}. Start your project with ${chalk_1.default.cyan("lasso dev")} first.` };
+    }
+}
+async function gitCommand(cwd, args) {
+    const result = await execFileAsync("git", args, { cwd, maxBuffer: 1024 * 1024 });
+    return result.stdout.trim();
+}
+async function getGitState(cwd) {
+    try {
+        await gitCommand(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    }
+    catch {
+        return { isRepo: false };
+    }
+    const status = (await gitCommand(cwd, ["status", "--short"])).split("\n").filter(Boolean);
+    const branch = await gitCommand(cwd, ["branch", "--show-current"]).catch(() => "");
+    const remote = await gitCommand(cwd, ["remote", "get-url", "origin"]).catch(() => "");
+    return { isRepo: true, branch, status, hasChanges: status.length > 0, hasRemote: Boolean(remote), remote };
+}
+function fileLineEnding(content) {
+    return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function withLineEnding(value, lineEnding) {
+    return value.replace(/\r\n?|\n/g, lineEnding);
+}
+function resolveProposedFile(cwd, proposedPath, allowNew = false) {
+    const root = node_path_1.default.resolve(cwd);
+    const candidate = node_path_1.default.resolve(root, proposedPath);
+    if (candidate.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(candidate))
+        return candidate;
+    // Some React/Next source maps contain an absolute path from an older
+    // checkout. Rebase only the recognizable src/... suffix into this project.
+    const normalized = proposedPath.replace(/\\/g, "/");
+    const srcIndex = normalized.lastIndexOf("/src/");
+    if (srcIndex >= 0) {
+        const rebased = node_path_1.default.join(root, normalized.slice(srcIndex + 1));
+        if (rebased.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(rebased))
+            return rebased;
+        if (allowNew && (rebased.startsWith(`${root}${node_path_1.default.sep}`) || rebased === root))
+            return rebased;
+    }
+    if (candidate.startsWith(`${root}${node_path_1.default.sep}`) || candidate === root) {
+        if (allowNew)
+            return candidate;
+        throw new Error(`Could not find the proposed file in the current project: ${proposedPath}`);
+    }
+    throw new Error(`The proposed file is outside the current project: ${proposedPath}`);
+}
+function occurrenceCount(content, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let from = 0;
+    while (true) {
+        const index = content.indexOf(needle, from);
+        if (index < 0)
+            return count;
+        count += 1;
+        from = index + needle.length;
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function whitespaceEquivalentRange(content, oldString) {
+    const trimmed = oldString.trim();
+    if (!trimmed)
+        return null;
+    const pattern = trimmed.split(/\s+/).map(escapeRegExp).join("\\s+");
+    const matches = Array.from(content.matchAll(new RegExp(pattern, "g")));
+    if (matches.length !== 1 || matches[0].index === undefined)
+        return null;
+    const start = matches[0].index;
+    return { start, end: start + matches[0][0].length };
+}
+function prepareChange(content, change) {
+    const lineEnding = fileLineEnding(content);
+    const oldString = withLineEnding(change.oldString, lineEnding);
+    const newString = withLineEnding(change.newString, lineEnding);
+    const matches = occurrenceCount(content, oldString);
+    if (matches === 0) {
+        const range = whitespaceEquivalentRange(content, oldString);
+        if (range)
+            return { ...range, oldString: content.slice(range.start, range.end), newString };
+        // If we can't find the exact match, try a fuzzy match by looking for similar content
+        // This handles cases where the AI didn't capture the exact context but the change is still valid
+        const contentNoWhitespace = content.replace(/\s+/g, " ");
+        const oldStringNoWhitespace = oldString.replace(/\s+/g, " ");
+        if (contentNoWhitespace.includes(oldStringNoWhitespace) && oldStringNoWhitespace.length > 20) {
+            // Found with whitespace normalization - attempt to locate and apply
+            const index = contentNoWhitespace.indexOf(oldStringNoWhitespace);
+            console.warn(`[Lasso] Applying change with fuzzy match for ${change.filePath}`);
+            // This is a best-effort approach - might not be perfect but better than failing
+            throw new Error(`Could not safely apply ${change.filePath}. The source changed after the suggestion was generated. Regenerate the review so it uses the current source.`);
+        }
+        throw new Error(`Could not safely apply ${change.filePath}. The source changed after the suggestion was generated. Regenerate the review so it uses the current source.`);
+    }
+    if (matches > 1) {
+        throw new Error(`Could not safely apply ${change.filePath}. The selected code is not unique (${matches} matches).`);
+    }
+    const start = content.indexOf(oldString);
+    return { start, end: start + oldString.length, oldString, newString };
+}
+function proposalMatchesCurrentSource(cwd, changes) {
+    try {
+        for (const change of changes) {
+            if (!change.oldString)
+                continue;
+            const filePath = resolveProposedFile(cwd, change.filePath);
+            const content = node_fs_1.default.readFileSync(filePath, "utf8");
+            // Try exact match first
+            try {
+                prepareChange(content, change);
+            }
+            catch {
+                // If exact match fails, try with normalized whitespace
+                const normalizedContent = content.replace(/\s+/g, " ").trim();
+                const normalizedOldString = change.oldString.replace(/\s+/g, " ").trim();
+                const normalizedNewString = change.newString.replace(/\s+/g, " ").trim();
+                if (!normalizedContent.includes(normalizedOldString)) {
+                    throw new Error("Source content does not match proposed change (even with normalized whitespace)");
+                }
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function triggerBuildFix(cwd, taskId, buildErrors, buildCommand, originalChanges, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext) {
+    const MAX_RETRIES = 3;
+    const context = buildErrorContext.get(taskId);
+    if (!context)
+        return;
+    context.retryCount += 1;
+    if (context.retryCount > MAX_RETRIES) {
+        // Max retries reached - revert changes and show error
+        for (const snapshot of taskSnapshots.get(taskId) || []) {
+            if (snapshot.content === null) {
+                if (node_fs_1.default.existsSync(snapshot.filePath))
+                    node_fs_1.default.unlinkSync(snapshot.filePath);
+            }
+            else {
+                node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+            }
+        }
+        taskSnapshots.delete(taskId);
+        buildErrorContext.delete(taskId);
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "error",
+            message: `⚠️ Build validation failed after ${MAX_RETRIES} attempts. The change was reverted. Errors:\n${buildErrors.slice(0, 5).join("\n")}${buildErrors.length > 5 ? `\n... and ${buildErrors.length - 5} more errors` : ""}`
+        }));
+        return;
+    }
+    // Re-apply the original changes
+    try {
+        const planned = new Map();
+        for (const change of originalChanges) {
+            const isNew = !change.oldString;
+            const filePath = resolveProposedFile(cwd, change.filePath, true);
+            const exists = node_fs_1.default.existsSync(filePath);
+            const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+            const prepared = (!exists || isNew)
+                ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                : prepareChange(content, change);
+            const fileChanges = planned.get(filePath) || [];
+            if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+            }
+            fileChanges.push({ filePath, content, exists, ...prepared });
+            planned.set(filePath, fileChanges);
+        }
+        for (const [filePath, changes] of planned) {
+            const exists = changes[0].exists;
+            const content = changes[0].content;
+            const nextContent = exists
+                ? [...changes]
+                    .sort((a, b) => b.start - a.start)
+                    .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                : changes[0].newString;
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+            node_fs_1.default.writeFileSync(filePath, nextContent);
+        }
+    }
+    catch (applyError) {
+        socket.send(JSON.stringify({
+            type: "agent_status",
+            taskId,
+            status: "error",
+            message: `Failed to re-apply original changes: ${applyError instanceof Error ? applyError.message : "Unknown error"}`
+        }));
+        return;
+    }
+    // Run agent to fix build errors
+    const { runOneShotAgent } = await import("./oneshot.js");
+    const fixPrompt = `The previous change caused build errors. Please fix them. Build command: ${buildCommand}\n\nBuild errors:\n${buildErrors.slice(0, 10).join("\n")}${buildErrors.length > 10 ? `\n... and ${buildErrors.length - 10} more errors` : ""}\n\nFix these errors by making minimal changes to the files. Attempt ${context.retryCount} of ${MAX_RETRIES}.`;
+    const controller = new AbortController();
+    taskControllers.set(taskId, controller);
+    socket.send(JSON.stringify({ type: "agent_status", taskId, status: "thinking", message: `Fixing build errors (attempt ${context.retryCount}/${MAX_RETRIES})...` }));
+    try {
+        const result = await runOneShotAgent(cwd, fixPrompt, "project", { provider: "google", model: "gemini-2.5-flash", lassoKey: resolvedLassoKey, serverUrl: "https://api.lasso.byorello.space" }, controller.signal, (status, message, detail) => {
+            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_status", taskId, status, message, detail }));
+            }
+        }, (prompt) => {
+            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_prompt", taskId, prompt }));
+            }
+        }, undefined, "https://api.lasso.byorello.space", resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey, taskId, undefined);
+        if (result.ok && result.changes && result.changes.length > 0) {
+            // Apply the fix
+            const snapshots = [];
+            const planned = new Map();
+            for (const change of result.changes) {
+                const isNew = !change.oldString;
+                const filePath = resolveProposedFile(cwd, change.filePath, true);
+                const exists = node_fs_1.default.existsSync(filePath);
+                const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+                const prepared = (!exists || isNew)
+                    ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                    : prepareChange(content, change);
+                const fileChanges = planned.get(filePath) || [];
+                if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                    throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+                }
+                fileChanges.push({ filePath, content, exists, ...prepared });
+                planned.set(filePath, fileChanges);
+            }
+            taskSnapshots.set(taskId, snapshots);
+            for (const [filePath, changes] of planned) {
+                const exists = changes[0].exists;
+                const content = changes[0].content;
+                snapshots.push({ filePath, content: exists ? content : null });
+                const nextContent = exists
+                    ? [...changes]
+                        .sort((a, b) => b.start - a.start)
+                        .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                    : changes[0].newString;
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+                node_fs_1.default.writeFileSync(filePath, nextContent);
+            }
+            // Validate the fix
+            const validation = await validateBuild(cwd);
+            if (validation.passed) {
+                // Build fixed!
+                buildErrorContext.delete(taskId);
+                socket.send(JSON.stringify({
+                    type: "applied",
+                    taskId,
+                    message: `Build errors fixed after ${context.retryCount} attempt${context.retryCount > 1 ? "s" : ""}. ${result.changes.length} file${result.changes.length === 1 ? "" : "s"} updated.`,
+                    validation
+                }));
+            }
+            else {
+                // Still failing - trigger another retry
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    taskId,
+                    status: "working",
+                    message: `⚠️ Build still failing. Retrying...`,
+                    detail: `Build command: ${validation.command}\nErrors:\n${validation.errors.slice(0, 5).join("\n")}${validation.errors.length > 5 ? `\n... and ${validation.errors.length - 5} more errors` : ""}`
+                }));
+                // Update context with new errors
+                buildErrorContext.set(taskId, {
+                    errors: validation.errors,
+                    command: validation.command,
+                    originalChanges: originalChanges,
+                    retryCount: context.retryCount
+                });
+                await triggerBuildFix(cwd, taskId, validation.errors, validation.command, originalChanges, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext);
+            }
+        }
+        else {
+            // Agent failed to produce a fix
+            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: result.error || "Failed to fix build errors" }));
+        }
+    }
+    catch (error) {
+        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "Build fix encountered an error" }));
+    }
+    finally {
+        if (taskControllers.get(taskId) === controller)
+            taskControllers.delete(taskId);
+    }
+}
+async function validateBuild(cwd) {
+    const pkgPath = node_path_1.default.join(cwd, "package.json");
+    if (!node_fs_1.default.existsSync(pkgPath)) {
+        return { passed: true, errors: [], command: "none" };
+    }
+    const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, "utf8"));
+    const scripts = pkg.scripts || {};
+    // Determine which build command to run
+    let buildCommand = "";
+    if (scripts.build) {
+        buildCommand = "build";
+    }
+    else if (scripts["build:cli"] || scripts["build:overlay"]) {
+        // Monorepo with separate build scripts
+        buildCommand = scripts["build:cli"] ? "build:cli" : "build:overlay";
+    }
+    else if (scripts.compile) {
+        buildCommand = "compile";
+    }
+    else if (scripts.check) {
+        buildCommand = "check";
+    }
+    else if (scripts.lint) {
+        buildCommand = "lint";
+    }
+    else if (scripts.typecheck) {
+        buildCommand = "typecheck";
+    }
+    else if (node_fs_1.default.existsSync(node_path_1.default.join(cwd, "tsconfig.json"))) {
+        buildCommand = "tsc"; // Run TypeScript compiler directly
+    }
+    else {
+        // No suitable build command found
+        return { passed: true, errors: [], command: "none" };
+    }
+    try {
+        const result = await execFileAsync(buildCommand === "tsc" ? "tsc" : "npm", buildCommand === "tsc" ? [] : ["run", buildCommand], { cwd, maxBuffer: 1024 * 1024 * 10, timeout: 60000 });
+        const output = result.stdout + result.stderr;
+        const errors = [];
+        // Parse TypeScript errors
+        if (output.includes("error TS")) {
+            const tsErrors = output.match(/error TS\d+.*$/gm) || [];
+            errors.push(...tsErrors);
+        }
+        // Parse general build errors
+        if (output.includes("Error:") || output.includes("error:")) {
+            const lines = output.split("\n");
+            for (const line of lines) {
+                if (line.includes("Error:") || line.includes("error:")) {
+                    errors.push(line.trim());
+                }
+            }
+        }
+        return {
+            passed: errors.length === 0,
+            errors,
+            command: buildCommand === "tsc" ? "tsc" : `npm run ${buildCommand}`
+        };
+    }
+    catch (error) {
+        const stderr = error.stderr || "";
+        const errors = [];
+        if (stderr.includes("error TS")) {
+            const tsErrors = stderr.match(/error TS\d+.*$/gm) || [];
+            errors.push(...tsErrors);
+        }
+        if (stderr.includes("Error:") || stderr.includes("error:")) {
+            const lines = stderr.split("\n");
+            for (const line of lines) {
+                if (line.includes("Error:") || line.includes("error:")) {
+                    errors.push(line.trim());
+                }
+            }
+        }
+        // If no specific errors found, include the full stderr
+        if (errors.length === 0 && stderr) {
+            errors.push(stderr);
+        }
+        return {
+            passed: false,
+            errors,
+            command: buildCommand === "tsc" ? "tsc" : `npm run ${buildCommand}`
+        };
+    }
+}
+function readEnvFile(cwd, filename) {
+    try {
+        return node_fs_1.default.readFileSync(node_path_1.default.join(cwd, filename), "utf8").split(/\r?\n/).reduce((values, line) => {
+            const match = line.match(/^\s*(?:export\s+)?([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+            if (match) {
+                let value = match[2].trim();
+                if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+                    value = value.slice(1, -1);
+                values[match[1]] = value.trim();
+            }
+            return values;
+        }, {});
+    }
+    catch {
+        return {};
+    }
+}
+async function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = exports.DEFAULT_BRIDGE_PORT) {
+    const bridgeServer = node_http_1.default.createServer(); // dedicated, empty HTTP server
+    const wss = new ws_1.WebSocketServer({ server: bridgeServer });
+    let overlaySocket = null;
+    const taskSnapshots = new Map();
+    const editRequests = new Map();
+    const editConfigs = new Map();
+    const reviewRefreshAttempts = new Map();
+    const buildErrorContext = new Map();
+    const envRoots = [cwd, node_path_1.default.join(cwd, "web"), node_path_1.default.join(cwd, "server")];
+    const fileEnv = envRoots.reduce((values, root) => ({
+        ...values,
+        ...readEnvFile(root, ".env"),
+        ...readEnvFile(root, ".env.local"),
+        ...readEnvFile(root, ".env.production"),
+    }), {});
+    // Prioritize CLI auth credentials over env vars
+    const cliCredentials = (0, auth_1.loadCredentials)();
+    const resolvedLassoKey = cliCredentials?.apiKey ||
+        (0, project_1.resolveLassoApiKey)(fileEnv) ||
+        process.env.LASSO_API_KEY ||
+        fileEnv.LASSO_API_KEY ||
+        process.env.VITE_LASSO_API_KEY ||
+        process.env.NEXT_LASSO_API_KEY ||
+        fileEnv.VITE_LASSO_API_KEY ||
+        fileEnv.NEXT_LASSO_API_KEY ||
+        "";
+    const lassoKeyConfigured = Boolean(resolvedLassoKey);
+    // Task queue for concurrent execution
+    const MAX_CONCURRENT_TASKS = 3;
+    const taskQueue = [];
+    const runningTasks = new Set();
+    const taskPriority = new Map(); // Lower number = higher priority
+    // Will be set when WebSocket connects
+    let currentSocket = null;
+    function processTaskQueue() {
+        if (runningTasks.size >= MAX_CONCURRENT_TASKS || taskQueue.length === 0 || !currentSocket)
+            return;
+        const socket = currentSocket; // Capture non-null reference
+        taskQueue.sort((a, b) => {
+            const priorityA = taskPriority.get(a.taskId) ?? 999;
+            const priorityB = taskPriority.get(b.taskId) ?? 999;
+            return priorityA - priorityB;
+        });
+        const task = taskQueue.shift();
+        if (!task)
+            return;
+        runningTasks.add(task.taskId);
+        if (task.message.type === "edit") {
+            const request = task.message;
+            taskControllers.get(request.taskId)?.abort();
+            const controller = new AbortController();
+            taskControllers.set(request.taskId, controller);
+            if (socket.readyState === socket.OPEN) {
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: "Working…" }));
+            }
+            void (0, agent_1.proposeChanges)(cwd, request, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: request.taskId, prompt }));
+                }
+            })
+                .then((proposal) => {
+                if (controller.signal.aborted || socket.readyState !== socket.OPEN)
+                    return;
+                if (!proposalMatchesCurrentSource(cwd, proposal.changes)) {
+                    const refreshAttempts = reviewRefreshAttempts.get(request.taskId) || 0;
+                    const MAX_REFRESH_ATTEMPTS = 3;
+                    if (refreshAttempts < MAX_REFRESH_ATTEMPTS) {
+                        reviewRefreshAttempts.set(request.taskId, refreshAttempts + 1);
+                        setTimeout(() => {
+                            if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                                enqueueTask(request.taskId, request, task.config, 0);
+                                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "working", message: `The source changed while the proposal was being prepared. Refreshing the review… (${refreshAttempts + 1}/${MAX_REFRESH_ATTEMPTS})` }));
+                            }
+                        }, 500 * (refreshAttempts + 1));
+                    }
+                    else {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: "The source is still changing after multiple refresh attempts. Stop the dev-server edit or try the request again." }));
+                    }
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "review", message: proposal.summary, changes: proposal.changes }));
+            })
+                .catch((error) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                if (controller.signal.aborted) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "stopped", message: "Agent stopped." }));
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: request.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not prepare a change." }));
+            })
+                .finally(() => {
+                if (taskControllers.get(request.taskId) === controller)
+                    taskControllers.delete(request.taskId);
+                runningTasks.delete(request.taskId);
+                taskPriority.delete(request.taskId);
+                processTaskQueue();
+            });
+        }
+        else if (task.message.type === "ask") {
+            const controller = new AbortController();
+            taskControllers.set(task.taskId, controller);
+            socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "working", message: "Working…" }));
+            void (0, agent_1.answerQuestion)(cwd, {
+                taskId: task.taskId,
+                question: task.message.question,
+                context: task.message.context,
+                element: task.message.element,
+                messages: task.message.messages,
+            }, task.config, controller.signal, (message, detail, level) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: level === "error" ? "error" : "working", message, detail }));
+                }
+            }, (prompt) => {
+                if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                    socket.send(JSON.stringify({ type: "agent_prompt", taskId: task.taskId, prompt }));
+                }
+            }).then((answer) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "assistant_message", taskId: task.taskId, message: answer }));
+            }).catch((error) => {
+                if (!controller.signal.aborted)
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: task.taskId, status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
+            }).finally(() => {
+                if (taskControllers.get(task.taskId) === controller)
+                    taskControllers.delete(task.taskId);
+                runningTasks.delete(task.taskId);
+                taskPriority.delete(task.taskId);
+                processTaskQueue();
+            });
+        }
+    }
+    function enqueueTask(taskId, message, config, priority = 0) {
+        taskPriority.set(taskId, priority);
+        taskQueue.push({ taskId, message, config });
+        processTaskQueue();
+    }
+    // Fetch workspace configuration from server (dashboard-configured providers)
+    let workspaceConfig = null;
+    if (lassoKeyConfigured) {
+        workspaceConfig = await (0, project_1.resolveWorkspaceConfig)(fileEnv);
+    }
+    // Fetch available models from server
+    let dynamicModels = { anthropic: [], openai: [], google: [], nvidia: [] };
+    try {
+        dynamicModels = await (0, project_1.fetchModels)(fileEnv);
+    }
+    catch (error) {
+        console.warn('[Lasso] Failed to fetch dynamic models, using fallback');
+    }
+    const localProviderKeys = {
+        google: process.env.GOOGLE_GENERATIVE_AI_API_KEY || fileEnv.GOOGLE_GENERATIVE_AI_API_KEY || process.env.GEMINI_API_KEY || fileEnv.GEMINI_API_KEY,
+        openai: process.env.OPENAI_API_KEY || fileEnv.OPENAI_API_KEY,
+        anthropic: process.env.ANTHROPIC_API_KEY || fileEnv.ANTHROPIC_API_KEY,
+        nvidia: process.env.NVIDIA_API_KEY || fileEnv.NVIDIA_API_KEY,
+        ollama: process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || process.env.OLLAMA_MODEL || fileEnv.OLLAMA_MODEL ? "ollama" : undefined,
+    };
+    let agentConfig = (() => {
+        const provider = (process.env.LASSO_AGENT_PROVIDER || fileEnv.LASSO_AGENT_PROVIDER || process.env.AI_PROVIDER || fileEnv.AI_PROVIDER || "").toLowerCase();
+        const selectedProvider = provider === "google" || provider === "gemini" ? "google" : provider === "openai" ? "openai" : provider === "ollama" ? "ollama" : provider === "anthropic" ? "anthropic" : provider === "nvidia" ? "nvidia" : localProviderKeys.ollama ? "ollama" : localProviderKeys.nvidia ? "nvidia" : localProviderKeys.google ? "google" : localProviderKeys.openai ? "openai" : localProviderKeys.anthropic ? "anthropic" : (cliCredentials ? "anthropic" : "google");
+        const apiKey = selectedProvider === "ollama" ? "ollama" : localProviderKeys[selectedProvider];
+        // If user has CLI auth, use Lasso gateway by default
+        if (!apiKey && !lassoKeyConfigured)
+            return null;
+        return {
+            provider: selectedProvider,
+            apiKey: apiKey || resolvedLassoKey,
+            model: process.env.LASSO_AGENT_MODEL || fileEnv.LASSO_AGENT_MODEL || process.env.AI_MODEL || fileEnv.AI_MODEL,
+            baseUrl: selectedProvider === "nvidia" ? "https://integrate.api.nvidia.com/v1" : process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL ? `${(process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api").replace(/\/api\/?$/, "")}/v1` : undefined,
+        };
+    })();
+    let activeAgentController = null;
+    const taskControllers = new Map();
+    let localAgents = new Set();
+    const pageIgnoredDirs = new Set(["node_modules", ".git", ".next", "dist", "build", ".turbo", "out", "coverage", ".vercel", ".cache"]);
+    const resolveInsideProject = (root, relative) => {
+        const target = node_path_1.default.resolve(root, relative && relative !== "." ? relative : "");
+        return target === root || target.startsWith(`${root}${node_path_1.default.sep}`) ? target : null;
+    };
+    // Directories are returned first so the overlay can render an explorer-style
+    // tree that mirrors how VS Code orders folders above files.
+    const pageEntries = (root, relative) => {
+        const directory = resolveInsideProject(root, relative);
+        if (!directory)
+            return [];
+        let entries = [];
+        try {
+            for (const entry of node_fs_1.default.readdirSync(directory, { withFileTypes: true })) {
+                if (entry.name.startsWith(".") || (entry.isDirectory() && pageIgnoredDirs.has(entry.name)))
+                    continue;
+                entries.push({
+                    name: entry.name,
+                    path: relative && relative !== "." ? node_path_1.default.join(relative, entry.name) : entry.name,
+                    type: entry.isDirectory() ? "directory" : "file",
+                });
+            }
+        }
+        catch {
+            // Folders that cannot be read are treated as empty.
+        }
+        return entries.sort((a, b) => a.type === b.type ? a.name.localeCompare(b.name) : a.type === "directory" ? -1 : 1);
+    };
+    bridgeServer.on("request", (req, res) => {
+        if (req.method !== "POST" || req.url?.split("?", 1)[0] !== "/__lasso/bridge/restart")
+            return;
+        activeAgentController?.abort();
+        for (const controller of taskControllers.values())
+            controller.abort();
+        taskControllers.clear();
+        activeAgentController = null;
+        for (const socket of wss.clients)
+            socket.close(1000, "Bridge restarted by the CLI");
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ ok: true }));
+    });
+    async function localModels() {
+        const base = process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api";
+        try {
+            const response = await fetch(`${base.replace(/\/$/, "")}/tags`);
+            if (!response.ok)
+                return [];
+            const payload = await response.json();
+            return (payload.models || []).filter((model) => model.name).map((model) => ({ id: model.name, label: `${model.name} · Local`, provider: "ollama" }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async function openCodeModels() {
+        if (!localAgents.has("opencode"))
+            return [];
+        try {
+            const result = await execFileAsync("opencode", ["models"], { maxBuffer: 1024 * 1024 });
+            return result.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.:@/-]+$/.test(line))
+                .map((model) => ({ id: `opencode:${model}`, label: `OpenCode · ${model}`, provider: "cli" }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async function cursorModels() {
+        if (!localAgents.has("cursor"))
+            return [];
+        try {
+            const result = await execFileAsync("cursor", ["model", "list"], { maxBuffer: 1024 * 1024 });
+            return result.stdout
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith("Available models"))
+                .map((line) => {
+                const parts = line.split(/\s+/);
+                const id = parts[0]?.trim();
+                const name = parts.slice(1).join(" ").trim();
+                return id ? { id: `cursor:${id}`, label: `Cursor · ${name}`, provider: "cli" } : null;
+            })
+                .filter((model) => model !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+    const availableModels = async (collabConfig = null, workspaceConfig = null) => {
+        localAgents = await (0, agent_1.detectLocalAgents)();
+        const locals = await localModels();
+        const discoveredOpenCodeModels = await openCodeModels();
+        const discoveredCursorModels = await cursorModels();
+        if (locals.length && !agentConfig) {
+            const base = process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || "http://localhost:11434/api";
+            agentConfig = { provider: "ollama", apiKey: "ollama", model: process.env.OLLAMA_MODEL || fileEnv.OLLAMA_MODEL, baseUrl: `${base.replace(/\/api\/?$/, "")}/v1` };
+        }
+        // Check if user has CLI auth credentials (lasso auth login)
+        const cliCredentials = (0, auth_1.loadCredentials)();
+        const hasCliAuth = Boolean(cliCredentials?.apiKey);
+        // Prioritize workspace config (dashboard) over project config
+        // Workspace config is fetched independently of project config
+        const workspacePlan = (workspaceConfig?.plan || "free").toLowerCase();
+        const workspaceProviders = workspaceConfig?.configuredProviders || [];
+        const projectPlan = (collabConfig?.plan || "free").toLowerCase();
+        const projectProviders = collabConfig?.configuredProviders || [];
+        // Use the highest-tier plan available
+        const isPaidPlan = workspacePlan !== "free" || projectPlan !== "free";
+        // Use workspace providers if available, otherwise fall back to project providers
+        const configuredProviders = workspaceProviders.length > 0 ? workspaceProviders : projectProviders;
+        // Build model list from dynamic server fetch, falling back to hardcoded models
+        const allModels = [
+            // Dynamic models from server API
+            ...dynamicModels.anthropic.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
+            ...dynamicModels.openai.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
+            ...dynamicModels.google.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
+            ...dynamicModels.nvidia.map(m => ({ id: m.id, label: m.name, provider: m.provider })),
+            // Fallback hardcoded models (only if dynamic fetch failed)
+            ...(dynamicModels.anthropic.length === 0 ? [
+                { id: "claude-opus-4-5-20251101", label: "Claude Opus 4.5", provider: "anthropic" },
+                { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5", provider: "anthropic" },
+                { id: "claude-haiku-4-5-20251015", label: "Claude Haiku 4.5", provider: "anthropic" },
+            ] : []),
+            ...(dynamicModels.openai.length === 0 ? [
+                { id: "gpt-5.1", label: "GPT-5.1", provider: "openai" },
+                { id: "gpt-5.1-codex", label: "GPT-5.1 Codex", provider: "openai" },
+                { id: "gpt-5.1-codex-mini", label: "GPT-5.1 Codex Mini", provider: "openai" },
+                { id: "o3", label: "OpenAI o3", provider: "openai" },
+                { id: "o3-mini", label: "OpenAI o3-mini", provider: "openai" },
+            ] : []),
+            ...(dynamicModels.google.length === 0 ? [
+                { id: "gemini-3-pro-preview", label: "Gemini 3 Pro", provider: "google" },
+                { id: "gemini-3-flash-preview", label: "Gemini 3 Flash", provider: "google" },
+                { id: "gemini-2.5-flash-preview-09-2025", label: "Gemini 2.5 Flash", provider: "google" },
+                { id: "gemini-2.5-flash-lite-preview-09-2025", label: "Gemini 2.5 Flash Lite", provider: "google" },
+            ] : []),
+            ...(dynamicModels.nvidia.length === 0 ? [
+                { id: "nvidia/llama-3.3-nemotron-super-49b-v1", label: "Llama 3.3 Nemotron Super 49B", provider: "nvidia" },
+                { id: "deepseek-ai/deepseek-r1-distill-llama-70b", label: "DeepSeek R1 Distill Llama 70B", provider: "nvidia" },
+                { id: "deepseek-ai/deepseek-r1-distill-llama-8b", label: "DeepSeek R1 Distill Llama 8B", provider: "nvidia" },
+                { id: "google/gemma-3-1b-it", label: "Gemma 3 1B Instruct", provider: "nvidia" },
+                { id: "openai/gpt-oss-120b", label: "GPT-OSS 120B", provider: "nvidia" },
+            ] : []),
+            // Local CLI agents (always included)
+            ...(localAgents.has("claude-code") ? [
+                { id: "claude-code:sonnet", label: "Claude Code · Sonnet 4.5", provider: "cli" },
+                { id: "claude-code:opus", label: "Claude Code · Opus 4.5", provider: "cli" },
+                { id: "claude-code:haiku", label: "Claude Code · Haiku 4.5", provider: "cli" },
+            ] : []),
+            ...(localAgents.has("codex") ? [
+                { id: "codex:gpt-5.1", label: "Codex · GPT-5.1", provider: "cli" },
+                { id: "codex:gpt-5.1-codex", label: "Codex · GPT-5.1-Codex", provider: "cli" },
+            ] : []),
+            ...(localAgents.has("opencode") ? [
+                { id: "opencode:opencode/big-pickle", label: "OpenCode · Big Pickle", provider: "cli" },
+                { id: "opencode:deepseek/deepseek-chat", label: "OpenCode · DeepSeek Chat", provider: "cli" },
+                { id: "opencode:anthropic/claude-sonnet-4-5", label: "OpenCode · Claude Sonnet 4.5", provider: "cli" },
+                { id: "opencode:openai/gpt-5.1", label: "OpenCode · GPT-5.1", provider: "cli" },
+            ] : []),
+            ...(localAgents.has("cursor") ? [
+                { id: "cursor:claude-sonnet-4.5", label: "Cursor · Claude Sonnet 4.5", provider: "cli" },
+                { id: "cursor:claude-opus-4", label: "Cursor · Claude Opus 4", provider: "cli" },
+                { id: "cursor:claude-3.5-sonnet", label: "Cursor · Claude 3.5 Sonnet", provider: "cli" },
+                { id: "cursor:gpt-4o", label: "Cursor · GPT-4o", provider: "cli" },
+                { id: "cursor:gpt-4o-mini", label: "Cursor · GPT-4o mini", provider: "cli" },
+            ] : []),
+            ...discoveredOpenCodeModels,
+            ...discoveredCursorModels,
+            ...locals,
+        ];
+        // Lock models based on provider API key configuration
+        // Paid plans have all models unlocked
+        // Free plans only have models unlocked for providers with configured API keys
+        const providerKeyMapping = {
+            anthropic: "ANTHROPIC_API_KEY",
+            openai: "OPENAI_API_KEY",
+            google: "GOOGLE_GENERATIVE_AI_API_KEY",
+            nvidia: "NVIDIA_API_KEY",
+            ollama: "OLLAMA_BASE_URL",
+        };
+        return allModels.map((model) => {
+            if (model.provider === "cli") {
+                // CLI agents are always unlocked (user manages their own credentials)
+                return model;
+            }
+            if (isPaidPlan) {
+                // Paid plans have all hosted models unlocked
+                return model;
+            }
+            // Free plans: check if provider is configured
+            let isConfigured = false;
+            let lockedReason = "Configure your API key in the dashboard to use this model";
+            if (hasCliAuth) {
+                // User has CLI auth: check dashboard-configured providers first
+                isConfigured = configuredProviders.includes(model.provider);
+                lockedReason = "Configure this provider in your workspace dashboard to use this model";
+            }
+            // If not configured via dashboard, fall back to env-based detection
+            if (!isConfigured) {
+                const envKey = providerKeyMapping[model.provider];
+                isConfigured = Boolean(process.env[envKey]) ||
+                    Boolean(fileEnv[envKey]) ||
+                    Boolean(localProviderKeys[model.provider]);
+                if (!isConfigured) {
+                    lockedReason = hasCliAuth
+                        ? "Configure this provider in your workspace dashboard, or set the provider API key in your .env file"
+                        : "Run `lasso auth login` to configure providers in your dashboard, or set the provider API key in your .env file";
+                }
+                else {
+                    lockedReason = "";
+                }
+            }
+            if (!isConfigured) {
+                return {
+                    ...model,
+                    locked: true,
+                    lockedReason: lockedReason || "Configure your API key to use this model",
+                };
+            }
+            return model;
+        });
+    };
+    wss.on("connection", (socket) => {
+        overlaySocket = socket;
+        currentSocket = socket;
+        console.log(chalk_1.default.green("✓") + " Overlay connected");
+        const creds = (0, auth_1.loadCredentials)();
+        const userInfo = creds?.userName
+            ? { name: creds.userName, email: creds.userEmail }
+            : (process.env.USER ? { name: process.env.USER } : null);
+        socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: lassoKeyConfigured || Boolean(agentConfig) || localAgents.size > 0, models: [], collab: collabConfig?.registered ? { ...collabConfig, plan: collabConfig.plan, configuredProviders: collabConfig.configuredProviders } : null, user: userInfo }));
+        void availableModels(collabConfig, workspaceConfig).then((models) => {
+            if (socket.readyState === socket.OPEN)
+                socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: lassoKeyConfigured || Boolean(agentConfig) || localAgents.size > 0, models, collab: collabConfig?.registered ? { ...collabConfig, plan: collabConfig.plan, configuredProviders: collabConfig.configuredProviders } : null, user: userInfo }));
+        });
+        void getGitState(cwd).then((git) => {
+            if (socket.readyState === socket.OPEN)
+                socket.send(JSON.stringify({ type: "git_state", git }));
+        });
+        socket.on("message", async (raw) => {
+            const msg = JSON.parse(raw.toString());
+            if (msg.type === "edit" || msg.type === "ask") {
+                console.log(`[lasso] received ${msg.type}:`, { model: msg.model, provider: msg.provider, selectionId: msg.context?.selectionId, messages: msg.messages?.length || 0, changes: msg.type === "edit" ? msg.changesHistory?.length || 0 : 0, screenshots: Boolean(msg.context?.screenshots?.full || msg.context?.screenshots?.element) });
+            }
+            else {
+                console.log("[lasso] received from overlay:", msg);
+            }
+            if (msg.type === "list_page_folders") {
+                const requested = msg.path || ".";
+                const root = node_path_1.default.resolve(cwd);
+                const directory = resolveInsideProject(root, requested);
+                if (!directory) {
+                    socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: [], error: "That folder is outside the current project." }));
+                    return;
+                }
+                socket.send(JSON.stringify({ type: "page_folders", path: requested, entries: pageEntries(root, requested), project: node_path_1.default.basename(root) }));
+                return;
+            }
+            if (msg.type === "create_page_folder") {
+                const root = node_path_1.default.resolve(cwd);
+                const name = node_path_1.default.basename(msg.name || "");
+                const parent = resolveInsideProject(root, msg.parent || ".");
+                if (!parent || !name || name !== msg.name || name === "." || name === "..") {
+                    socket.send(JSON.stringify({ type: "page_folder_created", path: msg.name || "", error: "Enter a folder name without slashes or dots." }));
+                    return;
+                }
+                const target = node_path_1.default.resolve(parent, name);
+                if (!target.startsWith(`${root}${node_path_1.default.sep}`)) {
+                    socket.send(JSON.stringify({ type: "page_folder_created", path: name, error: "Choose a folder inside the current project." }));
+                    return;
+                }
+                try {
+                    node_fs_1.default.mkdirSync(target);
+                    socket.send(JSON.stringify({ type: "page_folder_created", path: node_path_1.default.relative(root, target) }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({
+                        type: "page_folder_created",
+                        path: node_path_1.default.relative(root, target),
+                        error: error instanceof Error && error.message.includes("EEXIST") ? "A folder with that name already exists." : "The folder could not be created.",
+                    }));
+                }
+                return;
+            }
+            if (msg.type === "create_page") {
+                const root = node_path_1.default.resolve(cwd);
+                const folder = resolveInsideProject(root, msg.folder || ".");
+                // A page name may contain "/" so the overlay can create nested routes in
+                // one step, but every segment is validated and resolved inside the project.
+                const segments = (msg.fileName || "").split("/").map((segment) => segment.trim()).filter(Boolean);
+                const fileName = segments.pop() || "";
+                if (!folder || !fileName || segments.some((segment) => segment === "." || segment === "..") || fileName === "." || fileName === "..") {
+                    socket.send(JSON.stringify({ type: "page_created", path: msg.fileName || "", error: "Choose a valid project folder and file name." }));
+                    return;
+                }
+                const target = node_path_1.default.resolve(folder, ...segments, fileName);
+                if (!target.startsWith(`${root}${node_path_1.default.sep}`)) {
+                    socket.send(JSON.stringify({ type: "page_created", path: msg.fileName, error: "Choose a valid project folder and file name." }));
+                    return;
+                }
+                try {
+                    node_fs_1.default.mkdirSync(node_path_1.default.dirname(target), { recursive: true });
+                    node_fs_1.default.writeFileSync(target, msg.content.slice(0, 200000), { encoding: "utf8", flag: "wx" });
+                    socket.send(JSON.stringify({ type: "page_created", path: node_path_1.default.relative(root, target) }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({ type: "page_created", path: node_path_1.default.relative(root, target), error: error instanceof Error && error.message.includes("EEXIST") ? "A file with that name already exists." : "The page could not be created." }));
+                }
+                return;
+            }
+            if (msg.type === "ask") {
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
+                if (!lassoKeyConfigured && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Set your Lasso API key before asking the hosted agent a question." }));
+                    return;
+                }
+                if (!agentConfig && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "No hosted agent is configured. Select Claude Code/Codex or add a provider key." }));
+                    return;
+                }
+                taskControllers.get(msg.taskId)?.abort();
+                const controller = new AbortController();
+                taskControllers.set(msg.taskId, controller);
+                let selectedConfig;
+                if (localProvider) {
+                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
+                }
+                else {
+                    const requestedProvider = (msg.provider || agentConfig.provider);
+                    const providerLocalKey = localProviderKeys[requestedProvider];
+                    const apiKey = providerLocalKey || resolvedLassoKey;
+                    const baseUrl = requestedProvider === "nvidia"
+                        ? "https://integrate.api.nvidia.com/v1"
+                        : requestedProvider === "ollama"
+                            ? (agentConfig.baseUrl || "http://localhost:11434/v1")
+                            : agentConfig.baseUrl;
+                    selectedConfig = {
+                        ...agentConfig,
+                        provider: requestedProvider,
+                        model: msg.model,
+                        apiKey,
+                        baseUrl,
+                        lassoKey: resolvedLassoKey,
+                        serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
+                    };
+                }
+                // Enqueue task for concurrent execution
+                enqueueTask(msg.taskId, msg, selectedConfig, 1); // Priority 1 for ask tasks
+            }
+            else if (msg.type === "edit") {
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
+                if (!lassoKeyConfigured && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Set VITE_LASSO_API_KEY or NEXT_LASSO_API_KEY in your app environment before sending an edit." }));
+                    return;
+                }
+                if (!agentConfig && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message: "Add a supported agent key: GOOGLE_GENERATIVE_AI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY." }));
+                    return;
+                }
+                let selectedConfig;
+                if (localProvider) {
+                    selectedConfig = { provider: cliProvider, model: msg.model, lassoKey: resolvedLassoKey, serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv) };
+                }
+                else {
+                    const requestedProvider = (msg.provider || agentConfig.provider);
+                    const providerLocalKey = localProviderKeys[requestedProvider];
+                    const apiKey = providerLocalKey || resolvedLassoKey;
+                    const baseUrl = requestedProvider === "nvidia"
+                        ? "https://integrate.api.nvidia.com/v1"
+                        : requestedProvider === "ollama"
+                            ? (agentConfig.baseUrl || "http://localhost:11434/v1")
+                            : agentConfig.baseUrl;
+                    selectedConfig = {
+                        ...agentConfig,
+                        provider: requestedProvider,
+                        model: msg.model,
+                        apiKey,
+                        baseUrl,
+                        lassoKey: resolvedLassoKey,
+                        serverUrl: collabConfig?.serverUrl || (0, auth_1.serverUrlFrom)(fileEnv),
+                    };
+                }
+                editRequests.set(msg.taskId, msg);
+                editConfigs.set(msg.taskId, selectedConfig);
+                reviewRefreshAttempts.set(msg.taskId, 0);
+                // Enqueue task for concurrent execution with higher priority (0)
+                enqueueTask(msg.taskId, msg, selectedConfig, 0);
+            }
+            else if (msg.type === "agent_prompt_response") {
+                (0, agent_1.respondToAgentPrompt)(msg.taskId, msg.response);
+            }
+            else if (msg.type === "stop") {
+                if (msg.taskId) {
+                    taskControllers.get(msg.taskId)?.abort();
+                    // Remove from queue and running tasks
+                    const queueIndex = taskQueue.findIndex(t => t.taskId === msg.taskId);
+                    if (queueIndex !== -1)
+                        taskQueue.splice(queueIndex, 1);
+                    runningTasks.delete(msg.taskId);
+                    taskPriority.delete(msg.taskId);
+                }
+                else {
+                    for (const controller of taskControllers.values())
+                        controller.abort();
+                    taskQueue.length = 0;
+                    runningTasks.clear();
+                    taskPriority.clear();
+                }
+                socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "stopped", message: "Agent stopped." }));
+            }
+            else if (msg.type === "runtime_error") {
+                socket.send(JSON.stringify({ type: "agent_status", status: "error", message: `Runtime error detected${msg.selectionId ? ` for selection ${msg.selectionId}` : ""}: ${msg.details}` }));
+            }
+            else if (msg.type === "git_status") {
+                socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
+            }
+            else if (msg.type === "git_generate_message") {
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
+                if (!agentConfig && !localProvider) {
+                    socket.send(JSON.stringify({ type: "git_commit_message", error: "No AI provider is configured." }));
+                    return;
+                }
+                const selectedConfig = localProvider
+                    ? { provider: cliProvider, model: msg.model }
+                    : { ...agentConfig, provider: (msg.provider || agentConfig.provider), model: msg.model };
+                const controller = new AbortController();
+                activeAgentController?.abort();
+                activeAgentController = controller;
+                socket.send(JSON.stringify({ type: "git_progress", message: "Generating a commit message…" }));
+                void getGitState(cwd).then((git) => (0, agent_1.generateCommitMessage)(cwd, git.status || [], selectedConfig, controller.signal, (message, detail) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
+                        socket.send(JSON.stringify({ type: "git_progress", message: detail ? `${message} · ${detail}` : message }));
+                })).then((message) => {
+                    if (!controller.signal.aborted)
+                        socket.send(JSON.stringify({ type: "git_commit_message", message }));
+                }).catch((error) => {
+                    if (!controller.signal.aborted)
+                        socket.send(JSON.stringify({ type: "git_commit_message", error: error instanceof Error ? error.message : "Unable to generate a commit message." }));
+                }).finally(() => { if (activeAgentController === controller)
+                    activeAgentController = null; });
+            }
+            else if (msg.type === "git_init") {
+                try {
+                    await gitCommand(cwd, ["init"]);
+                    socket.send(JSON.stringify({ type: "git_result", message: "Git repository initialized." }));
+                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Git could not be initialized." }));
+                }
+            }
+            else if (msg.type === "git_commit") {
+                try {
+                    const commitMessage = msg.message.trim().slice(0, 120);
+                    if (!commitMessage)
+                        throw new Error("Enter a commit message first.");
+                    await gitCommand(cwd, ["add", "-A"]);
+                    await gitCommand(cwd, ["commit", "-m", commitMessage]);
+                    socket.send(JSON.stringify({ type: "git_result", message: "Changes committed." }));
+                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Changes could not be committed." }));
+                }
+            }
+            else if (msg.type === "git_push") {
+                try {
+                    await gitCommand(cwd, ["push"]);
+                    socket.send(JSON.stringify({ type: "git_result", message: "Changes pushed to the configured remote." }));
+                    socket.send(JSON.stringify({ type: "git_state", git: await getGitState(cwd) }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({ type: "git_result", error: error instanceof Error ? error.message : "Changes could not be pushed." }));
+                }
+            }
+            else if (msg.type === "transcribe") {
+                const serverUrl = (0, auth_1.serverUrlFrom)(fileEnv);
+                const creds = (0, auth_1.loadCredentials)();
+                const apiKey = resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey || creds?.apiKey;
+                try {
+                    const resp = await fetch(`${serverUrl}/api/v1/transcribe`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                        },
+                        body: JSON.stringify({
+                            audio: msg.audio,
+                            mimeType: msg.mimeType,
+                            language: msg.language,
+                        }),
+                    });
+                    const data = await resp.json();
+                    socket.send(JSON.stringify({
+                        type: "transcribe_result",
+                        requestId: msg.requestId,
+                        success: Boolean(data.success),
+                        text: data.text || "",
+                        provider: data.provider || "gradium",
+                        error: data.message,
+                    }));
+                }
+                catch (error) {
+                    socket.send(JSON.stringify({
+                        type: "transcribe_result",
+                        requestId: msg.requestId,
+                        success: false,
+                        error: error instanceof Error ? error.message : "Failed to contact transcription service",
+                    }));
+                }
+            }
+            else if (msg.type === "oneshot") {
+                console.log("[lasso] one-shot request:", msg.prompt, msg.scope);
+                const taskId = msg.taskId || `oneshot-${Date.now()}`;
+                const localProvider = msg.provider === "cli" || msg.model?.startsWith("claude-code:") || msg.model?.startsWith("opencode:") || msg.model?.startsWith("cursor:") || msg.model?.startsWith("codex:");
+                const cliProvider = msg.model?.startsWith("claude-code:") ? "claude-code" : msg.model?.startsWith("opencode:") ? "opencode" : msg.model?.startsWith("cursor:") ? "cursor" : "codex";
+                const apiKey = resolvedLassoKey || agentConfig?.apiKey || collabConfig?.apiKey;
+                if (!localProvider && !lassoKeyConfigured && !agentConfig && !apiKey) {
+                    socket.send(JSON.stringify({
+                        type: "agent_status",
+                        taskId,
+                        status: "error",
+                        message: "No AI provider or Lasso key configured. Sign in with 'lasso auth login' or configure a provider key in .env."
+                    }));
+                    return;
+                }
+                const provider = (msg.provider || agentConfig?.provider || "google");
+                const model = msg.model || agentConfig?.model;
+                if (!model) {
+                    socket.send(JSON.stringify({
+                        type: "error",
+                        message: "No model selected. Please select a model in settings."
+                    }));
+                    return;
+                }
+                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", 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");
+                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 }));
+                    }
+                }, (prompt) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_prompt", taskId, prompt }));
+                    }
+                }, msg.messages, targetApiUrl, apiKey, taskId, msg.pageContext).then((result) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        if (result.ok) {
+                            const hasChanges = Array.isArray(result.changes) && result.changes.length > 0;
+                            socket.send(JSON.stringify({
+                                type: "agent_status",
+                                taskId,
+                                status: hasChanges ? "review" : "complete",
+                                message: result.summary,
+                                todo: result.todo,
+                                changes: result.changes,
+                                thinking: result.thinking,
+                                totalThinkingTimeMs: result.totalThinkingTimeMs,
+                            }));
+                        }
+                        else {
+                            socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: result.error || "One-shot agent failed" }));
+                        }
+                    }
+                }).catch((error) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_status", taskId, status: "error", message: error instanceof Error ? error.message : "One-shot agent encountered an error" }));
+                    }
+                }).finally(() => {
+                    if (taskControllers.get(taskId) === controller)
+                        taskControllers.delete(taskId);
+                });
+            }
+            else if (msg.type === "apply") {
+                try {
+                    // Create snapshot before applying changes
+                    const filePaths = [...new Set(msg.changes.map(c => c.filePath))];
+                    const parentSnapshot = (0, snapshot_1.getSnapshotByTaskId)(cwd, msg.taskId);
+                    // Create pre-apply snapshot
+                    const preSnapshot = (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Pre-apply: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, parentSnapshot?.id);
+                    const snapshots = [];
+                    const planned = new Map();
+                    for (const change of msg.changes) {
+                        const isNew = !change.oldString;
+                        const filePath = resolveProposedFile(cwd, change.filePath, true);
+                        const exists = node_fs_1.default.existsSync(filePath);
+                        const content = exists ? node_fs_1.default.readFileSync(filePath, "utf8") : "";
+                        const prepared = (!exists || isNew)
+                            ? { start: 0, end: content.length, oldString: content, newString: change.newString }
+                            : prepareChange(content, change);
+                        const fileChanges = planned.get(filePath) || [];
+                        if (fileChanges.some((item) => prepared.start < item.end && item.start < prepared.end)) {
+                            throw new Error(`Could not safely apply ${change.filePath}. Proposed changes overlap.`);
+                        }
+                        fileChanges.push({ filePath, content, exists, ...prepared });
+                        planned.set(filePath, fileChanges);
+                    }
+                    // Apply each file's replacements from the end toward the beginning
+                    taskSnapshots.set(msg.taskId, snapshots);
+                    for (const [filePath, changes] of planned) {
+                        const exists = changes[0].exists;
+                        const content = changes[0].content;
+                        snapshots.push({ filePath, content: exists ? content : null });
+                        const nextContent = exists
+                            ? [...changes]
+                                .sort((a, b) => b.start - a.start)
+                                .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content)
+                            : changes[0].newString;
+                        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+                        node_fs_1.default.writeFileSync(filePath, nextContent);
+                    }
+                    // Create post-apply snapshot
+                    (0, snapshot_1.createSnapshot)(cwd, msg.taskId, `Applied: ${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"}`, filePaths, preSnapshot.id);
+                    // Run build validation after applying changes
+                    const validation = await validateBuild(cwd);
+                    if (!validation.passed) {
+                        // Build failed - automatically trigger retry with build error context
+                        const errorContext = validation.errors.slice(0, 10).join("\n");
+                        socket.send(JSON.stringify({
+                            type: "agent_status",
+                            taskId: msg.taskId,
+                            status: "working",
+                            message: `⚠️ Build validation failed. Attempting to fix build errors automatically...`,
+                            detail: `Build command: ${validation.command}\nErrors:\n${errorContext}${validation.errors.length > 10 ? `\n... and ${validation.errors.length - 10} more errors` : ""}`
+                        }));
+                        // Store context for retry
+                        buildErrorContext.set(msg.taskId, {
+                            errors: validation.errors,
+                            command: validation.command,
+                            originalChanges: msg.changes,
+                            retryCount: 0
+                        });
+                        // Trigger automatic build fix
+                        await triggerBuildFix(cwd, msg.taskId, validation.errors, validation.command, msg.changes, resolvedLassoKey, agentConfig, collabConfig, socket, taskControllers, taskSnapshots, buildErrorContext);
+                        return;
+                    }
+                    socket.send(JSON.stringify({
+                        type: "applied",
+                        taskId: msg.taskId,
+                        message: `${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"} updated. Your dev server will reload.`,
+                        validation
+                    }));
+                }
+                catch (error) {
+                    // Restore this task's snapshot if a filesystem error occurs
+                    for (const snapshot of taskSnapshots.get(msg.taskId) || []) {
+                        if (snapshot.content === null) {
+                            if (node_fs_1.default.existsSync(snapshot.filePath))
+                                node_fs_1.default.unlinkSync(snapshot.filePath);
+                        }
+                        else {
+                            node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                        }
+                    }
+                    taskSnapshots.delete(msg.taskId);
+                    const message = error instanceof Error ? error.message : "The change could not be applied.";
+                    socket.send(JSON.stringify({ type: "agent_status", taskId: msg.taskId, status: "error", message }));
+                }
+                finally {
+                    if (taskControllers.get(msg.taskId))
+                        taskControllers.delete(msg.taskId);
+                }
+            }
+            else if (msg.type === "undo") {
+                const snapshots = taskSnapshots.get(msg.taskId || "") || [];
+                for (const snapshot of snapshots) {
+                    if (snapshot.content === null) {
+                        if (node_fs_1.default.existsSync(snapshot.filePath))
+                            node_fs_1.default.unlinkSync(snapshot.filePath);
+                    }
+                    else {
+                        node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                    }
+                }
+                taskSnapshots.delete(msg.taskId || "");
+                socket.send(JSON.stringify({ type: "undone", taskId: msg.taskId, message: snapshots.length ? "The accepted change was reverted." : "There is no accepted change to undo." }));
+            }
+            else if (msg.type === "restore_snapshot") {
+                const success = (0, snapshot_1.restoreSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot restored successfully." : "Failed to restore snapshot."
+                }));
+            }
+            else if (msg.type === "get_timeline") {
+                const timeline = (0, snapshot_1.getTimeline)(cwd);
+                socket.send(JSON.stringify({ type: "timeline", snapshots: timeline }));
+            }
+            else if (msg.type === "delete_snapshot") {
+                const success = (0, snapshot_1.deleteSnapshot)(cwd, msg.snapshotId);
+                socket.send(JSON.stringify({
+                    type: "agent_status",
+                    message: success ? "Snapshot deleted." : "Failed to delete snapshot."
+                }));
+            }
+        });
+        socket.on("close", () => {
+            overlaySocket = null;
+            currentSocket = null;
+            console.log(chalk_1.default.yellow("!") + " Overlay disconnected");
+        });
+    });
+    let bridgeListening = false;
+    bridgeServer.on("listening", () => {
+        bridgeListening = true;
+    });
+    bridgeServer.on("error", (error) => {
+        if (error.code === "EADDRINUSE") {
+            console.warn(chalk_1.default.yellow("!") + ` Lasso bridge port ${bridgePort} is already in use; reusing the existing bridge.`);
+            return;
+        }
+        console.error(chalk_1.default.red("Lasso bridge error:"), error.message);
+    });
+    bridgeServer.listen(bridgePort, "127.0.0.1");
+    function send(msg) {
+        const socket = currentSocket;
+        if (socket && socket.readyState === socket.OPEN) {
+            socket.send(JSON.stringify(msg));
+        }
+    }
+    return {
+        send,
+        close() {
+            if (bridgeListening)
+                bridgeServer.close();
+            wss.close();
+        },
+    };
+}