@lasso-ai/cli 1.0.0

package/dist/cli/host/dns.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowsResolver = exports.LinuxResolver = exports.MacOSResolver = void 0;
+exports.buildDnsResponse = buildDnsResponse;
+exports.startDnsServer = startDnsServer;
+exports.createDomainResolver = createDomainResolver;
+exports.syncResolverAfterRegister = syncResolverAfterRegister;
+const node_dgram_1 = __importDefault(require("node:dgram"));
+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 paths_1 = require("./paths");
+const registry_1 = require("./registry");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const LOOPBACK = "127.0.0.1";
+function sudoWrite(file, content) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("sudo", ["tee", file], { stdio: ["pipe", "ignore", "inherit"] });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`sudo tee exited with code ${code}`));
+        });
+        child.stdin.end(content);
+    });
+}
+// ---- Minimal DNS responder — answers `*.lasso` → 127.0.0.1 so the local
+// domain namespace needs no per-project /etc/hosts entries.
+function encodeName(name) {
+    const parts = name.replace(/\.$/, "").split(".");
+    const chunks = [];
+    for (const part of parts) {
+        chunks.push(part.length);
+        for (const byte of Buffer.from(part, "ascii"))
+            chunks.push(byte);
+    }
+    chunks.push(0);
+    return Buffer.from(chunks);
+}
+function parseName(buf, offset) {
+    const labels = [];
+    let i = offset;
+    while (true) {
+        const len = buf[i];
+        if (len === 0) {
+            i += 1;
+            break;
+        }
+        if ((len & 0xc0) === 0xc0) {
+            i += 2;
+            return { name: labels.join(".") === "." ? "" : labels.join("."), next: i };
+        }
+        labels.push(buf.subarray(i + 1, i + 1 + len).toString("ascii"));
+        i += 1 + len;
+    }
+    return { name: labels.join("."), next: i };
+}
+function buildDnsResponse(query) {
+    if (query.length < 12)
+        return null;
+    const id = query.subarray(0, 2);
+    const qdcount = query.readUInt16BE(4);
+    if (qdcount === 0)
+        return null;
+    const { name, next } = parseName(query, 12);
+    const qtype = query.readUInt16BE(next);
+    const raiseRecursion = query[2] & 0x01; // RD flag is byte 2 bit 0
+    const isLasso = name.endsWith(`.${paths_1.TLD}`);
+    const rcode = isLasso ? 0 : 3; // NXDOMAIN for anything outside the namespace
+    const flags = 0x8000 | (raiseRecursion ? 0x0100 : 0) | 0x0400 | (rcode & 0x0f); // QR|RD|RA|rcode
+    const ancount = isLasso && qtype === 1 ? 1 : 0; // one A record when asked for A
+    const header = Buffer.alloc(12);
+    id.copy(header, 0);
+    header.writeUInt16BE(flags, 2);
+    header.writeUInt16BE(qdcount, 4);
+    header.writeUInt16BE(ancount, 6);
+    header.writeUInt16BE(0, 8);
+    header.writeUInt16BE(0, 10);
+    if (ancount === 0) {
+        return Buffer.concat([header, query.subarray(12, next + 4)]);
+    }
+    const answer = Buffer.alloc(16);
+    answer.writeUInt16BE(0xc00c, 0); // pointer to the question name
+    answer.writeUInt16BE(1, 2); // Type A
+    answer.writeUInt16BE(1, 4); // Class IN
+    answer.writeUInt32BE(300, 6); // TTL
+    answer.writeUInt16BE(4, 10); // RDLENGTH
+    for (const [i, octet] of LOOPBACK.split(".").map(Number).entries())
+        answer[12 + i] = octet;
+    return Buffer.concat([header, query.subarray(12, next + 4), answer]);
+}
+function startDnsServer(port) {
+    return new Promise((resolve, reject) => {
+        const socket = node_dgram_1.default.createSocket("udp4");
+        socket.on("message", (message, remote) => {
+            const reply = buildDnsResponse(message);
+            if (reply)
+                socket.send(reply, remote.port, remote.address);
+        });
+        socket.on("error", (error) => reject(error));
+        socket.bind(port, LOOPBACK, () => {
+            const address = socket.address();
+            resolve({ close: () => socket.close(), port: address.port });
+        });
+    });
+}
+const MAC_RESOLVER_FILE = "/etc/resolver/lasso";
+function macResolverContent(dnsPort) {
+    return `nameserver ${LOOPBACK}\nport ${dnsPort}\ntimeout 1\n`;
+}
+class MacOSResolver {
+    platform = "darwin";
+    async status() {
+        try {
+            const content = node_fs_1.default.readFileSync(MAC_RESOLVER_FILE, "utf8");
+            const port = content.match(/^port\s+(\d+)/m)?.[1] || "unknown";
+            return { installed: content.includes("nameserver"), detail: `/etc/resolver/lasso → 127.0.0.1:${port}` };
+        }
+        catch {
+            return { installed: false, detail: "`lasso` domain not configured (`/etc/resolver/lasso` missing)" };
+        }
+    }
+    async install(dnsPort) {
+        try {
+            // Writing to /etc/resolver needs the admin password (macOS maps it from
+            // the foreground terminal when sudo prompts).
+            // The resolver directory is not present on every macOS installation.
+            // Create it first so the subsequent sudo tee does not fail with ENOENT.
+            await execFileAsync("sudo", ["mkdir", "-p", node_path_1.default.dirname(MAC_RESOLVER_FILE)]);
+            await sudoWrite(MAC_RESOLVER_FILE, macResolverContent(dnsPort));
+            return { ok: true, message: `Installed /etc/resolver/lasso → 127.0.0.1:${dnsPort}` };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "failed";
+            return { ok: false, requiresSudo: true, message: `Could not write /etc/resolver/lasso (${reason}). Run "lasso daemon install" from a terminal so you can enter your password.` };
+        }
+    }
+    async uninstall() {
+        try {
+            await execFileAsync("sudo", ["rm", "-f", MAC_RESOLVER_FILE]);
+            return { ok: true, message: "Removed /etc/resolver/lasso." };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "failed";
+            return { ok: false, message: `Could not remove /etc/resolver/lasso (${reason}).` };
+        }
+    }
+}
+exports.MacOSResolver = MacOSResolver;
+class LinuxResolver {
+    platform = "linux";
+    systemdFile = "/etc/systemd/resolved.conf.d/lasso-host.conf";
+    async status() {
+        return { installed: node_fs_1.default.existsSync(this.systemdFile), detail: node_fs_1.default.existsSync(this.systemdFile) ? `systemd-resolved split-DNS configured for ~.${paths_1.TLD}` : "`lasso` domain not configured (systemd-resolved split-DNS missing)" };
+    }
+    async install(dnsPort) {
+        const body = `[Resolve]\nDNS=${LOOPBACK}#${dnsPort}\nDomains=~${paths_1.TLD}\n`;
+        try {
+            await execFileAsync("sudo", ["mkdir", "-p", node_path_1.default.dirname(this.systemdFile)]);
+            await sudoWrite(this.systemdFile, body);
+            await execFileAsync("sudo", ["systemctl", "try-restart", "systemd-resolved"]).catch(() => undefined);
+            return { ok: true, requiresSudo: true, message: `Installed systemd-resolved split-DNS for *.${paths_1.TLD} → 127.0.0.1:${dnsPort}` };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "failed";
+            return { ok: false, requiresSudo: true, message: `Could not configure systemd-resolved (${reason}).` };
+        }
+    }
+    async uninstall() {
+        try {
+            await execFileAsync("sudo", ["rm", "-f", this.systemdFile]);
+            await execFileAsync("sudo", ["systemctl", "try-restart", "systemd-resolved"]).catch(() => undefined);
+            return { ok: true, message: "Removed systemd-resolved split-DNS configuration." };
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "failed";
+            return { ok: false, message: `Could not remove systemd-resolved configuration (${reason}).` };
+        }
+    }
+}
+exports.LinuxResolver = LinuxResolver;
+const WINDOWS_HOSTS = node_path_1.default.join(process.env.SystemRoot || "C:\\Windows", "System32", "drivers", "etc", "hosts");
+const HOSTS_BLOCK_START = "# --- lasso-host ---";
+const HOSTS_BLOCK_END = "# --- end lasso-host ---";
+class WindowsResolver {
+    platform = "win32";
+    async status() {
+        const synced = await this.readHostsBlock();
+        return { installed: synced.length > 0, detail: synced.length > 0 ? `${synced.length} registered .${paths_1.TLD} domain(s) in hosts` : "no .lasso domains registered in hosts" };
+    }
+    async readHostsBlock() {
+        try {
+            const content = node_fs_1.default.readFileSync(WINDOWS_HOSTS, "utf8");
+            const match = content.match(new RegExp(`${HOSTS_BLOCK_START}\\n([\\s\\S]*?)\\n${HOSTS_BLOCK_END}`));
+            if (!match)
+                return [];
+            return match[1].split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+        }
+        catch {
+            return [];
+        }
+    }
+    decodeHost(entry) {
+        return entry.split(/\s+/)[1] || "";
+    }
+    async sync(registry) {
+        const lines = [`${HOSTS_BLOCK_START}`];
+        for (const domain of Object.keys(registry))
+            lines.push(`${LOOPBACK} ${domain}`);
+        lines.push(`${HOSTS_BLOCK_END}`);
+        const block = lines.join("\n");
+        const contents = node_fs_1.default.existsSync(WINDOWS_HOSTS) ? node_fs_1.default.readFileSync(WINDOWS_HOSTS, "utf8") : "";
+        const next = contents.includes(HOSTS_BLOCK_START) ? contents.replace(new RegExp(`${HOSTS_BLOCK_START}\\n[\\s\\S]*?\\n${HOSTS_BLOCK_END}`), block) : contents.trimEnd() + "\n" + block + "\n";
+        try {
+            await execFileAsync("net", ["session"]).catch(() => undefined);
+            node_fs_1.default.writeFileSync(WINDOWS_HOSTS, next);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async install() {
+        return { ok: false, message: "Windows has no per-domain DNS configuration. `lasso register` will add each registered domain to the hosts file instead (run from an elevated terminal)." };
+    }
+    async uninstall() {
+        return { ok: true, message: "Remove the '# --- lasso-host ---' block from your hosts file to remove Lasso Host mappings." };
+    }
+}
+exports.WindowsResolver = WindowsResolver;
+let resolverSingleton = null;
+function createDomainResolver(platform = process.platform) {
+    if (!resolverSingleton) {
+        if (platform === "darwin")
+            resolverSingleton = new MacOSResolver();
+        else if (platform === "linux")
+            resolverSingleton = new LinuxResolver();
+        else
+            resolverSingleton = new WindowsResolver();
+    }
+    return resolverSingleton;
+}
+// Windows keeps hosts entries in sync whenever the registry changes.
+function syncResolverAfterRegister() {
+    if (process.platform !== "win32")
+        return Promise.resolve(true);
+    const resolver = createDomainResolver();
+    return resolver.sync((0, registry_1.loadRegistry)());
+}

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

@@ -0,0 +1,32 @@
+import { hostAlive } from "./client";
+import { type DomainResolver } from "./dns";
+export declare function spawnDaemon(env: Record<string, string>): Promise<{
+    ok: boolean;
+    alreadyRunning?: boolean;
+    pid?: number;
+    error?: string;
+}>;
+export declare function isAutoStartInstalled(): boolean;
+export declare function enableAutoStart(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function disableAutoStart(): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export interface DaemonStatusReport {
+    running: boolean;
+    pid?: number | null;
+    health: Awaited<ReturnType<typeof hostAlive>>;
+    autoStart: boolean;
+    resolver: Awaited<ReturnType<DomainResolver["status"]>>;
+}
+export declare function daemonStatus(env: Record<string, string>): Promise<DaemonStatusReport>;
+export declare function stopDaemon(env: Record<string, string>): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+export declare function daemonPortMessage(env: Record<string, string>): string;
+export declare function daemonHttpsPortMessage(env: Record<string, string>): string;
+export declare function yesOrNo(promptText: string): Promise<boolean>;

package/dist/cli/host/install.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnDaemon = spawnDaemon;
+exports.isAutoStartInstalled = isAutoStartInstalled;
+exports.enableAutoStart = enableAutoStart;
+exports.disableAutoStart = disableAutoStart;
+exports.daemonStatus = daemonStatus;
+exports.stopDaemon = stopDaemon;
+exports.daemonPortMessage = daemonPortMessage;
+exports.daemonHttpsPortMessage = daemonHttpsPortMessage;
+exports.yesOrNo = yesOrNo;
+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_readline_1 = __importDefault(require("node:readline"));
+const node_child_process_1 = require("node:child_process");
+const client_1 = require("./client");
+const dns_1 = require("./dns");
+const paths_1 = require("./paths");
+const AGENT_LABEL = "com.lasso.host";
+const LAUNCH_AGENT_FILE = node_path_1.default.join(node_os_1.default.homedir(), "Library", "LaunchAgents", `${AGENT_LABEL}.plist`);
+function cliEntry() {
+    const entry = process.argv[1];
+    return entry && entry.endsWith(".js") ? entry : null;
+}
+function spawnDaemon(env) {
+    const port = (0, paths_1.hostProxyPort)(env);
+    const dnsPort = (0, paths_1.hostDnsPort)(env);
+    const httpsPort = (0, paths_1.hostHttpsPort)(env);
+    return (0, client_1.hostAlive)(port).then(async (health) => {
+        if (health)
+            return { ok: true, alreadyRunning: true };
+        const entry = cliEntry();
+        if (!entry)
+            return { ok: false, error: "Could not resolve the Lasso CLI entry point. Run this from the installed CLI." };
+        const child = (0, node_child_process_1.spawn)(process.execPath, [entry, "_host"], {
+            detached: true,
+            stdio: "ignore",
+            cwd: node_os_1.default.homedir(),
+            env: { ...process.env, LASSO_HOST_PORT: String(port), LASSO_HOST_HTTPS_PORT: String(httpsPort), LASSO_DNS_PORT: String(dnsPort) },
+        });
+        const pid = child.pid;
+        child.unref();
+        await new Promise((resolve) => setTimeout(resolve, 1800));
+        if (await (0, client_1.hostAlive)(port))
+            return { ok: true, pid };
+        return { ok: false, error: `Lasso Host did not come up on port ${port}. Check ${paths_1.LOG_FILE}.` };
+    });
+}
+function launchAgentPlist(entry) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${process.execPath}</string>
+    <string>${entry}</string>
+    <string>_host</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${paths_1.LOG_FILE}</string>
+  <key>StandardErrorPath</key>
+  <string>${paths_1.LOG_FILE}</string>
+</dict>
+</plist>
+`;
+}
+function isAutoStartInstalled() {
+    if (process.platform !== "darwin")
+        return false;
+    return node_fs_1.default.existsSync(LAUNCH_AGENT_FILE);
+}
+function launchctl(args) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)("launchctl", args);
+        let out = "";
+        child.stdout.on("data", (d) => (out += d));
+        child.stderr.on("data", (d) => (out += d));
+        child.on("close", (code) => resolve(out.trim()));
+    });
+}
+const uid = node_os_1.default.userInfo().uid;
+async function enableAutoStart() {
+    const entry = cliEntry();
+    if (!entry)
+        return { ok: false, error: "Could not resolve the Lasso CLI entry point. Run this from the installed CLI." };
+    if (process.platform !== "darwin") {
+        return { ok: true, error: undefined };
+    }
+    try {
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(LAUNCH_AGENT_FILE), { recursive: true });
+        node_fs_1.default.writeFileSync(LAUNCH_AGENT_FILE, launchAgentPlist(entry), { mode: 0o644 });
+        await launchctl(["bootstrap", `gui/${uid}`, LAUNCH_AGENT_FILE]);
+        return { ok: true };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "failed";
+        return { ok: false, error: `Could not install the launch agent (${reason}).` };
+    }
+}
+async function disableAutoStart() {
+    if (process.platform !== "darwin")
+        return { ok: true };
+    try {
+        await launchctl(["bootout", `gui/${uid}/${AGENT_LABEL}`]);
+        node_fs_1.default.rmSync(LAUNCH_AGENT_FILE, { force: true });
+        return { ok: true };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "failed";
+        return { ok: false, error: `Could not remove the launch agent (${reason}).` };
+    }
+}
+async function daemonStatus(env) {
+    const port = (0, paths_1.hostProxyPort)(env);
+    const pid = (0, client_1.readDaemonPid)();
+    const health = await (0, client_1.hostAlive)(port);
+    const running = Boolean(health);
+    return {
+        running,
+        pid: running ? (health?.pid ?? pid) : null,
+        health,
+        autoStart: isAutoStartInstalled(),
+        resolver: await (0, dns_1.createDomainResolver)().status(),
+    };
+}
+async function stopDaemon(env) {
+    const port = (0, paths_1.hostProxyPort)(env);
+    const health = await (0, client_1.hostAlive)(port);
+    if (health && typeof health.pid === "number") {
+        try {
+            process.kill(health.pid, "SIGTERM");
+        }
+        catch (error) {
+            return { ok: false, error: `Could not stop Lasso Host: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        const deadline = Date.now() + 8000;
+        while (Date.now() < deadline) {
+            if (!(await (0, client_1.hostAlive)(port)))
+                return { ok: true };
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        return { ok: false, error: "Lasso Host did not stop in time." };
+    }
+    const pid = (0, client_1.readDaemonPid)();
+    if (pid && (0, client_1.isProcessAlive)(pid)) {
+        process.kill(pid, "SIGTERM");
+        return { ok: true };
+    }
+    return { ok: true, error: undefined };
+}
+function daemonPortMessage(env) {
+    return `http://<project>.lasso:${(0, paths_1.hostProxyPort)(env)}`;
+}
+function daemonHttpsPortMessage(env) {
+    return `https://<project>.lasso:${(0, paths_1.hostHttpsPort)(env)}`;
+}
+function yesOrNo(promptText) {
+    return new Promise((resolve) => {
+        const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+        rl.question(promptText, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            resolve(normalized === "y" || normalized === "yes");
+        });
+    });
+}

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

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

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

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const bridge_1 = require("../bridge");
+const [cwd, publicPortArg, bridgePortArg] = process.argv.slice(2);
+const publicPort = Number(publicPortArg) || 3000;
+const bridgePort = Number(bridgePortArg) || 3056;
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const socket = node_net_1.default.createServer();
+        socket.once("error", reject);
+        socket.listen(0, "127.0.0.1", () => {
+            const address = socket.address();
+            if (!address || typeof address === "string")
+                return reject(new Error("Could not allocate Next.js port."));
+            socket.close(() => resolve(address.port));
+        });
+    });
+}
+void (async () => {
+    const nextPort = await freePort();
+    const nextBin = node_path_1.default.join(cwd, "node_modules", ".bin", "next");
+    if (!node_fs_1.default.existsSync(nextBin))
+        throw new Error("Next.js is not installed in this project.");
+    const bridge = (0, bridge_1.startBridge)(cwd, null, bridgePort);
+    const nextProcess = (0, node_child_process_1.spawn)(nextBin, ["dev", "--port", String(nextPort), "--hostname", "127.0.0.1"], {
+        cwd,
+        env: { ...process.env, PORT: String(nextPort) },
+        stdio: "inherit",
+    });
+    const proxy = http_proxy_1.default.createProxyServer({ target: `http://127.0.0.1:${nextPort}`, selfHandleResponse: true, ws: true });
+    const bundlePath = node_path_1.default.resolve(__dirname, "../../overlay.js");
+    proxy.on("proxyRes", (proxyRes, _req, res) => {
+        const chunks = [];
+        proxyRes.on("data", (chunk) => chunks.push(chunk));
+        proxyRes.on("end", () => {
+            const body = Buffer.concat(chunks).toString("utf8");
+            const contentType = String(proxyRes.headers["content-type"] || "");
+            const headers = { ...proxyRes.headers };
+            delete headers["content-length"];
+            res.writeHead(proxyRes.statusCode || 200, headers);
+            res.end(contentType.includes("text/html")
+                ? body.replace("</head>", `<script src="/__lasso/overlay.js?bridgePort=${bridgePort}"></script></head>`)
+                : body);
+        });
+    });
+    const server = node_http_1.default.createServer((req, res) => {
+        if (req.url?.split("?", 1)[0] === "/__lasso/overlay.js") {
+            res.setHeader("content-type", "application/javascript");
+            res.end(node_fs_1.default.readFileSync(bundlePath, "utf8"));
+            return;
+        }
+        proxy.web(req, res, {}, (error) => {
+            if (!res.headersSent) {
+                res.writeHead(502, { "content-type": "text/plain" });
+                res.end(`Next.js is still starting: ${error.message}`);
+            }
+        });
+    });
+    server.on("upgrade", (req, socket, head) => proxy.ws(req, socket, head));
+    server.listen(publicPort, "127.0.0.1");
+    const shutdown = () => {
+        bridge.close();
+        nextProcess.kill("SIGTERM");
+        proxy.close();
+        server.close(() => process.exit(0));
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+    nextProcess.once("exit", (code) => {
+        if (code && code !== 0)
+            process.exitCode = code;
+    });
+})();

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

@@ -0,0 +1,15 @@
+export declare const HOST_DIR: string;
+export declare const REGISTRY_FILE: string;
+export declare const PID_FILE: string;
+export declare const LOG_FILE: string;
+export declare const DEFAULT_PROXY_PORT: number;
+export declare const DEFAULT_HTTPS_PORT: number;
+export declare const DEFAULT_DNS_PORT: number;
+export declare const TLD = "lasso";
+export declare function hostProxyPort(env: Record<string, string>): number;
+export declare function hostDnsPort(env: Record<string, string>): number;
+export declare function hostHttpsPort(env: Record<string, string>): number;
+export declare function domainOf(hostname: string): string;
+export declare function isLassoDomain(hostname: string): boolean;
+export declare function attachHostPort(url: string, port: number): string;
+export declare function ensureHostDir(): string;

package/dist/cli/host/paths.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLD = exports.DEFAULT_DNS_PORT = exports.DEFAULT_HTTPS_PORT = exports.DEFAULT_PROXY_PORT = exports.LOG_FILE = exports.PID_FILE = exports.REGISTRY_FILE = exports.HOST_DIR = void 0;
+exports.hostProxyPort = hostProxyPort;
+exports.hostDnsPort = hostDnsPort;
+exports.hostHttpsPort = hostHttpsPort;
+exports.domainOf = domainOf;
+exports.isLassoDomain = isLassoDomain;
+exports.attachHostPort = attachHostPort;
+exports.ensureHostDir = ensureHostDir;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.HOST_DIR = process.env.LASSO_HOST_DIR || node_path_1.default.join(node_os_1.default.homedir(), ".lasso", "host");
+exports.REGISTRY_FILE = node_path_1.default.join(exports.HOST_DIR, "registry.json");
+exports.PID_FILE = node_path_1.default.join(exports.HOST_DIR, "daemon.pid");
+exports.LOG_FILE = node_path_1.default.join(exports.HOST_DIR, "daemon.log");
+// Local project URLs use HTTP on 6766 and HTTPS on 6767 by default.
+// LASSO_HOST_PORT remains available for teams that need a custom port.
+exports.DEFAULT_PROXY_PORT = Number(process.env.LASSO_HOST_PORT) || 6766;
+exports.DEFAULT_HTTPS_PORT = Number(process.env.LASSO_HOST_HTTPS_PORT) || 6767;
+exports.DEFAULT_DNS_PORT = Number(process.env.LASSO_DNS_PORT) || 5358;
+exports.TLD = "lasso";
+function hostProxyPort(env) {
+    return Number(process.env.LASSO_HOST_PORT || env.LASSO_HOST_PORT) || exports.DEFAULT_PROXY_PORT;
+}
+function hostDnsPort(env) {
+    return Number(process.env.LASSO_DNS_PORT || env.LASSO_DNS_PORT) || exports.DEFAULT_DNS_PORT;
+}
+function hostHttpsPort(env) {
+    return Number(process.env.LASSO_HOST_HTTPS_PORT || env.LASSO_HOST_HTTPS_PORT) || exports.DEFAULT_HTTPS_PORT;
+}
+function domainOf(hostname) {
+    return hostname.replace(/:\d+$/, "").toLowerCase();
+}
+function isLassoDomain(hostname) {
+    return domainOf(hostname).endsWith(`.${exports.TLD}`);
+}
+function attachHostPort(url, port) {
+    try {
+        const parsed = new URL(url);
+        parsed.port = String(port);
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        return url;
+    }
+}
+function ensureHostDir() {
+    node_fs_1.default.mkdirSync(exports.HOST_DIR, { recursive: true });
+    return exports.HOST_DIR;
+}

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

@@ -0,0 +1,31 @@
+export interface HostProject {
+    projectId: string;
+    directory: string;
+    registeredAt: string;
+}
+export type HostRegistry = Record<string, HostProject>;
+export declare const DOMAIN_RE: RegExp;
+export declare function ensureRegistryDir(): string;
+export declare function loadRegistry(): HostRegistry;
+export declare function saveRegistry(registry: HostRegistry): void;
+export declare function findByDirectory(registry: HostRegistry, directory: string): {
+    domain: string;
+    project: HostProject;
+} | null;
+export interface RegisterInput {
+    domain: string;
+    directory: string;
+    projectId?: string;
+    registry: HostRegistry;
+}
+/**
+ * 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.
+ */
+export declare function registerProject(input: RegisterInput): HostRegistry;
+export declare function unregisterDomain(registry: HostRegistry, domain: string): HostRegistry;
+export declare function slugifyProjectName(name: string): string;
+export declare function defaultDomainForDirectory(directory: string): string;
+export declare function generateUniqueDomain(directory: string, registry: HostRegistry): string;
+export declare function validateDomain(domain: string): boolean;