@lasso-ai/cli 1.0.0

package/dist/cli/bridge.js

@@ -0,0 +1,450 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 auth_1 = require("./auth");
+const DEFAULT_BRIDGE_PORT = 3056;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+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 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 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) {
+        throw new Error(`Could not safely apply ${change.filePath}. The source changed after the suggestion was generated.`);
+    }
+    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 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 {};
+    }
+}
+function startBridge(cwd = process.cwd(), collabConfig = null, bridgePort = 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;
+    let lastSnapshot = [];
+    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"),
+    }), {});
+    const lassoKeyConfigured = Boolean(process.env.VITE_LASSO_API_KEY || process.env.NEXT_LASSO_API_KEY || fileEnv.VITE_LASSO_API_KEY || fileEnv.NEXT_LASSO_API_KEY);
+    let agentConfig = (() => {
+        const provider = (process.env.LASSO_AGENT_PROVIDER || fileEnv.LASSO_AGENT_PROVIDER || process.env.AI_PROVIDER || fileEnv.AI_PROVIDER || "").toLowerCase();
+        const keys = {
+            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,
+            ollama: process.env.OLLAMA_BASE_URL || fileEnv.OLLAMA_BASE_URL || process.env.OLLAMA_MODEL || fileEnv.OLLAMA_MODEL,
+        };
+        const selectedProvider = provider === "google" || provider === "gemini" ? "google" : provider === "openai" ? "openai" : provider === "ollama" ? "ollama" : provider === "anthropic" ? "anthropic" : keys.ollama ? "ollama" : keys.google ? "google" : keys.openai ? "openai" : "anthropic";
+        const apiKey = selectedProvider === "ollama" ? "ollama" : keys[selectedProvider];
+        if (!apiKey)
+            return null;
+        return {
+            provider: selectedProvider,
+            apiKey,
+            model: process.env.LASSO_AGENT_MODEL || fileEnv.LASSO_AGENT_MODEL || process.env.AI_MODEL || fileEnv.AI_MODEL,
+            baseUrl: 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;
+    let localAgents = new Set();
+    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 [];
+        }
+    }
+    const availableModels = async () => {
+        localAgents = await (0, agent_1.detectLocalAgents)();
+        const locals = await localModels();
+        const discoveredOpenCodeModels = await openCodeModels();
+        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` };
+        }
+        return [
+            { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5", provider: "anthropic" },
+            { id: "claude-opus-4-1-20250805", label: "Claude Opus 4.1", provider: "anthropic" },
+            { id: "gpt-4.1", label: "GPT-4.1", provider: "openai" },
+            { id: "gpt-4.1-mini", label: "GPT-4.1 mini", provider: "openai" },
+            { id: "gemini-3.8-flash", label: "Gemini 3.8 Flash", provider: "google" },
+            { id: "gemini-3.7-flash", label: "Gemini 3.7 Flash", provider: "google" },
+            { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro Preview", provider: "google" },
+            { id: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview", provider: "google" },
+            { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro", provider: "google" },
+            { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash", provider: "google" },
+            { id: "gemini-2.5-flash-lite", label: "Gemini 2.5 Flash-Lite", provider: "google" },
+            ...(localAgents.has("claude-code") ? [
+                { id: "claude-code:sonnet", label: "Claude Code · Sonnet", provider: "cli" },
+                { id: "claude-code:opus", label: "Claude Code · Opus", provider: "cli" },
+                { id: "claude-code:haiku", label: "Claude Code · Haiku", provider: "cli" },
+            ] : []),
+            ...(localAgents.has("codex") ? [
+                { id: "codex:gpt-5", label: "Codex · GPT-5", provider: "cli" },
+                { id: "codex:gpt-5-codex", label: "Codex · GPT-5-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", provider: "cli" },
+                { id: "opencode:openai/gpt-5", label: "OpenCode · GPT-5", provider: "cli" },
+            ] : []),
+            ...discoveredOpenCodeModels,
+            ...locals,
+        ];
+    };
+    wss.on("connection", (socket) => {
+        overlaySocket = socket;
+        console.log(chalk_1.default.green("✓") + " Overlay connected");
+        socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: Boolean(agentConfig) || localAgents.size > 0, models: [], collab: collabConfig?.registered ? collabConfig : null }));
+        void availableModels().then((models) => {
+            if (socket.readyState === socket.OPEN)
+                socket.send(JSON.stringify({ type: "config", apiKeyConfigured: lassoKeyConfigured, agentConfigured: Boolean(agentConfig) || localAgents.size > 0, models, collab: collabConfig?.registered ? collabConfig : null }));
+        });
+        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 === "ask") {
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model.startsWith("claude-code:") ? "claude-code" : msg.model.startsWith("opencode:") ? "opencode" : "codex";
+                if (!lassoKeyConfigured && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", 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", status: "error", message: "No hosted agent is configured. Select Claude Code/Codex or add a provider key." }));
+                    return;
+                }
+                activeAgentController?.abort();
+                const controller = new AbortController();
+                activeAgentController = controller;
+                const selectedConfig = localProvider
+                    ? { provider: cliProvider, model: msg.model }
+                    : { ...agentConfig, provider: (msg.provider || agentConfig.provider), model: msg.model };
+                void (0, agent_1.answerQuestion)(cwd, { question: msg.question, context: msg.context, element: msg.element, messages: msg.messages }, selectedConfig, controller.signal, (message) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
+                        socket.send(JSON.stringify({ type: "agent_status", status: "working", message }));
+                }).then((answer) => {
+                    if (!controller.signal.aborted)
+                        socket.send(JSON.stringify({ type: "assistant_message", message: answer }));
+                }).catch((error) => {
+                    if (!controller.signal.aborted)
+                        socket.send(JSON.stringify({ type: "agent_status", status: "error", message: error instanceof Error ? error.message : "The agent could not answer." }));
+                }).finally(() => {
+                    if (activeAgentController === controller)
+                        activeAgentController = null;
+                });
+            }
+            else if (msg.type === "edit") {
+                const localProvider = msg.provider === "cli";
+                const cliProvider = msg.model.startsWith("claude-code:") ? "claude-code" : msg.model.startsWith("opencode:") ? "opencode" : "codex";
+                if (!lassoKeyConfigured && !localProvider) {
+                    socket.send(JSON.stringify({ type: "agent_status", 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", status: "error", message: "Add a supported agent key: GOOGLE_GENERATIVE_AI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY." }));
+                    return;
+                }
+                activeAgentController?.abort();
+                const controller = new AbortController();
+                activeAgentController = controller;
+                const selectedConfig = localProvider
+                    ? { provider: cliProvider, model: msg.model }
+                    : { ...agentConfig, provider: (msg.provider || agentConfig.provider), model: msg.model };
+                void (0, agent_1.proposeChanges)(cwd, msg, selectedConfig, controller.signal, (message) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN) {
+                        socket.send(JSON.stringify({ type: "agent_status", status: "working", message }));
+                    }
+                })
+                    .then((proposal) => {
+                    if (!controller.signal.aborted)
+                        socket.send(JSON.stringify({ type: "agent_status", status: "review", message: proposal.summary, changes: proposal.changes }));
+                })
+                    .catch((error) => {
+                    if (controller.signal.aborted)
+                        return;
+                    const message = error instanceof Error ? error.message : "The agent could not prepare a change.";
+                    socket.send(JSON.stringify({ type: "agent_status", status: "error", message }));
+                })
+                    .finally(() => {
+                    if (activeAgentController === controller)
+                        activeAgentController = null;
+                });
+            }
+            else if (msg.type === "stop") {
+                activeAgentController?.abort();
+                activeAgentController = null;
+                socket.send(JSON.stringify({ type: "agent_status", 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" : "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: "agent_status", status: "thinking", message: "Generating a commit message…" }));
+                void getGitState(cwd).then((git) => (0, agent_1.generateCommitMessage)(cwd, git.status || [], selectedConfig, controller.signal, (message) => {
+                    if (!controller.signal.aborted && socket.readyState === socket.OPEN)
+                        socket.send(JSON.stringify({ type: "agent_status", status: "working", 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);
+                try {
+                    const resp = await fetch(`${serverUrl}/api/v1/transcribe`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        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 === "apply") {
+                try {
+                    lastSnapshot = [];
+                    const planned = new Map();
+                    for (const change of msg.changes) {
+                        const filePath = node_path_1.default.resolve(cwd, change.filePath);
+                        if (!filePath.startsWith(`${node_path_1.default.resolve(cwd)}${node_path_1.default.sep}`))
+                            throw new Error("A proposed file was outside the project.");
+                        const content = node_fs_1.default.readFileSync(filePath, "utf8");
+                        const prepared = 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, ...prepared });
+                        planned.set(filePath, fileChanges);
+                    }
+                    // Validate every change before writing any file, then apply each
+                    // file's replacements from the end toward the beginning.
+                    for (const [filePath, changes] of planned) {
+                        const content = changes[0].content;
+                        lastSnapshot.push({ filePath, content });
+                        const nextContent = [...changes]
+                            .sort((a, b) => b.start - a.start)
+                            .reduce((value, change) => value.slice(0, change.start) + change.newString + value.slice(change.end), content);
+                        node_fs_1.default.writeFileSync(filePath, nextContent);
+                    }
+                    socket.send(JSON.stringify({ type: "applied", message: `${msg.changes.length} file${msg.changes.length === 1 ? "" : "s"} updated. Your dev server will reload.` }));
+                }
+                catch (error) {
+                    for (const snapshot of lastSnapshot)
+                        node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                    lastSnapshot = [];
+                    socket.send(JSON.stringify({ type: "agent_status", status: "error", message: error instanceof Error ? error.message : "The change could not be applied." }));
+                }
+            }
+            else if (msg.type === "undo") {
+                for (const snapshot of lastSnapshot)
+                    node_fs_1.default.writeFileSync(snapshot.filePath, snapshot.content);
+                const count = lastSnapshot.length;
+                lastSnapshot = [];
+                socket.send(JSON.stringify({ type: "undone", message: count ? "The accepted change was reverted." : "There is no accepted change to undo." }));
+            }
+        });
+        socket.on("close", () => {
+            overlaySocket = 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) {
+        if (overlaySocket?.readyState === overlaySocket?.OPEN) {
+            overlaySocket.send(JSON.stringify(msg));
+        }
+    }
+    return {
+        send,
+        close() {
+            if (bridgeListening)
+                bridgeServer.close();
+            wss.close();
+        },
+    };
+}

package/dist/cli/host/certificates.d.ts

@@ -0,0 +1,12 @@
+export declare const TLS_KEY_FILE: string;
+export declare const TLS_CERT_FILE: string;
+export declare function ensureHostCertificate(): {
+    ok: boolean;
+    trusted: boolean;
+    error?: string;
+};
+export declare function hostCertificateStatus(): {
+    present: boolean;
+    certificate: string;
+    key: string;
+};

package/dist/cli/host/certificates.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLS_CERT_FILE = exports.TLS_KEY_FILE = void 0;
+exports.ensureHostCertificate = ensureHostCertificate;
+exports.hostCertificateStatus = hostCertificateStatus;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const paths_1 = require("./paths");
+exports.TLS_KEY_FILE = node_path_1.default.join(paths_1.HOST_DIR, "host.key");
+exports.TLS_CERT_FILE = node_path_1.default.join(paths_1.HOST_DIR, "host.crt");
+function hasCertificate() {
+    return node_fs_1.default.existsSync(exports.TLS_KEY_FILE) && node_fs_1.default.existsSync(exports.TLS_CERT_FILE);
+}
+function ensureHostCertificate() {
+    node_fs_1.default.mkdirSync(paths_1.HOST_DIR, { recursive: true, mode: 0o700 });
+    if (hasCertificate())
+        return { ok: true, trusted: false };
+    try {
+        (0, node_child_process_1.execFileSync)("mkcert", ["-install"], { stdio: "ignore" });
+        (0, node_child_process_1.execFileSync)("mkcert", ["-cert-file", exports.TLS_CERT_FILE, "-key-file", exports.TLS_KEY_FILE, "localhost", "127.0.0.1", "::1", "*.lasso"], { stdio: "ignore" });
+        node_fs_1.default.chmodSync(exports.TLS_KEY_FILE, 0o600);
+        return { ok: true, trusted: true };
+    }
+    catch {
+        // mkcert is optional; OpenSSL still provides a usable local certificate.
+    }
+    const configFile = node_path_1.default.join(node_os_1.default.tmpdir(), `lasso-host-${process.pid}.cnf`);
+    try {
+        node_fs_1.default.writeFileSync(configFile, [
+            "[req]", "distinguished_name = req_distinguished_name", "x509_extensions = v3_req", "prompt = no",
+            "[req_distinguished_name]", "CN = *.lasso", "[v3_req]",
+            "subjectAltName = DNS:*.lasso,DNS:localhost,IP:127.0.0.1,IP:::1", "",
+        ].join("\n"), { mode: 0o600 });
+        (0, node_child_process_1.execFileSync)("openssl", ["req", "-x509", "-nodes", "-newkey", "rsa:2048", "-keyout", exports.TLS_KEY_FILE, "-out", exports.TLS_CERT_FILE, "-days", "825", "-config", configFile], { stdio: "ignore" });
+        node_fs_1.default.chmodSync(exports.TLS_KEY_FILE, 0o600);
+        return { ok: true, trusted: false };
+    }
+    catch (error) {
+        return { ok: false, trusted: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        node_fs_1.default.rmSync(configFile, { force: true });
+    }
+}
+function hostCertificateStatus() {
+    return { present: hasCertificate(), certificate: exports.TLS_CERT_FILE, key: exports.TLS_KEY_FILE };
+}

package/dist/cli/host/client.d.ts

@@ -0,0 +1,49 @@
+import { type HostProject } from "./registry";
+export interface HostHealth {
+    ok?: boolean;
+    service?: string;
+    version?: string;
+    pid?: number;
+    proxyPort?: number | null;
+    httpsPort?: number | null;
+    https?: boolean;
+    dnsPort?: number | null;
+    running?: number;
+    registered?: number;
+    projects?: Array<Record<string, unknown>>;
+}
+export declare function hostAlive(port: number): Promise<HostHealth | null>;
+export declare function readDaemonPid(): number | null;
+export declare function isProcessAlive(pid: number): boolean;
+export interface RegisterResult {
+    ok: boolean;
+    domain: string;
+    directory: string;
+    replaced?: boolean;
+    viaHost?: boolean;
+    error?: string;
+}
+export declare function registerWithHost(domain: string, directory: string, projectId: string, port: number): Promise<RegisterResult>;
+export declare function unregisterFromHost(domain: string, port: number): Promise<{
+    ok: boolean;
+    removed?: boolean;
+    error?: string;
+}>;
+export interface ProjectWithStatus extends HostProject {
+    domain: string;
+    status: "running" | "stopped";
+    port: number | null;
+    pid: number | null;
+}
+export declare function listHostProjects(port: number): Promise<{
+    health: HostHealth | null;
+    projects: ProjectWithStatus[];
+}>;
+export declare function stopHostProject(domain: string, port: number): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function restartHost(port: number): Promise<{
+    ok: boolean;
+    error?: string;
+}>;