input-kanban 0.0.2 → 0.0.4

package/src/runners/tmuxRunner.js

@@ -0,0 +1,220 @@
+import { fileURLToPath } from 'node:url';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import {
+  CODEX_BIN,
+  ensureDir,
+  nowIso,
+  readTextMaybe,
+  writeJsonAtomic
+} from '../utils.js';
+import {
+  DEFAULT_TMUX_BIN,
+  sanitizeTmuxSessionName,
+  sanitizeTmuxWindowName,
+  tmuxHasSession,
+  tmuxKillSession,
+  tmuxNewSession,
+  tmuxNewWindow,
+  tmuxSelectLayout,
+  tmuxSplitWindow
+} from '../tmux.js';
+
+function processKey(runId, taskId) {
+  return `${runId}:${taskId}`;
+}
+
+function roleForTask(taskId) {
+  if (taskId === 'planner') return 'planner';
+  if (taskId === 'judge') return 'judge';
+  return 'worker';
+}
+
+function windowNameForTask(taskId, batchId = null) {
+  const role = roleForTask(taskId);
+  if (role === 'worker') return sanitizeTmuxWindowName(batchId || 'batch-1');
+  return sanitizeTmuxWindowName(role);
+}
+
+function sessionNameForRun(runId) {
+  return sanitizeTmuxSessionName(`input-kanban-${runId}`);
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+const BIN_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../bin');
+const FORMATTER_BIN = path.join(BIN_DIR, 'input-kanban-format-events.js');
+const OVERVIEW_BIN = path.join(BIN_DIR, 'input-kanban-tmux-overview.js');
+
+function buildOverviewCommand(runStatePath) {
+  const quotedStatePath = shellQuote(runStatePath);
+  const quotedOverviewBin = shellQuote(OVERVIEW_BIN);
+  return `while true; do clear; node ${quotedOverviewBin} ${quotedStatePath}; sleep 2; done`;
+}
+
+function buildRunScript({ codexBin, formatterBin = FORMATTER_BIN, sandbox, cwd, outDir, runId, taskId, role }) {
+  return `#!/usr/bin/env bash
+set -u
+
+CODEX_BIN=${shellQuote(codexBin)}
+SANDBOX=${shellQuote(sandbox)}
+CWD=${shellQuote(cwd)}
+OUT_DIR=${shellQuote(outDir)}
+RUN_ID=${shellQuote(runId)}
+TASK_ID=${shellQuote(taskId)}
+ROLE=${shellQuote(role)}
+PROMPT_FILE="$OUT_DIR/prompt.md"
+EVENTS="$OUT_DIR/events.jsonl"
+STDERR_LOG="$OUT_DIR/stderr.log"
+FORMATTER_BIN=${shellQuote(formatterBin)}
+LAST_MESSAGE="$OUT_DIR/last_message.md"
+EXIT_CODE="$OUT_DIR/exit_code"
+
+cd "$CWD"
+rm -f "$EXIT_CODE"
+touch "$EVENTS" "$STDERR_LOG"
+"$CODEX_BIN" exec --json --sandbox "$SANDBOX" -C "$CWD" -o "$LAST_MESSAGE" "$(<"$PROMPT_FILE")" > >(tee -a "$EVENTS" | node "$FORMATTER_BIN") 2> >(tee -a "$STDERR_LOG" >&2)
+code=$?
+printf '%s' "$code" > "$EXIT_CODE"
+printf '\\nInput Kanban tmux task completed.\\n'
+printf 'runId: %s\\n' "$RUN_ID"
+printf 'taskId: %s\\n' "$TASK_ID"
+printf 'role: %s\\n' "$ROLE"
+printf 'exit code: %s\\n' "$code"
+printf 'artifact dir: %s\\n' "$OUT_DIR"
+printf 'Type exit or press Ctrl-D to close this tmux window.\\n'
+exec "\${SHELL:-/bin/sh}" -i
+`;
+}
+
+export function createTmuxRunner({
+  codexBin = CODEX_BIN,
+  tmuxBin = DEFAULT_TMUX_BIN,
+  tmuxOptions = {},
+  pollMs = 1000
+} = {}) {
+  const runningWindows = new Map();
+
+  async function startCodexTask({ runId, taskId, batchId = null, runStatePath = null, prompt, sandbox, cwd, outDir }) {
+    await ensureDir(outDir);
+    const sessionName = sessionNameForRun(runId);
+    const role = roleForTask(taskId);
+    const windowName = windowNameForTask(taskId, batchId);
+    const key = processKey(runId, taskId);
+    const promptFile = path.join(outDir, 'prompt.md');
+    const runScript = path.join(outDir, 'run.sh');
+    const exitFile = path.join(outDir, 'exit_code');
+    const metadataFile = path.join(outDir, 'tmux.json');
+    const startedAt = nowIso();
+
+    await fsp.writeFile(promptFile, prompt);
+    await fsp.writeFile(runScript, buildRunScript({ codexBin, sandbox, cwd, outDir, runId, taskId, role }));
+    await fsp.chmod(runScript, 0o755);
+
+    const metadata = {
+      type: 'input_kanban_tmux_task',
+      version: 1,
+      runner: 'tmux',
+      runId,
+      taskId,
+      role,
+      batchId,
+      sessionName,
+      windowName,
+      target: `${sessionName}:${windowName}`,
+      runScript,
+      promptFile,
+      cwd,
+      sandbox,
+      startedAt,
+      ready: false,
+      status: 'pending'
+    };
+    await writeJsonAtomic(metadataFile, metadata);
+
+    const overviewCommand = buildOverviewCommand(runStatePath || path.join(path.dirname(path.dirname(outDir)), 'run_state.json'));
+    const tmuxCommandOptions = { ...tmuxOptions, tmuxBin, cwd };
+    try {
+      if (await tmuxHasSession(sessionName, tmuxCommandOptions)) {
+        if (!runningWindows.has(`${runId}:__window:${windowName}`)) {
+          await tmuxNewWindow(sessionName, windowName, { ...tmuxCommandOptions, command: overviewCommand });
+          runningWindows.set(`${runId}:__window:${windowName}`, { sessionName, windowName, overview: true });
+        }
+      } else {
+        await tmuxNewSession(sessionName, { ...tmuxCommandOptions, windowName, command: overviewCommand });
+        runningWindows.set(`${runId}:__window:${windowName}`, { sessionName, windowName, overview: true });
+      }
+      await tmuxSplitWindow(sessionName, windowName, { ...tmuxCommandOptions, vertical: true, command: runScript });
+      await tmuxSelectLayout(sessionName, windowName, 'tiled', tmuxCommandOptions);
+    } catch (error) {
+      await writeJsonAtomic(metadataFile, {
+        ...metadata,
+        ready: false,
+        status: 'failed',
+        error: error?.message || String(error),
+        failedAt: nowIso()
+      });
+      throw error;
+    }
+
+    await writeJsonAtomic(metadataFile, {
+      ...metadata,
+      ready: true,
+      status: 'ready',
+      attachCommand: `${tmuxBin} attach-session -t ${sessionName}`,
+      selectWindowCommand: `${tmuxBin} select-window -t ${sessionName}:${windowName}`,
+      selectCommand: `${tmuxBin} select-window -t ${sessionName}:${windowName}`,
+      paneCommand: `${tmuxBin} select-window -t ${sessionName}:${windowName}`,
+      readyAt: nowIso()
+    });
+
+    const listeners = [];
+    let exited = false;
+    let exitCode = null;
+    const timer = setInterval(async () => {
+      const text = await readTextMaybe(exitFile, 1000);
+      if (text === '') return;
+      clearInterval(timer);
+      runningWindows.delete(key);
+      const code = Number(text.trim());
+      exited = true;
+      exitCode = Number.isNaN(code) ? null : code;
+      for (const listener of listeners) listener(exitCode);
+    }, Math.max(100, Number(pollMs) || 1000));
+
+    const handle = {
+      pid: null,
+      onExit(listener) {
+        if (exited) listener(exitCode);
+        else listeners.push(listener);
+      },
+      stop() {}
+    };
+    runningWindows.set(key, { sessionName, windowName, timer });
+    return handle;
+  }
+
+  async function stopRun(runId) {
+    for (const [key, value] of runningWindows.entries()) {
+      if (!key.startsWith(`${runId}:`)) continue;
+      clearInterval(value.timer);
+      runningWindows.delete(key);
+    }
+    const sessionName = sessionNameForRun(runId);
+    try {
+      if (await tmuxHasSession(sessionName, { ...tmuxOptions, tmuxBin })) {
+        await tmuxKillSession(sessionName, { ...tmuxOptions, tmuxBin });
+      }
+    } catch (error) {
+      if (!/no such session/i.test(error?.message || '')) throw error;
+    }
+  }
+
+  function hasRunning(runId, taskId) {
+    return runningWindows.has(processKey(runId, taskId));
+  }
+
+  return { kind: 'tmux', sessionNameForRun, startCodexTask, stopRun, hasRunning };
+}

package/src/runners/tmuxUtils.js

@@ -0,0 +1,17 @@
+export {
+  DEFAULT_TMUX_BIN,
+  TmuxUnavailableError,
+  checkTmuxAvailable,
+  ensureTmuxAvailable,
+  runTmux,
+  sanitizeTmuxName,
+  sanitizeTmuxSessionName,
+  sanitizeTmuxWindowName,
+  tmuxHasSession,
+  tmuxKillSession,
+  tmuxKillWindow,
+  tmuxNewSession,
+  tmuxNewWindow,
+  tmuxSelectLayout,
+  tmuxSplitWindow
+} from '../tmux.js';

package/src/server.js

@@ -3,7 +3,7 @@ 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 { APP_ROOT, DEFAULT_REPO, RUNNER, 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');
@@ -42,7 +42,7 @@ 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 });
+      return send(res, 200, { ok: true, appRoot: APP_ROOT, runsDir: RUNS_DIR, defaultRepo: DEFAULT_REPO, runner: RUNNER });
     }
     if (parts[1] === 'runs' && parts.length === 2) {
       if (req.method === 'GET') return send(res, 200, { runs: await listRuns({ includeArchived: url.searchParams.get('includeArchived') === '1' }) });
@@ -100,7 +100,7 @@ export async function startServer({ host = process.env.HOST || '127.0.0.1', port
     appClient.stop();
     await new Promise(resolve => server.close(resolve));
   };
-  return { server, appClient, host, port, url, defaultRepo: DEFAULT_REPO, runsDir: RUNS_DIR, stop };
+  return { server, appClient, host, port, url, defaultRepo: DEFAULT_REPO, runsDir: RUNS_DIR, runner: RUNNER, stop };
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) {

package/src/tmux.js

@@ -0,0 +1,156 @@
+import { execFile } from 'node:child_process';
+import crypto from 'node:crypto';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+export const DEFAULT_TMUX_BIN = process.env.KANBAN_TMUX_BIN || 'tmux';
+
+export class TmuxUnavailableError extends Error {
+  constructor(tmuxBin, result) {
+    const detail = result?.stderr || result?.stdout || result?.error?.message || 'command failed';
+    super(`tmux is unavailable: failed to run "${tmuxBin} -V" (${detail.trim()})`);
+    this.name = 'TmuxUnavailableError';
+    this.tmuxBin = tmuxBin;
+    this.result = result;
+  }
+}
+
+function normalizeResult(result) {
+  return {
+    code: Number.isInteger(result?.code) ? result.code : 0,
+    stdout: result?.stdout || '',
+    stderr: result?.stderr || '',
+    error: result?.error
+  };
+}
+
+async function defaultRunner(command, args, { timeoutMs = 3000 } = {}) {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, { timeout: timeoutMs, windowsHide: true });
+    return { code: 0, stdout, stderr };
+  } catch (error) {
+    const code = Number.isInteger(error?.code) ? error.code : error?.code === 'ENOENT' ? 127 : 1;
+    return { code, stdout: error?.stdout || '', stderr: error?.stderr || error?.message || '', error };
+  }
+}
+
+async function runCommand(command, args, options = {}) {
+  const runner = options.runner || defaultRunner;
+  return normalizeResult(await runner(command, args, { timeoutMs: options.timeoutMs || 3000 }));
+}
+
+function safeFallback(fallback) {
+  const value = String(fallback || 'tmux')
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, '');
+  return value || 'tmux';
+}
+
+export function sanitizeTmuxName(value, { fallback = 'tmux', maxLength = 80 } = {}) {
+  const limit = Math.max(16, Number(maxLength) || 80);
+  const original = String(value || '');
+  let name = original
+    .replace(/[^a-zA-Z0-9._-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, '');
+
+  if (!name) name = safeFallback(fallback);
+  if (name.length <= limit) return name;
+
+  const hash = crypto.createHash('sha256').update(original || name).digest('hex').slice(0, 8);
+  const prefixLength = Math.max(1, limit - hash.length - 1);
+  const fallbackPrefix = safeFallback(fallback).slice(0, prefixLength);
+  const prefix = name.slice(0, prefixLength).replace(/[^a-zA-Z0-9]+$/g, '') || fallbackPrefix;
+  return `${prefix}-${hash}`.slice(0, limit);
+}
+
+export function sanitizeTmuxSessionName(value, options = {}) {
+  return sanitizeTmuxName(value, { fallback: 'input-kanban', ...options });
+}
+
+export function sanitizeTmuxWindowName(value, options = {}) {
+  return sanitizeTmuxName(value, { fallback: 'worker', ...options });
+}
+
+export async function checkTmuxAvailable(options = {}) {
+  const tmuxBin = options.tmuxBin || DEFAULT_TMUX_BIN;
+  const result = await runCommand(tmuxBin, ['-V'], options);
+  return {
+    available: result.code === 0,
+    tmuxBin,
+    version: result.code === 0 ? result.stdout.trim() : '',
+    result
+  };
+}
+
+export async function ensureTmuxAvailable(options = {}) {
+  const status = await checkTmuxAvailable(options);
+  if (!status.available) throw new TmuxUnavailableError(status.tmuxBin, status.result);
+  return status;
+}
+
+export async function runTmux(args, options = {}) {
+  const tmuxBin = options.tmuxBin || DEFAULT_TMUX_BIN;
+  await ensureTmuxAvailable({ ...options, tmuxBin });
+  const result = await runCommand(tmuxBin, args, options);
+  if (result.code !== 0) {
+    const detail = result.stderr || result.stdout || 'command failed';
+    throw new Error(`tmux command failed: ${tmuxBin} ${args.join(' ')} (${detail.trim()})`);
+  }
+  return result;
+}
+
+export async function tmuxHasSession(sessionName, options = {}) {
+  const tmuxBin = options.tmuxBin || DEFAULT_TMUX_BIN;
+  const session = sanitizeTmuxSessionName(sessionName);
+  await ensureTmuxAvailable({ ...options, tmuxBin });
+  const result = await runCommand(tmuxBin, ['has-session', '-t', session], options);
+  return result.code === 0;
+}
+
+export async function tmuxNewSession(sessionName, options = {}) {
+  const session = sanitizeTmuxSessionName(sessionName);
+  const args = ['new-session', '-d', '-s', session];
+  if (options.windowName) args.push('-n', sanitizeTmuxWindowName(options.windowName));
+  if (options.cwd) args.push('-c', options.cwd);
+  if (options.command) args.push(options.command);
+  return runTmux(args, options);
+}
+
+export async function tmuxNewWindow(sessionName, windowName, options = {}) {
+  const session = sanitizeTmuxSessionName(sessionName);
+  const window = sanitizeTmuxWindowName(windowName);
+  const args = ['new-window', '-t', session, '-n', window];
+  if (options.cwd) args.push('-c', options.cwd);
+  if (options.command) args.push(options.command);
+  return runTmux(args, options);
+}
+
+export async function tmuxKillSession(sessionName, options = {}) {
+  return runTmux(['kill-session', '-t', sanitizeTmuxSessionName(sessionName)], options);
+}
+
+export async function tmuxSplitWindow(sessionName, windowName, options = {}) {
+  const session = sanitizeTmuxSessionName(sessionName);
+  const window = sanitizeTmuxWindowName(windowName);
+  const args = ['split-window', '-t', `${session}:${window}`];
+  if (options.vertical) args.push('-v');
+  else args.push('-h');
+  if (options.cwd) args.push('-c', options.cwd);
+  if (options.command) args.push(options.command);
+  return runTmux(args, options);
+}
+
+export async function tmuxSelectLayout(sessionName, windowName, layout = 'tiled', options = {}) {
+  const session = sanitizeTmuxSessionName(sessionName);
+  const window = sanitizeTmuxWindowName(windowName);
+  return runTmux(['select-layout', '-t', `${session}:${window}`, layout], options);
+}
+
+export async function tmuxKillWindow(sessionName, windowName, options = {}) {
+  const session = sanitizeTmuxSessionName(sessionName);
+  const window = sanitizeTmuxWindowName(windowName);
+  return runTmux(['kill-window', '-t', `${session}:${window}`], options);
+}

package/src/utils.js

@@ -7,6 +7,15 @@ export const APP_ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathn
 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 const VALID_RUNNERS = ['headless', 'tmux'];
+
+export function normalizeRunner(value = 'headless', source = 'KANBAN_RUNNER') {
+  const runner = String(value || '').trim();
+  if (VALID_RUNNERS.includes(runner)) return runner;
+  throw new Error(`invalid ${source}: ${value}; expected one of: ${VALID_RUNNERS.join(', ')}`);
+}
+
+export const RUNNER = normalizeRunner(process.env.KANBAN_RUNNER || 'headless');
 
 export async function ensureDir(dir) { await fsp.mkdir(dir, { recursive: true }); }
 export function nowIso() { return new Date().toISOString(); }