runlist 0.0.0 → 0.94.2

package/src/install.mjs

@@ -0,0 +1,222 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { bold, dim, green, yellow } from './color.mjs';
+import {
+  CLAUDE_MARKETPLACE, CLAUDE_PLUGIN_ID, claudeMarketplaceRefusalHint, installOpencodePlugin, opencodeDetected,
+  opencodeStatus, planClaudeInstall, removeOpencodePlugin,
+} from './host-integration.mjs';
+import { LEGACY_PLUGIN_ID, readInstalledPlugin, readInstalledPluginRecords } from './update.mjs';
+import { executableName, which } from './util.mjs';
+import { codexStatus, installCodexPlugin } from './codex-integration.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+
+const HOSTS = ['claude', 'codex', 'opencode'];
+const ALIASES = { 'claude-code': 'claude', claudecode: 'claude' };
+
+function flagValue(argv, name) {
+  const i = argv.indexOf(name);
+  return i >= 0 ? argv[i + 1] : undefined;
+}
+
+function hostStates() {
+  const plugin = readInstalledPlugin();
+  return {
+    claude: {
+      installed: Boolean(plugin),
+      version: plugin?.version ?? null,
+      id: plugin?.id ?? CLAUDE_PLUGIN_ID,
+      marketplace: plugin?.marketplace ?? null,
+      // false = record present, marketplace gone: Claude shows "failed to load".
+      marketplaceRegistered: plugin ? plugin.marketplaceRegistered : null,
+    },
+    opencode: { ...opencodeStatus({ version: pkg.version }), detected: opencodeDetected() },
+    codex: codexStatus({ version: pkg.version }),
+  };
+}
+
+function reportStatus(json) {
+  const states = hostStates();
+  if (json) {
+    process.stdout.write(JSON.stringify({ cli: pkg.version, hosts: states }, null, 2) + '\n');
+    return;
+  }
+  const { claude, codex, opencode } = states;
+  process.stdout.write(`${bold('runlist host integrations')}  ${dim(`CLI ${pkg.version}`)}\n\n`);
+
+  const claudeBroken = claude.installed && claude.marketplaceRegistered === false;
+  const claudeState = !claude.installed ? yellow('not installed')
+    : claudeBroken ? yellow(`${claude.version ?? 'installed'} — marketplace "${claude.marketplace}" not registered, plugin fails to load`)
+    : green(claude.version ?? 'installed');
+  process.stdout.write(`  claude    ${claudeState}\n`);
+  process.stdout.write(`            ${dim(claude.installed ? claude.id : 'plugin: SessionStart primer, PreToolUse guard, workflow skill')}\n`);
+
+  const codexState = codex.foreign ? yellow('unmanaged directory present')
+    : !codex.exists ? yellow('not installed')
+    : codex.stale ? yellow(`${codex.version} — behind CLI ${pkg.version}`)
+    : green(codex.version);
+  process.stdout.write(`  codex     ${codexState}\n`);
+  process.stdout.write(`            ${dim(codex.plugin)}\n`);
+
+  const ocState = opencode.foreign ? yellow('unmanaged file present')
+    : !opencode.exists ? yellow('not installed')
+    : opencode.stale ? yellow(`${opencode.version} — behind CLI ${pkg.version}`)
+    : green(opencode.version);
+  process.stdout.write(`  opencode  ${ocState}\n`);
+  process.stdout.write(`            ${dim(opencode.path)}\n`);
+
+  const todo = [];
+  if (!claude.installed || claudeBroken) todo.push('runlist install claude');
+  if (!codex.exists || codex.stale) todo.push('runlist install codex');
+  if (!opencode.exists || opencode.stale) todo.push('runlist install opencode');
+  if (todo.length) {
+    process.stdout.write('\n');
+    for (const cmd of todo) process.stdout.write(`Run ${bold(cmd)}\n`);
+  }
+  if (!opencode.exists) {
+    process.stdout.write(dim('\nWithout the OpenCode integration, every session in one OpenCode process\n'));
+    process.stdout.write(dim('shares one identity — so a session can release another session\'s plan —\n'));
+    process.stdout.write(dim('and no session-start primer runs.\n'));
+  }
+}
+
+function installCodex(argv, dryRun, json) {
+  if (argv.includes('--remove')) {
+    process.stderr.write('Codex removal is managed by `codex plugin remove`; the personal marketplace source is left available.\n');
+    process.exitCode = 1;
+    return;
+  }
+  const result = installCodexPlugin({ version: pkg.version, dryRun });
+  if (result.action === 'refused') {
+    if (json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    else process.stderr.write(`refused: ${result.reason}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!json) process.stdout.write(`${dryRun ? '[dry-run] ' : ''}${result.action} codex integration (${pkg.version}) at ${result.plugin}\n`);
+  if (dryRun) {
+    if (json) process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    return;
+  }
+  const selector = `runlist-codex@${result.marketplaceName}`;
+  if (!which('codex')) {
+    if (json) process.stdout.write(JSON.stringify({ ...result, pluginAdd: 'codex-cli-unavailable' }, null, 2) + '\n');
+    else process.stdout.write(`Install in Codex with: codex plugin add ${selector}\n`);
+    return;
+  }
+  const added = spawnSync(executableName('codex'), ['plugin', 'add', selector], {
+    stdio: json ? 'pipe' : 'inherit', encoding: json ? 'utf8' : undefined,
+    shell: process.platform === 'win32',
+  });
+  if (json) process.stdout.write(JSON.stringify({ ...result, pluginAdd: added.status === 0 ? 'installed' : 'failed', pluginAddExit: added.status }, null, 2) + '\n');
+  if (added.status !== 0) {
+    process.stderr.write(`Codex plugin source is ready; finish installation with: codex plugin add ${selector}\n`);
+    process.exitCode = 1;
+  } else if (!json) {
+    process.stdout.write('Start a new Codex thread and review/trust the plugin hooks to enable the primer and guard.\n');
+  }
+}
+
+function installClaude(argv, dryRun, json) {
+  const remove = argv.includes('--remove');
+  const steps = planClaudeInstall({ installed: readInstalledPlugin(), legacyInstalled: readInstalledPluginRecords({ id: LEGACY_PLUGIN_ID }), hasClaude: which('claude'), remove });
+  if (json) {
+    process.stdout.write(JSON.stringify({ host: 'claude', dryRun, steps }, null, 2) + '\n');
+    return;
+  }
+  let ran = false;
+  for (const step of steps) {
+    if (step.kind === 'skip') { process.stdout.write(`${dim('skip:')} ${step.reason}\n`); continue; }
+    if (step.kind === 'refusal') {
+      process.stdout.write(yellow(`${step.reason}\n`));
+      if (!dryRun) process.exitCode = 1;
+      continue;
+    }
+    if (step.kind === 'manual') {
+      process.stdout.write(`${yellow(step.reason ?? 'claude CLI not on PATH')} — run these from a Claude Code session:\n`);
+      for (const line of step.lines) process.stdout.write(`  ${bold(line)}\n`);
+      continue;
+    }
+    if (step.reason) process.stdout.write(`${step.reason}\n`);
+    if (dryRun) { process.stdout.write(dim(`[dry-run] Would run: ${step.cmd.join(' ')}${step.cwd ? ` (in ${step.cwd})` : ''}\n`)); continue; }
+    process.stdout.write(dim(`$ ${step.cmd.join(' ')}${step.cwd ? ` (in ${step.cwd})` : ''}\n`));
+    const result = spawnSync(executableName(step.cmd[0]), step.cmd.slice(1), {
+      stdio: 'inherit', shell: process.platform === 'win32',
+      ...(step.cwd ? { cwd: step.cwd } : {}),
+    });
+    ran = true;
+    if (result.status !== 0) {
+      process.stdout.write(yellow(`(claude exited ${result.status ?? '?'})\n`));
+      // Each later step here depends on this one (the plugin resolves through
+      // the marketplace), so unlike `update` there is nothing independent left.
+      if (step.step === 'marketplace' || step.cmd.includes('marketplace')) {
+        for (const line of claudeMarketplaceRefusalHint(readInstalledPlugin()?.marketplace)) process.stdout.write(yellow(`${line}\n`));
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
+  if (ran && !remove && !process.exitCode) process.stdout.write(green('\n✓ restart Claude Code (or /reload-plugins) to apply.\n'));
+}
+
+function installOpencode(argv, dryRun, json) {
+  const force = argv.includes('--force');
+  const dir = flagValue(argv, '--path');
+  const result = argv.includes('--remove')
+    ? removeOpencodePlugin({ dryRun, force, dir })
+    : installOpencodePlugin({ version: pkg.version, dryRun, force, dir });
+
+  if (json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    if (result.action === 'refused') process.exitCode = 1;
+    return result;
+  }
+
+  const prefix = dryRun ? dim('[dry-run] ') : '';
+  switch (result.action) {
+    case 'refused':
+      process.stderr.write(`${result.path}\n  refused: ${result.reason}\n  Pass --force to overwrite it.\n`);
+      process.exitCode = 1;
+      return result;
+    case 'current':
+      process.stdout.write(`${green('✓')} opencode integration already current (${result.version})\n${dim(result.path)}\n`);
+      return result;
+    case 'absent':
+      process.stdout.write(`${dim('nothing to remove:')} ${result.path}\n`);
+      return result;
+    case 'removed':
+      process.stdout.write(`${prefix}removed ${result.path}\n`);
+      process.stdout.write(dim('Restart OpenCode to apply. Sessions fall back to a process-scoped identity.\n'));
+      return result;
+    default:
+      process.stdout.write(`${prefix}${green('✓')} ${result.action} opencode integration (${pkg.version})\n${dim(result.path)}\n`);
+      if (dryRun) return result;
+      process.stdout.write('\nRestart OpenCode to apply. New sessions then get:\n');
+      process.stdout.write(`  ${dim('·')} a per-session ownership identity (one session can no longer release another's plan)\n`);
+      process.stdout.write(`  ${dim('·')} the ${bold('runlist hud')} primer at session start, like Claude Code's SessionStart hook\n`);
+      process.stdout.write(dim('\nPlans already in-session were claimed under the old process-scoped identity;\n'));
+      process.stdout.write(dim('close them before restarting, or reclaim with --force afterwards.\n'));
+      return result;
+  }
+}
+
+export function runInstall(argv, _config, opts = {}) {
+  const json = argv.includes('--json');
+  const requested = argv.find(a => !a.startsWith('-'));
+
+  if (!requested) { reportStatus(json); return; }
+  const host = ALIASES[requested] ?? requested;
+  if (!HOSTS.includes(host)) {
+    process.stderr.write(`Unknown host "${requested}". Known: ${HOSTS.join(', ')}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const dryRun = Boolean(opts.dryRun);
+  if (host === 'claude') { installClaude(argv, dryRun, json); return; }
+  if (host === 'codex') { installCodex(argv, dryRun, json); return; }
+  installOpencode(argv, dryRun, json);
+}

package/src/journal-read.mjs

@@ -0,0 +1,116 @@
+import { existsSync } from 'node:fs';
+import {
+  readJournalEntries,
+  journalFilePath,
+  isJournalEnabled,
+} from './journal.mjs';
+import { dim, green, red } from './color.mjs';
+
+function parseArgs(argv) {
+  const opts = { tail: null, errorsOnly: false, sessionFilter: null, since: null, byCommand: false, helpTopics: false, asJson: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--tail') {
+      const n = parseInt(argv[++i], 10);
+      opts.tail = Number.isFinite(n) && n > 0 ? n : 20;
+    } else if (a === '--errors') opts.errorsOnly = true;
+    else if (a === '--session' && argv[i + 1]) opts.sessionFilter = argv[++i];
+    else if (a === '--since' && argv[i + 1]) opts.since = argv[++i];
+    else if (a === '--by-command') opts.byCommand = true;
+    else if (a === '--help-topics') opts.helpTopics = true;
+    else if (a === '--json') opts.asJson = true;
+  }
+  // Default to last 20 when no view flag is given.
+  if (opts.tail === null && !opts.errorsOnly && !opts.sessionFilter
+      && !opts.since && !opts.byCommand && !opts.helpTopics) {
+    opts.tail = 20;
+  }
+  return opts;
+}
+
+export function runJournal(argv, config) {
+  const file = journalFilePath(config);
+  const retained = readJournalEntries(config);
+  if (!retained.length && !existsSync(file)) {
+    if (!isJournalEnabled(config)) {
+      process.stderr.write(
+        'Journal is opt-in. Enable with `RUNLIST_JOURNAL=1` (env) or `journal: true` (in runlist.config.mjs).\n',
+      );
+      return;
+    }
+    process.stderr.write(`No journal entries yet at ${file}.\n`);
+    return;
+  }
+
+  const opts = parseArgs(argv);
+  let entries = retained;
+  if (opts.errorsOnly) entries = entries.filter(e => e.exit !== 0);
+  if (opts.sessionFilter) entries = entries.filter(e => e.sid === opts.sessionFilter);
+  if (opts.since) entries = entries.filter(e => typeof e.ts === 'string' && e.ts >= opts.since);
+
+  if (opts.helpTopics) {
+    if (opts.tail) entries = entries.slice(-opts.tail);
+    const help = entries.filter(e => e.helpTopic);
+    const topics = [...new Set(help.map(e => e.helpTopic))].sort().map(topic => {
+      const rows = help.filter(e => e.helpTopic === topic);
+      return { topic, total: rows.length, sessions: new Set(rows.map(e => e.sid).filter(Boolean)).size, errors: rows.filter(e => e.exit !== 0).length };
+    });
+    const summary = {
+      totalInvocations: entries.length,
+      observedInvocations: entries.filter(e => e.outcome != null).length,
+      legacyInvocations: entries.filter(e => e.outcome == null).length,
+      helpInvocations: help.length,
+      sessions: new Set(entries.map(e => e.sid).filter(Boolean)).size,
+      versions: [...new Set(entries.map(e => e.v).filter(Boolean))].sort(),
+      first: entries[0]?.ts ?? null, last: entries.at(-1)?.ts ?? null,
+      coverage: 'Retained opt-in invocations; passive context, HUD, and dry runs are excluded. Legacy entries may predate help capture.',
+      topics,
+    };
+    if (opts.asJson) process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
+    else {
+      process.stdout.write(`${summary.helpInvocations} help calls / ${summary.totalInvocations} retained invocations; ${summary.sessions} sessions.\n${summary.coverage}\n`);
+      for (const row of topics) process.stdout.write(`${row.topic.padEnd(20)} ${row.total} help calls, ${row.sessions} sessions, ${row.errors} errors\n`);
+    }
+    return;
+  }
+
+  if (opts.byCommand) {
+    const groups = new Map();
+    for (const e of entries) {
+      const cmd = (e.argv && e.argv[0]) || '(none)';
+      if (!groups.has(cmd)) groups.set(cmd, []);
+      groups.get(cmd).push(e);
+    }
+    const rows = [...groups.entries()].map(([cmd, list]) => {
+      const total = list.length;
+      const errors = list.filter(e => e.exit !== 0).length;
+      const times = list.map(e => e.ms ?? 0).sort((a, b) => a - b);
+      const median = times.length ? times[Math.floor(times.length / 2)] : 0;
+      return { cmd, total, errors, median };
+    }).sort((a, b) => b.total - a.total);
+
+    if (opts.asJson) {
+      process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+      return;
+    }
+    for (const r of rows) {
+      const errPart = r.errors > 0 ? ` ${red(`${r.errors} err`)}` : '';
+      process.stdout.write(`${r.cmd.padEnd(20)} ${String(r.total).padStart(4)}× median ${r.median}ms${errPart}\n`);
+    }
+    return;
+  }
+
+  if (opts.tail) entries = entries.slice(-opts.tail);
+
+  if (opts.asJson) {
+    process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+    return;
+  }
+
+  for (const e of entries) {
+    const argvStr = Array.isArray(e.argv) ? e.argv.join(' ') : '';
+    const exitPart = e.exit === 0 ? green('ok') : red(`exit ${e.exit}`);
+    const errPart = e.err ? ` ${dim(`(${e.err})`)}` : '';
+    process.stdout.write(`[${e.ts}] ${argvStr} (${exitPart}, ${e.ms ?? '?'}ms)${errPart}\n`);
+  }
+}