@lasso-ai/cli 1.0.0

package/dist/cli/project.d.ts

@@ -0,0 +1,56 @@
+export declare const LASSO_CONFIG_FILE = "lasso.config.json";
+export interface CollabConfig {
+    projectId: string;
+    name: string;
+    version?: string;
+    realtimeUrl: string;
+    apiUrl: string;
+    registered: boolean;
+    registeredAt?: string;
+    claimed: boolean;
+    workspaceId?: string;
+    token?: string;
+    apiKey?: string;
+}
+export interface InitResult {
+    ok: boolean;
+    error?: string;
+    projectId?: string;
+    workspaceId?: string;
+    name?: string;
+    domain?: string;
+}
+export declare function readEnvFile(filename: string, cwd: string): Record<string, string>;
+/** Reads .env / .env.local / .env.production from the project and common sub-roots. */
+export declare function readProjectEnv(cwd: string): Record<string, string>;
+/**
+ * The Lasso API key (`lss_live_…`) is the CLI credential. Lookup order:
+ * the environment (`LASSO_API_KEY` + `.env` files) first, then the credential
+ * stored by `lasso auth login`. It is NEVER written to lasso.config.json.
+ */
+export declare function resolveLassoApiKey(fileEnv: Record<string, string>): string;
+/**
+ * The project identity that makes collaboration work. `lasso init` writes it;
+ * `lasso dev` reads it and validates it server-side against the API key's workspace.
+ * `domain` (the local `.lasso` Host domain) is optional and local-only.
+ */
+export declare function readProjectConfig(cwd: string): {
+    id: string;
+    source: string;
+    domain?: string;
+} | null;
+/**
+ * `lasso init` — creates (or re-registers) the project in the API key's workspace,
+ * writes `lasso.config.json` with the project id and its local `.lasso` Host domain,
+ * and registers the domain with Lasso Host (or the local registry if Host isn't
+ * running). Only `{ "id": "proj_…", "domain": "….lasso" }` is stored — the API key
+ * never touches this file.
+ */
+export declare function initProject(cwd: string, fileEnv: Record<string, string>): Promise<InitResult>;
+/**
+ * `lasso dev` — consumes `lasso.config.json`: authenticates with the API key, lets the
+ * server resolve the key's workspace, validates the project belongs to it, and
+ * authenticates the project session. Returns null-enabled CollabConfig so realtime is
+ * safely degraded (no collaboration, local editing unaffected) on any failure.
+ */
+export declare function resolveCollabSession(cwd: string, fileEnv: Record<string, string>, projectId: string): Promise<CollabConfig>;

