@just-every/manager 0.2.0

package/src/cli.ts

@@ -0,0 +1,483 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_HOST, DEFAULT_PORT, DATA_DIRS, PID_FILE } from './constants.js';
+import { runIntegrationSync, IntegrationAgent } from './integrations/sync.js';
+import { installIntegration } from './integrations/install.js';
+
+const program = new Command();
+
+program
+  .name('manager')
+  .description('Supervise local AI agents with Manager');
+
+const daemonCommand = program.command('daemon').description('Manage the managerd background service');
+
+daemonCommand
+  .command('start')
+  .description('Run managerd in the foreground')
+  .action(async () => {
+    const { startDaemon } = await import('./daemon/index.js');
+    await startDaemon();
+  });
+
+daemonCommand
+  .command('status')
+  .description('Check daemon health')
+  .option('--host <host>', 'Daemon host override', DEFAULT_HOST)
+  .option('--port <port>', 'Daemon port override', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const result = await queryDaemon('/status', opts.host, Number(opts.port));
+    if (!result.ok) {
+      console.error(chalk.red('Daemon unavailable:'), result.error ?? 'unknown');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk.green('managerd running'));
+    console.log('Uptime:', Math.round(result.uptimeMs / 1000), 's');
+    console.log('Codex connector:', result.codex);
+    console.log('Recent sessions:');
+    for (const session of result.sessions ?? []) {
+      console.log(` - ${session.id} [${session.agentType}] ${session.status}`);
+    }
+  });
+
+daemonCommand
+  .command('stop')
+  .description('Stop a running managerd instance')
+  .action(async () => {
+    const pid = await readPidFile();
+    if (!pid) {
+      console.log('managerd is not running.');
+      return;
+    }
+    try {
+      process.kill(pid, 'SIGTERM');
+      console.log(`Sent SIGTERM to managerd (pid ${pid}).`);
+    } catch (err: any) {
+      console.error(chalk.red('Failed to stop managerd:'), err?.message ?? err);
+    }
+  });
+
+daemonCommand
+  .command('logs')
+  .description('Show managerd logs')
+  .option('--follow', 'Stream logs until interrupted')
+  .action(async (opts) => {
+    await tailLogs(Boolean(opts.follow));
+  });
+
+daemonCommand
+  .command('install')
+  .description('Install managerd as a user-level systemd service')
+  .action(async () => {
+    await installSystemdService();
+  });
+
+const agentCommand = program.command('agent').description('Interact with local agents via managerd');
+
+agentCommand
+  .command('launch <agent>')
+  .description('Launch an agent session through the daemon')
+  .option('--cmd <path>', 'Override executable path')
+  .option('--arg <value...>', 'Arguments passed to the agent')
+  .option('--raw', 'Skip automatic Codex flag injection (testing only)')
+  .option('--max-restarts <n>', 'Maximum automatic restarts (default: 3)', '3')
+  .option('--no-auto-restart', 'Disable automatic restarts')
+  .option('--host <host>', 'Daemon host override', DEFAULT_HOST)
+  .option('--port <port>', 'Daemon port override', String(DEFAULT_PORT))
+  .action(async (agent: string, opts) => {
+    if (!['codex', 'gemini'].includes(agent)) {
+      console.error(chalk.red('Supported agents: codex, gemini'));
+      process.exitCode = 1;
+      return;
+    }
+    const maxRestarts = Number(opts.maxRestarts ?? 3);
+    const payload: any = {
+      agent,
+      command: opts.cmd,
+      args: opts.arg ?? [],
+      autoRestart: opts.autoRestart !== false,
+      maxRestarts: Number.isFinite(maxRestarts) ? maxRestarts : 3,
+    };
+    if (agent === 'codex') {
+      payload.disableManagedFlags = Boolean(opts.raw);
+    }
+    const response = await callDaemon('/rpc/launch', payload, opts.host, Number(opts.port));
+    if (!response.ok) {
+      console.error(chalk.red('Launch failed:'), response.error ?? 'unknown');
+      process.exitCode = 1;
+      return;
+    }
+    const { result } = response;
+    console.log(chalk.green(`${agent} session launched`));
+    console.log('Local session ID:', result.localSessionId);
+    console.log('Tool session ID:', result.toolSessionId);
+    console.log('Command:', `${result.command} ${result.args.join(' ')}`);
+  });
+
+agentCommand
+  .command('ingest-gemini <sessionFile>')
+  .description('Ingest a Gemini CLI session JSON file into managerd')
+  .option('--session-id <id>', 'Override Gemini session id')
+  .option('--host <host>', 'Daemon host override', DEFAULT_HOST)
+  .option('--port <port>', 'Daemon port override', String(DEFAULT_PORT))
+  .action(async (sessionFile, opts) => {
+    const absolute = path.resolve(sessionFile);
+    let contents: string;
+    try {
+      contents = await fs.readFile(absolute, 'utf8');
+    } catch (err: any) {
+      console.error(chalk.red('Unable to read session file:'), err?.message ?? err);
+      process.exitCode = 1;
+      return;
+    }
+    let data: any;
+    try {
+      data = JSON.parse(contents);
+    } catch (err: any) {
+      console.error(chalk.red('Session file is not valid JSON:'), err?.message ?? err);
+      process.exitCode = 1;
+      return;
+    }
+    const sessionId =
+      opts.sessionId ?? data.sessionId ?? data.id ?? inferSessionIdFromPath(absolute);
+    const payload = {
+      sessionId,
+      filePath: absolute,
+      data,
+    };
+    const response = await callDaemon('/rpc/gemini/ingest', payload, opts.host, Number(opts.port));
+    if (!response.ok) {
+      console.error(chalk.red('Gemini ingestion failed:'), response.error ?? 'unknown');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk.green('Gemini session ingested'));
+    if (response.inserted != null) {
+      console.log('Events inserted:', response.inserted);
+    }
+    if (response.warnings?.length) {
+      console.warn(chalk.yellow('Warnings:'));
+      response.warnings.forEach((warning: string) => console.warn(' -', warning));
+    }
+  });
+
+program
+  .command('sessions')
+  .description('List locally tracked sessions')
+  .option('--host <host>', 'Daemon host override', DEFAULT_HOST)
+  .option('--port <port>', 'Daemon port override', String(DEFAULT_PORT))
+  .action(async (opts) => {
+    const result = await queryDaemon('/sessions', opts.host, Number(opts.port));
+    if (!result.ok) {
+      console.error(chalk.red('Unable to read sessions:'), result.error ?? 'unknown');
+      process.exitCode = 1;
+      return;
+    }
+    if (!result.sessions?.length) {
+      console.log('No sessions recorded yet.');
+      return;
+    }
+    const rows = result.sessions.map((session: any) => ({
+      id: session.id.slice(0, 8),
+      agent: session.agentType,
+      status: session.status,
+      command: session.command,
+      started: formatDate(session.createdAt ?? session.created_at),
+      updated: formatDate(session.updatedAt ?? session.updated_at),
+    }));
+    const header = ['ID', 'Agent', 'Status', 'Started', 'Updated', 'Command'];
+    const lines = [header, ...rows.map((row: any) => [row.id, row.agent, row.status, row.started, row.updated, row.command])];
+    const widths = header.map((_, index) => Math.max(...lines.map((line) => String(line[index] ?? '').length)));
+    for (const line of lines) {
+      const formatted = line
+        .map((value, idx) => String(value ?? '').padEnd(widths[idx]))
+        .join('  ');
+      console.log(formatted);
+    }
+  });
+
+program
+  .command('sessions:events <sessionId>')
+  .description('View events captured for a session (ingests Codex transcripts on demand)')
+  .option('--host <host>', 'Daemon host override', DEFAULT_HOST)
+  .option('--port <port>', 'Daemon port override', String(DEFAULT_PORT))
+  .option('--limit <n>', 'Limit number of events', '20')
+  .option('--json', 'Print raw JSON')
+  .action(async (sessionId, opts) => {
+    const payload = {
+      sessionId,
+      limit: Number(opts.limit ?? 20),
+    };
+    const response = await callDaemon('/rpc/sessions/events', payload, opts.host, Number(opts.port));
+    if (!response.ok) {
+      console.error(chalk.red('Failed to fetch events:'), response.error ?? 'unknown');
+      process.exitCode = 1;
+      return;
+    }
+    const { events, warnings, session } = response;
+    if (session) {
+      console.log(chalk.bold(`Session ${session.id}`));
+      console.log(`Agent: ${session.agentType}`);
+      if (session.command) {
+        console.log(`Command: ${session.command}`);
+      }
+      console.log('Started:', formatDate(session.createdAt ?? session.created_at));
+      console.log('Status:', session.status);
+      console.log('');
+    }
+    if (warnings?.length) {
+      console.warn(chalk.yellow('Warnings:'));
+      for (const warning of warnings) {
+        console.warn('-', warning);
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify(events, null, 2));
+      return;
+    }
+    if (!events.length) {
+      console.log('No events recorded yet.');
+      return;
+    }
+    for (const event of events) {
+      renderEvent(event);
+    }
+  });
+
+const integrationsCommand = program.command('integrations').description('Inspect agent integrations');
+
+integrationsCommand
+  .command('sync <agent>')
+  .description('Check local integration status (read-only)')
+  .option('--json', 'Output JSON report')
+  .action(async (agent: string, opts) => {
+    if (!['codex', 'claude', 'gemini'].includes(agent)) {
+      console.error(chalk.red('Supported agents: codex, claude, gemini'));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const report = await runIntegrationSync(agent as IntegrationAgent);
+      if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      renderIntegrationReport(report);
+    } catch (err: any) {
+      console.error(chalk.red('Failed to run sync:'), err.message ?? err);
+      process.exitCode = 1;
+    }
+  });
+
+integrationsCommand
+  .command('install <agent>')
+  .description('Install helper assets for an integration')
+  .action(async (agent: string) => {
+    if (!['codex', 'claude', 'gemini'].includes(agent)) {
+      console.error(chalk.red('Supported agents: codex, claude, gemini'));
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const message = await installIntegration(agent as IntegrationAgent);
+      console.log(chalk.green('Install complete:'), message);
+    } catch (err: any) {
+      console.error(chalk.red('Install failed:'), err?.message ?? err);
+      process.exitCode = 1;
+    }
+  });
+
+program.parseAsync(process.argv);
+
+async function queryDaemon(pathname: string, host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}${pathname}`);
+    if (!res.ok) return { ok: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? 'connection_error' };
+  }
+}
+
+async function callDaemon(pathname: string, payload: any, host = DEFAULT_HOST, port = DEFAULT_PORT) {
+  try {
+    const res = await fetch(`http://${host}:${port}${pathname}`, {
+      method: 'POST',
+      body: JSON.stringify(payload),
+      headers: { 'content-type': 'application/json' },
+    });
+    if (!res.ok) return { ok: false, error: `HTTP ${res.status}` };
+    return await res.json();
+  } catch (err: any) {
+    return { ok: false, error: err?.message ?? 'connection_error' };
+  }
+}
+
+function renderEvent(event: any) {
+  const time = event.timestamp ? new Date(event.timestamp).toLocaleTimeString() : 'unknown time';
+  const header = `[${time}] ${event.role ? event.role.toUpperCase() : event.eventType}`;
+  if (event.eventType === 'message') {
+    console.log(header);
+    console.log(`  ${event.text ?? event.summary ?? JSON.stringify(event.content)}`);
+    return;
+  }
+  if (event.eventType === 'tool_use') {
+    console.log(`${header} TOOL ${event.toolName ?? ''}`.trim());
+    console.log(`  Input: ${truncate(event.toolInput ?? '', 200)}`);
+    return;
+  }
+  if (event.eventType === 'tool_result') {
+    console.log(`${header} TOOL RESULT`);
+    console.log(`  Output: ${truncate(event.toolOutput ?? '', 200)}`);
+    return;
+  }
+  if (event.eventType === 'error') {
+    console.log(`${header} ERROR ${event.errorType ?? ''}`.trim());
+    console.log(`  ${event.errorMessage}`);
+    return;
+  }
+  console.log(header);
+  console.log('  ', JSON.stringify(event));
+}
+
+function truncate(value: string, max = 200) {
+  if (!value) return '';
+  return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+
+function inferSessionIdFromPath(filePath: string): string {
+  const base = path.basename(filePath);
+  return base.replace(/\.[^.]+$/, '') || `gemini-${Date.now()}`;
+}
+
+function formatDate(value?: string): string {
+  if (!value) return '-';
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return '-';
+  return date.toLocaleString();
+}
+
+async function readPidFile(): Promise<number | null> {
+  try {
+    const contents = await fs.readFile(PID_FILE, 'utf8');
+    const pid = Number(contents.trim());
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+async function tailLogs(follow: boolean) {
+  const logPath = path.join(DATA_DIRS.logs, 'managerd.log');
+  try {
+    await fs.access(logPath);
+  } catch {
+    console.log('Logs not found yet. Run managerd once to create logs.');
+    return;
+  }
+
+  const printCurrent = async () => {
+    const text = await fs.readFile(logPath, 'utf8');
+    if (text) process.stdout.write(text);
+  };
+
+  if (!follow) {
+    await printCurrent();
+    return;
+  }
+
+  let position = 0;
+  const stats = await fs.stat(logPath);
+  if (stats.size > 0) {
+    await printCurrent();
+    position = stats.size;
+  }
+
+  console.log(chalk.gray('--- streaming managerd logs (Ctrl+C to stop) ---'));
+  const watcher = fsSync.watch(logPath, async (event) => {
+    if (event !== 'change') return;
+    try {
+      const handle = await fs.open(logPath, 'r');
+      const current = await handle.stat();
+      if (current.size > position) {
+        const length = current.size - position;
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, position);
+        process.stdout.write(buffer.toString());
+        position = current.size;
+      }
+      await handle.close();
+    } catch (err) {
+      console.error(chalk.red('Failed to read logs:'), err instanceof Error ? err.message : err);
+    }
+  });
+
+  const cleanup = () => watcher.close();
+  process.on('SIGINT', () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+
+async function installSystemdService() {
+  const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  await fs.mkdir(serviceDir, { recursive: true });
+  const servicePath = path.join(serviceDir, 'managerd.service');
+  const execStart = `${process.execPath} ${getManagerdEntry()}`;
+  const workingDir = path.dirname(getManagerdEntry());
+  const unit = `[Unit]\nDescription=Justevery Manager Daemon\nAfter=network.target\n\n[Service]\nExecStart=${execStart}\nRestart=on-failure\nEnvironment=MANAGERD_STORAGE=memory\nWorkingDirectory=${workingDir}\n\n[Install]\nWantedBy=default.target\n`;
+  await fs.writeFile(servicePath, unit, 'utf8');
+  console.log('Installed systemd service to', servicePath);
+  console.log('Run the following commands to enable it:');
+  console.log('  systemctl --user daemon-reload');
+  console.log('  systemctl --user enable --now managerd.service');
+}
+
+function getManagerdEntry(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, 'managerd.js');
+}
+
+function renderIntegrationReport(report: Awaited<ReturnType<typeof runIntegrationSync>>) {
+  console.log(chalk.bold(`Integration: ${report.agent}`));
+  console.log('Status:', report.status);
+  console.log('\nChecks:');
+  for (const check of report.checks) {
+    const prefix = statusIcon(check.status);
+    const detail = check.detail ? ` — ${check.detail}` : '';
+    console.log(` ${prefix} ${check.name}${detail}`);
+  }
+  if (report.manualSteps.length) {
+    console.log('\nManual steps:');
+    report.manualSteps.forEach((step, idx) => {
+      console.log(` ${idx + 1}. ${step}`);
+    });
+  } else {
+    console.log('\nNo manual steps required.');
+  }
+}
+
+function statusIcon(status: string) {
+  switch (status) {
+    case 'ok':
+      return chalk.green('✔');
+    case 'missing':
+      return chalk.red('✖');
+    case 'warn':
+      return chalk.yellow('!');
+    default:
+      return chalk.gray('-');
+  }
+}

package/src/connectors/claude.ts

@@ -0,0 +1,5 @@
+export class ClaudeConnector {
+  describe() {
+    return 'Claude hooks integration pending implementation';
+  }
+}

package/src/connectors/codex.ts

@@ -0,0 +1,135 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DEFAULT_CODEX_HISTORY, SessionStatus } from '../constants.js';
+import { SessionStore } from '../storage/session-store.js';
+
+export interface CodexLaunchRequest {
+  command?: string;
+  args?: string[];
+  disableManagedFlags?: boolean;
+  autoRestart?: boolean;
+  maxRestarts?: number;
+}
+
+export interface CodexLaunchResponse {
+  localSessionId: string;
+  toolSessionId: string;
+  command: string;
+  args: string[];
+}
+
+export class CodexConnector {
+  #store: SessionStore;
+  #sessions = new Map<
+    string,
+    {
+      command: string;
+      args: string[];
+      env: NodeJS.ProcessEnv;
+      autoRestart: boolean;
+      maxRestarts: number;
+      restarts: number;
+      child?: ReturnType<typeof spawn>;
+    }
+  >();
+
+  constructor(store: SessionStore) {
+    this.#store = store;
+  }
+
+  async launch(request: CodexLaunchRequest = {}): Promise<CodexLaunchResponse> {
+    const command = request.command ?? process.env.MANAGER_CODEX_COMMAND ?? 'codex';
+    const extraArgs = request.args ?? [];
+    const session = this.#store.createSession('codex', command, extraArgs);
+    const codexHistoryDir = process.env.MANAGER_CODEX_HISTORY ?? DEFAULT_CODEX_HISTORY;
+    const sessionDir = path.join(codexHistoryDir, session.toolSessionId);
+    await fs.mkdir(sessionDir, { recursive: true });
+
+    const enforcedFlags = request.disableManagedFlags || process.env.MANAGER_CODEX_DISABLE_FLAGS === '1'
+      ? []
+      : ['--output_dir', sessionDir, '--output_format', 'json'];
+    const env = {
+      ...process.env,
+      MANAGER_SESSION_ID: session.id,
+    };
+    const state = {
+      command,
+      args: [...extraArgs, ...enforcedFlags],
+      env,
+      autoRestart: request.autoRestart !== false,
+      maxRestarts: request.maxRestarts ?? 3,
+      restarts: 0,
+    };
+    this.#sessions.set(session.id, state);
+    this.spawnProcess(session.id, state);
+
+    return {
+      localSessionId: session.id,
+      toolSessionId: session.toolSessionId,
+      command,
+      args: [...extraArgs, ...enforcedFlags],
+    };
+  }
+
+  private spawnProcess(
+    sessionId: string,
+    state: {
+      command: string;
+      args: string[];
+      env: NodeJS.ProcessEnv;
+      autoRestart: boolean;
+      maxRestarts: number;
+      restarts: number;
+      child?: ReturnType<typeof spawn>;
+    },
+  ) {
+    const child = spawn(state.command, state.args, {
+      env: state.env,
+      stdio: 'ignore',
+    });
+    state.child = child;
+    this.#store.updateStatus(sessionId, SessionStatus.Running);
+
+    child.once('exit', (code) => this.handleExit(sessionId, state, code));
+    child.once('error', (err) => {
+      console.error('[codex] failed to launch', err);
+      this.handleExit(sessionId, state, -1);
+    });
+  }
+
+  private handleExit(
+    sessionId: string,
+    state: {
+      command: string;
+      args: string[];
+      env: NodeJS.ProcessEnv;
+      autoRestart: boolean;
+      maxRestarts: number;
+      restarts: number;
+      child?: ReturnType<typeof spawn>;
+    },
+    code: number | null,
+  ) {
+    const exitCode = code ?? -1;
+    const successful = exitCode === 0;
+    this.#store.updateStatus(sessionId, successful ? SessionStatus.Completed : SessionStatus.Failed, exitCode);
+    if (state.autoRestart && !successful && state.restarts < state.maxRestarts) {
+      state.restarts += 1;
+      const delay = Math.min(1000 * state.restarts, 5000);
+      setTimeout(() => {
+        console.warn(`[codex] restarting session ${sessionId} attempt ${state.restarts}`);
+        this.spawnProcess(sessionId, state);
+      }, delay);
+      return;
+    }
+    this.#sessions.delete(sessionId);
+  }
+}
+
+export function describeCodexConnector(): string {
+  const command = process.env.MANAGER_CODEX_COMMAND ?? 'codex';
+  const dir = process.env.MANAGER_CODEX_HISTORY ?? DEFAULT_CODEX_HISTORY;
+  return `command=${command} historyDir=${dir}`;
+}