@lasso-ai/cli 1.0.0

package/dist/cli/host/registry.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_RE = void 0;
+exports.ensureRegistryDir = ensureRegistryDir;
+exports.loadRegistry = loadRegistry;
+exports.saveRegistry = saveRegistry;
+exports.findByDirectory = findByDirectory;
+exports.registerProject = registerProject;
+exports.unregisterDomain = unregisterDomain;
+exports.slugifyProjectName = slugifyProjectName;
+exports.defaultDomainForDirectory = defaultDomainForDirectory;
+exports.generateUniqueDomain = generateUniqueDomain;
+exports.validateDomain = validateDomain;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("./paths");
+exports.DOMAIN_RE = new RegExp(`^[a-z0-9]([a-z0-9-]*[a-z0-9])?\\.${paths_1.TLD}$`);
+function ensureRegistryDir() {
+    node_fs_1.default.mkdirSync(paths_1.HOST_DIR, { recursive: true });
+    return paths_1.HOST_DIR;
+}
+function loadRegistry() {
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(paths_1.REGISTRY_FILE, "utf8"));
+        if (raw && typeof raw === "object" && !Array.isArray(raw))
+            return raw;
+    }
+    catch {
+        // no registry yet
+    }
+    return {};
+}
+function saveRegistry(registry) {
+    ensureRegistryDir();
+    const temp = `${paths_1.REGISTRY_FILE}.tmp`;
+    node_fs_1.default.writeFileSync(temp, JSON.stringify(registry, null, 2) + "\n", { mode: 0o600 });
+    node_fs_1.default.renameSync(temp, paths_1.REGISTRY_FILE);
+}
+function findByDirectory(registry, directory) {
+    const resolved = node_path_1.default.resolve(directory);
+    for (const [domain, project] of Object.entries(registry)) {
+        if (node_path_1.default.resolve(project.directory) === resolved)
+            return { domain, project };
+    }
+    return null;
+}
+/**
+ * Registers (or re-registers) a domain → directory mapping. Never duplicates:
+ * an existing entry for the same domain is replaced, and any other domain
+ * pointing at the same directory is dropped first.
+ */
+function registerProject(input) {
+    const { domain, directory, projectId, registry } = input;
+    const next = {};
+    for (const [existingDomain, project] of Object.entries(registry)) {
+        if (existingDomain === domain)
+            continue;
+        if (node_path_1.default.resolve(project.directory) === node_path_1.default.resolve(directory))
+            continue;
+        next[existingDomain] = project;
+    }
+    next[domain] = {
+        projectId: projectId || "",
+        directory: node_path_1.default.resolve(directory),
+        registeredAt: new Date().toISOString(),
+    };
+    return next;
+}
+function unregisterDomain(registry, domain) {
+    const next = { ...registry };
+    delete next[domain];
+    return next;
+}
+function slugifyProjectName(name) {
+    const slug = name
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9-]/g, "")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || "app";
+}
+function defaultDomainForDirectory(directory) {
+    return `${slugifyProjectName(node_path_1.default.basename(directory))}.${paths_1.TLD}`;
+}
+function generateUniqueDomain(directory, registry) {
+    const base = defaultDomainForDirectory(directory);
+    if (!registry[base])
+        return base;
+    for (let i = 2; i < 1000; i++) {
+        const candidate = `${base.slice(0, -(paths_1.TLD.length + 1))}-${i}.${paths_1.TLD}`;
+        if (!registry[candidate])
+            return candidate;
+    }
+    return `${base.slice(0, -(paths_1.TLD.length + 1))}-${Date.now().toString(36)}.${paths_1.TLD}`;
+}
+function validateDomain(domain) {
+    return exports.DOMAIN_RE.test(domain);
+}

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

