aimux-cli 0.1.16 → 0.1.19

package/dist/local-ui-server.js

@@ -0,0 +1,185 @@
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { createServer } from "node:http";
+import { extname, resolve as pathResolve, sep } from "node:path";
+import { platform } from "node:os";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+export const DEFAULT_LOCAL_UI_HOST = "127.0.0.1";
+export const DEFAULT_LOCAL_UI_PORT = 43192;
+const MIME_TYPES = {
+    ".css": "text/css; charset=utf-8",
+    ".html": "text/html; charset=utf-8",
+    ".ico": "image/x-icon",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".map": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain; charset=utf-8",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+function packageRoot() {
+    return pathResolve(fileURLToPath(import.meta.url), "..", "..");
+}
+export function resolveDefaultLocalUiRoot() {
+    return pathResolve(packageRoot(), "dist-ui");
+}
+function isLoopbackHost(host) {
+    return host === "localhost" || host === "::1" || host === "127.0.0.1";
+}
+function formatHostForUrl(host) {
+    return host.includes(":") ? `[${host}]` : host;
+}
+function send(res, status, body) {
+    res.writeHead(status, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+    });
+    res.end(body);
+}
+function setCommonHeaders(res) {
+    res.setHeader("X-Content-Type-Options", "nosniff");
+}
+function localConfigJavascript(config) {
+    return `window.__AIMUX_LOCAL_CONFIG__=${JSON.stringify(config)};\n`;
+}
+function isInsideRoot(root, target) {
+    const resolvedRoot = pathResolve(root);
+    const resolvedTarget = pathResolve(target);
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(`${resolvedRoot}${sep}`);
+}
+function resolveRequestPath(uiRoot, req) {
+    const rawPath = (req.url ?? "/").split(/[?#]/, 1)[0] ?? "/";
+    try {
+        if (decodeURIComponent(rawPath).split("/").includes(".."))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const url = new URL(req.url ?? "/", "http://local.aimux");
+    let pathname;
+    try {
+        pathname = decodeURIComponent(url.pathname);
+    }
+    catch {
+        return null;
+    }
+    if (pathname.includes("\0"))
+        return null;
+    if (pathname === "/")
+        pathname = "/index.html";
+    const target = pathResolve(uiRoot, `.${pathname}`);
+    if (!isInsideRoot(uiRoot, target))
+        return null;
+    return target;
+}
+function serveFile(req, res, path) {
+    const ext = extname(path).toLowerCase();
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    const isIndex = ext === ".html";
+    res.writeHead(200, {
+        "Content-Type": contentType,
+        "Cache-Control": isIndex ? "no-cache" : "public, max-age=31536000, immutable",
+    });
+    if (req.method === "HEAD") {
+        res.end();
+        return;
+    }
+    createReadStream(path)
+        .on("error", () => {
+        if (!res.headersSent)
+            send(res, 500, "Internal server error");
+        else
+            res.destroy();
+    })
+        .pipe(res);
+}
+function requestHandler(uiRoot, config) {
+    return (req, res) => {
+        setCommonHeaders(res);
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            send(res, 405, "Method not allowed");
+            return;
+        }
+        const url = new URL(req.url ?? "/", "http://local.aimux");
+        if (url.pathname === "/aimux-local-config.js") {
+            res.writeHead(200, {
+                "Content-Type": "text/javascript; charset=utf-8",
+                "Cache-Control": "no-store",
+            });
+            res.end(req.method === "HEAD" ? undefined : localConfigJavascript(config));
+            return;
+        }
+        const target = resolveRequestPath(uiRoot, req);
+        if (!target) {
+            send(res, 403, "Forbidden");
+            return;
+        }
+        if (existsSync(target) && statSync(target).isFile()) {
+            serveFile(req, res, target);
+            return;
+        }
+        if (!extname(new URL(req.url ?? "/", "http://local.aimux").pathname)) {
+            const indexPath = pathResolve(uiRoot, "index.html");
+            if (existsSync(indexPath)) {
+                serveFile(req, res, indexPath);
+                return;
+            }
+        }
+        send(res, 404, "Not found");
+    };
+}
+export async function startLocalUiServer(options) {
+    const host = options.host ?? DEFAULT_LOCAL_UI_HOST;
+    const port = options.port ?? DEFAULT_LOCAL_UI_PORT;
+    if (!isLoopbackHost(host)) {
+        throw new Error(`Local UI host must be loopback (127.0.0.1, localhost, or ::1), got ${host}`);
+    }
+    const uiRoot = pathResolve(options.uiRoot ?? resolveDefaultLocalUiRoot());
+    const indexPath = pathResolve(uiRoot, "index.html");
+    if (!existsSync(indexPath)) {
+        throw new Error(`Local UI build not found at ${uiRoot}. Run yarn build:ui:local first.`);
+    }
+    const server = createServer(requestHandler(uiRoot, options.config));
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+    });
+    const address = server.address();
+    const actualPort = typeof address === "object" && address ? address.port : port;
+    const url = `http://${formatHostForUrl(host)}:${actualPort}`;
+    return {
+        host,
+        port: actualPort,
+        url,
+        uiRoot,
+        close: () => closeServer(server),
+    };
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+}
+export function openUrlInBrowser(url) {
+    const os = platform();
+    const command = os === "darwin" ? "open" : os === "win32" ? "cmd" : "xdg-open";
+    const args = os === "win32" ? ["/c", "start", "", url] : [url];
+    const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+}

