@egnis-it/vibe-cli 0.1.0

package/bin/vibe.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from "../src/cli.js";
+
+main(process.argv.slice(2)).catch((error) => {
+  const message = error && error.message ? error.message : String(error);
+  console.error(`Error: ${message}`);
+  process.exitCode = error.exitCode || 1;
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@egnis-it/vibe-cli",
+  "version": "0.1.0",
+  "description": "CLI for deploying apps to Egnis Vibe.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src",
+    "package.json"
+  ],
+  "bin": {
+    "vibe": "bin/vibe.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/cli.js

@@ -0,0 +1,285 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+import {
+  checkSlug,
+  cleanupZip,
+  createZip,
+  deployApp,
+  getConfigSummary,
+  inspectApp,
+  listDatasources,
+  loadSession,
+  login,
+  openApp,
+  requireSlug,
+  streamLogs,
+  validateDatasourceSelection,
+} from "./vibe.js";
+
+const HELP = `vibe - Egnis Vibe deployment CLI
+
+Usage:
+  vibe login
+  vibe preflight [path] [--type <auto|static|server>]
+  vibe deploy [path] --slug <slug> --title <title> [options]
+  vibe status <slug>
+  vibe logs <jobId>
+  vibe datasources
+  vibe open <slug> [--browser]
+  vibe config
+
+Options:
+  --dry-run                         Inspect and package locally without uploading.
+  --keep-zip                        Keep the generated zip after deploy/dry-run.
+  --type <auto|static|server>       App type. Defaults to auto.
+  --datasources <ids>               Comma-separated datasource ids for server apps.
+  --description <text>              Hub description.
+  --tags <text>                     Hub tags.
+  --usage <text>                    Hub usage text.
+  --yes                             Update an existing slug you own without prompting.
+  --stream                          Stream build logs after deploy.
+  --api-base <url>                  Defaults to https://vibe.egnis.net.
+  --json                            Print machine-readable JSON where supported.
+`;
+
+export async function main(argv) {
+  const { command, positional, options } = parseArgs(argv);
+  const apiBase = options.apiBase || process.env.VIBE_API_BASE || "https://vibe.egnis.net";
+
+  if (!command || options.help || command === "help") {
+    console.log(HELP);
+    return;
+  }
+
+  if (command === "login") {
+    const session = await login({ apiBase, log: console.log });
+    if (options.json) console.log(JSON.stringify({ ok: true, email: session.email || null }, null, 2));
+    return;
+  }
+
+  if (command === "preflight") {
+    const appDir = positional[0] || process.cwd();
+    const inspection = await inspectApp(appDir, options.type || "auto");
+    if (options.json) console.log(JSON.stringify({ ok: true, ...inspection }, null, 2));
+    else printInspection(inspection);
+    return;
+  }
+
+  if (command === "deploy") {
+    const appDir = positional[0] || process.cwd();
+    const slug = requireSlug(options.slug);
+    const title = options.title;
+    if (!title) throw usageError("Missing --title.");
+
+    let zipPath;
+    try {
+      const inspection = await inspectApp(appDir, options.type || "auto");
+      const appType = inspection.appType;
+      zipPath = await createZip(appDir);
+      if (options.dryRun) {
+        const result = { ok: true, dryRun: true, zipPath: options.keepZip ? zipPath : null, ...inspection };
+        if (options.json) console.log(JSON.stringify(result, null, 2));
+        else {
+          printInspection(inspection);
+          if (options.keepZip) console.log(`Zip: ${zipPath}`);
+          else console.log("Zip verified and cleaned up. Use --keep-zip to inspect it.");
+          console.log("Dry run complete. Nothing uploaded.");
+        }
+        return;
+      }
+
+      const session = await loadSession();
+      if (options.datasources) {
+        const datasources = await listDatasources({ apiBase, session: session.session });
+        validateDatasourceSelection(options.datasources, datasources);
+      }
+      const slugInfo = await checkSlug({ apiBase, session: session.session, slug });
+
+      if (!slugInfo.available && !slugInfo.mine) {
+        throw usageError(`Slug '${slug}' is not available.`);
+      }
+
+      if (slugInfo.mine && !options.yes) {
+        const ok = await confirm(`'${slug}' already belongs to you. Update it? [y/N] `);
+        if (!ok) throw usageError("Deploy cancelled.");
+      }
+
+      const result = await deployApp({
+        apiBase,
+        session: session.session,
+        zipPath,
+        slug,
+        title,
+        appType,
+        datasources: options.datasources,
+        description: options.description,
+        tags: options.tags,
+        usage: options.usage,
+      });
+      const urls = openApp(slug);
+
+      if (options.json) {
+        console.log(JSON.stringify({ ok: true, ...result, appType, urls }, null, 2));
+      } else {
+        console.log(`Uploaded ${slug} as ${appType}.`);
+        if (result.jobId) console.log(`Job: ${result.jobId}`);
+        console.log(`App: ${urls.app}`);
+        console.log(`Hub: ${urls.hub}`);
+      }
+
+      if (options.stream && result.jobId) {
+        const logs = await streamLogs({ apiBase, session: session.session, jobId: result.jobId, log: console.log });
+        if (!options.json && logs.done) {
+          console.log("Build log reached done event.");
+          console.log(`App: ${urls.app}`);
+          console.log(`Hub: ${urls.hub}`);
+        }
+      }
+    } finally {
+      if (!options.keepZip) await cleanupZip(zipPath);
+    }
+    return;
+  }
+
+  if (command === "status") {
+    const slug = requireSlug(positional[0] || options.slug);
+    const session = await loadSession();
+    const result = await checkSlug({ apiBase, session: session.session, slug });
+    if (options.json) console.log(JSON.stringify(result, null, 2));
+    else printStatus(slug, result);
+    return;
+  }
+
+  if (command === "logs") {
+    const jobId = positional[0] || options.jobId;
+    if (!jobId) throw usageError("Missing jobId.");
+    const session = await loadSession();
+    await streamLogs({ apiBase, session: session.session, jobId, log: console.log });
+    return;
+  }
+
+  if (command === "datasources") {
+    const session = await loadSession();
+    const result = await listDatasources({ apiBase, session: session.session });
+    if (options.json) console.log(JSON.stringify(result, null, 2));
+    else printDatasources(result);
+    return;
+  }
+
+  if (command === "open") {
+    const slug = requireSlug(positional[0] || options.slug);
+    const urls = openApp(slug);
+    console.log(urls.app);
+    console.log(urls.hub);
+    if (options.browser) await spawnAndWait("open", [urls.app]);
+    return;
+  }
+
+  if (command === "config") {
+    const summary = await getConfigSummary();
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  throw usageError(`Unknown command '${command}'.`);
+}
+
+export function parseArgs(argv) {
+  const options = {};
+  const positional = [];
+  let command = null;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (!command && !token.startsWith("-")) {
+      command = token;
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      const [rawKey, inlineValue] = token.slice(2).split(/=(.*)/s, 2);
+      const key = toCamelCase(rawKey);
+      if (["yes", "stream", "json", "help", "browser", "dryRun", "keepZip"].includes(key)) {
+        options[key] = inlineValue === undefined ? true : inlineValue !== "false";
+        continue;
+      }
+      const value = inlineValue === undefined ? argv[++i] : inlineValue;
+      if (value === undefined || value.startsWith("--")) throw usageError(`Missing value for --${rawKey}.`);
+      options[key] = value;
+      continue;
+    }
+
+    positional.push(token);
+  }
+
+  return { command, positional, options };
+}
+
+function printStatus(slug, result) {
+  if (result.available) {
+    console.log(`${slug}: available`);
+  } else if (result.mine) {
+    console.log(`${slug}: owned by you`);
+    if (result.title) console.log(`Title: ${result.title}`);
+  } else {
+    console.log(`${slug}: unavailable`);
+  }
+}
+
+function printInspection(inspection) {
+  console.log(`App type: ${inspection.appType}`);
+  console.log(`Root: ${inspection.root}`);
+  console.log(`Files: start.sh=${inspection.files.startSh}, index.html=${inspection.files.indexHtml}, package.json=${inspection.files.packageJson}`);
+  if (inspection.package) {
+    console.log(`Package: name=${inspection.package.name || "(none)"}, build=${inspection.package.hasBuildScript}`);
+  }
+  if (inspection.excludes?.length) console.log(`Excluded: ${inspection.excludes.join(", ")}`);
+  for (const warning of inspection.warnings || []) {
+    console.log(`Warning: ${warning}`);
+  }
+}
+
+function printDatasources(datasources) {
+  if (!Array.isArray(datasources)) {
+    console.log(JSON.stringify(datasources, null, 2));
+    return;
+  }
+  for (const item of datasources) {
+    const state = item.available ? "available" : "unavailable";
+    console.log(`${item.id}: ${state}${item.label ? ` - ${item.label}` : ""}`);
+  }
+}
+
+async function confirm(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = createInterface({ input, output });
+  try {
+    const answer = await rl.question(question);
+    return ["y", "yes"].includes(answer.trim().toLowerCase());
+  } finally {
+    rl.close();
+  }
+}
+
+function spawnAndWait(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "ignore" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(usageError(`${command} exited with code ${code}.`));
+    });
+  });
+}
+
+function toCamelCase(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function usageError(message) {
+  const error = new Error(`${message}\n\n${HELP}`);
+  error.exitCode = 2;
+  return error;
+}

package/src/vibe.js

@@ -0,0 +1,485 @@
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { deflateRawSync } from "node:zlib";
+
+export const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+
+export function requireSlug(slug) {
+  if (!slug) throw new VibeError("Missing slug.");
+  if (!/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/.test(slug)) {
+    throw new VibeError("Slug must use lowercase letters, numbers, and hyphens, and cannot start or end with a hyphen.");
+  }
+  return slug;
+}
+
+export async function detectAppType(appDir, requested = "auto") {
+  return (await inspectApp(appDir, requested)).appType;
+}
+
+export async function inspectApp(appDir, requested = "auto") {
+  const root = path.resolve(appDir);
+  await stat(root);
+
+  if (!["auto", "static", "server"].includes(requested)) {
+    throw new VibeError("--type must be auto, static, or server.");
+  }
+
+  const files = {
+    startSh: existsSync(path.join(root, "start.sh")),
+    indexHtml: existsSync(path.join(root, "index.html")),
+    packageJson: existsSync(path.join(root, "package.json")),
+  };
+  const packageInfo = files.packageJson ? await readPackageInfo(path.join(root, "package.json")) : null;
+
+  if (requested === "server") {
+    if (!files.startSh) throw new VibeError("Server apps require start.sh in the app root.");
+    return buildInspection(root, "server", files, packageInfo);
+  }
+
+  if (requested === "static") {
+    if (!files.indexHtml && !files.packageJson) throw new VibeError("Static apps require index.html or package.json in the app root.");
+    if (!files.indexHtml && packageInfo && !packageInfo.hasBuildScript) {
+      throw new VibeError("Static package apps require a package.json build script when index.html is not present.");
+    }
+    return buildInspection(root, "static", files, packageInfo);
+  }
+
+  if (files.startSh) return buildInspection(root, "server", files, packageInfo);
+  if (files.indexHtml) return buildInspection(root, "static", files, packageInfo);
+  if (files.packageJson) {
+    if (!packageInfo?.hasBuildScript) {
+      throw new VibeError("Found package.json, but no index.html or build script. Add index.html for a static app, add scripts.build for a built static app, or add start.sh for a server app.");
+    }
+    return buildInspection(root, "static", files, packageInfo);
+  }
+  throw new VibeError("No deployable app found. Add start.sh for server apps, or index.html/package.json for static apps.");
+}
+
+export async function createZip(appDir) {
+  const root = path.resolve(appDir);
+  await stat(root);
+  const workDir = await mkdtemp(path.join(tmpdir(), "vibe-deploy-"));
+  const zipPath = path.join(workDir, "vibe-deploy.zip");
+  try {
+    const entries = await collectZipEntries(root);
+    const totalBytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+    if (totalBytes > MAX_UPLOAD_BYTES) {
+      throw new VibeError(`Upload is too large before compression: ${formatBytes(totalBytes)}. Vibe limit is ${formatBytes(MAX_UPLOAD_BYTES)}.`);
+    }
+
+    const zip = await buildZip(entries);
+    if (zip.length > MAX_UPLOAD_BYTES) {
+      throw new VibeError(`Upload zip is too large: ${formatBytes(zip.length)}. Vibe limit is ${formatBytes(MAX_UPLOAD_BYTES)}.`);
+    }
+
+    await writeFile(zipPath, zip);
+    return zipPath;
+  } catch (error) {
+    await cleanupZip(zipPath);
+    throw error;
+  }
+}
+
+export async function cleanupZip(zipPath) {
+  if (!zipPath) return;
+  await rm(path.dirname(zipPath), { recursive: true, force: true });
+}
+
+function buildInspection(root, appType, files, packageInfo) {
+  const warnings = [];
+  if (appType === "server") {
+    warnings.push("Server app must listen on process.env.PORT.");
+    if (!files.packageJson) warnings.push("No package.json found. This is OK for Python/shell apps if start.sh installs or runs everything needed.");
+  }
+  if (appType === "static" && files.packageJson) {
+    warnings.push("Static package apps are built by Vibe; keep build output out of the zip.");
+    if (!files.indexHtml && packageInfo && !packageInfo.hasBuildScript) {
+      warnings.push("No build script found. Static package deployment will fail unless Vibe has a custom build command.");
+    }
+  }
+  return {
+    root,
+    appType,
+    files,
+    package: packageInfo,
+    excludes: ZIP_EXCLUDES,
+    warnings,
+  };
+}
+
+const ZIP_EXCLUDES = ["node_modules", ".git", "dist", ".env*", ".npmrc", ".yarnrc", ".omx", ".codex", ".agents", ".claude", "coverage", "*.pem", "*.key", "*service-account*.json", "credentials*.json", "*.DS_Store"];
+
+async function collectZipEntries(root) {
+  const entries = [];
+
+  async function walk(dir, relativeDir = "") {
+    const dirents = await readdir(dir, { withFileTypes: true });
+    for (const dirent of dirents) {
+      const relativePath = relativeDir ? `${relativeDir}/${dirent.name}` : dirent.name;
+      if (shouldExclude(relativePath, dirent.name)) continue;
+
+      const absolutePath = path.join(dir, dirent.name);
+      if (dirent.isDirectory()) {
+        await walk(absolutePath, relativePath);
+      } else if (dirent.isFile()) {
+        const info = await stat(absolutePath);
+        entries.push({
+          absolutePath,
+          zipPath: relativePath.split(path.sep).join("/"),
+          size: info.size,
+          mtime: info.mtime,
+        });
+      }
+    }
+  }
+
+  await walk(root);
+  entries.sort((a, b) => a.zipPath.localeCompare(b.zipPath));
+  return entries;
+}
+
+function shouldExclude(relativePath, basename) {
+  const parts = relativePath.split("/");
+  const first = parts[0];
+  if (["node_modules", ".git", "dist", ".omx", ".codex", ".agents", ".claude", "coverage"].includes(first)) return true;
+  if (basename === ".npmrc" || basename === ".yarnrc" || basename === ".DS_Store") return true;
+  if (basename.startsWith(".env")) return true;
+  if (basename.endsWith(".pem") || basename.endsWith(".key")) return true;
+  if (/service-account.*\.json$/i.test(basename)) return true;
+  if (/^credentials.*\.json$/i.test(basename)) return true;
+  return false;
+}
+
+async function buildZip(entries) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const data = await readFile(entry.absolutePath);
+    const name = Buffer.from(entry.zipPath, "utf8");
+    const crc = crc32(data);
+    const { dosTime, dosDate } = toDosDateTime(entry.mtime);
+
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(0x04034b50, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(0x0800, 6); // UTF-8 names
+    const compressed = deflateRawSync(data, { level: 9 });
+    const useCompressed = compressed.length < data.length;
+    const payload = useCompressed ? compressed : data;
+    const method = useCompressed ? 8 : 0;
+
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(dosTime, 10);
+    local.writeUInt16LE(dosDate, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(payload.length, 18);
+    local.writeUInt32LE(data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    localParts.push(local, name, payload);
+
+    const central = Buffer.alloc(46);
+    central.writeUInt32LE(0x02014b50, 0);
+    central.writeUInt16LE(20, 4);
+    central.writeUInt16LE(20, 6);
+    central.writeUInt16LE(0x0800, 8);
+    central.writeUInt16LE(method, 10);
+    central.writeUInt16LE(dosTime, 12);
+    central.writeUInt16LE(dosDate, 14);
+    central.writeUInt32LE(crc, 16);
+    central.writeUInt32LE(payload.length, 20);
+    central.writeUInt32LE(data.length, 24);
+    central.writeUInt16LE(name.length, 28);
+    central.writeUInt16LE(0, 30);
+    central.writeUInt16LE(0, 32);
+    central.writeUInt16LE(0, 34);
+    central.writeUInt16LE(0, 36);
+    central.writeUInt32LE(0, 38);
+    central.writeUInt32LE(offset, 42);
+    centralParts.push(central, name);
+
+    offset += local.length + name.length + payload.length;
+  }
+
+  const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(0x06054b50, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(centralSize, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+
+  return Buffer.concat([...localParts, ...centralParts, end]);
+}
+
+function toDosDateTime(date) {
+  const year = Math.max(1980, date.getFullYear());
+  return {
+    dosTime: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+    dosDate: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+  };
+}
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, index) => {
+  let value = index;
+  for (let i = 0; i < 8; i += 1) value = (value & 1) ? (0xedb88320 ^ (value >>> 1)) : (value >>> 1);
+  return value >>> 0;
+});
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function formatBytes(bytes) {
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+async function readPackageInfo(packagePath) {
+  try {
+    const parsed = JSON.parse(await readFile(packagePath, "utf8"));
+    return {
+      name: typeof parsed.name === "string" ? parsed.name : null,
+      private: Boolean(parsed.private),
+      hasBuildScript: Boolean(parsed.scripts && typeof parsed.scripts.build === "string" && parsed.scripts.build.trim()),
+    };
+  } catch {
+    throw new VibeError("package.json is not valid JSON.");
+  }
+}
+
+export async function login({ apiBase, log = () => {} }) {
+  const start = await postJson(`${apiBase}/__egnis/device/start`);
+  const deviceCode = start.device_code;
+  const userCode = start.user_code;
+  if (!deviceCode || !userCode) throw new VibeError("Device login did not return a code.");
+
+  log(`Open https://vibe.egnis.net/__egnis/device and enter code ${userCode}`);
+
+  for (let i = 0; i < 120; i += 1) {
+    await sleep(5000);
+    const poll = await postJson(`${apiBase}/__egnis/device/poll`, { device_code: deviceCode });
+    if (poll.status === "approved") {
+      if (!poll.session) throw new VibeError("Login was approved but no session was returned.");
+      const session = { session: poll.session, email: poll.email || null, apiBase, createdAt: new Date().toISOString() };
+      await saveSession(session);
+      log("Login complete.");
+      return session;
+    }
+    if (poll.status === "expired") throw new VibeError("Device code expired. Run vibe login again.");
+    if (poll.status && poll.status !== "pending") throw new VibeError(`Device login failed: ${poll.status}`);
+  }
+
+  throw new VibeError("Timed out waiting for device approval.");
+}
+
+export async function checkSlug({ apiBase, session, slug }) {
+  requireSlug(slug);
+  return getJson(`${apiBase}/api/slug-check/${slug}`, session);
+}
+
+export async function listDatasources({ apiBase, session }) {
+  return getJson(`${apiBase}/api/datasources`, session);
+}
+
+export function validateDatasourceSelection(requested, available) {
+  if (!requested) return [];
+  const ids = requested.split(",").map((id) => id.trim()).filter(Boolean);
+  const byId = new Map((Array.isArray(available) ? available : []).map((item) => [item.id, item]));
+  for (const id of ids) {
+    const item = byId.get(id);
+    if (!item) throw new VibeError(`Unknown datasource '${id}'.`);
+    if (!item.available) throw new VibeError(`Datasource '${id}' is not available.`);
+  }
+  return ids;
+}
+
+export async function deployApp({
+  apiBase,
+  session,
+  zipPath,
+  slug,
+  title,
+  appType,
+  datasources,
+  description,
+  tags,
+  usage,
+}) {
+  const form = new FormData();
+  const zipBytes = await readFile(zipPath);
+  form.append("file", new Blob([zipBytes]), "vibe-deploy.zip");
+  form.append("slug", slug);
+  form.append("title", title);
+  if (description) form.append("description", description);
+  if (tags) form.append("tags", tags);
+  if (usage) form.append("usage", usage);
+  if (appType === "server") form.append("apptype", "server");
+  if (datasources) form.append("datasources", datasources);
+
+  const result = await fetchJson(`${apiBase}/upload`, {
+    method: "POST",
+    headers: { Cookie: `__egnis_session=${session}` },
+    body: form,
+  });
+
+  if (!result.ok) throw new VibeError(result.error || "Upload failed.");
+  return result;
+}
+
+export async function streamLogs({ apiBase, session, jobId, log = () => {} }) {
+  let lastResult = { done: false, data: null };
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    if (attempt > 0) log(`Reconnecting log stream (${attempt + 1}/3)...`);
+    lastResult = await streamLogsOnce({ apiBase, session, jobId, log });
+    if (lastResult.done) {
+      const data = lastResult.data;
+      if (data && (data.ok === false || data.success === false || data.error)) {
+        throw new VibeError(data.error || "Vibe build failed.");
+      }
+      return lastResult;
+    }
+  }
+  throw new VibeError("Log stream ended before the done event. Re-run `vibe logs <jobId>` to inspect the final result.");
+}
+
+async function streamLogsOnce({ apiBase, session, jobId, log }) {
+  const response = await fetch(`${apiBase}/events/${jobId}`, {
+    headers: { Cookie: `__egnis_session=${session}` },
+  });
+  if (!response.ok) throw new VibeError(`Log stream failed: HTTP ${response.status}`);
+
+  const state = { event: "message", data: [], done: false, doneData: null };
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  for await (const chunk of response.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() || "";
+    for (const line of lines) handleSseLine(line, state, log);
+    if (state.done) break;
+  }
+
+  if (buffer) handleSseLine(buffer, state, log);
+  return { done: state.done, data: state.doneData };
+}
+
+function handleSseLine(line, state, log) {
+  if (line === "") {
+    dispatchSse(state);
+    return;
+  }
+  if (line.startsWith(":")) return;
+  log(line);
+  if (line.startsWith("event:")) state.event = line.slice(6).trim() || "message";
+  else if (line.startsWith("data:")) state.data.push(line.slice(5).trimStart());
+}
+
+function dispatchSse(state) {
+  if (state.event === "done") {
+    state.done = true;
+    const raw = state.data.join("\n").trim();
+    if (raw) {
+      try {
+        state.doneData = JSON.parse(raw);
+      } catch {
+        state.doneData = { raw };
+      }
+    }
+  }
+  state.event = "message";
+  state.data = [];
+}
+
+export function openApp(slug) {
+  requireSlug(slug);
+  return {
+    app: `https://${slug}.egnis.net`,
+    hub: `https://vibe.egnis.net/s/${slug}`,
+  };
+}
+
+export async function loadSession() {
+  const file = sessionPath();
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    throw new VibeError("No Vibe session found. Run vibe login first.");
+  }
+  if (!parsed.session) throw new VibeError("Saved Vibe session is invalid. Run vibe login again.");
+  return parsed;
+}
+
+export async function saveSession(session) {
+  const file = sessionPath();
+  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  await writeFile(file, `${JSON.stringify(session, null, 2)}\n`, { mode: 0o600 });
+}
+
+export async function getConfigSummary() {
+  const file = sessionPath();
+  try {
+    const saved = JSON.parse(await readFile(file, "utf8"));
+    return {
+      sessionPath: file,
+      loggedIn: Boolean(saved.session),
+      email: saved.email || null,
+      apiBase: saved.apiBase || null,
+      createdAt: saved.createdAt || null,
+    };
+  } catch {
+    return { sessionPath: file, loggedIn: false };
+  }
+}
+
+async function getJson(url, session) {
+  return fetchJson(url, { headers: { Cookie: `__egnis_session=${session}` } });
+}
+
+async function postJson(url, body) {
+  return fetchJson(url, {
+    method: "POST",
+    headers: body ? { "Content-Type": "application/json" } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+async function fetchJson(url, options = {}) {
+  const response = await fetch(url, options);
+  const text = await response.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new VibeError(`Expected JSON from ${url}, got: ${text.slice(0, 200)}`);
+  }
+  if (!response.ok) throw new VibeError(data.error || `HTTP ${response.status}`);
+  return data;
+}
+
+function sessionPath() {
+  const root = process.env.VIBE_CONFIG_DIR
+    || (process.env.XDG_CONFIG_HOME ? path.join(process.env.XDG_CONFIG_HOME, "egnis-vibe") : path.join(homedir(), ".config", "egnis-vibe"));
+  return path.join(root, "session.json");
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export class VibeError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "VibeError";
+  }
+}