@@ -0,0 +1,23 @@
+import { type ChildProcess } from "node:child_process";
+export type RuntimeStatus = "starting" | "running" | "failed" | "crashed";
+export interface ProjectRuntime {
+    pid: number;
+    port: number;
+    framework: string;
+    startedAt: number;
+    ready: boolean;
+    child: ChildProcess;
+}
+export declare function pickFreePort(): Promise<number>;
+export declare function isReady(port: number): Promise<boolean>;
+export interface StartRuntimeResult {
+    ok: boolean;
+    error?: string;
+    runtime?: ProjectRuntime;
+}
+/**
+ * Starts the project's development server on a free port and waits until it
+ * answers HTTP before returning. Reuses Lasso's existing framework detection —
+ * the Host never guesses a package manager or hardcodes a runtime.
+ */
+export declare function startProjectRuntime(directory: string): Promise<StartRuntimeResult>;

package/dist/cli/host/runtime.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickFreePort = pickFreePort;
+exports.isReady = isReady;
+exports.startProjectRuntime = startProjectRuntime;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const framework_1 = require("../utils/framework");
+const paths_1 = require("./paths");
+const READY_TIMEOUT_MS = 60_000;
+const READY_POLL_MS = 500;
+function pickFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = node_net_1.default.createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close();
+                reject(new Error("Could not allocate a local port."));
+                return;
+            }
+            const port = address.port;
+            server.close(() => resolve(port));
+        });
+        server.on("error", reject);
+    });
+}
+function localBin(directory, name) {
+    const bin = node_path_1.default.join(directory, "node_modules", ".bin", name);
+    return node_fs_1.default.existsSync(bin) ? bin : null;
+}
+function log(directory, message) {
+    try {
+        node_fs_1.default.appendFileSync(paths_1.LOG_FILE, `[${new Date().toISOString()}] ${node_path_1.default.basename(directory)}: ${message}\n`);
+    }
+    catch {
+        // logging is best-effort
+    }
+}
+function spawnCommand(directory, port, bridgePort) {
+    const framework = (0, framework_1.detectFramework)(directory);
+    if (framework === "vite") {
+        // Launch Vite programmatically with .lasso allowlisted (Vite rejects unknown
+        // Host headers by default) while keeping it isolated in its own process.
+        const entry = node_path_1.default.join(__dirname, "vite-host-entry.js");
+        if (node_fs_1.default.existsSync(entry))
+            return { command: process.execPath, args: [entry, directory, String(port), String(bridgePort)], framework };
+    }
+    if (framework === "next") {
+        const entry = node_path_1.default.join(__dirname, "next-host-entry.js");
+        if (node_fs_1.default.existsSync(entry))
+            return { command: process.execPath, args: [entry, directory, String(port), String(bridgePort)], framework };
+    }
+    // No explicit NPM script should be invoked blindly; only framework dev bins
+    // are trusted to accept --port, so an unknown framework cannot be auto-started.
+    return null;
+}
+function isReady(port) {
+    return new Promise((resolve) => {
+        const request = httpRequest(port);
+        request.on("response", (response) => {
+            response.resume();
+            resolve(true);
+        });
+        request.on("error", () => resolve(false));
+        request.setTimeout(1500, () => {
+            request.destroy();
+            resolve(false);
+        });
+        request.end();
+    });
+}
+function httpRequest(port) {
+    return node_http_1.default.request({ host: "127.0.0.1", port, path: "/", method: "GET", headers: { connection: "close" } });
+}
+async function waitUntilReady(port) {
+    const deadline = Date.now() + READY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (await isReady(port))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, READY_POLL_MS));
+    }
+    return false;
+}
+/**
+ * Starts the project's development server on a free port and waits until it
+ * answers HTTP before returning. Reuses Lasso's existing framework detection —
+ * the Host never guesses a package manager or hardcodes a runtime.
+ */
+async function startProjectRuntime(directory) {
+    const port = await pickFreePort();
+    const bridgePort = await pickFreePort();
+    const plan = spawnCommand(directory, port, bridgePort);
+    if (!plan) {
+        return { ok: false, error: `${node_path_1.default.basename(directory)} is not a Vite or Next.js project, so Lasso Host can't start it automatically. Run its dev server yourself.` };
+    }
+    const child = (0, node_child_process_1.spawn)(plan.command, plan.args, {
+        cwd: directory,
+        env: { ...process.env, PORT: String(port) },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    const runtime = {
+        pid: child.pid || 0,
+        port,
+        framework: plan.framework,
+        startedAt: Date.now(),
+        ready: false,
+        child,
+    };
+    log(directory, `starting ${plan.framework} dev server on ${port} (pid ${child.pid})`);
+    child.stdout?.on("data", (chunk) => log(directory, String(chunk).trimEnd()));
+    child.stderr?.on("data", (chunk) => log(directory, `stderr: ${String(chunk).trimEnd()}`));
+    child.on("error", (error) => {
+        log(directory, `spawn error: ${error.message}`);
+    });
+    if (child.pid === undefined) {
+        return { ok: false, error: `Could not start the project runtime for ${node_path_1.default.basename(directory)}.` };
+    }
+    const ready = await waitUntilReady(port);
+    if (!ready) {
+        child.kill("SIGTERM");
+        log(directory, "dev server did not become ready; stopping it");
+        return { ok: false, error: `${node_path_1.default.basename(directory)}'s dev server did not become ready within ${READY_TIMEOUT_MS / 1000}s. Check its logs.` };
+    }
+    runtime.ready = true;
+    log(directory, `dev server ready on ${port}`);
+    return { ok: true, runtime };
+}

package/dist/cli/host/vite-host-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/host/vite-host-entry.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_url_1 = require("node:url");
+const bridge_1 = require("../bridge");
+const [cwd, portArg, bridgePortArg] = process.argv.slice(2);
+const port = Number(portArg) || 5173;
+const bridgePort = Number(bridgePortArg) || 3056;
+function lassoOverlayPlugin() {
+    const bundlePath = node_path_1.default.resolve(__dirname, "../../overlay.js");
+    return {
+        name: "lasso-inject",
+        transformIndexHtml(html) {
+            return html.replace("</head>", `<script src="/__lasso/overlay.js?bridgePort=${bridgePort}"></script></head>`);
+        },
+        configureServer(server) {
+            server.middlewares.use("/__lasso/overlay.js", (_req, res) => {
+                res.setHeader("Content-Type", "application/javascript");
+                res.end(node_fs_1.default.readFileSync(bundlePath, "utf8"));
+            });
+        },
+    };
+}
+void (async () => {
+    const bridge = (0, bridge_1.startBridge)(cwd, null, bridgePort);
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+    const viteEntry = require.resolve("vite");
+    const { createServer } = await import((0, node_url_1.pathToFileURL)(viteEntry).href);
+    const server = await createServer({
+        root: cwd,
+        server: {
+            host: "127.0.0.1",
+            port,
+            strictPort: true,
+            allowedHosts: [
+                ".lasso",
+                "lasso",
+                "localhost",
+                "127.0.0.1",
+                ...(process.env.LASSO_HOST_ALLOWED_HOSTS ? process.env.LASSO_HOST_ALLOWED_HOSTS.split(",") : []),
+            ],
+        },
+        plugins: [lassoOverlayPlugin()],
+    });
+    await server.listen();
+    process.on("SIGTERM", () => {
+        bridge.close();
+        void server.close().then(() => process.exit(0));
+    });
+    process.on("SIGINT", () => {
+        bridge.close();
+        void server.close().then(() => process.exit(0));
+    });
+})();

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const bridge_1 = require("./bridge");
+const vite_1 = require("./server/vite");
+const next_1 = require("./server/next");
+const framework_1 = require("./utils/framework");
+const project_1 = require("./project");
+const auth_1 = require("./auth");
+const daemon_1 = require("./host/daemon");
+const paths_1 = require("./host/paths");
+const install_1 = require("./host/install");
+const client_1 = require("./host/client");
+const registry_1 = require("./host/registry");
+const VERSION = "0.1.0";
+const program = new commander_1.Command();
+program.name("lasso").description("Select UI in your running app, describe a change, AI edits the real source.").version(VERSION);
+function projectEnv() {
+    return (0, project_1.readProjectEnv)(process.cwd());
+}
+// prettier-ignore
+program.command("init")
+    .description("Register this app with your Lasso workspace, create lasso.config.json, and register a local .lasso domain with Lasso Host")
+    .action(async () => {
+    const cwd = process.cwd();
+    const existing = (0, project_1.readProjectConfig)(cwd);
+    if (existing) {
+        console.log(chalk_1.default.green("✓") + ` Already initialized: ${chalk_1.default.cyan(existing.id)} (from ${existing.source}).`);
+        if (existing.domain)
+            console.log(chalk_1.default.dim(`  Local domain: ${chalk_1.default.cyan(existing.domain)}`));
+        console.log(chalk_1.default.dim(`  Run ${chalk_1.default.cyan("lasso register")} to re-register the domain with Lasso Host.`));
+        return;
+    }
+    console.log(chalk_1.default.dim("Registering the project with your Lasso workspace…"));
+    const result = await (0, project_1.initProject)(cwd, projectEnv());
+    if (!result.ok) {
+        console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+        process.exit(1);
+    }
+    console.log("");
+    console.log(chalk_1.default.green("✓") + ` Project created: ${chalk_1.default.cyan(result.projectId)}`);
+    if (result.domain)
+        console.log(chalk_1.default.green("✓") + ` Local domain: ${chalk_1.default.cyan(result.domain)}`);
+    if (result.workspaceId)
+        console.log(chalk_1.default.green("✓") + ` Workspace: ${chalk_1.default.cyan(result.workspaceId)}`);
+    console.log("");
+    console.log(chalk_1.default.dim(`Created:`));
+    console.log(chalk_1.default.dim(`  ${project_1.LASSO_CONFIG_FILE} — commit it so teammates share this project.`));
+});
+// prettier-ignore
+const daemon = program.command("daemon [action]")
+    .description("Start/stop Lasso Host — the local .lasso domain server (start|status|stop|restart|install|uninstall)")
+    .usage("[action]")
+    .action(async (action) => {
+    const env = projectEnv();
+    const port = (0, paths_1.hostProxyPort)(env);
+    const dnsPort = (0, paths_1.hostDnsPort)(env);
+    switch (action || "start") {
+        case "start": {
+            const result = await (0, install_1.spawnDaemon)(env);
+            if (!result.ok) {
+                if (result.error)
+                    console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (result.alreadyRunning) {
+                console.log(chalk_1.default.dim("Lasso Host is already running."));
+                const { projects } = await (0, client_1.listHostProjects)(port);
+                for (const project of projects) {
+                    console.log(chalk_1.default.green("✓") + ` ${chalk_1.default.cyan(project.domain)}`);
+                }
+                return;
+            }
+            console.log(chalk_1.default.green("✓") + " Lasso Host started" + (result.pid ? ` (pid ${result.pid})` : "") + ".");
+            console.log(chalk_1.default.dim(`  Projects become available at ${chalk_1.default.cyan(`${(0, install_1.daemonPortMessage)(env)}`)} once you run ${chalk_1.default.cyan("lasso init")} in them.`));
+            console.log(chalk_1.default.dim(`  Secure URL: ${chalk_1.default.cyan((0, install_1.daemonHttpsPortMessage)(env))} · microphone/WebRTC compatible.`));
+            console.log(chalk_1.default.dim(`  DNS listener: 127.0.0.1:${dnsPort} · Log: ~/.lasso/host/daemon.log`));
+            return;
+        }
+        case "status": {
+            const report = await (0, install_1.daemonStatus)(env);
+            console.log("");
+            console.log(chalk_1.default.bold("Lasso Host"));
+            console.log(chalk_1.default.dim(`  Status: ${report.running ? chalk_1.default.green("running") + (report.pid ? ` (pid ${report.pid})` : "") : chalk_1.default.red("not running")}`));
+            console.log(chalk_1.default.dim(`  Proxy port: ${(0, paths_1.hostProxyPort)(env)}`));
+            console.log(chalk_1.default.dim(`  HTTPS port: ${(0, paths_1.hostHttpsPort)(env)}${report.health?.https ? chalk_1.default.green(" (certificate ready)") : chalk_1.default.yellow(" (certificate unavailable)")}`));
+            console.log(chalk_1.default.dim(`  DNS port: ${(0, paths_1.hostDnsPort)(env)}`));
+            console.log(chalk_1.default.dim(`  Domain resolution: ${report.resolver.installed ? chalk_1.default.green("configured") : chalk_1.default.yellow("not configured")} — ${report.resolver.detail}`));
+            console.log(chalk_1.default.dim(`  Automatic startup: ${report.autoStart ? chalk_1.default.green("enabled (LaunchAgent)") : chalk_1.default.yellow("disabled")}`));
+            if (report.running && report.health) {
+                console.log(chalk_1.default.dim(`  Registered projects: ${report.health.registered ?? 0}`));
+                console.log(chalk_1.default.dim(`  Running now: ${report.health.running ?? 0}`));
+            }
+            return;
+        }
+        case "stop": {
+            const result = await (0, install_1.stopDaemon)(env);
+            if (result.error) {
+                console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(chalk_1.default.green("✓") + " Lasso Host stopped.");
+            return;
+        }
+        case "restart": {
+            await (0, install_1.stopDaemon)(env);
+            const result = await (0, install_1.spawnDaemon)(env);
+            if (!result.ok) {
+                if (result.error)
+                    console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+                process.exitCode = 1;
+                return;
+            }
+            console.log(chalk_1.default.green("✓") + " Lasso Host restarted.");
+            return;
+        }
+        case "install": {
+            console.log(chalk_1.default.dim("Installing Lasso Host…"));
+            const enabled = await (0, install_1.enableAutoStart)();
+            if (enabled.error)
+                console.error(chalk_1.default.yellow("!") + ` ${enabled.error}`);
+            else
+                console.log(chalk_1.default.green("✓") + " Automatic startup configured (LaunchAgent).");
+            const resolverResult = await createResolverInstall(dnsPort);
+            if (resolverResult.ok)
+                console.log(chalk_1.default.green("✓") + ` Domain resolution: ${resolverResult.message}`);
+            else
+                console.log(chalk_1.default.yellow("!") + ` Domain resolution: ${resolverResult.message}`);
+            const spawned = await (0, install_1.spawnDaemon)(env);
+            if (spawned.ok) {
+                console.log(chalk_1.default.green("✓") + (spawned.alreadyRunning ? " Lasso Host already running." : " Lasso Host started."));
+            }
+            else if (spawned.error) {
+                console.error(chalk_1.default.yellow("!") + ` ${spawned.error}`);
+            }
+            console.log(chalk_1.default.dim(`  ${(0, install_1.daemonPortMessage)(env)} (HTTP) · ${(0, install_1.daemonHttpsPortMessage)(env)} (secure) — run ${chalk_1.default.cyan("lasso init")} in a project to get a domain.`));
+            return;
+        }
+        case "uninstall": {
+            const disabled = await (0, install_1.disableAutoStart)();
+            if (disabled.error)
+                console.error(chalk_1.default.yellow("!") + ` ${disabled.error}`);
+            else
+                console.log(chalk_1.default.green("✓") + " Automatic startup disabled.");
+            const stopped = await (0, install_1.stopDaemon)(env);
+            if (stopped.error)
+                console.error(chalk_1.default.yellow("!") + ` ${stopped.error}`);
+            else
+                console.log(chalk_1.default.green("✓") + " Lasso Host stopped.");
+            const resolverResult = await createResolverUninstall();
+            if (resolverResult.ok)
+                console.log(chalk_1.default.green("✓") + ` Domain resolution: ${resolverResult.message}`);
+            else
+                console.log(chalk_1.default.yellow("!") + ` Domain resolution: ${resolverResult.message}`);
+            return;
+        }
+        default:
+            console.error(chalk_1.default.red("✗") + ` Unknown daemon action "${action}". Try: start | status | stop | restart | install | uninstall`);
+            process.exitCode = 1;
+    }
+});
+// prettier-ignore
+program.command("_host", { hidden: true })
+    .description("Run Lasso Host in the foreground (internal)")
+    .action(async () => {
+    const env = projectEnv();
+    const result = await (0, daemon_1.startHost)({ proxyPort: (0, paths_1.hostProxyPort)(env), httpsPort: (0, paths_1.hostHttpsPort)(env), dnsPort: (0, paths_1.hostDnsPort)(env), version: VERSION });
+    if (result.error) {
+        console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+        process.exit(1);
+    }
+    (0, daemon_1.waitForShutdown)();
+});
+function createResolverInstall(dnsPort) {
+    // Lazy import to keep the daemon command light.
+    return import("./host/dns.js").then(({ createDomainResolver }) => createDomainResolver().install(dnsPort));
+}
+function createResolverUninstall() {
+    return import("./host/dns.js").then(({ createDomainResolver }) => createDomainResolver().uninstall(0));
+}
+// prettier-ignore
+program.command("projects")
+    .description("List projects registered with Lasso Host and their running state")
+    .action(async () => {
+    const port = (0, paths_1.hostProxyPort)(projectEnv());
+    const { health, projects } = await (0, client_1.listHostProjects)(port);
+    if (projects.length === 0) {
+        console.log(chalk_1.default.dim("No projects registered with Lasso Host yet. Run ") + chalk_1.default.cyan("lasso init") + chalk_1.default.dim(" in a project to register one."));
+        return;
+    }
+    console.log("");
+    console.log(chalk_1.default.bold("Lasso Projects") + (health ? "" : chalk_1.default.dim("  (Lasso Host is not running)")));
+    for (const project of projects) {
+        const marker = project.status === "running" ? chalk_1.default.green("●") : chalk_1.default.gray("○");
+        console.log(` ${marker} ${chalk_1.default.cyan(project.domain)}`);
+        console.log(chalk_1.default.dim(`   ${project.directory}`));
+        const detail = project.status === "running" && project.port ? `Running · ${project.port}${project.pid ? ` (pid ${project.pid})` : ""}` : "Stopped";
+        console.log(`   ${project.status === "running" ? chalk_1.default.green(detail) : chalk_1.default.gray(detail)}`);
+    }
+    if (!health) {
+        console.log("");
+        console.log(chalk_1.default.dim(`  Start it with ${chalk_1.default.cyan("lasso daemon")}.`));
+    }
+});
+// prettier-ignore
+program.command("register [domain]")
+    .description("Register the current project under a local .lasso domain with Lasso Host (uses lasso.config.json or generates one)")
+    .action(async (domainArg) => {
+    const cwd = process.cwd();
+    const env = projectEnv();
+    const port = (0, paths_1.hostProxyPort)(env);
+    const config = (0, project_1.readProjectConfig)(cwd);
+    const projectId = config?.id || "";
+    let domain = (domainArg || "").trim().toLowerCase();
+    if (domain && !(0, registry_1.validateDomain)(domain)) {
+        console.error(chalk_1.default.red("✗") + ` "${domain}" is not a valid .lasso domain (lowercase letters, numbers, and hyphens).`);
+        process.exit(1);
+    }
+    if (!domain) {
+        if (config?.domain) {
+            domain = config.domain;
+        }
+        else {
+            domain = (0, registry_1.generateUniqueDomain)(cwd, (0, registry_1.loadRegistry)());
+        }
+    }
+    const result = await (0, client_1.registerWithHost)(domain, cwd, projectId, port);
+    if (!result.ok) {
+        console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+        process.exit(1);
+    }
+    if (config && config.domain && config.domain !== domain) {
+        console.log(chalk_1.default.dim("Changed domain:"));
+        console.log(chalk_1.default.dim(`  Removed: ${config.domain}`));
+        console.log(chalk_1.default.green(`  Registered: ${chalk_1.default.cyan(domain)} → ${chalk_1.default.dim(cwd)}`));
+        const updated = { id: config.id, domain };
+        require("node:fs").writeFileSync(node_path_1.default.join(cwd, project_1.LASSO_CONFIG_FILE), JSON.stringify(updated, null, 2) + "\n");
+        console.log(chalk_1.default.dim(`  Updated ${project_1.LASSO_CONFIG_FILE}.`));
+    }
+    else {
+        console.log(chalk_1.default.green("✓") + ` Registered ${chalk_1.default.cyan(domain)}`);
+        console.log(chalk_1.default.green("✓") + ` Points to ${chalk_1.default.dim(cwd)}`);
+        if (config && !config.domain) {
+            require("node:fs").writeFileSync(node_path_1.default.join(cwd, project_1.LASSO_CONFIG_FILE), JSON.stringify({ id: config.id, domain }, null, 2) + "\n");
+            console.log(chalk_1.default.dim(`  Added domain to ${project_1.LASSO_CONFIG_FILE}.`));
+        }
+    }
+});
+// prettier-ignore
+const auth = program.command("auth").description("Sign this machine into your Lasso account (the `lasso auth` OAuth flow)");
+// prettier-ignore
+auth.command("login").description("Sign in with the browser OAuth flow and store a Lasso credential locally").action(async () => {
+    const cwd = process.cwd();
+    const fileEnv = (0, project_1.readProjectEnv)(cwd);
+    const result = await (0, auth_1.authLogin)(cwd, fileEnv);
+    if (!result.ok) {
+        console.error(chalk_1.default.red("✗") + ` ${result.error}`);
+        process.exit(1);
+    }
+});
+// prettier-ignore
+auth.command("status").description("Show the Lasso credential stored on this machine").action(() => {
+    const credentials = (0, auth_1.loadCredentials)();
+    if (!credentials) {
+        console.log(chalk_1.default.dim("Not authenticated. Run ") + chalk_1.default.cyan("npx lasso auth login") + chalk_1.default.dim(" to sign in."));
+        return;
+    }
+    const summary = (0, auth_1.credentialSummary)(credentials);
+    console.log(chalk_1.default.green("✓") + ` Authenticated as ${chalk_1.default.bold(summary.userEmail || "your account")}` + (summary.userName ? ` (${summary.userName})` : ""));
+    if (summary.workspaceName)
+        console.log(chalk_1.default.dim(`Workspace: ${summary.workspaceName} (${summary.workspaceId})`));
+    if (summary.masked)
+        console.log(chalk_1.default.dim("Credential: ") + summary.masked);
+    console.log(chalk_1.default.dim(`Stored at: ${node_path_1.default.join(node_os_1.default.homedir(), ".lasso", "credentials.json")}`));
+});
+// prettier-ignore
+auth.command("logout").description("Remove the Lasso credential from this machine").action(() => {
+    if (!(0, auth_1.loadCredentials)()) {
+        console.log(chalk_1.default.dim("Not authenticated."));
+        return;
+    }
+    (0, auth_1.authLogout)();
+    console.log(chalk_1.default.green("✓") + " Signed out. Revoke the key from the dashboard if you no longer need it.");
+});
+// prettier-ignore
+program.command("dev", { isDefault: true }).description("Start your dev server with the Lasso overlay attached").action(async () => {
+    const cwd = process.cwd();
+    const framework = (0, framework_1.detectFramework)(cwd);
+    const fileEnv = (0, project_1.readProjectEnv)(cwd);
+    const existing = (0, project_1.readProjectConfig)(cwd);
+    let collabConfig = null;
+    if (existing?.id) {
+        collabConfig = await (0, project_1.resolveCollabSession)(cwd, fileEnv, existing.id);
+    }
+    else {
+        console.log(chalk_1.default.yellow("!") + ` No ${chalk_1.default.bold(project_1.LASSO_CONFIG_FILE)} found. Run ${chalk_1.default.cyan("npx lasso init")} to enable realtime collaboration.`);
+    }
+    (0, bridge_1.startBridge)(cwd, collabConfig);
+    switch (framework) {
+        case "vite":
+            console.log(chalk_1.default.green("✓") + " Detected: Vite");
+            await (0, vite_1.startViteServer)(cwd);
+            break;
+        case "next":
+            console.log(chalk_1.default.green("✓") + " Detected: Next.js");
+            await (0, next_1.startNextServer)(cwd);
+            break;
+        default:
+            console.log(chalk_1.default.yellow("!") + " Couldn't detect a supported framework (Vite or Next.js) in this directory.");
+            process.exit(1);
+    }
+});
+program.parse();