@lasso-ai/cli 1.0.0

package/dist/cli/auth.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverUrlFrom = serverUrlFrom;
+exports.fetchWithTimeout = fetchWithTimeout;
+exports.loadCredentials = loadCredentials;
+exports.saveCredentials = saveCredentials;
+exports.clearCredentials = clearCredentials;
+exports.authLogin = authLogin;
+exports.authStatus = authStatus;
+exports.credentialSummary = credentialSummary;
+exports.authLogout = authLogout;
+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 chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+const CREDENTIALS_DIR = node_path_1.default.join(node_os_1.default.homedir(), ".lasso");
+const CREDENTIALS_FILE = node_path_1.default.join(CREDENTIALS_DIR, "credentials.json");
+/**
+ * Base URL of the Lasso API (the main server, not the realtime server). The
+ * `lasso auth` flow lives here because the browser confirm needs the web session.
+ * Defaults to the local development port used by `server/` and `web/`.
+ */
+function serverUrlFrom(fileEnv) {
+    return (process.env.LASSO_AUTH_URL ||
+        fileEnv.LASSO_AUTH_URL ||
+        process.env.LASSO_API_URL ||
+        fileEnv.LASSO_API_URL ||
+        "http://localhost:3005").replace(/\/$/, "");
+}
+function fetchWithTimeout(url, init, timeoutMs = 8000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timer));
+}
+function loadCredentials() {
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(CREDENTIALS_FILE, "utf8"));
+        if (raw && typeof raw.apiKey === "string" && raw.apiKey)
+            return raw;
+    }
+    catch {
+        // no credentials yet
+    }
+    return null;
+}
+function saveCredentials(credentials) {
+    node_fs_1.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    const temp = `${CREDENTIALS_FILE}.tmp`;
+    node_fs_1.default.writeFileSync(temp, JSON.stringify(credentials, null, 2) + "\n", { mode: 0o600 });
+    node_fs_1.default.renameSync(temp, CREDENTIALS_FILE);
+    try {
+        node_fs_1.default.chmodSync(CREDENTIALS_FILE, 0o600);
+    }
+    catch {
+        // chmod is best-effort (Windows)
+    }
+}
+function clearCredentials() {
+    try {
+        node_fs_1.default.unlinkSync(CREDENTIALS_FILE);
+    }
+    catch {
+        // nothing to clear
+    }
+}
+function mask(key) {
+    return `${key.slice(0, 9)}••••${key.slice(-4)}`;
+}
+/**
+ * `lasso auth login` — device-style OAuth. The CLI asks the server for a
+ * one-time code + verification URL, opens the browser, and polls the status
+ * endpoint until the logged-in dashboard user authorizes. On success the
+ * freshly minted API key is stored in ~/.lasso/credentials.json (0600).
+ */
+async function authLogin(cwd, fileEnv) {
+    const serverUrl = serverUrlFrom(fileEnv);
+    const apiUrl = `${serverUrl}/api/v1`;
+    let startResponse;
+    try {
+        startResponse = await fetchWithTimeout(`${apiUrl}/auth/cli/start`, { method: "POST" });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : "request failed";
+        return { ok: false, error: `Could not reach the Lasso API at ${serverUrl} (${reason}). Is the Lasso server running?` };
+    }
+    if (!startResponse.ok) {
+        const body = (await startResponse.json().catch(() => ({})));
+        return { ok: false, error: body.message || `Could not start the login flow (${startResponse.status}).` };
+    }
+    const started = (await startResponse.json());
+    if (!started.cliId || !started.verificationUrl) {
+        return { ok: false, error: "The server did not return an authorization URL." };
+    }
+    console.log(`\n${chalk_1.default.bold("Lasso CLI authorization")}`);
+    console.log(`  Open this URL to authorize the Lasso CLI:\n`);
+    console.log(`  ${chalk_1.default.cyan(started.verificationUrl)}\n`);
+    let opened = false;
+    if (!process.env.LASSO_NO_BROWSER) {
+        opened = Boolean(await (0, open_1.default)(started.verificationUrl).catch(() => null));
+    }
+    if (opened) {
+        console.log(chalk_1.default.dim("  Waiting for you to authorize in the browser…\n"));
+    }
+    else {
+        console.log(chalk_1.default.dim("  Tip: paste the URL into your browser if it didn't open automatically.\n"));
+    }
+    const pollMs = 2000;
+    const timeoutMs = Math.max((started.expiresInSeconds || 600) * 1000 - 5000, 10000);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        let response;
+        try {
+            response = await fetchWithTimeout(`${apiUrl}/auth/cli/status?code=${encodeURIComponent(started.cliId)}`);
+        }
+        catch {
+            continue;
+        }
+        if (!response.ok)
+            continue;
+        const status = (await response.json().catch(() => ({})));
+        if (status.status === "authorized" && status.apiKey) {
+            const credentials = {
+                apiKey: status.apiKey,
+                keyId: status.keyId || "",
+                workspaceId: status.workspaceId || "",
+                workspaceName: status.workspaceName || "",
+                userName: status.user?.name || "",
+                userEmail: status.user?.email || "",
+                createdAt: new Date().toISOString(),
+            };
+            saveCredentials(credentials);
+            const who = credentials.userEmail || "your account";
+            console.log(chalk_1.default.green("✓") + ` Authenticated as ${chalk_1.default.bold(who)}` + (credentials.workspaceName ? ` (workspace ${chalk_1.default.cyan(credentials.workspaceName)})` : "") + ".");
+            console.log(chalk_1.default.dim(`  Credential saved to ${CREDENTIALS_FILE}.`));
+            return { ok: true };
+        }
+        if (status.status === "expired" || status.status === "error") {
+            return { ok: false, error: status.message || "The authorization link expired. Run `lasso auth login` again." };
+        }
+    }
+    return { ok: false, error: "Timed out waiting for authorization. Run `lasso auth login` again when ready." };
+}
+function authStatus() {
+    return loadCredentials();
+}
+function credentialSummary(credentials) {
+    return {
+        userEmail: credentials.userEmail,
+        userName: credentials.userName,
+        workspaceName: credentials.workspaceName,
+        workspaceId: credentials.workspaceId,
+        masked: mask(credentials.apiKey),
+    };
+}
+function authLogout() {
+    clearCredentials();
+}

