@pleri/olam-cli 0.1.7

package/host-cp/src/world-pr-state.mjs

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @typedef {object} PrStateEntry
+ * @property {string} pr_url
+ * @property {number|null} pr_number
+ * @property {string|null} pr_repo
+ * @property {string|null} pr_created_at
+ * @property {'open'|'merged'|'merged_destroyed'} pr_state
+ * @property {string|null} pr_merged_at
+ * @property {boolean} auto_destroy_on_merge
+ */
+
+/**
+ * @param {string} filePath
+ */
+export function createWorldPrStateStore(filePath) {
+  /** @type {Record<string, PrStateEntry>} */
+  let cache = {};
+  let cacheMtimeMs = -1;
+
+  function readFromDisk() {
+    if (!fs.existsSync(filePath)) {
+      cache = {};
+      cacheMtimeMs = 0;
+      return;
+    }
+    try {
+      const stat = fs.statSync(filePath);
+      if (stat.mtimeMs === cacheMtimeMs) return;
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      cache = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+      cacheMtimeMs = stat.mtimeMs;
+    } catch (err) {
+      console.error(`world-pr-state: failed to read ${filePath}: ${err.message}`);
+      cache = {};
+      cacheMtimeMs = 0;
+    }
+  }
+
+  function writeToDisk() {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(cache, null, 2), 'utf-8');
+    fs.renameSync(tmp, filePath);
+    try {
+      cacheMtimeMs = fs.statSync(filePath).mtimeMs;
+    } catch {
+      cacheMtimeMs = 0;
+    }
+  }
+
+  function getAll() {
+    readFromDisk();
+    return { ...cache };
+  }
+
+  /** @param {string} worldId */
+  function get(worldId) {
+    readFromDisk();
+    return cache[worldId] ?? null;
+  }
+
+  /**
+   * Upsert — merges data with the existing entry.
+   * @param {string} worldId
+   * @param {Partial<PrStateEntry>} data
+   */
+  function set(worldId, data) {
+    readFromDisk();
+    const existing = cache[worldId] ?? {};
+    cache = { ...cache, [worldId]: { ...existing, ...data } };
+    writeToDisk();
+  }
+
+  /** @param {string} worldId */
+  function remove(worldId) {
+    readFromDisk();
+    if (!(worldId in cache)) return;
+    const next = { ...cache };
+    delete next[worldId];
+    cache = next;
+    writeToDisk();
+  }
+
+  function getWorldsToWatch() {
+    readFromDisk();
+    return Object.entries(cache)
+      .filter(([, entry]) => entry.pr_url && entry.pr_state !== 'merged_destroyed')
+      .map(([worldId, entry]) => ({ worldId, ...entry }));
+  }
+
+  return { getAll, get, set, remove, getWorldsToWatch };
+}

package/host-cp/src/world-progress.mjs

