@just-every/manager 0.2.0

package/src/ingestion/codex-ingestor.ts

@@ -0,0 +1,161 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { DEFAULT_CODEX_HISTORY, DEFAULT_CODEX_TRANSCRIPT } from '../constants.js';
+import { SessionRecord } from '../storage/session-store.js';
+import { EventStore, AgentEventRecord } from '../storage/event-store.js';
+
+interface IngestResult {
+  events: number;
+  warnings: string[];
+}
+
+export class CodexIngestor {
+  constructor(private eventStore: EventStore) {}
+
+  async ingest(session: SessionRecord): Promise<IngestResult> {
+    const historyDir = process.env.MANAGER_CODEX_HISTORY ?? DEFAULT_CODEX_HISTORY;
+    const sessionDir = path.join(historyDir, session.toolSessionId);
+    const transcriptPath = path.join(
+      sessionDir,
+      process.env.MANAGER_CODEX_TRANSCRIPT ?? DEFAULT_CODEX_TRANSCRIPT,
+    );
+
+    const warnings: string[] = [];
+    const stats = await fs.stat(transcriptPath).catch(() => null);
+    if (!stats) {
+      warnings.push(`Transcript file not found at ${transcriptPath}`);
+      return { events: 0, warnings };
+    }
+
+    const content = await fs.readFile(transcriptPath, 'utf8');
+    let parsed: CodexTranscript;
+    try {
+      parsed = JSON.parse(content);
+    } catch (err: any) {
+      warnings.push(`Failed to parse ${transcriptPath}: ${err.message}`);
+      return { events: 0, warnings };
+    }
+
+    const existingMax = this.eventStore.maxSequence(session.id);
+    const sourceFile = path.basename(transcriptPath);
+    const records = normalizeCodexTranscript(session.id, parsed, existingMax, sourceFile);
+    this.eventStore.insert(records);
+    return { events: records.length, warnings };
+  }
+}
+
+interface CodexTranscript {
+  messages?: CodexMessage[];
+}
+
+interface CodexMessage {
+  role: string;
+  content: string | CodexContentBlock[];
+  timestamp?: number;
+  id?: string;
+}
+
+type CodexContentBlock =
+  | { type: 'text'; text: string }
+  | { type: 'tool_use'; name: string; input: unknown; id?: string }
+  | { type: 'tool_result'; tool_use_id?: string; content?: unknown }
+  | { type: 'error'; error?: { type?: string; message?: string };
+  };
+
+export function normalizeCodexTranscript(
+  sessionId: string,
+  transcript: CodexTranscript,
+  startSequence: number,
+  sourceFile: string = DEFAULT_CODEX_TRANSCRIPT,
+): AgentEventRecord[] {
+  const records: AgentEventRecord[] = [];
+  let sequence = startSequence;
+  for (const message of transcript.messages ?? []) {
+    const timestamp = message.timestamp ?? Date.now();
+    if (typeof message.content === 'string') {
+      sequence += 1;
+      records.push({
+        id: buildEventId(sessionId, sequence),
+        sessionId,
+        eventType: 'message',
+        sequence,
+        timestamp,
+        role: message.role,
+        text: message.content,
+        rawPayload: JSON.stringify(message),
+        sourceFile,
+      });
+      continue;
+    }
+    for (const block of message.content ?? []) {
+      if (block.type === 'text') {
+        sequence += 1;
+        records.push({
+          id: buildEventId(sessionId, sequence),
+          sessionId,
+          eventType: 'message',
+          sequence,
+          timestamp,
+          role: message.role,
+          text: block.text,
+          rawPayload: JSON.stringify(block),
+          sourceFile,
+        });
+      } else if (block.type === 'tool_use') {
+        sequence += 1;
+        records.push({
+          id: buildEventId(sessionId, sequence),
+          sessionId,
+          eventType: 'tool_use',
+          sequence,
+          timestamp,
+          role: message.role,
+          toolName: block.name,
+          toolInput: safeStringify(block.input),
+          rawPayload: JSON.stringify(block),
+          sourceFile,
+        });
+      } else if (block.type === 'tool_result') {
+        sequence += 1;
+        records.push({
+          id: buildEventId(sessionId, sequence),
+          sessionId,
+          eventType: 'tool_result',
+          sequence,
+          timestamp,
+          role: message.role,
+          toolOutput: safeStringify(block.content),
+          rawPayload: JSON.stringify(block),
+          sourceFile,
+        });
+      } else if (block.type === 'error') {
+        sequence += 1;
+        records.push({
+          id: buildEventId(sessionId, sequence),
+          sessionId,
+          eventType: 'error',
+          sequence,
+          timestamp,
+          role: message.role,
+          errorType: block.error?.type ?? 'unknown',
+          errorMessage: block.error?.message ?? 'Unknown error',
+          rawPayload: JSON.stringify(block),
+          sourceFile,
+        });
+      }
+    }
+  }
+  return records;
+}
+
+function buildEventId(sessionId: string, sequence: number): string {
+  return `${sessionId}:${sequence}`;
+}
+
+function safeStringify(input: unknown): string {
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return '';
+  }
+}

