vibeman 0.0.5 → 0.0.7

package/dist/api.js

@@ -0,0 +1,43 @@
+// ../api/src/index.ts
+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();
+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);
+    }
+  }
+  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}`);
+});
+async function listFiles(pathInput) {
+  const target = normalize(resolve(root, pathInput));
+  const entries = await readdir(target, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    kind: entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other"
+  }));
+}
+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

@@ -1,114 +1,237 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { createServer } from 'node:net';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
-// resolve into apps/cli/dist/runtime/**
-const runtime = (...p) => path.join(__dirname, 'runtime', ...p);
-// very small logger
-const log = {
-    info: (msg) => console.log(`ℹ️  ${msg}`),
-    error: (msg, err) => console.error(`❌ ${msg}`, err),
-};
-// cross-platform npm command
-const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-/** test if a TCP port is open on host (localhost by default) */
-async function isPortInUse(port, host = 'localhost') {
-    const hosts = host === 'localhost' ? ['localhost', '127.0.0.1', '0.0.0.0'] : [host];
-    for (const h of hosts) {
-        const inUse = await new Promise((resolve) => {
-            const srv = createServer()
-                .once('error', () => resolve(true))
-                .once('listening', () => srv.close(() => resolve(false)))
-                .listen(port, h);
-        });
-        if (inUse)
-            return true;
-    }
-    return false;
+
+// 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);
 }
-/** load ~/.vibeman/.local/settings.json with defaults */
-async function loadSettings() {
-    const defaults = { server: { port: 6969, host: 'localhost', autoOpenBrowser: true } };
-    try {
-        const p = path.resolve('.vibeman/.local/settings.json');
-        if (fs.existsSync(p))
-            return { ...defaults, ...JSON.parse(fs.readFileSync(p, 'utf8')) };
+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;
     }
-    catch {
-        /* ignore */
+    if (!arg.startsWith("-") && output.path === ".") {
+      output.path = arg;
     }
-    return defaults;
+  }
+  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));
+  });
 }
-async function startVibeman(targetDir = '.', opts = {}) {
-    /* ----- resolve project settings & CLI flags ----- */
-    process.chdir(path.resolve(targetDir));
-    const cfg = await loadSettings();
-    const webPort = opts.port ? +opts.port : cfg.server.port;
-    const host = opts.host || cfg.server.host;
-    const openBrowser = 'open' in opts ? !!opts.open : cfg.server.autoOpenBrowser;
-    const apiBasePort = webPort;
-    const apiListenPort = apiBasePort + 1;
-    if (await isPortInUse(webPort, host)) {
-        log.error(`Port ${webPort} is already in use.`);
-        process.exit(1);
+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;
     }
-    if (await isPortInUse(apiListenPort, host)) {
-        log.error(`API port ${apiListenPort} is already in use.`);
-        process.exit(1);
+  }
+  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;
     }
-    /* ----- API server (runtime/api/index.js) ----- */
-    const apiEntry = runtime('api', 'index.js');
-    if (!fs.existsSync(apiEntry)) {
-        log.error('API artefacts missing – did you run `pnpm run build`?');
-        process.exit(1);
+    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);
     }
-    spawn(process.execPath, [apiEntry], {
-        stdio: 'inherit',
-        env: { ...process.env, HOST: host, PORT: String(apiBasePort) },
-    }).on('error', (e) => {
-        log.error('Failed to start API server', e);
-        process.exit(1);
-    });
-    /* ----- Web server (runtime/web/standalone/server.js) or dev fallback --- */
-    const webEntry = runtime('web', 'server.js');
-    const webProc = spawn(process.execPath, [webEntry], {
-        stdio: 'inherit',
-        env: { ...process.env, PORT: String(webPort), HOSTNAME: host },
-    });
-    webProc.on('error', (e) => {
-        log.error('Failed to start web server', e);
-        process.exit(1);
-    });
-    /* ----- optionally open browser --------------------------------------- */
-    if (openBrowser) {
-        setTimeout(async () => {
-            try {
-                const open = await import('open');
-                await open.default(`http://${host}:${webPort}`);
-            }
-            catch {
-                log.info(`🌐 Open http://${host}:${webPort} in your browser`);
-            }
-        }, 3000);
+  });
+}
+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);
 }
-const program = new Command();
-program
-    .name('vibeman')
-    .description('A Git-native, Markdown-first product-and-task dashboard')
-    .version(pkg.version);
-program
-    .command('start')
-    .argument('[dir]', 'Target project directory', '.')
-    .option('-p, --port <port>', 'Port number')
-    .option('-H, --host <host>', 'Bind address')
-    .option('--no-open', 'Do not open browser')
-    .action((dir, options) => startVibeman(dir, options));
-/* default action → same as `start .` */
-program.action(() => startVibeman('.', {}));
-program.parse();