@dmsdc-ai/aigentry-telepty 0.4.3 → 0.4.5

package/src/bridge/supervisor-launcher.js

@@ -0,0 +1,193 @@
+'use strict';
+
+// Per-session supervisor process lifecycle. Spawns `telepty-supervisor-bin`
+// (single-binary `telepty supervisor` mode is post-P2 per dispatch §6.6 A),
+// waits for manifest.json to reach Status::Ready, and offers a liveness
+// probe.
+//
+// Binary discovery order (dispatch §Phase-1 plan):
+//   1. TELEPTY_SUPERVISOR_BIN env (absolute path)
+//   2. ./target/{release,debug}/telepty-supervisor-bin relative to repo root
+//   3. PATH lookup via which/where
+//
+// Stdlib only — child_process + fs (Constitution §17).
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn: childSpawn, spawnSync } = require('node:child_process');
+
+const { manifestPath, socketPath } = require('./j3-shim');
+
+const DEFAULT_READY_TIMEOUT_MS = 3000;
+const DEFAULT_READY_POLL_MS = 50;
+const READY_STATUSES = new Set(['ready', 'draining']);
+const BIN_NAME = 'telepty-supervisor-bin';
+
+class SupervisorLauncherError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = 'SupervisorLauncherError';
+  }
+}
+
+function whichSync(name) {
+  try {
+    const cmd = process.platform === 'win32' ? 'where' : 'which';
+    const res = spawnSync(cmd, [name], { encoding: 'utf8' });
+    if (res.status === 0) {
+      const line = res.stdout.trim().split(/\r?\n/)[0];
+      return line || null;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Resolve the supervisor binary path. Throws ERR_BIN_NOT_FOUND when no
+ * candidate is found.
+ * @param {{env?: NodeJS.ProcessEnv}} [options]
+ * @returns {string}
+ */
+function resolveBinary({ env = process.env } = {}) {
+  if (env.TELEPTY_SUPERVISOR_BIN) {
+    if (fs.existsSync(env.TELEPTY_SUPERVISOR_BIN)) {
+      return env.TELEPTY_SUPERVISOR_BIN;
+    }
+    throw new SupervisorLauncherError(
+      'ERR_BIN_NOT_FOUND',
+      `TELEPTY_SUPERVISOR_BIN points at '${env.TELEPTY_SUPERVISOR_BIN}' but the file does not exist`,
+    );
+  }
+  // Repo-relative (src/bridge → repo root → target/{release,debug})
+  const repoRoot = path.resolve(__dirname, '..', '..');
+  const candidates = [
+    path.join(repoRoot, 'target', 'release', BIN_NAME),
+    path.join(repoRoot, 'target', 'debug', BIN_NAME),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  const onPath = whichSync(BIN_NAME);
+  if (onPath) return onPath;
+  throw new SupervisorLauncherError(
+    'ERR_BIN_NOT_FOUND',
+    `${BIN_NAME} not found. Set TELEPTY_SUPERVISOR_BIN, build via 'cargo build -p telepty-supervisor-bin', or install on PATH.`,
+  );
+}
+
+/**
+ * Spawn a supervisor for a session. Returns a handle exposing the child
+ * process and manifest/socket paths. Caller is responsible for invoking
+ * `waitReady(sid)` before issuing bridge operations and for cleaning up the
+ * child on shutdown.
+ *
+ * stdio defaults to `['ignore', 'ignore', 'pipe']` — the supervisor mirrors
+ * PTY output to its own stdout for M1/M2 smoke parity, which would mix with
+ * the parent's stdout if inherited. Stderr (tracing) is piped so callers can
+ * surface ready/error logs if needed.
+ *
+ * @param {{sid: string, argv: string[], cwd?: ?string, binary?: ?string, env?: NodeJS.ProcessEnv, stdio?: Array}} opts
+ */
+function spawn(opts) {
+  const {
+    sid,
+    argv,
+    cwd = null,
+    binary = null,
+    env = process.env,
+    stdio = ['ignore', 'ignore', 'pipe'],
+  } = opts || {};
+
+  if (typeof sid !== 'string' || sid.length === 0) {
+    throw new SupervisorLauncherError('ERR_BAD_ARG', 'sid required');
+  }
+  if (!Array.isArray(argv) || argv.length === 0) {
+    throw new SupervisorLauncherError('ERR_BAD_ARG', 'argv must be a non-empty array');
+  }
+
+  const bin = binary || resolveBinary({ env });
+  const args = ['--sid', sid];
+  if (cwd) args.push('--cwd', cwd);
+  args.push('--', ...argv);
+
+  const child = childSpawn(bin, args, { stdio, env, detached: false });
+
+  return {
+    child,
+    pid: child.pid,
+    sid,
+    binary: bin,
+    manifestPath: manifestPath(sid),
+    socketPath: socketPath(sid),
+  };
+}
+
+/**
+ * Poll the per-session manifest until it reaches a ready status. Resolves
+ * with the manifest object; rejects with ERR_READY_TIMEOUT on deadline.
+ *
+ * Uses TELEPTY_SESSIONS_DIR / HOME (via j3-shim's lazy resolution) so tests
+ * can redirect the sessions root deterministically.
+ *
+ * @param {string} sid
+ * @param {{timeoutMs?: number, pollMs?: number}} [options]
+ * @returns {Promise<object>}
+ */
+async function waitReady(sid, { timeoutMs = DEFAULT_READY_TIMEOUT_MS, pollMs = DEFAULT_READY_POLL_MS } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const mp = manifestPath(sid);
+  while (Date.now() < deadline) {
+    try {
+      const raw = fs.readFileSync(mp, 'utf8');
+      const m = JSON.parse(raw);
+      // supervisor.rs writes the manifest with Status::Ready *before* it calls
+      // ipc::bind_socket; gate on both so callers can immediately connect.
+      if (m && m.id === sid && READY_STATUSES.has(m.status) && fs.existsSync(m.ipc.path)) {
+        return m;
+      }
+    } catch {
+      // ENOENT / mid-write race — keep polling.
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  throw new SupervisorLauncherError(
+    'ERR_READY_TIMEOUT',
+    `supervisor for '${sid}' did not become ready within ${timeoutMs}ms`,
+  );
+}
+
+/**
+ * Best-effort liveness probe — manifest present with ready/draining status
+ * AND the recorded pid is alive. Used by callers to decide bridge vs daemon
+ * fallback.
+ * @param {string} sid
+ * @returns {boolean}
+ */
+function isAlive(sid) {
+  try {
+    const raw = fs.readFileSync(manifestPath(sid), 'utf8');
+    const m = JSON.parse(raw);
+    if (!m || m.id !== sid) return false;
+    if (!READY_STATUSES.has(m.status)) return false;
+    if (typeof m.pid !== 'number' || m.pid <= 0) return false;
+    try {
+      process.kill(m.pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  resolveBinary,
+  spawn,
+  waitReady,
+  isAlive,
+  whichSync,
+  SupervisorLauncherError,
+  BIN_NAME,
+};

package/src/config-file.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const { parseDuration } = require('./lifecycle');
+
+function configDir(options = {}) {
+  return options.configDir || path.join(os.homedir(), '.telepty');
+}
+
+function candidateConfigPaths(options = {}) {
+  const dir = configDir(options);
+  return [
+    path.join(dir, 'config.json'),
+    path.join(dir, 'config.yaml'),
+    path.join(dir, 'config.yml')
+  ];
+}
+
+function parseScalar(value) {
+  const trimmed = String(value || '').trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function parseSimpleYaml(raw, filePath) {
+  const result = {};
+  const lines = String(raw || '').split(/\r?\n/);
+  for (const [index, line] of lines.entries()) {
+    const withoutComment = line.replace(/\s+#.*$/, '').trim();
+    if (!withoutComment) continue;
+    const match = withoutComment.match(/^([A-Za-z0-9_]+)\s*:\s*(.*?)\s*$/);
+    if (!match) {
+      throw new Error(`Invalid config syntax in ${filePath}:${index + 1}`);
+    }
+    result[match[1]] = parseScalar(match[2]);
+  }
+  return result;
+}
+
+function parseConfigContent(raw, filePath) {
+  if (filePath.endsWith('.json')) {
+    return JSON.parse(raw);
+  }
+  return parseSimpleYaml(raw, filePath);
+}
+
+function normalizeConfig(parsed, filePath) {
+  const input = parsed && typeof parsed === 'object' ? parsed : {};
+  const idleTtlRaw = Object.prototype.hasOwnProperty.call(input, 'idle_ttl_default')
+    ? input.idle_ttl_default
+    : 'off';
+  const idleTtlDefaultMs = parseDuration(idleTtlRaw, { fieldName: 'idle_ttl_default' });
+
+  return {
+    path: filePath || null,
+    idle_ttl_default: idleTtlRaw == null ? 'off' : String(idleTtlRaw),
+    idleTtlDefaultMs
+  };
+}
+
+function loadTeleptyConfig(options = {}) {
+  const paths = options.paths || candidateConfigPaths(options);
+  for (const filePath of paths) {
+    if (!fs.existsSync(filePath)) continue;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = parseConfigContent(raw, filePath);
+    return normalizeConfig(parsed, filePath);
+  }
+  return normalizeConfig({ idle_ttl_default: 'off' }, null);
+}
+
+module.exports = {
+  candidateConfigPaths,
+  parseSimpleYaml,
+  parseConfigContent,
+  normalizeConfig,
+  loadTeleptyConfig
+};

package/src/lifecycle.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const { killWindowsProcess } = require('./win-kill-process');
+
+const DURATION_RE = /^(\d+)(ms|s|m|h|d)$/i;
+const UNIT_MS = {
+  ms: 1,
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000
+};
+
+function parseDuration(value, options = {}) {
+  const fieldName = options.fieldName || 'duration';
+  if (value == null || value === '') {
+    throw new Error(`${fieldName} is required`);
+  }
+
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new Error(`${fieldName} must be a non-negative duration`);
+    }
+    return Math.floor(value);
+  }
+
+  const raw = String(value).trim().toLowerCase();
+  if (raw === 'off') {
+    return null;
+  }
+
+  const match = raw.match(DURATION_RE);
+  if (!match) {
+    throw new Error(`${fieldName} must be a duration like 30m, 1h, 2d, or off`);
+  }
+
+  const amount = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  if (!Number.isSafeInteger(amount)) {
+    throw new Error(`${fieldName} is too large`);
+  }
+  return amount * UNIT_MS[unit];
+}
+
+function computeIdleSeconds(lastActivityAt, nowMs = Date.now()) {
+  if (!lastActivityAt) return null;
+  const ts = new Date(lastActivityAt).getTime();
+  if (!Number.isFinite(ts)) return null;
+  return Math.max(0, Math.floor((nowMs - ts) / 1000));
+}
+
+function formatIdleDuration(seconds) {
+  const totalMinutes = Math.max(0, Math.floor(Number(seconds || 0) / 60));
+  const days = Math.floor(totalMinutes / (24 * 60));
+  const hours = Math.floor((totalMinutes % (24 * 60)) / 60);
+  const minutes = totalMinutes % 60;
+
+  if (days > 0) return `${days}d ${hours}h`;
+  if (hours > 0) return `${hours}h ${minutes}m`;
+  return `${minutes}m`;
+}
+
+function getSessionPid(session) {
+  if (!session) return null;
+  const candidates = [
+    session.ptyProcess && session.ptyProcess.pid,
+    session.ptyPid,
+    session.pty_pid,
+    session.pid,
+    session.ownerPid,
+    session.owner_pid
+  ];
+  for (const pid of candidates) {
+    if (Number.isInteger(pid) && pid > 0) return pid;
+  }
+  return null;
+}
+
+function isProcessAlive(pid, processKill = process.kill) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    processKill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err && err.code === 'EPERM') return true;
+    return false;
+  }
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function sendSignal(pid, signal, options = {}) {
+  const platform = options.platform || process.platform;
+  if (platform === 'win32') {
+    if (signal === 'SIGKILL' || signal === 'SIGTERM') {
+      return (options.killWindowsProcess || killWindowsProcess)(pid, options.windows || {});
+    }
+    return false;
+  }
+
+  const processKill = options.processKill || process.kill;
+  try {
+    processKill(pid, signal);
+    return true;
+  } catch (err) {
+    if (err && err.code === 'ESRCH') return false;
+    throw err;
+  }
+}
+
+async function killSessionProcess(session, options = {}) {
+  const pid = options.pid || getSessionPid(session);
+  const timeoutMs = Math.max(0, Math.floor(options.timeoutMs ?? 5000));
+  const force = options.force === true;
+  const sleep = options.sleep || defaultSleep;
+  const processKill = options.processKill || process.kill;
+  const platform = options.platform || process.platform;
+
+  if (!pid) {
+    return { pid: null, signaled: false, escalated: false, reason: 'NO_PROCESS' };
+  }
+
+  if (force) {
+    const killed = sendSignal(pid, 'SIGKILL', { ...options, platform, processKill });
+    return { pid, signaled: killed, signal: 'SIGKILL', escalated: false, reason: killed ? null : 'NOT_RUNNING' };
+  }
+
+  const terminated = sendSignal(pid, 'SIGTERM', { ...options, platform, processKill });
+  if (!terminated) {
+    return { pid, signaled: false, signal: 'SIGTERM', escalated: false, reason: 'NOT_RUNNING' };
+  }
+
+  if (timeoutMs > 0) {
+    await sleep(timeoutMs);
+  }
+
+  const alive = options.isAlive ? options.isAlive(pid) : isProcessAlive(pid, processKill);
+  if (!alive) {
+    return { pid, signaled: true, signal: 'SIGTERM', escalated: false, reason: null };
+  }
+
+  const killed = sendSignal(pid, 'SIGKILL', { ...options, platform, processKill });
+  return { pid, signaled: true, signal: 'SIGTERM', escalated: killed, escalatedSignal: killed ? 'SIGKILL' : null, reason: killed ? null : 'ESCALATION_FAILED' };
+}
+
+function cleanupSessionArtifacts(sessionId, options = {}) {
+  const sessionsRoot = options.sessionsRoot || process.env.TELEPTY_SESSIONS_DIR || path.join(os.homedir(), '.telepty', 'sessions');
+  const sessionDir = path.join(sessionsRoot, sessionId);
+  const removed = [];
+  for (const filename of ['supervisor.sock', 'session.sock']) {
+    const filePath = path.join(sessionDir, filename);
+    try {
+      fs.rmSync(filePath, { force: true });
+      removed.push(filePath);
+    } catch {}
+  }
+  return removed;
+}
+
+function effectiveIdleTtlMs(session, config = {}) {
+  if (session && Object.prototype.hasOwnProperty.call(session, 'idleTtlMs')) {
+    return session.idleTtlMs == null ? null : Number(session.idleTtlMs);
+  }
+  if (session && Object.prototype.hasOwnProperty.call(session, 'idle_ttl_ms')) {
+    return session.idle_ttl_ms == null ? null : Number(session.idle_ttl_ms);
+  }
+  return config.idleTtlDefaultMs == null ? null : Number(config.idleTtlDefaultMs);
+}
+
+function selectIdleTtlVictims(sessions, config = {}, options = {}) {
+  const nowMs = options.nowMs ?? Date.now();
+  const entries = sessions instanceof Map ? Array.from(sessions.entries()) : Object.entries(sessions || {});
+  const victims = [];
+
+  for (const [id, session] of entries) {
+    const ttlMs = effectiveIdleTtlMs(session, config);
+    if (!Number.isFinite(ttlMs) || ttlMs < 0) continue;
+    const idleSeconds = computeIdleSeconds(session && session.lastActivityAt, nowMs);
+    if (idleSeconds == null) continue;
+    const idleMs = idleSeconds * 1000;
+    if (idleMs > ttlMs) {
+      victims.push({ id, session, idleMs, idleSeconds, ttlMs });
+    }
+  }
+
+  return victims;
+}
+
+function selectCleanOlderThanTargets(sessions, options = {}) {
+  const olderThanMs = options.olderThanMs;
+  if (!Number.isFinite(olderThanMs) || olderThanMs < 0) {
+    throw new Error('olderThanMs must be a non-negative duration');
+  }
+
+  const nowMs = options.nowMs ?? Date.now();
+  const useIdle = options.idle === true;
+  const entries = Array.isArray(sessions) ? sessions.map((s) => [s.id, s]) : Object.entries(sessions || {});
+  const targets = [];
+
+  for (const [id, session] of entries) {
+    const timestamp = useIdle ? session.lastActivityAt : session.createdAt;
+    if (!timestamp) continue;
+    const ts = new Date(timestamp).getTime();
+    if (!Number.isFinite(ts)) continue;
+    const ageMs = Math.max(0, nowMs - ts);
+    if (ageMs > olderThanMs) {
+      targets.push({
+        id,
+        session,
+        reference: useIdle ? 'lastActivityAt' : 'createdAt',
+        ageMs,
+        ageSeconds: Math.floor(ageMs / 1000)
+      });
+    }
+  }
+
+  return targets;
+}
+
+module.exports = {
+  parseDuration,
+  computeIdleSeconds,
+  formatIdleDuration,
+  getSessionPid,
+  isProcessAlive,
+  killSessionProcess,
+  cleanupSessionArtifacts,
+  effectiveIdleTtlMs,
+  selectIdleTtlVictims,
+  selectCleanOlderThanTargets
+};

package/src/prompt-symbol-registry.js

@@ -33,19 +33,49 @@ const ENTRIES = {
       return { found: false };
     },
   },
-  // codex renders idle as " › <placeholder>" (column 2). Status footer
-  // ("gpt-5.5 …" or "gpt-5 …") sits 1–2 lines below.
+  // #472 (0.4.5): codex previously matched on a strict line-leading "^ › "
+  // shape; on real cmux captures the '›' tail-renders on the same row as the
+  // model-status footer and DECRQM/cursor-pos fragments leak in, so that
+  // strict matcher misses. Multi-signal tolerant matcher: picker anti-pattern
+  // first (resume-picker UI must NOT be considered ready), then a tolerant
+  // (a + b) signal pair, then the legacy strict scan as a back-compat
+  // fallback. Reason field surfaces which signal fired for log-attribution.
   codex: {
     symbol: '›',
     byteSeq: Buffer.from([0xE2, 0x80, 0xBA]),
     detect(screen) {
-      const lines = String(screen == null ? '' : screen).split('\n');
+      const text = String(screen == null ? '' : screen);
+
+      // Step 1: modal-UI anti-pattern. Resume picker, first-run directory
+      // trust prompt, and generic "Press enter to continue" modals are all
+      // pre-prompt UIs where Enter would not submit a user message. Treat
+      // any of them as NOT ready.
+      if (
+        /Resume a previous session/.test(text) ||
+        /^Filter:/m.test(text) ||
+        /Do you trust the contents/i.test(text) ||
+        /Press enter to continue/i.test(text)
+      ) {
+        return { found: false, reason: 'codex_modal_ui' };
+      }
+
+      // Step 2: multi-signal tolerant. The codex boot box contains
+      // "OpenAI Codex (v<version>)" and the status row contains
+      // "gpt-<ver> <profile> fast". Both present anywhere on the captured
+      // screen → ready, regardless of where the literal '›' rendered.
+      if (/OpenAI Codex \(v/.test(text) && /gpt-[0-9.]+\s+\w+\s+fast/.test(text)) {
+        return { found: true, reason: 'codex_multi_signal' };
+      }
+
+      // Step 3: legacy strict line-leading scan — preserved for back-compat
+      // on clean cmux captures where the original matcher already worked.
+      const lines = text.split('\n');
       for (let i = lines.length - 1; i >= 0; i--) {
         const line = lines[i];
         if (!/^ › /.test(line)) continue;
         const footer = (lines[i + 1] || '') + '\n' + (lines[i + 2] || '');
         if (/gpt-\d/.test(footer)) {
-          return { found: true, line_index: i, col: 2 };
+          return { found: true, line_index: i, col: 2, reason: 'codex_strict_line' };
         }
       }
       return { found: false };

package/src/submit-gate.js

@@ -227,7 +227,13 @@ async function awaitPromptSymbol(session, opts = {}) {
         if (lastSeenAt === null) {
           lastSeenAt = now();
         } else if (now() - lastSeenAt >= stabilityMs) {
-          return { ready: true, last_seen_at: lastSeenAt, waited_ms: now() - start };
+          // #472 (0.4.5): tag the success reason for debuggability — pairs
+          // with daemon.js startup-restore optimistic-ready logging so we
+          // can attribute every bootstrap_ready flip to a concrete signal.
+          if (match.reason && typeof console !== 'undefined' && console.log) {
+            console.log(`[bootstrap] ${session.command} ready via: ${match.reason}`);
+          }
+          return { ready: true, last_seen_at: lastSeenAt, waited_ms: now() - start, reason: match.reason };
         }
       } else {
         // symbol disappeared — reset the stability streak