@lasso-ai/cli 1.0.0

package/dist/cli/host/client.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostAlive = hostAlive;
+exports.readDaemonPid = readDaemonPid;
+exports.isProcessAlive = isProcessAlive;
+exports.registerWithHost = registerWithHost;
+exports.unregisterFromHost = unregisterFromHost;
+exports.listHostProjects = listHostProjects;
+exports.stopHostProject = stopHostProject;
+exports.restartHost = restartHost;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const auth_1 = require("../auth");
+const registry_1 = require("./registry");
+const dns_1 = require("./dns");
+const paths_1 = require("./paths");
+async function hostAlive(port) {
+    try {
+        const response = await (0, auth_1.fetchWithTimeout)(`http://127.0.0.1:${port}/_host/health`, {}, 2500);
+        if (!response.ok)
+            return null;
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+function readDaemonPid() {
+    try {
+        const pid = Number(node_fs_1.default.readFileSync(paths_1.PID_FILE, "utf8").trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function registerWithHost(domain, directory, projectId, port) {
+    const health = await hostAlive(port);
+    if (health) {
+        try {
+            const response = await (0, auth_1.fetchWithTimeout)(`http://127.0.0.1:${port}/_host/register`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ domain, directory, projectId }),
+            });
+            const body = (await response.json());
+            if (!response.ok || !body.ok)
+                return { ok: false, domain, directory, error: body.error || "The host rejected the registration." };
+            return { ok: true, domain, directory: node_path_1.default.resolve(directory), replaced: Boolean(body.replaced), viaHost: true };
+        }
+        catch {
+            // fall through to a direct registry write
+        }
+    }
+    try {
+        const current = (0, registry_1.loadRegistry)();
+        const next = (0, registry_1.registerProject)({ domain, directory, projectId, registry: current });
+        (0, registry_1.saveRegistry)(next);
+        await (0, dns_1.syncResolverAfterRegister)();
+        return { ok: true, domain, directory: node_path_1.default.resolve(directory), replaced: Boolean(current[domain] && current[domain].directory !== node_path_1.default.resolve(directory)) };
+    }
+    catch (error) {
+        return { ok: false, domain, directory, error: error instanceof Error ? error.message : "Could not write the Lasso Host registry." };
+    }
+}
+async function unregisterFromHost(domain, port) {
+    const health = await hostAlive(port);
+    if (health) {
+        const response = await (0, auth_1.fetchWithTimeout)(`http://127.0.0.1:${port}/_host/unregister`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ domain }),
+        });
+        const body = (await response.json());
+        if (!response.ok || !body.ok)
+            return { ok: false, error: body.error || "The host rejected the unregister." };
+        return { ok: true, removed: Boolean(body.removed) };
+    }
+    const had = domain in (0, registry_1.loadRegistry)();
+    (0, registry_1.saveRegistry)((0, registry_1.unregisterDomain)((0, registry_1.loadRegistry)(), domain));
+    await (0, dns_1.syncResolverAfterRegister)();
+    return { ok: true, removed: had };
+}
+async function listHostProjects(port) {
+    const health = await hostAlive(port);
+    if (health?.projects) {
+        const projects = health.projects;
+        return {
+            health,
+            projects: projects.map((p) => ({
+                projectId: String(p.projectId || ""),
+                directory: String(p.directory || ""),
+                registeredAt: "",
+                domain: String(p.domain || ""),
+                status: p.status === "running" ? "running" : "stopped",
+                port: typeof p.port === "number" ? p.port : null,
+                pid: typeof p.pid === "number" ? p.pid : null,
+            })),
+        };
+    }
+    const registry = (0, registry_1.loadRegistry)();
+    return {
+        health,
+        projects: Object.entries(registry).map(([domain, project]) => ({ ...project, domain, status: "stopped", port: null, pid: null })),
+    };
+}
+async function stopHostProject(domain, port) {
+    const health = await hostAlive(port);
+    if (!health)
+        return { ok: false, error: "Lasso Host is not running." };
+    const response = await (0, auth_1.fetchWithTimeout)(`http://127.0.0.1:${port}/_host/stop`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ domain }),
+    });
+    const body = (await response.json());
+    if (!response.ok || !body.ok)
+        return { ok: false, error: body.error || "The host rejected the stop request." };
+    return { ok: true };
+}
+async function restartHost(port) {
+    const health = await hostAlive(port);
+    if (!health)
+        return { ok: false, error: "Lasso Host is not running." };
+    const response = await (0, auth_1.fetchWithTimeout)(`http://127.0.0.1:${port}/_host/restart`, { method: "POST" });
+    if (!response.ok)
+        return { ok: false, error: "The host rejected the restart request." };
+    return { ok: true };
+}

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

