vibeman 0.0.6 → 0.0.7

package/dist/api.js

@@ -1,35 +1,32 @@
-// @bun
 // ../api/src/index.ts
-import { readdir } from "fs/promises";
-import { resolve, normalize } from "path";
-var port = Number(Bun.env.API_PORT ?? 6970);
+import { readdir } from "node:fs/promises";
+import { createServer } from "node:http";
+import { resolve, normalize } from "node:path";
+var port = Number(process.env.API_PORT ?? 6970);
 var startedAt = Date.now();
 var root = process.cwd();
-Bun.serve({
-  port,
-  async fetch(request) {
-    const { pathname, searchParams } = new URL(request.url);
-    if (pathname === "/api/health") {
-      return json({ ok: true, uptimeMs: Date.now() - startedAt, root });
-    }
-    if (pathname === "/api/files") {
-      const rawPath = searchParams.get("path") ?? ".";
-      try {
-        const entries = await listFiles(rawPath);
-        return json({ path: rawPath, entries });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unable to read directory";
-        return json({ error: message }, 400);
-      }
+var server = createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  if (url.pathname === "/api/health") {
+    return sendJson(res, { ok: true, uptimeMs: Date.now() - startedAt, root });
+  }
+  if (url.pathname === "/api/files") {
+    const rawPath = url.searchParams.get("path") ?? ".";
+    try {
+      const entries = await listFiles(rawPath);
+      return sendJson(res, { path: rawPath, entries });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unable to read directory";
+      return sendJson(res, { error: message }, 400);
     }
-    return new Response("Not found", { status: 404 });
-  },
-  development: {
-    hmr: true,
-    console: true
   }
+  res.statusCode = 404;
+  res.setHeader("content-type", "text/plain; charset=utf-8");
+  res.end("Not found");
+});
+server.listen(port, () => {
+  console.log(`API ready on http://localhost:${port}`);
 });
-console.log(`API ready on http://localhost:${port}`);
 async function listFiles(pathInput) {
   const target = normalize(resolve(root, pathInput));
   const entries = await readdir(target, { withFileTypes: true });
@@ -38,12 +35,9 @@ async function listFiles(pathInput) {
     kind: entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other"
   }));
 }