package/dist/cli/bridge.d.ts

@@ -0,0 +1,160 @@
+import { type SourceChange } from "./agent";
+import type { CollabConfig } from "./project";
+type GitState = {
+    isRepo: boolean;
+    branch?: string;
+    status?: string[];
+    hasChanges?: boolean;
+    hasRemote?: boolean;
+    remote?: string;
+};
+export type BridgeMessage = {
+    type: "hello";
+    from: "overlay" | "cli";
+} | {
+    type: "edit";
+    instruction: string;
+    model: string;
+    provider?: "anthropic" | "openai" | "google" | "ollama" | "cli";
+    messages?: Array<{
+        role: string;
+        content: string;
+        createdAt?: string;
+    }>;
+    changesHistory?: Array<{
+        summary: string;
+        changes: SourceChange[];
+        createdAt?: string;
+    }>;
+    context?: {
+        selectionId?: string;
+        position?: Record<string, number>;
+        viewport?: Record<string, unknown>;
+        styles?: Record<string, string>;
+        attributes?: Record<string, string>;
+        runtimeErrors?: string[];
+        screenshots?: {
+            full?: string;
+            element?: string;
+        };
+    };
+    element: {
+        tag: string;
+        group: string;
+        label: string;
+        html?: string;
+        sourceHint?: string;
+    };
+} | {
+    type: "ask";
+    question: string;
+    model: string;
+    provider?: "anthropic" | "openai" | "google" | "ollama" | "cli";
+    messages?: Array<{
+        role: string;
+        content: string;
+        createdAt?: string;
+    }>;
+    context?: {
+        selectionId?: string;
+        position?: Record<string, number>;
+        viewport?: Record<string, unknown>;
+        styles?: Record<string, string>;
+        attributes?: Record<string, string>;
+        runtimeErrors?: string[];
+        screenshots?: {
+            full?: string;
+            element?: string;
+        };
+    };
+    element: {
+        tag: string;
+        group: string;
+        label: string;
+        html?: string;
+        sourceHint?: string;
+    };
+} | {
+    type: "runtime_error";
+    selectionId?: string;
+    details: string;
+} | {
+    type: "apply";
+    changes: SourceChange[];
+} | {
+    type: "undo";
+} | {
+    type: "stop";
+} | {
+    type: "git_status";
+} | {
+    type: "git_generate_message";
+    model: string;
+    provider?: "anthropic" | "openai" | "google" | "ollama" | "cli";
+} | {
+    type: "git_init";
+} | {
+    type: "git_commit";
+    message: string;
+} | {
+    type: "git_push";
+} | {
+    type: "agent_status";
+    status: "thinking" | "working" | "review" | "error" | "stopped";
+    message: string;
+} | {
+    type: "transcribe";
+    requestId: string;
+    audio: string;
+    mimeType?: string;
+    language?: string;
+};
+type ModelOption = {
+    id: string;
+    label: string;
+    provider: "anthropic" | "openai" | "google" | "ollama" | "cli";
+};
+export type ServerBridgeMessage = {
+    type: "config";
+    apiKeyConfigured: boolean;
+    agentConfigured: boolean;
+    models: ModelOption[];
+    collab?: CollabConfig | null;
+} | {
+    type: "git_state";
+    git: GitState;
+} | {
+    type: "git_result";
+    message?: string;
+    error?: string;
+} | {
+    type: "git_commit_message";
+    message?: string;
+    error?: string;
+} | {
+    type: "agent_status";
+    status: "thinking" | "working" | "review" | "error" | "stopped";
+    message: string;
+    changes?: SourceChange[];
+} | {
+    type: "assistant_message";
+    message: string;
+} | {
+    type: "applied";
+    message: string;
+} | {
+    type: "undone";
+    message: string;
+} | {
+    type: "transcribe_result";
+    requestId: string;
+    success: boolean;
+    text?: string;
+    provider?: string;
+    error?: string;
+};
+export declare function startBridge(cwd?: string, collabConfig?: CollabConfig | null, bridgePort?: number): {
+    send: (msg: ServerBridgeMessage) => void;
+    close(): void;
+};
+export {};