input-kanban 0.0.1

package/src/server.js

@@ -0,0 +1,111 @@
+import http from 'node:http';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CodexAppServerClient } from './appServerClient.js';
+import { APP_ROOT, DEFAULT_REPO, RUNS_DIR } from './utils.js';
+import { createRun, listRuns, startPlanner, dispatchRun, startJudge, refreshRun, readRunFile, readRunTaskText, markTaskCompleted, stopRun, archiveRun } from './orchestrator.js';
+
+const PUBLIC_DIR = path.join(APP_ROOT, 'public');
+
+function send(res, status, body, type = 'application/json') {
+  const data = type === 'application/json' ? JSON.stringify(body, null, 2) : body;
+  res.writeHead(status, { 'Content-Type': `${type}; charset=utf-8` });
+  res.end(data);
+}
+
+async function readBody(req) {
+  const chunks = [];
+  for await (const c of req) chunks.push(c);
+  const text = Buffer.concat(chunks).toString('utf8');
+  if (!text) return {};
+  try { return JSON.parse(text); } catch { return { text }; }
+}
+
+function notFound(res) { send(res, 404, { error: 'not found' }); }
+function methodNotAllowed(res) { send(res, 405, { error: 'method not allowed' }); }
+
+async function serveStatic(req, res, pathname) {
+  let file = pathname === '/' ? path.join(PUBLIC_DIR, 'index.html') : path.join(PUBLIC_DIR, pathname.replace(/^\/+/, ''));
+  file = path.resolve(file);
+  if (!file.startsWith(PUBLIC_DIR)) return notFound(res);
+  try {
+    const data = await fsp.readFile(file);
+    const ext = path.extname(file);
+    const type = ext === '.html' ? 'text/html' : ext === '.js' ? 'text/javascript' : ext === '.css' ? 'text/css' : 'text/plain';
+    res.writeHead(200, { 'Content-Type': `${type}; charset=utf-8` });
+    res.end(data);
+  } catch { notFound(res); }
+}
+
+async function handleApi(req, res, url, appClient) {
+  const parts = url.pathname.split('/').filter(Boolean);
+  try {
+    if (req.method === 'GET' && url.pathname === '/api/health') {
+      return send(res, 200, { ok: true, appRoot: APP_ROOT, runsDir: RUNS_DIR, defaultRepo: DEFAULT_REPO });
+    }
+    if (parts[1] === 'runs' && parts.length === 2) {
+      if (req.method === 'GET') return send(res, 200, { runs: await listRuns({ includeArchived: url.searchParams.get('includeArchived') === '1' }) });
+      if (req.method === 'POST') {
+        const body = await readBody(req);
+        return send(res, 201, await createRun(body));
+      }
+      return methodNotAllowed(res);
+    }
+    if (parts[1] === 'runs' && parts.length >= 3) {
+      const runId = parts[2];
+      if (parts.length === 4 && parts[3] === 'status' && req.method === 'GET') return send(res, 200, await refreshRun(runId, appClient));
+      if (parts.length === 4 && parts[3] === 'plan' && req.method === 'POST') return send(res, 202, await startPlanner(runId));
+      if (parts.length === 4 && parts[3] === 'dispatch' && req.method === 'POST') return send(res, 202, await dispatchRun(runId));
+      if (parts.length === 4 && parts[3] === 'judge' && req.method === 'POST') return send(res, 202, await startJudge(runId));
+      if (parts.length === 4 && parts[3] === 'stop' && req.method === 'POST') {
+        const body = await readBody(req);
+        return send(res, 200, await stopRun(runId, body));
+      }
+      if (parts.length === 4 && parts[3] === 'archive' && req.method === 'POST') {
+        const body = await readBody(req);
+        return send(res, 200, await archiveRun(runId, body));
+      }
+      if (parts.length === 4 && parts[3] === 'task-text' && req.method === 'GET') return send(res, 200, await readRunTaskText(runId), 'text/plain');
+      if (parts.length === 6 && parts[3] === 'tasks' && parts[5] === 'file' && req.method === 'GET') {
+        const text = await readRunFile(runId, parts[4], url.searchParams.get('name') || 'last_message.md');
+        return send(res, 200, text, 'text/plain');
+      }
+      if (parts.length === 6 && parts[3] === 'tasks' && parts[5] === 'mark-completed' && req.method === 'POST') {
+        const body = await readBody(req);
+        return send(res, 200, await markTaskCompleted(runId, parts[4], body));
+      }
+    }
+    notFound(res);
+  } catch (e) {
+    send(res, 500, { error: e.message });
+  }
+}
+
+export function createHttpServer({ appClient = new CodexAppServerClient() } = {}) {
+  return http.createServer(async (req, res) => {
+    const url = new URL(req.url, `http://${req.headers.host || '127.0.0.1'}`);
+    if (url.pathname.startsWith('/api/')) return await handleApi(req, res, url, appClient);
+    return await serveStatic(req, res, url.pathname);
+  });
+}
+
+export async function startServer({ host = process.env.HOST || '127.0.0.1', port = Number(process.env.PORT || 8787), log = true } = {}) {
+  const appClient = new CodexAppServerClient();
+  const server = createHttpServer({ appClient });
+  await new Promise(resolve => server.listen(port, host, resolve));
+  const url = `http://${host}:${port}`;
+  if (log) console.log(`input-kanban listening on ${url}`);
+  const stop = async () => {
+    appClient.stop();
+    await new Promise(resolve => server.close(resolve));
+  };
+  return { server, appClient, host, port, url, defaultRepo: DEFAULT_REPO, runsDir: RUNS_DIR, stop };
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const instance = await startServer();
+  const shutdown = () => { instance.stop().finally(() => process.exit(0)); };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/src/utils.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+export const APP_ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+export const DEFAULT_REPO = path.resolve(process.env.KANBAN_DEFAULT_REPO || process.cwd());
+export const RUNS_DIR = path.resolve(process.env.KANBAN_RUNS_DIR || path.join(process.env.HOME || APP_ROOT, '.input-kanban', 'runs'));
+export const CODEX_BIN = process.env.KANBAN_CODEX_BIN || 'codex';
+
+export async function ensureDir(dir) { await fsp.mkdir(dir, { recursive: true }); }
+export function nowIso() { return new Date().toISOString(); }
+export function safeIdPart(s) { return String(s || '').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'run'; }
+export function makeRunId(label='run') {
+  const ts = new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, 'Z');
+  return `run_${ts}_${safeIdPart(label)}_${crypto.randomBytes(3).toString('hex')}`;
+}
+export async function readJson(file, fallback=null) {
+  try { return JSON.parse(await fsp.readFile(file, 'utf8')); } catch { return fallback; }
+}
+export async function writeJsonAtomic(file, data) {
+  await ensureDir(path.dirname(file));
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  await fsp.writeFile(tmp, JSON.stringify(data, null, 2));
+  await fsp.rename(tmp, file);
+}
+export async function fileInfo(file) {
+  try { const st = await fsp.stat(file); return { exists: true, size: st.size, mtimeMs: st.mtimeMs, mtime: st.mtime.toISOString() }; }
+  catch { return { exists: false }; }
+}
+export async function readTextMaybe(file, maxBytes=200000) {
+  try {
+    const st = await fsp.stat(file);
+    const start = Math.max(0, st.size - maxBytes);
+    const fh = await fsp.open(file, 'r');
+    try {
+      const buf = Buffer.alloc(st.size - start);
+      await fh.read(buf, 0, buf.length, start);
+      return buf.toString('utf8');
+    } finally { await fh.close(); }
+  } catch { return ''; }
+}
+export function extractFirstJsonObject(text) {
+  if (!text) return null;
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidates = [];
+  if (fenced) candidates.push(fenced[1]);
+  candidates.push(text);
+  for (const c of candidates) {
+    const start = c.indexOf('{');
+    if (start < 0) continue;
+    let depth = 0, inStr = false, esc = false;
+    for (let i = start; i < c.length; i++) {
+      const ch = c[i];
+      if (inStr) { if (esc) esc = false; else if (ch === '\\') esc = true; else if (ch === '"') inStr = false; continue; }
+      if (ch === '"') inStr = true;
+      else if (ch === '{') depth++;
+      else if (ch === '}') { depth--; if (depth === 0) { try { return JSON.parse(c.slice(start, i + 1)); } catch {} } }
+    }
+  }
+  return null;
+}
+export async function listRunDirs() {
+  await ensureDir(RUNS_DIR);
+  const entries = await fsp.readdir(RUNS_DIR, { withFileTypes: true });
+  return entries.filter(e => e.isDirectory()).map(e => path.join(RUNS_DIR, e.name)).sort().reverse();
+}
+export function pathForRun(runId) { return path.join(RUNS_DIR, safeIdPart(runId)); }
+export function roleDir(runDir, role, taskId=null) {
+  if (role === 'worker') return path.join(runDir, 'workers', safeIdPart(taskId));
+  return path.join(runDir, role);
+}
+export async function appendFileStream(stream, file) {
+  await ensureDir(path.dirname(file));
+  const ws = fs.createWriteStream(file, { flags: 'a' });
+  stream.pipe(ws);
+  return ws;
+}