@@ -0,0 +1,50 @@
+export declare const SERVICE_NAME = "lasso-host";
+export interface HostRuntimeOptions {
+    proxyPort: number;
+    httpsPort: number;
+    dnsPort: number;
+    version?: string;
+}
+export declare class LassoHost {
+    private readonly opts;
+    private readonly server;
+    private readonly secureServer;
+    private dnsHandle;
+    private readonly resolver;
+    private readonly registry;
+    private readonly running;
+    private readonly crashLog;
+    private readonly proxies;
+    constructor(opts: HostRuntimeOptions);
+    private log;
+    projectView(domain: string): {
+        domain: string;
+        directory: string;
+        projectId: string;
+        status: string;
+        port: number | null;
+        pid: number | null;
+    } | null;
+    private projectList;
+    private commitRegistry;
+    private proxyFor;
+    private ensureRunning;
+    private routes;
+    private health;
+    private handleRequest;
+    private proxyToProject;
+    private handleUpgrade;
+    start(): Promise<{
+        error?: string;
+    }>;
+    stop(): Promise<void>;
+    resolverStatus(): Promise<{
+        installed: boolean;
+        detail: string;
+    }>;
+}
+export declare function getHost(): LassoHost | null;
+export declare function startHost(opts: HostRuntimeOptions): Promise<{
+    error?: string;
+}>;
+export declare function waitForShutdown(): void;

package/dist/cli/host/daemon.js