package/dist/login-flow.d.ts

@@ -0,0 +1,7 @@
+export interface LoginOptions {
+    webAppUrl?: string;
+    action?: "security-unlock";
+}
+export declare function runLoginFlow(opts?: LoginOptions): Promise<{
+    userId: string;
+}>;

package/dist/login-flow.js

@@ -0,0 +1,119 @@
+// Browser-based `aimux login` flow.
+//
+// Mirrors the `gh auth login` / `vercel login` pattern:
+//   1. Spin up a localhost callback server on an ephemeral port.
+//   2. Open the browser to the web app's /cli-auth page, passing the callback.
+//   3. The web app signs the user in via Clerk, calls the relay to mint a
+//      long-lived daemon token, and redirects to the callback with the token.
+//   4. We capture the token, persist it, and shut the server down.
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { saveCredentials } from "./credentials.js";
+import { resolveRelayUrl, resolveWebAppUrl } from "./connection-targets.js";
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+const HTML_CONTENT_TYPE = "text/html; charset=utf-8";
+function openBrowser(url) {
+    const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "cmd" : "xdg-open";
+    const args = platform() === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+        child.on("error", () => { });
+        child.unref();
+    }
+    catch { }
+}
+export async function runLoginFlow(opts = {}) {
+    // Relay URL is read from env only (no CLI override): the daemon token is
+    // minted by whichever relay the web app uses, so it has to be the same
+    // one the daemon then connects to — pinning it to env keeps both ends in
+    // sync.
+    const webAppUrl = resolveWebAppUrl(opts.webAppUrl);
+    const relayUrl = resolveRelayUrl();
+    const state = randomBytes(16).toString("hex");
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (url.pathname !== "/callback") {
+                res.statusCode = 404;
+                res.end("Not found");
+                return;
+            }
+            if (url.searchParams.get("state") !== state) {
+                res.statusCode = 403;
+                res.setHeader("content-type", HTML_CONTENT_TYPE);
+                res.end('<html><body style="font-family:system-ui;text-align:center;padding-top:80px"><h2>Login failed</h2><p>State mismatch — this callback was not initiated by this login session.</p></body></html>');
+                return;
+            }
+            const token = url.searchParams.get("token");
+            const userId = url.searchParams.get("userId");
+            const error = url.searchParams.get("error");
+            clearTimeout(timer);
+            server.close();
+            if (error) {
+                res.statusCode = 400;
+                res.setHeader("content-type", HTML_CONTENT_TYPE);
+                res.end(`<html><body style="font-family:system-ui;text-align:center;padding-top:80px"><h2>Login failed</h2><p>${escapeHtml(error)}</p><p>You can close this tab and try again.</p></body></html>`);
+                reject(new Error(error));
+                return;
+            }
+            if (!token || !userId) {
+                const message = "Callback missing token or userId";
+                res.statusCode = 400;
+                res.setHeader("content-type", HTML_CONTENT_TYPE);
+                res.end(`<html><body style="font-family:system-ui;text-align:center;padding-top:80px"><h2>Login failed</h2><p>${escapeHtml(message)}</p><p>You can close this tab and try again.</p></body></html>`);
+                reject(new Error(message));
+                return;
+            }
+            try {
+                saveCredentials({
+                    version: 1,
+                    relayUrl,
+                    token,
+                    userId,
+                    createdAt: new Date().toISOString(),
+                    remoteEnabled: true,
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                res.statusCode = 500;
+                res.setHeader("content-type", HTML_CONTENT_TYPE);
+                res.end(`<html><body style="font-family:system-ui;text-align:center;padding-top:80px"><h2>Login failed</h2><p>Could not save credentials: ${escapeHtml(message)}</p><p>You can close this tab and try again.</p></body></html>`);
+                reject(new Error(`Could not save credentials: ${message}`));
+                return;
+            }
+            res.statusCode = 200;
+            res.setHeader("content-type", HTML_CONTENT_TYPE);
+            res.end(`<html><body style="font-family:system-ui;text-align:center;padding-top:80px"><h2>✓ Logged in to aimux</h2><p>You can close this tab and return to the terminal.</p></body></html>`);
+            resolve({ userId });
+        });
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("Login timed out after 5 minutes"));
+        }, LOGIN_TIMEOUT_MS);
+        server.on("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            const port = typeof address === "object" && address ? address.port : 0;
+            const callback = `http://127.0.0.1:${port}/callback`;
+            const qs = new URLSearchParams({
+                callback,
+                state,
+            });
+            if (opts.action)
+                qs.set("action", opts.action);
+            const authUrl = `${webAppUrl}/cli-auth?${qs.toString()}`;
+            console.log("Opening your browser to sign in...");
+            console.log(`If it doesn't open, visit:\n  ${authUrl}\n`);
+            openBrowser(authUrl);
+        });
+    });
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}