package/src/ingestion/gemini-ingestor.ts

@@ -0,0 +1,223 @@
+import { EventStore, AgentEventRecord } from '../storage/event-store.js';
+import { SessionRecord } from '../storage/session-store.js';
+
+export interface GeminiSessionPayload {
+  sessionId?: string;
+  projectHash?: string;
+  messages?: GeminiMessage[];
+  events?: GeminiMessage[];
+  chats?: GeminiMessage[];
+}
+
+interface GeminiMessage {
+  id?: string;
+  role?: string;
+  type?: string;
+  timestamp?: string;
+  text?: string;
+  content?: unknown;
+  toolName?: string;
+  toolArgs?: unknown;
+  toolResult?: unknown;
+  tool?: { name?: string; input?: unknown; output?: unknown };
+  message?: string;
+}
+
+export interface GeminiIngestResult {
+  inserted: number;
+  warnings: string[];
+}
+
+export class GeminiIngestor {
+  constructor(private events: EventStore) {}
+
+  ingest(session: SessionRecord, payload: GeminiSessionPayload): GeminiIngestResult {
+    const warnings: string[] = [];
+    const blocks = collectGeminiBlocks(payload);
+    if (!blocks.length) {
+      warnings.push('No Gemini messages found in payload');
+      return { inserted: 0, warnings };
+    }
+
+    const startSequence = this.events.maxSequence(session.id);
+    const records: AgentEventRecord[] = [];
+    let sequence = startSequence;
+    for (const block of blocks) {
+      sequence += 1;
+      const record = mapGeminiBlock(session.id, sequence, block);
+      if (record) {
+        records.push(record);
+      }
+    }
+
+    if (records.length) {
+      this.events.insert(records);
+    }
+    return { inserted: records.length, warnings };
+  }
+}
+
+interface NormalizedBlock {
+  kind: 'message' | 'tool_use' | 'tool_result';
+  role?: string;
+  text?: string;
+  toolName?: string;
+  toolInput?: unknown;
+  toolOutput?: unknown;
+  timestamp?: string;
+  raw?: unknown;
+}
+
+function collectGeminiBlocks(payload: GeminiSessionPayload): NormalizedBlock[] {
+  const sourceArrays = [payload.messages, payload.events, payload.chats].filter(
+    Array.isArray,
+  ) as GeminiMessage[][];
+  const blocks: NormalizedBlock[] = [];
+  for (const messages of sourceArrays) {
+    for (const message of messages) {
+      blocks.push(...normalizeGeminiMessage(message));
+    }
+  }
+  return blocks;
+}
+
+function normalizeGeminiMessage(message: GeminiMessage): NormalizedBlock[] {
+  const role = message.role || inferRoleFromType(message.type);
+  const timestamp = message.timestamp;
+  const blocks: NormalizedBlock[] = [];
+  const type = (message.type || '').toLowerCase();
+
+  if (type.includes('tool_call') || type === 'tool_use') {
+    blocks.push({
+      kind: 'tool_use',
+      role: role ?? 'assistant',
+      toolName: message.toolName ?? message.tool?.name,
+      toolInput: message.toolArgs ?? message.tool?.input ?? message.content,
+      timestamp,
+      raw: message,
+    });
+    return blocks;
+  }
+
+  if (type.includes('tool_result') || type === 'tool_execution_result') {
+    blocks.push({
+      kind: 'tool_result',
+      role: role ?? 'assistant',
+      toolName: message.toolName ?? message.tool?.name,
+      toolOutput: message.toolResult ?? message.tool?.output ?? message.content,
+      timestamp,
+      raw: message,
+    });
+    return blocks;
+  }
+
+  if (typeof message.text === 'string') {
+    blocks.push({
+      kind: 'message',
+      role: role ?? 'assistant',
+      text: message.text,
+      timestamp,
+      raw: message,
+    });
+    return blocks;
+  }
+
+  if (typeof message.content === 'string') {
+    blocks.push({
+      kind: 'message',
+      role: role ?? 'assistant',
+      text: message.content,
+      timestamp,
+      raw: message,
+    });
+    return blocks;
+  }
+
+  if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      if (typeof part === 'string') {
+        blocks.push({ kind: 'message', role: role ?? 'assistant', text: part, timestamp, raw: message });
+      } else if (part && typeof part === 'object') {
+        const blockType = (part.type || '').toLowerCase();
+        if (blockType === 'tool_use') {
+          blocks.push({
+            kind: 'tool_use',
+            role: role ?? 'assistant',
+            toolName: part.name,
+            toolInput: part.input,
+            timestamp,
+            raw: part,
+          });
+        } else if (blockType === 'tool_result') {
+          blocks.push({
+            kind: 'tool_result',
+            role: role ?? 'assistant',
+            toolName: part.name,
+            toolOutput: part.content ?? part.result,
+            timestamp,
+            raw: part,
+          });
+        } else if (blockType === 'text' && typeof part.text === 'string') {
+          blocks.push({ kind: 'message', role: role ?? 'assistant', text: part.text, timestamp, raw: part });
+        }
+      }
+    }
+    return blocks;
+  }
+
+  if (message.message) {
+    blocks.push({ kind: 'message', role: role ?? 'assistant', text: message.message, timestamp, raw: message });
+  }
+  return blocks;
+}
+
+function mapGeminiBlock(
+  sessionId: string,
+  sequence: number,
+  block: NormalizedBlock,
+): AgentEventRecord | null {
+  const timestamp = block.timestamp ? parseTimestamp(block.timestamp) : Date.now();
+  const base: AgentEventRecord = {
+    id: `${sessionId}:gemini:${sequence}`,
+    sessionId,
+    eventType: block.kind,
+    sequence,
+    timestamp,
+    role: block.role ?? 'assistant',
+    rawPayload: block.raw ? safeStringify(block.raw) : null,
+    sourceFile: 'gemini-ingest',
+  };
+
+  if (block.kind === 'message') {
+    return { ...base, text: block.text ?? '' };
+  }
+  if (block.kind === 'tool_use') {
+    return { ...base, toolName: block.toolName ?? 'unknown_tool', toolInput: safeStringify(block.toolInput) };
+  }
+  if (block.kind === 'tool_result') {
+    return { ...base, toolName: block.toolName ?? 'unknown_tool', toolOutput: safeStringify(block.toolOutput) };
+  }
+  return null;
+}
+
+function inferRoleFromType(type?: string): string | undefined {
+  if (!type) return undefined;
+  const value = type.toLowerCase();
+  if (value.includes('user')) return 'user';
+  if (value.includes('system')) return 'system';
+  return 'assistant';
+}
+
+function safeStringify(input: unknown): string | null {
+  if (input == null) return null;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+
+function parseTimestamp(value: string): number {
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? Date.now() : ms;
+}

package/src/integrations/install.ts

@@ -0,0 +1,38 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { exec as execCb } from 'node:child_process';
+
+const exec = promisify(execCb);
+
+export type IntegrationAgent = 'codex' | 'claude' | 'gemini';
+
+export async function installIntegration(agent: IntegrationAgent) {
+  switch (agent) {
+    case 'claude':
+      return installClaudeHook();
+    case 'gemini':
+      return installGeminiWatcher();
+    case 'codex':
+      return 'Codex integration does not require installation; history dir is created automatically.';
+    default:
+      throw new Error(`Unknown agent ${agent}`);
+  }
+}
+
+async function installClaudeHook(): Promise<string> {
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.config', 'claude');
+  const hookDir = path.join(configDir, 'hooks');
+  const scriptPath = path.join(hookDir, 'managerd-hook.sh');
+  await fs.mkdir(hookDir, { recursive: true });
+  const script = `#!/usr/bin/env bash\nset -euo pipefail\npayload="$(cat)"\nif [ -z "$payload" ]; then\n  exit 0\nfi\nurl="${process.env.MANAGERD_HOOK_URL ?? 'http://127.0.0.1:7765/hooks/claude'}"\ncurl -fsS -X POST "$url" -H 'content-type: application/json' -d "$payload" >/dev/null 2>&1 || true\n`;
+  await fs.writeFile(scriptPath, script, { mode: 0o755 });
+  return `Hook script installed to ${scriptPath}. Point Claude Code hooks at this script to stream events to managerd.`;
+}
+
+async function installGeminiWatcher(): Promise<string> {
+  const sessionsDir = path.join(os.homedir(), '.gemini', 'tmp');
+  await fs.mkdir(sessionsDir, { recursive: true });
+  return `Gemini watcher enabled (managerd scans ${sessionsDir}). Ensure Gemini CLI writes session files there.`;
+}

package/src/integrations/sync.ts

@@ -0,0 +1,173 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+export type IntegrationAgent = 'codex' | 'claude' | 'gemini';
+
+export interface IntegrationCheck {
+  name: string;
+  status: 'ok' | 'missing' | 'warn' | 'info';
+  detail?: string;
+}
+
+export interface IntegrationReport {
+  agent: IntegrationAgent;
+  status: 'ready' | 'partial' | 'not_detected';
+  checks: IntegrationCheck[];
+  manualSteps: string[];
+}
+
+const home = os.homedir();
+
+export async function runIntegrationSync(agent: IntegrationAgent): Promise<IntegrationReport> {
+  switch (agent) {
+    case 'codex':
+      return syncCodex();
+    case 'claude':
+      return syncClaude();
+    case 'gemini':
+      return syncGemini();
+    default:
+      throw new Error(`Unknown integration agent: ${agent}`);
+  }
+}
+
+function syncCodex(): IntegrationReport {
+  const checks: IntegrationCheck[] = [];
+  const manualSteps: string[] = [];
+  const command = process.env.MANAGER_CODEX_COMMAND ?? 'codex';
+  const historyDir = process.env.MANAGER_CODEX_HISTORY ?? path.join(home, '.codex', 'sessions');
+  const configPath = path.join(home, '.codex', 'config.json');
+
+  const cmdPath = resolveCommand(command);
+  if (cmdPath) {
+    checks.push({ name: `Codex binary (${command})`, status: 'ok', detail: cmdPath });
+  } else {
+    checks.push({ name: `Codex binary (${command})`, status: 'missing', detail: 'not found on PATH' });
+  }
+
+  if (fs.existsSync(historyDir)) {
+    checks.push({ name: 'History directory', status: 'ok', detail: historyDir });
+  } else {
+    checks.push({ name: 'History directory', status: 'missing', detail: historyDir });
+    manualSteps.push(`Create the history directory: mkdir -p ${historyDir}`);
+  }
+
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(raw);
+      const configuredHistory = config.history_dir;
+      if (configuredHistory === historyDir) {
+        checks.push({ name: 'Codex history_dir', status: 'ok', detail: configuredHistory });
+      } else {
+        checks.push({
+          name: 'Codex history_dir',
+          status: 'warn',
+          detail: `Config uses ${configuredHistory || 'unset'}`,
+        });
+        manualSteps.push(`Update ${configPath} -> history_dir = "${historyDir}"`);
+      }
+    } catch (err: any) {
+      checks.push({ name: 'Codex config parse', status: 'warn', detail: err.message });
+      manualSteps.push(`Fix JSON in ${configPath} so manager can verify settings.`);
+    }
+  } else {
+    checks.push({ name: 'Codex config file', status: 'missing', detail: configPath });
+    manualSteps.push(`Create ${configPath} with { "history_dir": "${historyDir}" }`);
+  }
+
+  const status = determineStatus(checks, cmdPath ? 'ready' : 'not_detected');
+  return { agent: 'codex', status, checks, manualSteps };
+}
+
+function syncClaude(): IntegrationReport {
+  const checks: IntegrationCheck[] = [];
+  const manualSteps: string[] = [];
+  const configDir = path.join(home, '.config', 'claude');
+  const hookPath = path.join(configDir, 'hooks', 'on_session_start');
+
+  if (fs.existsSync(configDir)) {
+    checks.push({ name: 'Claude config directory', status: 'ok', detail: configDir });
+  } else {
+    checks.push({ name: 'Claude config directory', status: 'missing', detail: configDir });
+    manualSteps.push(`Create ${configDir} (Claude Code stores hooks here).`);
+  }
+
+  if (fs.existsSync(hookPath)) {
+    const content = fs.readFileSync(hookPath, 'utf8');
+    if (content.includes('manager')) {
+      checks.push({ name: 'Hook script', status: 'ok', detail: hookPath });
+    } else {
+      checks.push({ name: 'Hook script', status: 'warn', detail: 'does not reference manager CLI' });
+      manualSteps.push(`Update ${hookPath} to forward events to manager (see docs/manager-daemon-cli.md).`);
+    }
+  } else {
+    checks.push({ name: 'Hook script', status: 'missing', detail: hookPath });
+    manualSteps.push(`Create a hook script at ${hookPath} that runs manager's Claude hook helper.`);
+  }
+
+  return { agent: 'claude', status: determineStatus(checks), checks, manualSteps };
+}
+
+function syncGemini(): IntegrationReport {
+  const checks: IntegrationCheck[] = [];
+  const manualSteps: string[] = [];
+  const geminiDir = path.join(home, '.gemini');
+  const configPath = path.join(geminiDir, 'config.toml');
+  const desiredEndpoint = process.env.MANAGER_GEMINI_OTLP ?? 'http://127.0.0.1:4318';
+
+  if (fs.existsSync(geminiDir)) {
+    checks.push({ name: 'Gemini directory', status: 'ok', detail: geminiDir });
+  } else {
+    checks.push({ name: 'Gemini directory', status: 'missing', detail: geminiDir });
+    manualSteps.push('Install Gemini CLI and log in so ~/.gemini is created.');
+  }
+
+  if (fs.existsSync(configPath)) {
+    const text = fs.readFileSync(configPath, 'utf8');
+    const enabled = /telemetry\.enabled\s*=\s*true/.test(text);
+    const endpointMatch = text.includes(desiredEndpoint);
+    checks.push({
+      name: 'Telemetry enabled',
+      status: enabled ? 'ok' : 'warn',
+      detail: enabled ? 'enabled' : 'telemetry.enabled not true',
+    });
+    checks.push({
+      name: 'OTLP endpoint',
+      status: endpointMatch ? 'ok' : 'warn',
+      detail: endpointMatch ? desiredEndpoint : 'endpoint not set to manager',
+    });
+    if (!enabled || !endpointMatch) {
+      manualSteps.push(
+        `Edit ${configPath} telemetry section so exporter targets ${desiredEndpoint}.`,
+      );
+    }
+  } else {
+    checks.push({ name: 'Gemini config file', status: 'missing', detail: configPath });
+    manualSteps.push(`Create ${configPath} and set telemetry endpoint to ${desiredEndpoint}.`);
+  }
+
+  return { agent: 'gemini', status: determineStatus(checks), checks, manualSteps };
+}
+
+function determineStatus(checks: IntegrationCheck[], fallback: 'ready' | 'not_detected' = 'ready'): 'ready' | 'partial' | 'not_detected' {
+  if (checks.some((check) => check.status === 'missing')) {
+    return fallback === 'not_detected' && checks.every((c) => c.status === 'missing')
+      ? 'not_detected'
+      : 'partial';
+  }
+  if (checks.some((check) => check.status === 'warn')) {
+    return 'partial';
+  }
+  return fallback === 'not_detected' ? 'not_detected' : 'ready';
+}
+
+function resolveCommand(command: string): string | null {
+  const resolved = spawnSync('which', [command], { encoding: 'utf8' });
+  if (resolved.status === 0) {
+    return resolved.stdout.trim();
+  }
+  return null;
+}

package/src/managerd.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startDaemon } from './daemon/index.js';
+
+startDaemon().catch((err) => {
+  console.error('Failed to start managerd', err);
+  process.exitCode = 1;
+});