@@ -0,0 +1,368 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LassoHost = exports.SERVICE_NAME = void 0;
+exports.getHost = getHost;
+exports.startHost = startHost;
+exports.waitForShutdown = waitForShutdown;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_path_1 = __importDefault(require("node:path"));
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const registry_1 = require("./registry");
+const runtime_1 = require("./runtime");
+const dns_1 = require("./dns");
+const paths_1 = require("./paths");
+const certificates_1 = require("./certificates");
+exports.SERVICE_NAME = "lasso-host";
+function writeJson(res, status, body) {
+    res.writeHead(status, { "content-type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+function readBody(req) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+            }
+            catch {
+                resolve({});
+            }
+        });
+    });
+}
+function logline(message) {
+    try {
+        node_fs_1.default.appendFileSync(paths_1.LOG_FILE, `[${new Date().toISOString()}] ${message}\n`);
+    }
+    catch {
+        // best-effort
+    }
+}
+class LassoHost {
+    opts;
+    server;
+    secureServer;
+    dnsHandle = null;
+    resolver;
+    registry;
+    running = new Map();
+    crashLog = new Map();
+    proxies = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        this.server = node_http_1.default.createServer((req, res) => this.handleRequest(req, res));
+        this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
+        this.secureServer = node_https_1.default.createServer({}, (req, res) => this.handleRequest(req, res));
+        this.secureServer.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
+        this.resolver = (0, dns_1.createDomainResolver)();
+        this.registry = (0, registry_1.loadRegistry)();
+        this.log(`host starting (version ${opts.version || "unknown"})`);
+    }
+    log(message) {
+        logline(message);
+    }
+    // ---- helpers ------------------------------------------------------
+    projectView(domain) {
+        const project = this.registry[domain];
+        if (!project)
+            return null;
+        const runtime = this.running.get(domain);
+        return {
+            domain,
+            directory: project.directory,
+            projectId: project.projectId,
+            status: runtime?.ready ? "running" : "stopped",
+            port: runtime?.port ?? null,
+            pid: runtime?.pid ?? null,
+        };
+    }
+    projectList() {
+        return Object.keys(this.registry).map((domain) => this.projectView(domain));
+    }
+    commitRegistry(registry) {
+        for (const key of Object.keys(this.registry))
+            delete this.registry[key];
+        Object.assign(this.registry, registry);
+        (0, registry_1.saveRegistry)(this.registry);
+    }
+    proxyFor(port) {
+        let proxy = this.proxies.get(port);
+        if (!proxy) {
+            proxy = http_proxy_1.default.createProxyServer({ target: `http://127.0.0.1:${port}`, ws: true });
+            proxy.on("error", () => {
+                // forwarded per-request below
+            });
+            this.proxies.set(port, proxy);
+        }
+        return proxy;
+    }
+    async ensureRunning(domain) {
+        const existing = this.running.get(domain);
+        if (existing)
+            return existing;
+        const project = this.registry[domain];
+        if (!project)
+            return null;
+        const crashes = (this.crashLog.get(domain) || []).filter((t) => Date.now() - t < 5 * 60_000);
+        if (crashes.length >= 3) {
+            throw new Error(`${domain} kept crashing on startup; not auto-restarting. Fix the project or run "lasso daemon restart".`);
+        }
+        this.crashLog.set(domain, crashes);
+        const result = await (0, runtime_1.startProjectRuntime)(project.directory);
+        if (!result.ok || !result.runtime) {
+            this.crashLog.set(domain, [...crashes, Date.now()]);
+            throw new Error(result.error || `Could not start ${domain}.`);
+        }
+        const runtime = result.runtime;
+        this.running.set(domain, runtime);
+        runtime.child.on("exit", (code, signal) => {
+            if (this.running.get(domain) === runtime) {
+                this.running.delete(domain);
+                this.log(`project ${domain} exited (code=${code} signal=${signal})`);
+            }
+        });
+        return runtime;
+    }
+    // ---- control surface ---------------------------------------------
+    routes() {
+        return [
+            { route: "GET /_host/health", handler: (_req, res) => this.health(res) },
+            { route: "GET /_host/registry", handler: (_req, res) => writeJson(res, 200, { ok: true, projects: this.projectList() }) },
+            {
+                route: "POST /_host/register",
+                handler: async (req, res) => {
+                    const body = await readBody(req);
+                    const domain = String(body.domain || "").trim().toLowerCase();
+                    const directory = String(body.directory || "").trim();
+                    const projectId = String(body.projectId || "").trim();
+                    if (!(0, registry_1.validateDomain)(domain))
+                        return writeJson(res, 400, { ok: false, error: `"${domain}" is not a valid .lasso domain.` });
+                    if (!directory || !node_fs_1.default.existsSync(directory) || !node_fs_1.default.statSync(directory).isDirectory()) {
+                        return writeJson(res, 400, { ok: false, error: "The project directory does not exist or is not a directory." });
+                    }
+                    for (const [existingDomain, project] of Object.entries(this.registry)) {
+                        if (node_path_1.default.resolve(project.directory) === node_path_1.default.resolve(directory) && existingDomain !== domain) {
+                            this.running.get(existingDomain)?.child.kill("SIGTERM");
+                            this.running.delete(existingDomain);
+                        }
+                    }
+                    const next = (0, registry_1.registerProject)({ domain, directory, projectId, registry: this.registry });
+                    this.commitRegistry(next);
+                    await (0, dns_1.syncResolverAfterRegister)();
+                    this.log(`registered ${domain} → ${directory}`);
+                    writeJson(res, 200, { ok: true, domain, directory: node_path_1.default.resolve(directory), projects: Object.keys(next).length });
+                },
+            },
+            {
+                route: "POST /_host/unregister",
+                handler: async (req, res) => {
+                    const body = await readBody(req);
+                    const domain = String(body.domain || "").trim().toLowerCase();
+                    if (!domain)
+                        return writeJson(res, 400, { ok: false, error: "A domain is required." });
+                    const had = domain in this.registry;
+                    this.running.get(domain)?.child.kill("SIGTERM");
+                    this.running.delete(domain);
+                    this.commitRegistry((0, registry_1.unregisterDomain)(this.registry, domain));
+                    await (0, dns_1.syncResolverAfterRegister)();
+                    this.log(`unregistered ${domain}`);
+                    writeJson(res, 200, { ok: true, domain, removed: had });
+                },
+            },
+            {
+                route: "POST /_host/stop",
+                handler: async (req, res) => {
+                    const body = await readBody(req);
+                    const domain = String(body.domain || "").trim().toLowerCase();
+                    const runtime = this.running.get(domain);
+                    if (!runtime)
+                        return writeJson(res, 200, { ok: true, domain, status: "stopped" });
+                    runtime.child.kill("SIGTERM");
+                    this.running.delete(domain);
+                    this.log(`stopped ${domain}`);
+                    writeJson(res, 200, { ok: true, domain, status: "stopped" });
+                },
+            },
+            {
+                route: "POST /_host/restart",
+                handler: async (_req, res) => {
+                    const stopped = [];
+                    for (const [domain, runtime] of this.running) {
+                        runtime.child.kill("SIGTERM");
+                        this.running.delete(domain);
+                        stopped.push(domain);
+                        this.log(`stopped ${domain} for restart`);
+                    }
+                    writeJson(res, 200, { ok: true, stopped });
+                },
+            },
+        ];
+    }
+    health(res) {
+        writeJson(res, 200, {
+            ok: true,
+            service: exports.SERVICE_NAME,
+            version: this.opts.version || "unknown",
+            pid: process.pid,
+            dnsPort: this.dnsHandle?.port ?? null,
+            proxyPort: this.opts.proxyPort,
+            httpsPort: this.opts.httpsPort,
+            https: (0, certificates_1.hostCertificateStatus)().present,
+            running: this.running.size,
+            registered: Object.keys(this.registry).length,
+            projects: this.projectList(),
+        });
+    }
+    // ---- request handling --------------------------------------------
+    handleRequest(req, res) {
+        const url = req.url || "/";
+        const route = this.routes().find((r) => r.route === `${req.method} ${url}`);
+        if (route) {
+            void Promise.resolve(route.handler(req, res, {})).catch((error) => {
+                this.log(line(error));
+                writeJson(res, 500, { ok: false, error: line(error) });
+            });
+            return;
+        }
+        const isControl = url.startsWith("/_host/");
+        if (isControl) {
+            writeJson(res, 404, { ok: false, error: "Unknown Lasso Host control endpoint." });
+            return;
+        }
+        const hostname = (0, paths_1.domainOf)(req.headers.host || "");
+        if (!(0, paths_1.isLassoDomain)(hostname)) {
+            writeJson(res, 404, { ok: false, error: "Lasso Host only proxies *.lasso domains.", host: req.headers.host });
+            return;
+        }
+        void this.proxyToProject(hostname, req, res);
+    }
+    async proxyToProject(hostname, req, res) {
+        let runtime;
+        try {
+            const started = await this.ensureRunning(hostname);
+            if (!started) {
+                writeJson(res, 404, { ok: false, domain: hostname, error: `No Lasso project is registered for ${hostname}. Run "lasso init" in the project first.` });
+                return;
+            }
+            runtime = started;
+        }
+        catch (error) {
+            const message = line(error);
+            this.log(`request for ${hostname} failed: ${message}`);
+            writeJson(res, 503, { ok: false, domain: hostname, error: message });
+            return;
+        }
+        this.proxyFor(runtime.port).web(req, res, {}, (error) => {
+            this.log(`proxy error for ${hostname}: ${line(error)}`);
+            if (!res.headersSent)
+                writeJson(res, 502, { ok: false, error: "The project's dev server is not responding." });
+            else
+                res.destroy();
+        });
+    }
+    handleUpgrade(req, socket, head) {
+        const hostname = (0, paths_1.domainOf)(req.headers.host || "");
+        if (!(0, paths_1.isLassoDomain)(hostname)) {
+            socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+            socket.destroy();
+            return;
+        }
+        void (async () => {
+            let runtime;
+            try {
+                const started = await this.ensureRunning(hostname);
+                if (!started)
+                    throw new Error("not registered");
+                runtime = started;
+            }
+            catch {
+                socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+                socket.destroy();
+                return;
+            }
+            this.proxyFor(runtime.port).ws(req, socket, head, {}, (error) => {
+                this.log(`ws proxy error for ${hostname}: ${line(error)}`);
+                socket.destroy();
+            });
+        })();
+    }
+    // ---- lifecycle ---------------------------------------------------
+    async start() {
+        try {
+            this.dnsHandle = await (0, dns_1.startDnsServer)(this.opts.dnsPort);
+            this.log(`dns server listening on 127.0.0.1:${this.opts.dnsPort}`);
+        }
+        catch (error) {
+            this.dnsHandle = null;
+            this.log(`dns server failed to start on ${this.opts.dnsPort}: ${line(error)}`);
+        }
+        const certificate = (0, certificates_1.ensureHostCertificate)();
+        if (!certificate.ok)
+            this.log(`https certificate unavailable: ${certificate.error}`);
+        else {
+            this.secureServer.setSecureContext({ key: node_fs_1.default.readFileSync(certificates_1.TLS_KEY_FILE), cert: node_fs_1.default.readFileSync(certificates_1.TLS_CERT_FILE) });
+            this.log(`https certificate ready${certificate.trusted ? " (trusted by mkcert)" : " (local trust may be required)"}`);
+        }
+        return await new Promise((resolve) => {
+            this.server.once("error", (error) => {
+                resolve({ error: error.code === "EADDRINUSE" ? `Lasso Host is already running on port ${this.opts.proxyPort}.` : line(error) });
+            });
+            this.server.listen(this.opts.proxyPort, "127.0.0.1", () => {
+                node_fs_1.default.writeFileSync(paths_1.PID_FILE, String(process.pid), { encoding: "utf8" });
+                this.log(`proxy listening on 127.0.0.1:${this.opts.proxyPort}`);
+                if (!certificate.ok)
+                    return resolve({});
+                this.secureServer.once("error", (error) => { this.log(`https proxy failed: ${line(error)}`); resolve({}); });
+                this.secureServer.listen(this.opts.httpsPort, "127.0.0.1", () => {
+                    this.log(`https proxy listening on 127.0.0.1:${this.opts.httpsPort}`);
+                    resolve({});
+                });
+            });
+        });
+    }
+    async stop() {
+        for (const [, runtime] of this.running)
+            runtime.child.kill("SIGTERM");
+        this.running.clear();
+        for (const proxy of this.proxies.values())
+            proxy.close();
+        this.proxies.clear();
+        this.server.close();
+        this.secureServer.close();
+        this.dnsHandle?.close();
+        try {
+            node_fs_1.default.unlinkSync(paths_1.PID_FILE);
+        }
+        catch {
+            // already gone
+        }
+    }
+    resolverStatus() {
+        return this.resolver.status();
+    }
+}
+exports.LassoHost = LassoHost;
+function line(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+let host = null;
+function getHost() {
+    return host;
+}
+function startHost(opts) {
+    host = new LassoHost(opts);
+    return host.start();
+}
+function waitForShutdown() {
+    const shutdown = () => {
+        void host?.stop().then(() => process.exit(0));
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+}

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

@@ -0,0 +1,80 @@
+import { type HostRegistry } from "./registry";
+export declare function buildDnsResponse(query: Buffer): Buffer | null;
+export interface DnsServerHandle {
+    close: () => void;
+    port: number;
+}
+export declare function startDnsServer(port: number): Promise<DnsServerHandle>;
+export interface DomainResolver {
+    platform: string;
+    status: () => Promise<{
+        installed: boolean;
+        detail: string;
+    }>;
+    install: (dnsPort: number) => Promise<{
+        ok: boolean;
+        requiresSudo?: boolean;
+        message: string;
+    }>;
+    uninstall: (dnsPort: number) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare class MacOSResolver implements DomainResolver {
+    readonly platform = "darwin";
+    status(): Promise<{
+        installed: boolean;
+        detail: string;
+    }>;
+    install(dnsPort: number): Promise<{
+        ok: boolean;
+        message: string;
+        requiresSudo?: undefined;
+    } | {
+        ok: boolean;
+        requiresSudo: boolean;
+        message: string;
+    }>;
+    uninstall(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare class LinuxResolver implements DomainResolver {
+    readonly platform = "linux";
+    private readonly systemdFile;
+    status(): Promise<{
+        installed: boolean;
+        detail: string;
+    }>;
+    install(dnsPort: number): Promise<{
+        ok: boolean;
+        requiresSudo: boolean;
+        message: string;
+    }>;
+    uninstall(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare class WindowsResolver implements DomainResolver {
+    readonly platform = "win32";
+    status(): Promise<{
+        installed: boolean;
+        detail: string;
+    }>;
+    readHostsBlock(): Promise<string[]>;
+    decodeHost(entry: string): string;
+    sync(registry: HostRegistry): Promise<boolean>;
+    install(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    uninstall(): Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+}
+export declare function createDomainResolver(platform?: NodeJS.Platform): DomainResolver;
+export declare function syncResolverAfterRegister(): Promise<boolean>;