@just-every/manager 0.2.0

package/dist/chunk-KD5PYPXI.js

@@ -0,0 +1,1277 @@
+import {
+  DATA_DIRS,
+  DB_PATH,
+  DEFAULT_CODEX_HISTORY,
+  DEFAULT_CODEX_TRANSCRIPT,
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  PID_FILE,
+  __require
+} from "./chunk-ZQKKKD3J.js";
+
+// src/daemon/index.ts
+import process2 from "process";
+import fs8 from "fs/promises";
+
+// src/daemon/http-server.ts
+import http from "http";
+import { URL } from "url";
+
+// src/storage/session-store.ts
+import path from "path";
+import fs2 from "fs";
+import { randomUUID } from "crypto";
+
+// src/utils/fs.ts
+import fs from "fs/promises";
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+// src/storage/session-store.ts
+var cachedDatabase = null;
+function loadDatabase() {
+  if (cachedDatabase) return cachedDatabase;
+  try {
+    cachedDatabase = __require("better-sqlite3");
+    return cachedDatabase;
+  } catch (err) {
+    throw new Error("better-sqlite3 native bindings are unavailable. Rebuild dependencies or set MANAGERD_STORAGE=memory.");
+  }
+}
+var SqliteSessionStore = class {
+  db;
+  constructor(dbPath = DB_PATH) {
+    const dir = path.dirname(dbPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const Database = loadDatabase();
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS local_sessions (
+        id TEXT PRIMARY KEY,
+        agent_type TEXT NOT NULL,
+        tool_session_id TEXT NOT NULL,
+        status TEXT NOT NULL,
+        command TEXT NOT NULL,
+        args TEXT NOT NULL,
+        exit_code INTEGER,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_local_sessions_agent_type ON local_sessions(agent_type);
+    `);
+  }
+  createSession(agentType, command, args, options = {}) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const toolSessionId = options.toolSessionId ?? id;
+    this.db.prepare(`
+        INSERT INTO local_sessions (id, agent_type, tool_session_id, status, command, args, exit_code, created_at, updated_at)
+        VALUES (@id, @agentType, @toolSessionId, @status, @command, @args, NULL, @createdAt, @updatedAt)
+      `).run({
+      id,
+      agentType,
+      toolSessionId,
+      status: "launching" /* Launching */,
+      command,
+      args: JSON.stringify(args),
+      createdAt: now,
+      updatedAt: now
+    });
+    return {
+      id,
+      agentType,
+      toolSessionId,
+      status: "launching" /* Launching */,
+      command,
+      args,
+      createdAt: now,
+      updatedAt: now,
+      exitCode: null
+    };
+  }
+  updateStatus(id, status, exitCode = null) {
+    this.db.prepare(`
+        UPDATE local_sessions
+        SET status=@status, exit_code=@exitCode, updated_at=@updatedAt
+        WHERE id=@id
+      `).run({ id, status, exitCode, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  listRecent(limit = 10) {
+    const rows = this.db.prepare(`SELECT * FROM local_sessions ORDER BY datetime(updated_at) DESC LIMIT ?`).all(limit);
+    return rows.map((row) => this.denormalize(row));
+  }
+  get(id) {
+    const row = this.db.prepare(`SELECT * FROM local_sessions WHERE id=? LIMIT 1`).get(id);
+    return row ? this.denormalize(row) : null;
+  }
+  denormalize(row) {
+    return {
+      id: row.id,
+      agentType: row.agent_type,
+      toolSessionId: row.tool_session_id,
+      status: row.status,
+      command: row.command,
+      args: JSON.parse(row.args ?? "[]"),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      exitCode: row.exit_code ?? null
+    };
+  }
+  findByToolSession(agentType, toolSessionId) {
+    const row = this.db.prepare(
+      `SELECT * FROM local_sessions WHERE agent_type = @agentType AND tool_session_id = @toolSessionId LIMIT 1`
+    ).get({ agentType, toolSessionId });
+    return row ? this.denormalize(row) : null;
+  }
+};
+var MemorySessionStore = class {
+  records = /* @__PURE__ */ new Map();
+  toolIndex = /* @__PURE__ */ new Map();
+  createSession(agentType, command, args, options = {}) {
+    const id = randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      id,
+      agentType,
+      toolSessionId: options.toolSessionId ?? id,
+      status: "launching" /* Launching */,
+      command,
+      args,
+      createdAt: now,
+      updatedAt: now,
+      exitCode: null
+    };
+    this.records.set(id, record);
+    this.toolIndex.set(this.toolKey(agentType, record.toolSessionId), record);
+    return record;
+  }
+  updateStatus(id, status, exitCode = null) {
+    const record = this.records.get(id);
+    if (!record) return;
+    record.status = status;
+    record.exitCode = exitCode;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.toolIndex.set(this.toolKey(record.agentType, record.toolSessionId), record);
+  }
+  listRecent(limit = 10) {
+    return Array.from(this.records.values()).sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1).slice(0, limit);
+  }
+  get(id) {
+    return this.records.get(id) ?? null;
+  }
+  findByToolSession(agentType, toolSessionId) {
+    return this.toolIndex.get(this.toolKey(agentType, toolSessionId)) ?? null;
+  }
+  toolKey(agentType, toolSessionId) {
+    return `${agentType}:${toolSessionId}`;
+  }
+};
+function createSessionStore() {
+  if (process.env.MANAGERD_STORAGE === "memory") {
+    return new MemorySessionStore();
+  }
+  return new SqliteSessionStore();
+}
+async function ensureBaseDirs(dir) {
+  await ensureDir(dir);
+  await ensureDir(path.join(dir, "logs"));
+  await ensureDir(path.join(dir, "sessions"));
+}
+
+// src/connectors/codex.ts
+import { spawn } from "child_process";
+import fs3 from "fs/promises";
+import path2 from "path";
+var CodexConnector = class {
+  #store;
+  #sessions = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.#store = store;
+  }
+  async launch(request = {}) {
+    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 = path2.join(codexHistoryDir, session.toolSessionId);
+    await fs3.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]
+    };
+  }
+  spawnProcess(sessionId, state) {
+    const child = spawn(state.command, state.args, {
+      env: state.env,
+      stdio: "ignore"
+    });
+    state.child = child;
+    this.#store.updateStatus(sessionId, "running" /* 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);
+    });
+  }
+  handleExit(sessionId, state, code) {
+    const exitCode = code ?? -1;
+    const successful = exitCode === 0;
+    this.#store.updateStatus(sessionId, successful ? "completed" /* Completed */ : "failed" /* Failed */, exitCode);
+    if (state.autoRestart && !successful && state.restarts < state.maxRestarts) {
+      state.restarts += 1;
+      const delay = Math.min(1e3 * state.restarts, 5e3);
+      setTimeout(() => {
+        console.warn(`[codex] restarting session ${sessionId} attempt ${state.restarts}`);
+        this.spawnProcess(sessionId, state);
+      }, delay);
+      return;
+    }
+    this.#sessions.delete(sessionId);
+  }
+};
+function describeCodexConnector() {
+  const command = process.env.MANAGER_CODEX_COMMAND ?? "codex";
+  const dir = process.env.MANAGER_CODEX_HISTORY ?? DEFAULT_CODEX_HISTORY;
+  return `command=${command} historyDir=${dir}`;
+}
+
+// src/connectors/gemini.ts
+import { spawn as spawn2 } from "child_process";
+import path3 from "path";
+import fs4 from "fs/promises";
+var GeminiConnector = class {
+  #store;
+  #sessions = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.#store = store;
+  }
+  async launch(request = {}) {
+    const command = request.command ?? process.env.MANAGER_GEMINI_COMMAND ?? "gemini";
+    const args = request.args ?? [];
+    const session = this.#store.createSession("gemini", command, args);
+    const sessionLogDir = process.env.MANAGER_GEMINI_LOG_DIR ?? path3.join(process.env.HOME || "", ".gemini", "sessions");
+    await fs4.mkdir(sessionLogDir, { recursive: true });
+    const env = {
+      ...process.env,
+      MANAGER_SESSION_ID: session.id,
+      MANAGER_GEMINI_SESSION_ID: session.toolSessionId,
+      GEMINI_SESSION_LOG: path3.join(sessionLogDir, `${session.toolSessionId}.jsonl`)
+    };
+    const state = {
+      command,
+      args,
+      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
+    };
+  }
+  spawnProcess(sessionId, state) {
+    const child = spawn2(state.command, state.args, {
+      env: state.env,
+      stdio: "ignore"
+    });
+    state.child = child;
+    this.#store.updateStatus(sessionId, "running" /* Running */);
+    child.once("exit", (code) => this.handleExit(sessionId, state, code));
+    child.once("error", (err) => {
+      console.error("[gemini] failed to launch", err);
+      this.handleExit(sessionId, state, -1);
+    });
+  }
+  handleExit(sessionId, state, code) {
+    const exitCode = code ?? -1;
+    const successful = exitCode === 0;
+    this.#store.updateStatus(sessionId, successful ? "completed" /* Completed */ : "failed" /* Failed */, exitCode);
+    if (state.autoRestart && !successful && state.restarts < state.maxRestarts) {
+      state.restarts += 1;
+      const delay = Math.min(1e3 * state.restarts, 5e3);
+      setTimeout(() => {
+        console.warn(`[gemini] restarting session ${sessionId} attempt ${state.restarts}`);
+        this.spawnProcess(sessionId, state);
+      }, delay);
+      return;
+    }
+    this.#sessions.delete(sessionId);
+  }
+};
+function describeGeminiConnector() {
+  const command = process.env.MANAGER_GEMINI_COMMAND ?? "gemini";
+  const logDir = process.env.MANAGER_GEMINI_LOG_DIR ?? path3.join(process.env.HOME || "", ".gemini", "sessions");
+  return `command=${command} logDir=${logDir}`;
+}
+
+// src/storage/event-store.ts
+import path4 from "path";
+var SqliteEventStore = class {
+  db;
+  constructor(dbPath = DB_PATH) {
+    const dir = path4.dirname(dbPath);
+    ensureDir(dir);
+    const Database = loadSqlite();
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_events (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        event_type TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        timestamp INTEGER NOT NULL,
+        role TEXT,
+        text TEXT,
+        tool_name TEXT,
+        tool_input TEXT,
+        tool_output TEXT,
+        error_type TEXT,
+        error_message TEXT,
+        raw_payload TEXT,
+        source_file TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_agent_events_session ON agent_events(session_id, sequence);
+    `);
+  }
+  insert(events) {
+    if (!events.length) return;
+    const stmt = this.db.prepare(`
+      INSERT OR IGNORE INTO agent_events (
+        id, session_id, event_type, sequence, timestamp,
+        role, text, tool_name, tool_input, tool_output,
+        error_type, error_message, raw_payload, source_file
+      ) VALUES (@id, @sessionId, @eventType, @sequence, @timestamp,
+        @role, @text, @toolName, @toolInput, @toolOutput,
+        @errorType, @errorMessage, @rawPayload, @sourceFile)
+    `);
+    const tx = this.db.transaction((records) => {
+      for (const record of records) {
+        stmt.run(record);
+      }
+    });
+    tx(events);
+  }
+  listBySession(sessionId, limit = 20) {
+    const rows = this.db.prepare("SELECT * FROM agent_events WHERE session_id = ? ORDER BY sequence DESC LIMIT ?").all(sessionId, limit);
+    return rows.map((row) => ({
+      id: row.id,
+      sessionId: row.session_id,
+      eventType: row.event_type,
+      sequence: row.sequence,
+      timestamp: row.timestamp,
+      role: row.role,
+      text: row.text,
+      toolName: row.tool_name,
+      toolInput: row.tool_input,
+      toolOutput: row.tool_output,
+      errorType: row.error_type,
+      errorMessage: row.error_message,
+      rawPayload: row.raw_payload,
+      sourceFile: row.source_file
+    }));
+  }
+  maxSequence(sessionId) {
+    const row = this.db.prepare("SELECT MAX(sequence) as max FROM agent_events WHERE session_id = ?").get(sessionId);
+    return row?.max ?? 0;
+  }
+};
+var MemoryEventStore = class {
+  events = /* @__PURE__ */ new Map();
+  insert(records) {
+    if (!records.length) return;
+    for (const record of records) {
+      const sessionEvents = this.events.get(record.sessionId) ?? [];
+      if (sessionEvents.some((existing) => existing.id === record.id)) continue;
+      sessionEvents.push(record);
+      this.events.set(record.sessionId, sessionEvents);
+    }
+  }
+  listBySession(sessionId, limit = 20) {
+    const events = this.events.get(sessionId) ?? [];
+    return [...events].sort((a, b) => b.sequence - a.sequence).slice(0, limit);
+  }
+  maxSequence(sessionId) {
+    const events = this.events.get(sessionId) ?? [];
+    if (!events.length) return 0;
+    return Math.max(...events.map((event) => event.sequence));
+  }
+};
+function loadSqlite() {
+  try {
+    return __require("better-sqlite3");
+  } catch (err) {
+    throw new Error("better-sqlite3 native bindings are unavailable. Rebuild dependencies or set MANAGERD_STORAGE=memory.");
+  }
+}
+function createEventStore() {
+  if (process.env.MANAGERD_STORAGE === "memory") {
+    return new MemoryEventStore();
+  }
+  return new SqliteEventStore();
+}
+
+// src/ingestion/codex-ingestor.ts
+import path5 from "path";
+import fs5 from "fs/promises";
+var CodexIngestor = class {
+  constructor(eventStore) {
+    this.eventStore = eventStore;
+  }
+  async ingest(session) {
+    const historyDir = process.env.MANAGER_CODEX_HISTORY ?? DEFAULT_CODEX_HISTORY;
+    const sessionDir = path5.join(historyDir, session.toolSessionId);
+    const transcriptPath = path5.join(
+      sessionDir,
+      process.env.MANAGER_CODEX_TRANSCRIPT ?? DEFAULT_CODEX_TRANSCRIPT
+    );
+    const warnings = [];
+    const stats = await fs5.stat(transcriptPath).catch(() => null);
+    if (!stats) {
+      warnings.push(`Transcript file not found at ${transcriptPath}`);
+      return { events: 0, warnings };
+    }
+    const content = await fs5.readFile(transcriptPath, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (err) {
+      warnings.push(`Failed to parse ${transcriptPath}: ${err.message}`);
+      return { events: 0, warnings };
+    }
+    const existingMax = this.eventStore.maxSequence(session.id);
+    const sourceFile = path5.basename(transcriptPath);
+    const records = normalizeCodexTranscript(session.id, parsed, existingMax, sourceFile);
+    this.eventStore.insert(records);
+    return { events: records.length, warnings };
+  }
+};
+function normalizeCodexTranscript(sessionId, transcript, startSequence, sourceFile = DEFAULT_CODEX_TRANSCRIPT) {
+  const records = [];
+  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, sequence) {
+  return `${sessionId}:${sequence}`;
+}
+function safeStringify(input) {
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return "";
+  }
+}
+
+// src/ingestion/claude-ingestor.ts
+var ClaudeIngestor = class {
+  constructor(store, events) {
+    this.store = store;
+    this.events = events;
+  }
+  ensureSession(sessionId) {
+    const existing = this.store.findByToolSession("claude", sessionId);
+    if (existing) {
+      return existing;
+    }
+    return this.store.createSession("claude", "claude-code", [], { toolSessionId: sessionId });
+  }
+  ingest(hook) {
+    const session = this.ensureSession(hook.sessionId);
+    const timestamp = parseTimestamp(hook.timestamp);
+    const baseSequence = this.events.maxSequence(session.id);
+    const record = mapClaudeHookToEvent(session.id, baseSequence + 1, hook, timestamp);
+    if (!record) {
+      return { inserted: 0 };
+    }
+    this.events.insert([record]);
+    if (record.eventType === "session_start") {
+      this.store.updateStatus(session.id, "running" /* Running */);
+    }
+    if (record.eventType === "session_end") {
+      this.store.updateStatus(session.id, "completed" /* Completed */);
+    }
+    return { inserted: 1 };
+  }
+};
+function parseTimestamp(value) {
+  if (!value) return Date.now();
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? Date.now() : ms;
+}
+function mapClaudeHookToEvent(sessionId, sequence, hook, timestamp) {
+  const payload = hook.payload ?? {};
+  const type = (hook.event || "").toLowerCase();
+  switch (type) {
+    case "sessionstart":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "session_start",
+        sequence,
+        timestamp,
+        role: "system",
+        text: payload.summary ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "sessionend":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "session_end",
+        sequence,
+        timestamp,
+        role: "system",
+        text: payload.summary ?? "Session ended",
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "userpromptsubmit":
+    case "userprompt":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "user_prompt",
+        sequence,
+        timestamp,
+        role: "user",
+        text: payload.prompt ?? payload.text ?? "",
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "pretooluse":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "tool_use",
+        sequence,
+        timestamp,
+        role: "assistant",
+        text: payload.commentary ?? null,
+        toolName: payload.toolName ?? payload.tool?.name ?? "unknown_tool",
+        toolInput: safeStringify2(payload.input ?? payload.toolInput),
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "posttooluse":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "tool_result",
+        sequence,
+        timestamp,
+        role: "assistant",
+        text: payload.commentary ?? null,
+        toolName: payload.toolName ?? payload.tool?.name ?? "unknown_tool",
+        toolOutput: safeStringify2(payload.result ?? payload.toolOutput ?? payload.output),
+        errorType: payload.error?.type ?? null,
+        errorMessage: payload.error?.message ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "permissionrequest":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "permission_request",
+        sequence,
+        timestamp,
+        role: "assistant",
+        text: payload.reason ?? payload.prompt ?? "Permission requested",
+        toolInput: safeStringify2(payload.details),
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    case "notification":
+      return {
+        id: buildEventId2(sessionId, sequence),
+        sessionId,
+        eventType: "notification",
+        sequence,
+        timestamp,
+        role: "system",
+        text: payload.message ?? payload.text ?? "Notification",
+        errorType: payload.severity ?? null,
+        rawPayload: JSON.stringify(hook),
+        sourceFile: "claude-hook"
+      };
+    default:
+      return null;
+  }
+}
+function buildEventId2(sessionId, sequence) {
+  return `${sessionId}:claude:${sequence}`;
+}
+function safeStringify2(input) {
+  if (input == null) return null;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+
+// src/ingestion/gemini-ingestor.ts
+var GeminiIngestor = class {
+  constructor(events) {
+    this.events = events;
+  }
+  ingest(session, payload) {
+    const warnings = [];
+    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 = [];
+    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 };
+  }
+};
+function collectGeminiBlocks(payload) {
+  const sourceArrays = [payload.messages, payload.events, payload.chats].filter(
+    Array.isArray
+  );
+  const blocks = [];
+  for (const messages of sourceArrays) {
+    for (const message of messages) {
+      blocks.push(...normalizeGeminiMessage(message));
+    }
+  }
+  return blocks;
+}
+function normalizeGeminiMessage(message) {
+  const role = message.role || inferRoleFromType(message.type);
+  const timestamp = message.timestamp;
+  const blocks = [];
+  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, sequence, block) {
+  const timestamp = block.timestamp ? parseTimestamp2(block.timestamp) : Date.now();
+  const base = {
+    id: `${sessionId}:gemini:${sequence}`,
+    sessionId,
+    eventType: block.kind,
+    sequence,
+    timestamp,
+    role: block.role ?? "assistant",
+    rawPayload: block.raw ? safeStringify3(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: safeStringify3(block.toolInput) };
+  }
+  if (block.kind === "tool_result") {
+    return { ...base, toolName: block.toolName ?? "unknown_tool", toolOutput: safeStringify3(block.toolOutput) };
+  }
+  return null;
+}
+function inferRoleFromType(type) {
+  if (!type) return void 0;
+  const value = type.toLowerCase();
+  if (value.includes("user")) return "user";
+  if (value.includes("system")) return "system";
+  return "assistant";
+}
+function safeStringify3(input) {
+  if (input == null) return null;
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function parseTimestamp2(value) {
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? Date.now() : ms;
+}
+
+// src/watchers/gemini-log-watcher.ts
+import path7 from "path";
+import fs7 from "fs/promises";
+
+// src/utils/logger.ts
+import pino from "pino";
+import path6 from "path";
+import fs6 from "fs";
+if (!fs6.existsSync(DATA_DIRS.logs)) {
+  fs6.mkdirSync(DATA_DIRS.logs, { recursive: true });
+}
+var logger = pino({
+  level: process.env.LOG_LEVEL ?? "info",
+  base: void 0
+}, pino.destination(path6.join(DATA_DIRS.logs, "managerd.log")));
+
+// src/watchers/gemini-log-watcher.ts
+var GeminiLogWatcher = class {
+  #store;
+  #ingestor;
+  #rootDir;
+  #interval;
+  #timer;
+  #seen = /* @__PURE__ */ new Map();
+  constructor(store, ingestor, options = {}) {
+    this.#store = store;
+    this.#ingestor = ingestor;
+    this.#rootDir = options.rootDir ?? process.env.MANAGER_GEMINI_LOG_ROOT ?? path7.join(process.env.HOME || "", ".gemini", "tmp");
+    this.#interval = options.intervalMs ?? 5e3;
+  }
+  start() {
+    if (this.#timer) return;
+    this.#timer = setInterval(() => {
+      this.scan().catch((err) => logger.warn({ err }, "gemini log scan failed"));
+    }, this.#interval);
+    void this.scan();
+  }
+  stop() {
+    if (!this.#timer) return;
+    clearInterval(this.#timer);
+    this.#timer = void 0;
+  }
+  async scan() {
+    let dirs = [];
+    try {
+      const rootEntries = await fs7.readdir(this.#rootDir, { withFileTypes: true });
+      for (const entry of rootEntries) {
+        if (entry.isDirectory()) {
+          const chatsDir = path7.join(this.#rootDir, entry.name, "chats");
+          dirs.push(chatsDir);
+        }
+      }
+    } catch (err) {
+      if (err?.code !== "ENOENT") {
+        logger.debug({ err }, "gemini root not accessible");
+      }
+      return;
+    }
+    for (const dir of dirs) {
+      let files = [];
+      try {
+        const entries = await fs7.readdir(dir, { withFileTypes: true });
+        files = entries.filter((d) => d.isFile() && /session-.*\.(jsonl?|log)$/i.test(d.name)).map((d) => path7.join(dir, d.name));
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          logger.debug({ err }, "failed to read gemini chat dir");
+        }
+        continue;
+      }
+      for (const filePath of files) {
+        await this.processFile(filePath);
+      }
+    }
+  }
+  async processFile(filePath) {
+    let stats;
+    try {
+      stats = await fs7.stat(filePath);
+    } catch {
+      return;
+    }
+    const lastProcessed = this.#seen.get(filePath) ?? 0;
+    if (stats.mtimeMs <= lastProcessed) {
+      return;
+    }
+    let text;
+    try {
+      text = await fs7.readFile(filePath, "utf8");
+    } catch (err) {
+      logger.warn({ err }, "failed to read gemini session file");
+      return;
+    }
+    const payload = parseGeminiFile(text);
+    if (!payload) {
+      logger.warn({ filePath }, "unable to parse gemini session file");
+      this.#seen.set(filePath, stats.mtimeMs);
+      return;
+    }
+    const sessionId = payload.sessionId ?? inferSessionIdFromPath(filePath);
+    const session = this.#store.findByToolSession("gemini", sessionId) ?? this.#store.createSession("gemini", "gemini-cli", [], { toolSessionId: sessionId });
+    try {
+      this.#ingestor.ingest(session, payload);
+      this.#seen.set(filePath, stats.mtimeMs);
+    } catch (err) {
+      logger.error({ err }, "gemini ingestion failed");
+    }
+  }
+};
+function parseGeminiFile(contents) {
+  const trimmed = contents.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return { messages: parsed };
+    }
+    return parsed;
+  } catch {
+    const lines = trimmed.split(/\r?\n/).filter(Boolean);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    if (!messages.length) return null;
+    return { messages };
+  }
+}
+function inferSessionIdFromPath(filePath) {
+  const base = path7.basename(filePath);
+  return base.replace(/\.[^.]+$/, "") || `gemini-${Date.now()}`;
+}
+
+// src/daemon/http-server.ts
+var ManagerDaemon = class {
+  #store;
+  #codex;
+  #gemini;
+  #events;
+  #codexIngestor;
+  #claudeIngestor;
+  #geminiIngestor;
+  #geminiWatcher;
+  #server;
+  #startedAt = Date.now();
+  #host;
+  #port;
+  constructor(store = createSessionStore(), options = {}) {
+    this.#store = store;
+    this.#codex = new CodexConnector(this.#store);
+    this.#gemini = new GeminiConnector(this.#store);
+    this.#events = createEventStore();
+    this.#codexIngestor = new CodexIngestor(this.#events);
+    this.#claudeIngestor = new ClaudeIngestor(this.#store, this.#events);
+    this.#geminiIngestor = new GeminiIngestor(this.#events);
+    this.#geminiWatcher = new GeminiLogWatcher(this.#store, this.#geminiIngestor);
+    this.#host = options.host ?? DEFAULT_HOST;
+    this.#port = options.port ?? DEFAULT_PORT;
+  }
+  async start() {
+    if (this.#server) return;
+    this.#server = http.createServer((req, res) => {
+      this.route(req, res).catch((err) => {
+        logger.error({ err }, "unhandled daemon error");
+        this.writeJson(res, 500, { ok: false, error: "internal_error" });
+      });
+    });
+    await new Promise((resolve) => {
+      this.#server.listen(this.#port, this.#host, () => {
+        logger.info({ host: this.#host, port: this.#port }, "managerd listening");
+        resolve();
+      });
+    });
+    this.#geminiWatcher.start();
+  }
+  async stop() {
+    this.#geminiWatcher.stop();
+    if (!this.#server) return;
+    await new Promise((resolve, reject) => {
+      this.#server.close((err) => err ? reject(err) : resolve());
+    });
+    this.#server = void 0;
+  }
+  async route(req, res) {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (req.method === "GET" && url.pathname === "/healthz") {
+      return this.writeJson(res, 200, { ok: true });
+    }
+    if (req.method === "GET" && url.pathname === "/status") {
+      const sessions = this.#store.listRecent(5);
+      return this.writeJson(res, 200, {
+        ok: true,
+        uptimeMs: Date.now() - this.#startedAt,
+        codex: describeCodexConnector(),
+        gemini: describeGeminiConnector(),
+        runningSessions: sessions.filter((s) => s.status === "running" /* Running */).length,
+        sessions
+      });
+    }
+    if (req.method === "GET" && url.pathname === "/sessions") {
+      return this.writeJson(res, 200, { ok: true, sessions: this.#store.listRecent(25) });
+    }
+    if (req.method === "POST" && url.pathname === "/rpc/launch") {
+      const body = await this.parseJson(req);
+      const agent = body?.agent ?? "codex";
+      if (agent === "codex") {
+        const result = await this.#codex.launch({
+          command: body?.command,
+          args: body?.args,
+          disableManagedFlags: body?.disableManagedFlags,
+          autoRestart: body?.autoRestart !== false,
+          maxRestarts: body?.maxRestarts ?? 3
+        });
+        return this.writeJson(res, 200, { ok: true, result });
+      }
+      if (agent === "gemini") {
+        const result = await this.#gemini.launch({
+          command: body?.command,
+          args: body?.args,
+          autoRestart: body?.autoRestart !== false,
+          maxRestarts: body?.maxRestarts ?? 3
+        });
+        return this.writeJson(res, 200, { ok: true, result });
+      }
+      return this.writeJson(res, 400, { ok: false, error: "unsupported_agent" });
+    }
+    if (req.method === "POST" && url.pathname === "/hooks/claude") {
+      return this.handleClaudeHook(req, res);
+    }
+    if (req.method === "POST" && url.pathname === "/rpc/gemini/ingest") {
+      return this.handleGeminiIngest(req, res);
+    }
+    if (req.method === "POST" && url.pathname === "/rpc/sessions/events") {
+      const body = await this.parseJson(req);
+      const sessionId = body?.sessionId;
+      const limit = Number(body?.limit ?? 20);
+      if (!sessionId) {
+        return this.writeJson(res, 400, { ok: false, error: "missing_session_id" });
+      }
+      const session = this.#store.get(sessionId);
+      if (!session) {
+        return this.writeJson(res, 404, { ok: false, error: "session_not_found" });
+      }
+      let warnings = [];
+      try {
+        const result = await this.#codexIngestor.ingest(session);
+        warnings = result.warnings;
+      } catch (err) {
+        warnings.push(`Ingestion failed: ${err.message}`);
+      }
+      const events = this.#events.listBySession(sessionId, limit);
+      return this.writeJson(res, 200, { ok: true, session, events, warnings });
+    }
+    this.writeJson(res, 404, { ok: false, error: "not_found" });
+  }
+  async handleClaudeHook(_req, res) {
+    const body = await this.parseJson(_req);
+    const incoming = Array.isArray(body?.events) ? body.events : [body];
+    if (!incoming.length) {
+      return this.writeJson(res, 400, { ok: false, error: "no_events" });
+    }
+    const results = incoming.map((raw) => {
+      if (!raw || typeof raw !== "object") {
+        return { ok: false, error: "invalid_event" };
+      }
+      const eventName = raw.event ?? raw.type;
+      const sessionId = raw.sessionId ?? raw.session_id;
+      if (!eventName || !sessionId) {
+        return { ok: false, error: "missing_fields", sessionId };
+      }
+      const hookEvent = {
+        event: String(eventName),
+        sessionId: String(sessionId),
+        timestamp: raw.timestamp,
+        payload: raw.payload ?? raw.data ?? raw
+      };
+      try {
+        const result = this.#claudeIngestor.ingest(hookEvent);
+        return { ok: true, sessionId: hookEvent.sessionId, inserted: result.inserted };
+      } catch (err) {
+        logger.error({ err }, "claude hook ingestion failed");
+        return { ok: false, sessionId: hookEvent.sessionId, error: err?.message ?? "ingest_failed" };
+      }
+    });
+    const ok = results.every((item) => item.ok);
+    return this.writeJson(res, ok ? 202 : 207, { ok, results });
+  }
+  async handleGeminiIngest(req, res) {
+    const body = await this.parseJson(req);
+    const data = body?.data;
+    const fileHint = body?.filePath;
+    if (!data || typeof data !== "object") {
+      return this.writeJson(res, 400, { ok: false, error: "missing_payload" });
+    }
+    const providedId = body?.sessionId ?? data.sessionId ?? data["id"];
+    const sessionId = (providedId || fileHint || `gemini-${Date.now()}`).toString();
+    let session = this.#store.findByToolSession("gemini", sessionId);
+    if (!session) {
+      session = this.#store.createSession("gemini", "gemini-cli", [], { toolSessionId: sessionId });
+    }
+    try {
+      const result = this.#geminiIngestor.ingest(session, data);
+      return this.writeJson(res, 200, { ok: true, inserted: result.inserted, warnings: result.warnings });
+    } catch (err) {
+      logger.error({ err }, "gemini ingest failed");
+      return this.writeJson(res, 500, { ok: false, error: err?.message ?? "ingest_failed" });
+    }
+  }
+  async parseJson(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch (err) {
+      logger.warn({ err }, "failed to parse json");
+      return {};
+    }
+  }
+  writeJson(res, status, payload) {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, {
+      "content-type": "application/json",
+      "content-length": Buffer.byteLength(body)
+    });
+    res.end(body);
+  }
+};
+
+// src/daemon/index.ts
+async function startDaemon() {
+  await ensureBaseDirs(DATA_DIRS.root);
+  await ensurePidAvailable();
+  const daemon = new ManagerDaemon();
+  let cleanedUp = false;
+  const cleanup = async () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    await daemon.stop().catch(() => {
+    });
+    await removePidFile();
+  };
+  process2.on("SIGINT", async () => {
+    logger.info("received SIGINT, shutting down");
+    await cleanup();
+    process2.exit(0);
+  });
+  process2.on("SIGTERM", async () => {
+    logger.info("received SIGTERM, shutting down");
+    await cleanup();
+    process2.exit(0);
+  });
+  process2.on("exit", () => {
+    void cleanup();
+  });
+  await daemon.start();
+  await fs8.writeFile(PID_FILE, String(process2.pid), "utf8");
+  logger.info("managerd is running. Press Ctrl+C to exit.");
+}
+async function ensurePidAvailable() {
+  try {
+    const contents = await fs8.readFile(PID_FILE, "utf8");
+    const pid = Number(contents.trim());
+    if (Number.isFinite(pid) && isProcessAlive(pid)) {
+      throw new Error(`managerd already running (pid ${pid})`);
+    }
+    await removePidFile();
+  } catch {
+  }
+}
+async function removePidFile() {
+  await fs8.unlink(PID_FILE).catch(() => {
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process2.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  startDaemon
+};