@@ -0,0 +1,322 @@
+/**
+ * World progress computation — maps world state onto the 8-phase ladder
+ * shown in the inbox row progress bar.
+ *
+ * @module world-progress
+ */
+
+import path from 'node:path';
+import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readPlanProgress } from './plan-progress.mjs';
+
+const execFileAsync = promisify(execFile);
+
+// Mirror of @olam/core/src/world-paths.mjs. Inlined deliberately: host-cp's
+// slim Docker image does NOT bundle @olam/core (see server.mjs ~L560 for the
+// architectural decision). Keep these two definitions in sync until the
+// host-cp image build is taught to vendor workspace deps.
+const WORLD_DB_FILENAME = 'world.db';
+function getWorldDbPath(workspacePath) {
+  return path.join(workspacePath, WORLD_DB_FILENAME);
+}
+
+/**
+ * Phase ladder definition.
+ * @type {Array<{name: string, index: number}>}
+ */
+const PHASES = [
+  { name: 'starting', index: 1 },
+  { name: 'implementing', index: 2 },
+  { name: 'committing', index: 3 },
+  { name: 'pushing', index: 4 },
+  { name: 'in_review', index: 5 },
+  { name: 'ci_failed', index: 6 },
+  { name: 'ready', index: 7 },
+  { name: 'merged', index: 8 },
+];
+
+const PHASE_TOTAL = PHASES.length;
+const IDLE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Determine the current phase from observable state.
+ *
+ * @param {{
+ *   thoughts: number,
+ *   commitsAhead: number,
+ *   pushed: boolean,
+ *   prUrl: string|null,
+ *   prChecks: 'pending'|'passing'|'failing'|null,
+ *   prState: 'open'|'merged'|'closed'|null,
+ * }} state
+ * @returns {string} phase name
+ */
+export function determinePhase({ thoughts, commitsAhead, pushed, prUrl, prChecks, prState }) {
+  // merged
+  if (prState === 'merged') return 'merged';
+
+  // prUrl exists
+  if (prUrl) {
+    if (prChecks === 'failing') return 'ci_failed';
+    if (prChecks === 'passing' && prState === 'open') return 'ready';
+    // prChecks is null or pending
+    return 'in_review';
+  }
+
+  // No PR yet
+  if (pushed) return 'pushing';
+  if (commitsAhead >= 1) return 'committing';
+  if (thoughts >= 30) return 'implementing';
+  return 'starting';
+}
+
+/**
+ * Build the safe/default response for a world.
+ *
+ * @param {string} worldId
+ * @returns {object}
+ */
+export function makeSafeResponse(worldId) {
+  return {
+    worldId,
+    phase: 'starting',
+    phaseIndex: 1,
+    phaseTotal: PHASE_TOTAL,
+    isIdle: false,
+    thoughts: 0,
+    lastActivityAt: null,
+    runtimeMs: 0,
+    commitsAhead: 0,
+    pushed: false,
+    prUrl: null,
+    prNumber: null,
+    prChecks: null,
+    prState: null,
+    plan: null,
+  };
+}
+
+/**
+ * Read a world row from worlds.db.
+ *
+ * @param {string} dbPath
+ * @param {string} worldId
+ * @returns {{ branch: string, repos: string[], workspacePath: string, createdAt: string } | null}
+ */
+function defaultReadWorldRow(dbPath, worldId) {
+  try {
+    const Database = createRequire(import.meta.url)('better-sqlite3');
+    const db = new Database(dbPath, { readonly: true });
+    db.pragma('journal_mode = WAL');
+    const row = db.prepare(
+      'SELECT branch, repos, workspace_path, created_at FROM worlds WHERE id = ?',
+    ).get(worldId);
+    db.close();
+    if (!row) return null;
+    let repos = [];
+    try {
+      repos = typeof row.repos === 'string' ? JSON.parse(row.repos) : (row.repos ?? []);
+    } catch {
+      repos = [];
+    }
+    return {
+      branch: row.branch ?? 'main',
+      repos,
+      workspacePath: row.workspace_path ?? '',
+      createdAt: row.created_at ?? null,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read thought count and last activity from a world.db.
+ *
+ * @param {string} dbPath
+ * @returns {{ count: number, lastAt: string|null }}
+ */
+function defaultReadThoughts(dbPath) {
+  try {
+    const Database = createRequire(import.meta.url)('better-sqlite3');
+    const db = new Database(dbPath, { readonly: true });
+    db.pragma('journal_mode = WAL');
+    const row = db
+      .prepare('SELECT COUNT(*) AS cnt, MAX(created_at) AS last_at FROM thought_nodes')
+      .get();
+    db.close();
+    return {
+      count: Number(row?.cnt ?? 0),
+      lastAt: row?.last_at ?? null,
+    };
+  } catch {
+    return { count: 0, lastAt: null };
+  }
+}
+
+/**
+ * Count commits ahead of origin/main for a git worktree.
+ *
+ * @param {string} worktreePath
+ * @returns {Promise<number>}
+ */
+async function defaultGitCommitsAhead(worktreePath) {
+  try {
+    const { stdout } = await execFileAsync(
+      'git',
+      ['-C', worktreePath, 'rev-list', 'origin/main..HEAD', '--count'],
+      { timeout: 5000 },
+    );
+    const n = parseInt(stdout.trim(), 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Check whether the branch has been pushed to origin.
+ *
+ * @param {string} worktreePath
+ * @param {string} branch
+ * @returns {Promise<boolean>}
+ */
+async function defaultGitIsPushed(worktreePath, branch) {
+  try {
+    await execFileAsync(
+      'git',
+      ['-C', worktreePath, 'rev-parse', '--quiet', '--verify', `origin/${branch}`],
+      { timeout: 5000 },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Compute the current progress state for a world.
+ *
+ * @param {string} worldId
+ * @param {{
+ *   worldsDbPath?: string,
+ *   prCache?: { getPr: (prUrl: string, getToken: () => Promise<string|null>) => Promise<{state:string|null,number:number|null,checks:string|null}|null> },
+ *   prStateStore?: { get: (worldId: string) => object|null },
+ *   getGhToken?: () => Promise<string|null>,
+ *   _readWorldRow?: (dbPath: string, worldId: string) => object|null,
+ *   _readThoughts?: (dbPath: string) => { count: number, lastAt: string|null },
+ *   _gitCommitsAhead?: (worktreePath: string) => Promise<number>,
+ *   _gitIsPushed?: (worktreePath: string, branch: string) => Promise<boolean>,
+ * }} [deps]
+ * @returns {Promise<object>}
+ */
+export async function computeProgress(worldId, deps = {}) {
+  const safe = makeSafeResponse(worldId);
+
+  try {
+    const {
+      worldsDbPath = process.env.OLAM_WORLDS_DB ?? path.join(homedir(), '.olam/worlds.db'),
+      prCache = null,
+      prStateStore = null,
+      getGhToken = async () => null,
+      _readWorldRow = defaultReadWorldRow,
+      _readThoughts = defaultReadThoughts,
+      _gitCommitsAhead = defaultGitCommitsAhead,
+      _gitIsPushed = defaultGitIsPushed,
+    } = deps;
+
+    // Read world row
+    const worldRow = _readWorldRow(worldsDbPath, worldId);
+    if (!worldRow) return safe;
+
+    const { branch, repos, workspacePath, createdAt } = worldRow;
+    const worktreePath = repos.length > 0 ? path.join(workspacePath, repos[0]) : workspacePath;
+
+    // Compute runtimeMs
+    const runtimeMs = createdAt ? Date.now() - new Date(createdAt).getTime() : 0;
+
+    // Read thoughts
+    const thoughtsDbPath = getWorldDbPath(workspacePath);
+    const { count: thoughts, lastAt: thoughtsLastAt } = _readThoughts(thoughtsDbPath);
+
+    // Git state
+    const [commitsAhead, pushed] = await Promise.all([
+      _gitCommitsAhead(worktreePath),
+      _gitIsPushed(worktreePath, branch),
+    ]);
+
+    // PR state — check prStateStore first
+    let prUrl = null;
+    let prNumber = null;
+    let prState = null;
+    let prChecks = null;
+
+    if (prStateStore) {
+      const prEntry = prStateStore.get(worldId);
+      if (prEntry) {
+        prUrl = prEntry.pr_url ?? null;
+        prNumber = prEntry.pr_number ?? null;
+        // Normalize merged_destroyed → merged
+        const rawState = prEntry.pr_state ?? null;
+        prState = rawState === 'merged_destroyed' ? 'merged' : (rawState === 'none' ? null : rawState);
+      }
+    }
+
+    // Live PR data from cache
+    if (prUrl && prCache) {
+      try {
+        const livePr = await prCache.getPr(prUrl, getGhToken);
+        if (livePr) {
+          prChecks = livePr.checks;
+          // Update state if live data shows merged
+          if (livePr.state === 'merged') prState = 'merged';
+          if (livePr.number != null) prNumber = livePr.number;
+        }
+      } catch {
+        // Non-fatal
+      }
+    }
+
+    // Determine phase
+    const phase = determinePhase({ thoughts, commitsAhead, pushed, prUrl, prChecks, prState });
+    const phaseEntry = PHASES.find((p) => p.name === phase) ?? PHASES[0];
+
+    // Idle overlay — only for implementing or committing phases
+    let isIdle = false;
+    if (phase === 'implementing' || phase === 'committing') {
+      if (thoughtsLastAt) {
+        const lastActivityMs = new Date(thoughtsLastAt).getTime();
+        if (!isNaN(lastActivityMs) && Date.now() - lastActivityMs > IDLE_THRESHOLD_MS) {
+          isIdle = true;
+        }
+      }
+    }
+
+    // Plan progress — additive; null when no tracker found
+    const lastActivityAtMs = thoughtsLastAt ? new Date(thoughtsLastAt).getTime() : null;
+    const plan = readPlanProgress(worktreePath, branch, { lastActivityAtMs });
+
+    return {
+      worldId,
+      phase,
+      phaseIndex: phaseEntry.index,
+      phaseTotal: PHASE_TOTAL,
+      isIdle,
+      thoughts,
+      lastActivityAt: thoughtsLastAt ?? null,
+      runtimeMs: Math.max(0, runtimeMs),
+      commitsAhead,
+      pushed,
+      prUrl,
+      prNumber,
+      prChecks,
+      prState,
+      plan,
+    };
+  } catch {
+    return safe;
+  }
+}

package/host-cp/src/world-tunnel-manager.mjs

@@ -0,0 +1,288 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+// Deployment-mode values injected by server.mjs via configure().
+// Defaults are bare-node-safe so the module is usable in tests without configure().
+let HOST_FOR_WORLD = process.env.OLAM_HOST_FOR_WORLD ?? '127.0.0.1';
+let TUNNELS_PATH =
+  process.env.OLAM_WORLD_TUNNELS_PATH ??
+  path.join(os.homedir(), '.olam', 'world-tunnels.json');
+
+/**
+ * Called by server.mjs immediately after it resolves HOST_FOR_WORLD and
+ * WORLD_TUNNELS_PATH from the deployment-mode branch. Avoids re-deriving
+ * container-specific literals (host.docker.internal, /data/…) in this module.
+ * Re-runs loadState() when tunnelsPath differs from the env-var default so
+ * container-mode persistence is loaded from /data/ rather than ~/.olam/.
+ */
+export function configure({ hostForWorld, tunnelsPath }) {
+  HOST_FOR_WORLD = hostForWorld;
+  if (tunnelsPath !== TUNNELS_PATH) {
+    TUNNELS_PATH = tunnelsPath;
+    loadState();
+  }
+}
+
+const TUNNEL_TIMEOUT_MS = 30_000;
+const PROBE_TIMEOUT_MS = 3_000;
+const URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+
+export const STATUS = {
+  IDLE: 'idle',
+  STARTING: 'starting',
+  RUNNING: 'running',
+  ERROR: 'error',
+  STALE: 'stale',
+};
+
+export class AlreadyStartingError extends Error {
+  constructor(worldId, serviceName) {
+    super(`tunnel for ${serviceName} in world ${worldId} is already starting`);
+    this.name = 'AlreadyStartingError';
+    this.worldId = worldId;
+    this.serviceName = serviceName;
+  }
+}
+
+export class TunnelTimeoutError extends Error {
+  constructor(worldId, serviceName) {
+    super(`tunnel for ${serviceName} in world ${worldId} timed out after 30s with no URL`);
+    this.name = 'TunnelTimeoutError';
+    this.worldId = worldId;
+    this.serviceName = serviceName;
+  }
+}
+
+// Key: `${worldId}:${serviceName}` → {worldId, serviceName, port, status, url, process?}
+const registry = new Map();
+
+function tunnelKey(worldId, serviceName) {
+  return `${worldId}:${serviceName}`;
+}
+
+function loadState() {
+  try {
+    if (!fs.existsSync(TUNNELS_PATH)) return;
+    const raw = fs.readFileSync(TUNNELS_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return;
+    for (const [key, entry] of Object.entries(data)) {
+      registry.set(key, { ...entry, process: null });
+    }
+  } catch (err) {
+    console.error(`world-tunnel-manager: loadState failed: ${err.message}`);
+  }
+}
+
+function saveState() {
+  try {
+    const dir = path.dirname(TUNNELS_PATH);
+    fs.mkdirSync(dir, { recursive: true });
+    const data = {};
+    for (const [key, entry] of registry) {
+      // eslint-disable-next-line no-unused-vars
+      const { process: _proc, ...rest } = entry;
+      data[key] = rest;
+    }
+    const tmp = `${TUNNELS_PATH}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, TUNNELS_PATH);
+  } catch (err) {
+    console.error(`world-tunnel-manager: saveState failed: ${err.message}`);
+  }
+}
+
+/**
+ * Start a cloudflared quick-tunnel for a world service.
+ * Resolves with the assigned trycloudflare.com URL.
+ * Rejects with AlreadyStartingError if the service is already starting/running.
+ * Rejects with TunnelTimeoutError if no URL is emitted within 30s.
+ *
+ * @param {string} worldId
+ * @param {string} serviceName
+ * @param {number} port  host-side port (i.e. the published port on this machine)
+ * @returns {Promise<string>} the public tunnel URL
+ */
+export async function startTunnel(worldId, serviceName, port) {
+  const key = tunnelKey(worldId, serviceName);
+  const existing = registry.get(key);
+  if (existing && (existing.status === STATUS.STARTING || existing.status === STATUS.RUNNING)) {
+    throw new AlreadyStartingError(worldId, serviceName);
+  }
+
+  const entry = {
+    worldId,
+    serviceName,
+    port,
+    status: STATUS.STARTING,
+    url: null,
+    process: null,
+  };
+  registry.set(key, entry);
+  saveState();
+
+  const target = `http://${HOST_FOR_WORLD}:${port}`;
+  const child = spawn('cloudflared', ['tunnel', '--url', target], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    detached: false,
+  });
+  entry.process = child;
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    function settle(resolvedUrl) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+
+      if (resolvedUrl) {
+        entry.status = STATUS.RUNNING;
+        entry.url = resolvedUrl;
+        saveState();
+        resolve(resolvedUrl);
+      } else {
+        entry.status = STATUS.ERROR;
+        entry.process = null;
+        saveState();
+        reject(new TunnelTimeoutError(worldId, serviceName));
+      }
+    }
+
+    const timer = setTimeout(() => settle(null), TUNNEL_TIMEOUT_MS);
+
+    function scanChunk(chunk) {
+      const lines = chunk.toString().split('\n');
+      for (const line of lines) {
+        const match = URL_PATTERN.exec(line);
+        if (match) { settle(match[0]); return; }
+      }
+    }
+
+    child.stdout.on('data', scanChunk);
+    child.stderr.on('data', scanChunk);
+
+    child.on('error', (err) => {
+      console.error(`world-tunnel-manager: cloudflared spawn error: ${err.message}`);
+      settle(null);
+    });
+
+    child.on('exit', (code) => {
+      if (!settled) {
+        console.error(`world-tunnel-manager: cloudflared exited (code ${code}) before URL`);
+        settle(null);
+      } else {
+        // Process died after URL was emitted (tunnel dropped)
+        entry.status = STATUS.ERROR;
+        entry.process = null;
+        saveState();
+      }
+    });
+  });
+}
+
+/**
+ * Stop a tunnel for a specific service. No-op if the service has no tunnel.
+ * @param {string} worldId
+ * @param {string} serviceName
+ */
+export function stopTunnel(worldId, serviceName) {
+  const key = tunnelKey(worldId, serviceName);
+  const entry = registry.get(key);
+  if (!entry) return;
+  if (entry.process) {
+    try { entry.process.kill('SIGTERM'); } catch { /* already dead */ }
+    entry.process = null;
+  }
+  entry.status = STATUS.IDLE;
+  entry.url = null;
+  saveState();
+}
+
+/**
+ * Return the current tunnel state for all services in a world.
+ * @param {string} worldId
+ * @returns {Array<{name: string, port: number, url: string|null, status: string}>}
+ */
+export function getWorldTunnels(worldId) {
+  const result = [];
+  for (const entry of registry.values()) {
+    if (entry.worldId === worldId) {
+      result.push({
+        name: entry.serviceName,
+        port: entry.port,
+        url: entry.url,
+        status: entry.status,
+      });
+    }
+  }
+  return result;
+}
+
+/**
+ * Kill all tunnels for a world. Called when a world is destroyed.
+ * Idempotent — no-op if world has no tunnels.
+ * @param {string} worldId
+ */
+export function killWorld(worldId) {
+  const toDelete = [];
+  for (const [key, entry] of registry) {
+    if (entry.worldId !== worldId) continue;
+    if (entry.process) {
+      try { entry.process.kill('SIGTERM'); } catch { /* already dead */ }
+      entry.process = null;
+    }
+    toDelete.push(key);
+  }
+  for (const key of toDelete) registry.delete(key);
+  if (toDelete.length > 0) saveState();
+}
+
+/**
+ * On startup, probe each persisted "running" tunnel. If the URL is unreachable,
+ * mark as stale so the UI can surface a Re-publish affordance.
+ */
+export async function probeAllOnStartup() {
+  const toProbe = [];
+  for (const [key, entry] of registry) {
+    if (entry.status === STATUS.RUNNING && entry.url) {
+      toProbe.push({ key, url: entry.url });
+    }
+  }
+
+  await Promise.all(
+    toProbe.map(async ({ key, url }) => {
+      try {
+        const res = await fetch(url, {
+          signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      } catch {
+        const entry = registry.get(key);
+        if (entry) {
+          entry.status = STATUS.STALE;
+          saveState();
+        }
+      }
+    }),
+  );
+}
+
+function killAll() {
+  for (const entry of registry.values()) {
+    if (entry.process) {
+      try { entry.process.kill('SIGTERM'); } catch { /* already dead */ }
+      entry.process = null;
+    }
+  }
+}
+
+process.on('SIGTERM', killAll);
+process.on('exit', killAll);
+
+// Initialise on module load using env-var or bare-node default path.
+// configure() re-runs loadState() when server.mjs provides a different path
+// (container mode: /data/world-tunnels.json vs the ~/.olam default above).
+loadState();