package/dist/cli/project.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LASSO_CONFIG_FILE = void 0;
+exports.readEnvFile = readEnvFile;
+exports.readProjectEnv = readProjectEnv;
+exports.resolveLassoApiKey = resolveLassoApiKey;
+exports.readProjectConfig = readProjectConfig;
+exports.initProject = initProject;
+exports.resolveCollabSession = resolveCollabSession;
+const node_fs_1 = __importDefault(require("node:fs"));
+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 node_util_1 = require("node:util");
+const chalk_1 = __importDefault(require("chalk"));
+const framework_1 = require("./utils/framework");
+const auth_1 = require("./auth");
+const registry_1 = require("./host/registry");
+const client_1 = require("./host/client");
+const paths_1 = require("./host/paths");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+exports.LASSO_CONFIG_FILE = "lasso.config.json";
+const PROJECT_STATE_FILE = ".lasso-project.json";
+function readEnvFile(filename, cwd) {
+    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 {};
+    }
+}
+/** Reads .env / .env.local / .env.production from the project and common sub-roots. */
+function readProjectEnv(cwd) {
+    const envRoots = [cwd, node_path_1.default.join(cwd, "web"), node_path_1.default.join(cwd, "server")];
+    return envRoots.reduce((values, root) => ({
+        ...values,
+        ...readEnvFile(".env", root),
+        ...readEnvFile(".env.local", root),
+        ...readEnvFile(".env.production", root),
+    }), {});
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function envFrom(fileEnv) {
+    const all = { ...process.env, ...fileEnv };
+    return all[`REALTIME_URL`] || all[`LASSO_REALTIME_URL`] || all[`NEXT_PUBLIC_REALTIME_URL`] || all[`API_URL`] || "";
+}
+function realtimeUrlFrom(fileEnv) {
+    const fromEnv = envFrom(fileEnv);
+    if (fromEnv)
+        return fromEnv;
+    const all = { ...process.env, ...fileEnv };
+    // If a local port override is explicitly set, prefer localhost.
+    if (all[`COLLAB_PORT`] || all[`REALTIME_PORT`]) {
+        const port = all[`COLLAB_PORT`] || all[`REALTIME_PORT`];
+        return `http://localhost:${port}`;
+    }
+    // Default to the hosted collab server; fall back to local dev server.
+    return `https://collab.lasso.byorello.space`;
+}
+/**
+ * The Lasso API key (`lss_live_…`) is the CLI credential. Lookup order:
+ * the environment (`LASSO_API_KEY` + `.env` files) first, then the credential
+ * stored by `lasso auth login`. It is NEVER written to lasso.config.json.
+ */
+function resolveLassoApiKey(fileEnv) {
+    const fromEnv = (process.env.LASSO_API_KEY || fileEnv.LASSO_API_KEY || "").trim();
+    if (fromEnv)
+        return fromEnv;
+    const stored = (0, auth_1.loadCredentials)();
+    return stored?.apiKey || "";
+}
+function parseAuthor(author) {
+    if (typeof author === "string")
+        return author;
+    if (author && typeof author === "object") {
+        const parts = [author.name, author.email].filter(Boolean);
+        return parts.join(" ");
+    }
+    return "";
+}
+function parseRepository(repository) {
+    if (typeof repository === "string")
+        return repository;
+    if (repository && typeof repository === "object") {
+        const url = repository.url;
+        if (url)
+            return url.replace(/^git\+/, "");
+    }
+    return "";
+}
+function dependencyNames(pkg) {
+    const names = [];
+    for (const section of ["dependencies", "devDependencies", "peerDependencies"]) {
+        const map = pkg[section];
+        if (map && typeof map === "object")
+            names.push(...Object.keys(map));
+    }
+    return names.slice(0, 80);
+}
+async function detectGitRemote(cwd) {
+    try {
+        const result = await execFileAsync("git", ["remote", "get-url", "origin"], { cwd, maxBuffer: 1024 * 1024 });
+        return result.stdout.trim();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The project identity that makes collaboration work. `lasso init` writes it;
+ * `lasso dev` reads it and validates it server-side against the API key's workspace.
+ * `domain` (the local `.lasso` Host domain) is optional and local-only.
+ */
+function readProjectConfig(cwd) {
+    const direct = readJson(node_path_1.default.join(cwd, exports.LASSO_CONFIG_FILE));
+    const directId = direct && typeof direct.id === "string" ? direct.id.trim() : "";
+    if (directId) {
+        const domain = direct && typeof direct.domain === "string" ? direct.domain.trim() : undefined;
+        return { id: directId, source: exports.LASSO_CONFIG_FILE, domain: domain || undefined };
+    }
+    // Transitional: honor the legacy state file until a fresh `lasso init` is run.
+    const legacy = readJson(node_path_1.default.join(cwd, PROJECT_STATE_FILE));
+    const legacyId = legacy && typeof legacy.projectId === "string" ? legacy.projectId.trim() : "";
+    if (legacyId)
+        return { id: legacyId, source: PROJECT_STATE_FILE };
+    return null;
+}
+async function buildProjectMetadata(cwd, framework) {
+    const pkg = readJson(node_path_1.default.join(cwd, "package.json")) || {};
+    const name = typeof pkg.name === "string" && pkg.name ? pkg.name : node_path_1.default.basename(cwd) || "untitled";
+    const version = typeof pkg.version === "string" ? pkg.version : "";
+    const gitRemote = (typeof pkg.repository === "string" ? pkg.repository : parseRepository(pkg.repository)) || (await detectGitRemote(cwd));
+    const payload = {
+        name,
+        version,
+        description: typeof pkg.description === "string" ? pkg.description : "",
+        framework,
+        gitRemote,
+        repository: gitRemote,
+        author: parseAuthor(pkg.author),
+        homepage: typeof pkg.homepage === "string" ? pkg.homepage : "",
+        keywords: Array.isArray(pkg.keywords) ? pkg.keywords.slice(0, 40) : [],
+        packageInfo: {
+            name,
+            version,
+            description: typeof pkg.description === "string" ? pkg.description : "",
+            license: typeof pkg.license === "string" ? pkg.license : "",
+            type: typeof pkg.type === "string" ? pkg.type : "",
+            dependencies: dependencyNames(pkg),
+        },
+    };
+    return { name, version, gitRemote, payload };
+}
+function promptForApiKey() {
+    return new Promise((resolve) => {
+        const rl = node_readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`No Lasso key found. Run ${chalk_1.default.cyan("npx lasso auth login")} to sign in, or paste an API key (create one in the dashboard: ${chalk_1.default.cyan("lss_live_…")}): `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || null);
+        });
+    });
+}
+/**
+ * `lasso init` — creates (or re-registers) the project in the API key's workspace,
+ * writes `lasso.config.json` with the project id and its local `.lasso` Host domain,
+ * and registers the domain with Lasso Host (or the local registry if Host isn't
+ * running). Only `{ "id": "proj_…", "domain": "….lasso" }` is stored — the API key
+ * never touches this file.
+ */
+async function initProject(cwd, fileEnv) {
+    const realtimeUrl = realtimeUrlFrom(fileEnv).replace(/\/$/, "");
+    const apiUrl = `${realtimeUrl}/api/v1`;
+    const framework = (0, framework_1.detectFramework)(cwd);
+    const { name, payload } = await buildProjectMetadata(cwd, framework);
+    let apiKey = resolveLassoApiKey(fileEnv);
+    if (!apiKey)
+        apiKey = (await promptForApiKey()) || "";
+    if (!apiKey) {
+        return { ok: false, error: "No Lasso API key found. Set LASSO_API_KEY in your environment or paste it when prompted." };
+    }
+    try {
+        const response = await (0, auth_1.fetchWithTimeout)(`${apiUrl}/collab/projects/register`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(payload),
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok) {
+            if (response.status === 401) {
+                return { ok: false, error: "Your Lasso API key is invalid or inactive. Create or reactivate one in the dashboard." };
+            }
+            if (response.status === 403) {
+                return { ok: false, error: "Your API key does not have access to a Lasso workspace." };
+            }
+            return { ok: false, error: body.message || `Project registration failed (${response.status}).` };
+        }
+        const projectId = body.project?.id;
+        if (!projectId) {
+            return { ok: false, error: "The server did not return a project id." };
+        }
+        const registry = (0, registry_1.loadRegistry)();
+        const existing = (0, registry_1.findByDirectory)(registry, cwd);
+        const domain = existing ? existing.domain : (0, registry_1.generateUniqueDomain)(cwd, registry);
+        await (0, client_1.registerWithHost)(domain, cwd, projectId, (0, paths_1.hostProxyPort)(fileEnv));
+        node_fs_1.default.writeFileSync(node_path_1.default.join(cwd, exports.LASSO_CONFIG_FILE), JSON.stringify({ id: projectId, domain }, null, 2) + "\n");
+        return {
+            ok: true,
+            projectId,
+            workspaceId: body.project?.workspaceId,
+            name: body.project?.name || name,
+            domain,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "request failed";
+        return { ok: false, error: `Could not reach the Lasso realtime server at ${realtimeUrl} (${reason}). Is it running?` };
+    }
+}
+/**
+ * `lasso dev` — consumes `lasso.config.json`: authenticates with the API key, lets the
+ * server resolve the key's workspace, validates the project belongs to it, and
+ * authenticates the project session. Returns null-enabled CollabConfig so realtime is
+ * safely degraded (no collaboration, local editing unaffected) on any failure.
+ */
+async function resolveCollabSession(cwd, fileEnv, projectId) {
+    const realtimeUrl = realtimeUrlFrom(fileEnv).replace(/\/$/, "");
+    const apiUrl = `${realtimeUrl}/api/v1`;
+    const config = {
+        projectId,
+        name: "",
+        version: "",
+        realtimeUrl,
+        apiUrl,
+        registered: false,
+        claimed: false,
+    };
+    const apiKey = resolveLassoApiKey(fileEnv);
+    if (!apiKey) {
+        console.warn(chalk_1.default.yellow("!") + " No Lasso credential found. Run " + chalk_1.default.cyan("npx lasso auth login") + " (or set LASSO_API_KEY) to enable realtime collaboration.");
+        return config;
+    }
+    try {
+        const response = await (0, auth_1.fetchWithTimeout)(`${apiUrl}/collab/projects/${encodeURIComponent(projectId)}/session`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${apiKey}` },
+        });
+        if (!response.ok) {
+            const reason = response.status === 401
+                ? "Your Lasso API key is invalid or inactive."
+                : response.status === 403
+                    ? "This project belongs to another workspace."
+                    : `The server rejected the project session (${response.status}).`;
+            console.warn(chalk_1.default.yellow("!") + ` Realtime collaboration unavailable: ${reason}`);
+            return config;
+        }
+        const body = (await response.json());
+        config.name = body.project?.name || "";
+        config.version = body.project?.version || "";
+        config.workspaceId = body.project?.workspaceId || "";
+        config.token = body.token || "";
+        config.apiKey = apiKey;
+        config.registered = true;
+        config.claimed = Boolean(body.session?.id);
+        config.registeredAt = new Date().toISOString();
+        console.log(chalk_1.default.green("✓") +
+            " Project session opened " +
+            chalk_1.default.cyan(config.name || projectId) +
+            `${config.workspaceId ? ` · workspace ${config.workspaceId}` : ""}`);
+        return config;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "request failed";
+        console.warn(chalk_1.default.yellow("!") + ` Realtime collaboration unavailable: cannot reach ${realtimeUrl} (${reason}).`);
+        return config;
+    }
+}

package/dist/cli/server/next.d.ts

@@ -0,0 +1,6 @@
+import http from "node:http";
+import { type ChildProcess } from "node:child_process";
+export declare function startNextServer(cwd: string): Promise<{
+    nextProcess: ChildProcess;
+    server: http.Server;
+}>;

package/dist/cli/server/next.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startNextServer = startNextServer;
+const chalk_1 = __importDefault(require("chalk"));
+const node_http_1 = __importDefault(require("node:http"));
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const PUBLIC_PORT = 3000; // what the user opens in the browser
+const INTERNAL_PORT = 3055; // where the real `next dev` actually runs
+function serveOverlayBundle(res) {
+    const bundlePath = (0, node_path_1.resolve)(process.cwd(), "node_modules/lasso/dist/overlay.js");
+    // when running from within the Lasso repo itself (not yet published),
+    // this resolves relative to Lasso's own dist folder instead — adjust
+    // the path to point at your actual dist/overlay.js location for now.
+    res.setHeader("Content-Type", "application/javascript");
+    res.end((0, node_fs_1.readFileSync)(bundlePath, "utf-8"));
+}
+async function startNextServer(cwd) {
+    // 1. Spawn the user's own Next dev server on an internal port
+    const nextBin = (0, node_path_1.resolve)(cwd, "node_modules/.bin/next");
+    const nextProcess = (0, node_child_process_1.spawn)(nextBin, ["dev", "--port", String(INTERNAL_PORT)], {
+        cwd,
+        stdio: "inherit",
+    });
+    // 2. Proxy pointing at that internal port
+    const proxy = http_proxy_1.default.createProxyServer({
+        target: `http://localhost:${INTERNAL_PORT}`,
+        selfHandleResponse: true, // needed so we can rewrite HTML before it reaches the browser
+        ws: true,
+    });
+    proxy.on("proxyRes", (proxyRes, req, res) => {
+        const chunks = [];
+        proxyRes.on("data", (chunk) => chunks.push(chunk));
+        proxyRes.on("end", () => {
+            const body = Buffer.concat(chunks).toString("utf-8");
+            const contentType = proxyRes.headers["content-type"] || "";
+            res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+            if (contentType.includes("text/html")) {
+                res.end(body.replace("</head>", `<script src="/__lasso/overlay.js?bridgePort=3056"></script></head>`));
+            }
+            else {
+                res.end(body);
+            }
+        });
+    });
+    // 3. Our own HTTP server: serve the real overlay bundle directly,
+    //    proxy everything else through to Next
+    const server = node_http_1.default.createServer((req, res) => {
+        if (req.url === "/__lasso/overlay.js") {
+            serveOverlayBundle(res);
+            return;
+        }
+        proxy.web(req, res, {}, (err) => {
+            console.error(chalk_1.default.red("Proxy error:"), err.message);
+            res.writeHead(502);
+            res.end("Bad gateway — is the Next.js dev server still starting up?");
+        });
+    });
+    // Forward WebSocket upgrades (Next's Fast Refresh) straight through —
+    // without this, HMR breaks the moment it's sitting behind a proxy.
+    server.on("upgrade", (req, socket, head) => {
+        if (req.url === "/__lasso/ws")
+            return; // let attachBridge's own listener handle this one
+        proxy.ws(req, socket, head);
+    });
+    server.listen(PUBLIC_PORT, () => {
+        console.log(chalk_1.default.green("✓") + " Next.js dev server running with Lasso attached");
+        console.log(`  ${chalk_1.default.cyan(`http://localhost:${PUBLIC_PORT}`)}`);
+    });
+    return { nextProcess, server };
+}

package/dist/cli/server/vite.d.ts

@@ -0,0 +1 @@
+export declare function startViteServer(cwd: string): Promise<any>;

package/dist/cli/server/vite.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startViteServer = startViteServer;
+const chalk_1 = __importDefault(require("chalk"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_path_2 = require("node:path");
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+const node_module_1 = require("node:module");
+// const PLACEHOLDER_OVERLAY_JS = `
+// console.log("[lasso] overlay placeholder loaded");
+// alert("Lasso overlay injected successfully!");
+// `;
+function lassoInjectPlugin(bridgePort = 3056) {
+    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) => {
+                const bundlePath = (0, node_path_2.resolve)(process.cwd(), "node_modules/lasso/dist/overlay.js");
+                res.setHeader("Content-Type", "application/javascript");
+                res.end((0, node_fs_1.readFileSync)(bundlePath, "utf-8"));
+            });
+        }
+    };
+}
+async function startViteServer(cwd) {
+    // Anchor resolution to the TARGET project, not Lasso's own file location —
+    // works from a CJS-compiled file, unlike import.meta.url.
+    const require = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+    // Still only used to FIND the path.
+    const viteEntry = require.resolve("vite");
+    // Still must LOAD via dynamic import — Vite ships ESM-only,
+    // and require() can't load an ESM-only package regardless of
+    // how correctly it resolved the path.
+    const { createServer } = await import((0, node_url_1.pathToFileURL)(viteEntry).href);
+    const server = await createServer({
+        root: cwd,
+        server: { open: false },
+        plugins: [lassoInjectPlugin()],
+    });
+    await server.listen();
+    console.log(chalk_1.default.green("✓") + " Vite dev server running with Lasso attached");
+    server.printUrls();
+    return server;
+}

package/dist/cli/utils/framework.d.ts

@@ -0,0 +1,2 @@
+export type Framework = "vite" | "next" | "unknown";
+export declare function detectFramework(cwd: string): Framework;

package/dist/cli/utils/framework.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = detectFramework;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function detectFramework(cwd) {
+    const hasFile = (name) => (0, node_fs_1.existsSync)((0, node_path_1.resolve)(cwd, name));
+    if (hasFile("next.config.js") || hasFile("next.config.ts") || hasFile("next.config.mjs")) {
+        return "next";
+    }
+    if (hasFile("vite.config.ts") || hasFile("vite.config.js") || hasFile("vite.config.mjs")) {
+        return "vite";
+    }
+    // Fallback: check package.json deps in case there's no config file
+    // (e.g. a Vite project relying purely on defaults).
+    const pkgPath = (0, node_path_1.resolve)(cwd, "package.json");
+    if (hasFile("package.json")) {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps.next)
+            return "next";
+        if (deps.vite)
+            return "vite";
+    }
+    return "unknown";
+}