-function json(payload, status = 200) {
-  return new Response(JSON.stringify(payload), {
-    status,
-    headers: {
-      "content-type": "application/json",
-      "cache-control": "no-store"
-    }
-  });
+function sendJson(res, payload, status = 200) {
+  res.statusCode = status;
+  res.setHeader("content-type", "application/json");
+  res.setHeader("cache-control", "no-store");
+  res.end(JSON.stringify(payload));
 }

package/dist/index.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawn } from "node:child_process";
+import { createReadStream, existsSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer, request } from "node:http";
+import { request as requestSecure } from "node:https";
+import { basename, dirname, extname, normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var args = process.argv.slice(2);
+var command = args[0];
+if (!command || command === "--help" || command === "-h" || command === "help") {
+  printHelp();
+  process.exit(0);
+}
+if (command !== "start") {
+  console.error(`Unknown command: ${command}`);
+  printHelp();
+  process.exit(1);
+}
+var options = parseStartArgs(args.slice(1));
+await startApps(options);
+function parseStartArgs(argv) {
+  const output = {
+    path: ".",
+    apiPort: 6970,
+    uiPort: 6969,
+    open: true
+  };
+  for (let i = 0;i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg)
+      continue;
+    if (arg === "--port") {
+      const mainPort = Number(argv[i + 1]);
+      output.uiPort = mainPort;
+      output.apiPort = mainPort + 1;
+      i += 1;
+      continue;
+    }
+    if (arg === "--no-open") {
+      output.open = false;
+      continue;
+    }
+    if (!arg.startsWith("-") && output.path === ".") {
+      output.path = arg;
+    }
+  }
+  return output;
+}
+async function startApps(options2) {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const distRoot = resolveDistRoot(moduleDir);
+  const distApi = distRoot ? resolve(distRoot, "api.js") : "";
+  const distUiRoot = distRoot ? resolve(distRoot, "ui") : "";
+  const nodePath = resolveNodePath();
+  if (!distRoot || !existsSync(distApi) || !existsSync(resolve(distUiRoot, "index.html"))) {
+    console.error("Missing dist runtime files. Run the build first.");
+    process.exit(1);
+  }
+  const apiProcess = spawn(nodePath, [distApi], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      API_PORT: String(options2.apiPort)
+    },
+    stdio: "inherit"
+  });
+  const uiServer = createUiServer({
+    apiBase: `http://localhost:${options2.apiPort}`,
+    uiRoot: distUiRoot
+  });
+  uiServer.listen(options2.uiPort, () => {
+    console.log(`UI ready on http://localhost:${options2.uiPort}`);
+  });
+  const url = new URL(`http://localhost:${options2.uiPort}/`);
+  url.searchParams.set("path", options2.path);
+  if (options2.open) {
+    await openBrowser(url.toString());
+  }
+  console.log(`
+Vibeman running:`);
+  console.log(` API: http://localhost:${options2.apiPort}`);
+  console.log(` UI:  ${url.toString()}`);
+  console.log("Press Ctrl+C to stop.");
+  const stop = () => {
+    apiProcess.kill();
+    uiServer.close();
+  };
+  process.on("SIGINT", () => {
+    stop();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    stop();
+    process.exit(0);
+  });
+  const exitCode = await waitForExit(apiProcess);
+  stop();
+  process.exit(exitCode ?? 1);
+}
+async function openBrowser(target) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    spawn("open", [target], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    spawn("cmd", ["/c", "start", target], { stdio: "ignore", detached: true }).unref();
+    return;
+  }
+  spawn("xdg-open", [target], { stdio: "ignore", detached: true }).unref();
+}
+function printHelp() {
+  console.log(`vibeman CLI
+
+Usage:
+  vibeman start [path] [--port <port>] [--no-open]
+
+Examples:
+  vibeman start .
+  vibeman start ./notes --port 7010
+`);
+}
+function waitForExit(child) {
+  return new Promise((resolvePromise) => {
+    child.once("exit", (code) => resolvePromise(code));
+  });
+}
+function resolveDistRoot(selfDir) {
+  const execDir = dirname(process.execPath);
+  const candidates = [
+    selfDir,
+    resolve(execDir, ".."),
+    resolve(execDir, "../.."),
+    resolve(selfDir, ".."),
+    resolve(selfDir, "../..")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, "api.js")) && existsSync(resolve(candidate, "ui", "index.html"))) {
+      return candidate;
+    }
+  }
+  return "";
+}
+function resolveNodePath() {
+  const execBase = basename(process.execPath);
+  return execBase === "node" || execBase === "node.exe" ? process.execPath : "node";
+}
+function createUiServer({ apiBase, uiRoot }) {
+  return createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname.startsWith("/api")) {
+      proxyApi(req, res, url, apiBase);
+      return;
+    }
+    try {
+      const filePath = resolveStaticPath(uiRoot, url.pathname);
+      const fileStat = await stat(filePath);
+      if (fileStat.isDirectory()) {
+        return serveFile(resolve(filePath, "index.html"), res);
+      }
+      return serveFile(filePath, res);
+    } catch {
+      return serveFile(resolve(uiRoot, "index.html"), res);
+    }
+  });
+}
+function resolveStaticPath(uiRoot, pathname) {
+  const normalized = normalize(pathname).replace(/^(\.\.(\/|\\|$))+/, "");
+  const target = resolve(uiRoot, normalized.slice(1));
+  if (!target.startsWith(uiRoot)) {
+    throw new Error("Invalid path");
+  }
+  return target;
+}
+function serveFile(filePath, res) {
+  if (!existsSync(filePath)) {
+    res.statusCode = 404;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end("Not found");
+    return;
+  }
+  res.statusCode = 200;
+  res.setHeader("content-type", contentType(filePath));
+  createReadStream(filePath).pipe(res);
+}
+function contentType(filePath) {
+  switch (extname(filePath)) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".json":
+      return "application/json; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".ico":
+      return "image/x-icon";
+    default:
+      return "application/octet-stream";
+  }
+}
+function proxyApi(req, res, url, apiBase) {
+  const target = new URL(apiBase);
+  target.pathname = url.pathname;
+  target.search = url.search;
+  const isSecure = target.protocol === "https:";
+  const proxyRequest = (isSecure ? requestSecure : request)({
+    protocol: target.protocol,
+    hostname: target.hostname,
+    port: target.port,
+    method: req.method,
+    path: target.pathname + target.search,
+    headers: {
+      ...req.headers,
+      host: target.host
+    }
+  }, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+    proxyRes.pipe(res);
+  });
+  proxyRequest.on("error", (error) => {
+    res.statusCode = 502;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end(`Proxy error: ${error instanceof Error ? error.message : "unknown"}`);
+  });
+  req.pipe(proxyRequest);
+}