@cerkel/cli 0.0.0-stage → 1.0.0

package/dist/bin.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { hostname } from "node:os";
+import { watch } from "node:fs";
+import { readFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { main } from "./cli.js";
+import { globalTimers } from "./context.js";
+import { FileCredentialStore, SystemCredentialStore, credentialsFilePath, legacyCredentialsFilePath } from "./credentials.js";
+function version() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function ask(question, hidden) {
+    // Prompts go to stderr so `cerkel … > out.txt` still shows them and never captures them.
+    let muted = false;
+    const output = new Writable({
+        write(chunk, _enc, cb) {
+            if (!muted)
+                process.stderr.write(chunk);
+            cb();
+        },
+    });
+    const rl = createInterface({ input: process.stdin, output, terminal: process.stdin.isTTY === true });
+    try {
+        const pending = rl.question(question);
+        // Mute only after the prompt itself is written, so the question shows but keystrokes do not.
+        muted = hidden;
+        return await pending;
+    }
+    finally {
+        rl.close();
+        if (hidden)
+            process.stderr.write("\n");
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(typeof c === "string" ? Buffer.from(c) : c);
+    return Buffer.concat(chunks).toString("utf8");
+}
+/** One shared line reader for the console's prompt loop (history works, Ctrl-D ends it). */
+let lineReader = null;
+let linesClosed = false;
+function readLine(question) {
+    if (linesClosed)
+        return Promise.resolve(null);
+    if (!lineReader) {
+        lineReader = createInterface({ input: process.stdin, output: process.stderr, terminal: process.stdin.isTTY === true });
+        lineReader.on("close", () => { linesClosed = true; });
+    }
+    const rl = lineReader;
+    return new Promise((resolve) => {
+        const onClose = () => resolve(null);
+        rl.once("close", onClose);
+        rl.question(question).then((a) => { rl.off("close", onClose); resolve(a); }, () => resolve(null));
+    });
+}
+const io = {
+    out: (line) => process.stdout.write(line + "\n"),
+    err: (line) => process.stderr.write(line + "\n"),
+    isTTY: process.stdin.isTTY === true && process.stderr.isTTY === true,
+    prompt: (q) => ask(q, false),
+    promptSecret: (q) => ask(q, true),
+    readStdin,
+    readLine,
+    closeLines: () => { lineReader?.close(); },
+};
+function openUrl(url) {
+    const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", '""', url.replace(/&/g, "^&")]] : ["xdg-open", [url]];
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsVerbatimArguments: process.platform === "win32" });
+        child.on("error", () => {
+            process.stderr.write(`Could not open a browser; open the link above yourself.\n`);
+            resolve();
+        });
+        child.unref();
+        resolve();
+    });
+}
+const CALLBACK_PAGE = `<!doctype html><meta charset="utf-8"><title>cerkel</title>
+<body style="font-family:system-ui,sans-serif;max-width:32rem;margin:4rem auto;padding:0 1rem;line-height:1.5">
+<h1 style="font-size:1.25rem">You can close this tab</h1><p>Go back to your terminal — cerkel has what it needs.</p></body>`;
+/**
+ * The browser half of `cerkel login` lands here: 127.0.0.1 only (never 0.0.0.0, so nothing on the
+ * network can reach it), a random free port, one callback, then it closes.
+ */
+function listenLoopback() {
+    return new Promise((resolve, reject) => {
+        let deliver = null;
+        let got = null;
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (req.method !== "GET" || url.pathname !== "/callback") {
+                res.writeHead(404).end();
+                return;
+            }
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(CALLBACK_PAGE);
+            if (!got) {
+                got = url.searchParams;
+                deliver?.(got);
+            }
+        });
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            const port = typeof addr === "object" && addr ? addr.port : 0;
+            resolve({
+                port,
+                waitForCallback: (timeoutMs) => new Promise((res, rej) => {
+                    if (got)
+                        return res(got);
+                    const t = setTimeout(() => rej(new Error("timeout")), timeoutMs);
+                    deliver = (q) => { clearTimeout(t); res(q); };
+                }),
+                close: () => { server.close(); server.closeAllConnections?.(); },
+            });
+        });
+    });
+}
+const ctx = {
+    cwd: process.cwd(),
+    env: process.env,
+    fetch: (input, init) => fetch(input, init),
+    credentials: new SystemCredentialStore(new FileCredentialStore(credentialsFilePath(), legacyCredentialsFilePath())),
+    io,
+    now: () => new Date(),
+    timers: globalTimers,
+    watch: (dir, onChange) => {
+        const w = watch(dir, { recursive: true }, (_event, filename) => onChange(filename ? filename.toString() : null));
+        w.on("error", (e) => process.stderr.write(`Watch error: ${e.message}\n`));
+        return w;
+    },
+    openUrl,
+    listenLoopback,
+    hostname: hostname(),
+    onInterrupt: (handler) => {
+        process.on("SIGINT", handler);
+        return () => process.off("SIGINT", handler);
+    },
+    version: version(),
+};
+main(process.argv.slice(2), ctx).then((code) => {
+    process.exitCode = code;
+}, (e) => {
+    // main() already redacts and reports every expected failure; this is the last-ditch net.
+    process.stderr.write(`Unexpected error: ${e instanceof Error ? e.message.replace(/rzn_[A-Za-z0-9_-]{16,}/g, "***") : "unknown"}\n`);
+    process.exitCode = 1;
+});

package/dist/chunk.js

@@ -0,0 +1,31 @@
+import { writeRank } from "./layout.js";
+/**
+ * The server refuses bodies over 1,000,000 bytes. Aim well under it so the envelope, JSON
+ * escaping of Arabic text and a proxy's own headers never tip a request over.
+ */
+export const MAX_CHUNK_BYTES = 800_000;
+const ENVELOPE_BYTES = 512;
+/**
+ * Split files into requests, keeping the server's write order across requests: every section
+ * goes out before any settings/CSS, and those before any template. A single file larger than
+ * the limit travels alone and the server's 413 explains itself.
+ */
+export function chunkFiles(files, limit = MAX_CHUNK_BYTES) {
+    const ordered = [...files].sort((a, b) => writeRank(a.path) - writeRank(b.path) || a.path.localeCompare(b.path));
+    const chunks = [];
+    let current = [];
+    let size = ENVELOPE_BYTES;
+    for (const f of ordered) {
+        const bytes = Buffer.byteLength(JSON.stringify(f), "utf8") + 1;
+        if (current.length > 0 && size + bytes > limit) {
+            chunks.push(current);
+            current = [];
+            size = ENVELOPE_BYTES;
+        }
+        current.push(f);
+        size += bytes;
+    }
+    if (current.length > 0)
+        chunks.push(current);
+    return chunks;
+}