@just-every/manager 0.2.0

package/src/storage/event-store.ts

@@ -0,0 +1,153 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { DB_PATH } from '../constants.js';
+import { ensureDir } from '../utils/fs.js';
+
+export interface AgentEventRecord {
+  id: string;
+  sessionId: string;
+  eventType: string;
+  sequence: number;
+  timestamp: number;
+  role?: string | null;
+  text?: string | null;
+  toolName?: string | null;
+  toolInput?: string | null;
+  toolOutput?: string | null;
+  errorType?: string | null;
+  errorMessage?: string | null;
+  rawPayload?: string | null;
+  sourceFile?: string | null;
+}
+
+export interface EventStore {
+  insert(events: AgentEventRecord[]): void;
+  listBySession(sessionId: string, limit?: number): AgentEventRecord[];
+  maxSequence(sessionId: string): number;
+}
+
+class SqliteEventStore implements EventStore {
+  private db: import('better-sqlite3');
+
+  constructor(dbPath: string = DB_PATH) {
+    const dir = path.dirname(dbPath);
+    ensureDir(dir);
+    const Database = loadSqlite();
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.migrate();
+  }
+
+  private 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: AgentEventRecord[]): void {
+    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: AgentEventRecord[]) => {
+      for (const record of records) {
+        stmt.run(record);
+      }
+    });
+    tx(events);
+  }
+
+  listBySession(sessionId: string, limit = 20): AgentEventRecord[] {
+    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: string): number {
+    const row = this.db
+      .prepare('SELECT MAX(sequence) as max FROM agent_events WHERE session_id = ?')
+      .get(sessionId);
+    return row?.max ?? 0;
+  }
+}
+
+class MemoryEventStore implements EventStore {
+  private events = new Map<string, AgentEventRecord[]>();
+
+  insert(records: AgentEventRecord[]): void {
+    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: string, limit = 20): AgentEventRecord[] {
+    const events = this.events.get(sessionId) ?? [];
+    return [...events]
+      .sort((a, b) => b.sequence - a.sequence)
+      .slice(0, limit);
+  }
+
+  maxSequence(sessionId: string): number {
+    const events = this.events.get(sessionId) ?? [];
+    if (!events.length) return 0;
+    return Math.max(...events.map((event) => event.sequence));
+  }
+}
+
+function loadSqlite(): typeof import('better-sqlite3') {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require('better-sqlite3');
+  } catch (err) {
+    throw new Error('better-sqlite3 native bindings are unavailable. Rebuild dependencies or set MANAGERD_STORAGE=memory.');
+  }
+}
+
+export function createEventStore(): EventStore {
+  if (process.env.MANAGERD_STORAGE === 'memory') {
+    return new MemoryEventStore();
+  }
+  return new SqliteEventStore();
+}

package/src/storage/session-store.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { MemorySessionStore } from './session-store.js';
+import { SessionStatus } from '../constants.js';
+
+describe('SessionStore', () => {
+  it('creates and updates sessions', async () => {
+    const store = new MemorySessionStore();
+    const created = store.createSession('codex', 'codex', ['--foo']);
+
+    expect(created.agentType).toBe('codex');
+    expect(created.status).toBe(SessionStatus.Launching);
+
+    store.updateStatus(created.id, SessionStatus.Running);
+    const refreshed = store.get(created.id);
+    expect(refreshed?.status).toBe(SessionStatus.Running);
+
+    store.updateStatus(created.id, SessionStatus.Completed, 0);
+    const done = store.get(created.id);
+    expect(done?.status).toBe(SessionStatus.Completed);
+    expect(done?.exitCode).toBe(0);
+
+    const recent = store.listRecent(5);
+    expect(recent.length).toBe(1);
+    expect(recent[0].id).toBe(created.id);
+
+    const external = store.findByToolSession('codex', created.toolSessionId);
+    expect(external?.id).toBe(created.id);
+
+    const override = store.createSession('claude', 'claude', [], { toolSessionId: 'claude-session' });
+    expect(override.toolSessionId).toBe('claude-session');
+    const found = store.findByToolSession('claude', 'claude-session');
+    expect(found?.id).toBe(override.id);
+  });
+});

package/src/storage/session-store.ts

@@ -0,0 +1,231 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { AgentType, DB_PATH, SessionStatus } from '../constants.js';
+import { ensureDir } from '../utils/fs.js';
+
+export interface SessionRecord {
+  id: string;
+  agentType: AgentType;
+  toolSessionId: string;
+  status: SessionStatus;
+  command: string;
+  args: string[];
+  createdAt: string;
+  updatedAt: string;
+  exitCode: number | null;
+}
+
+export interface CreateSessionOptions {
+  toolSessionId?: string;
+}
+
+export interface SessionStore {
+  createSession(
+    agentType: AgentType,
+    command: string,
+    args: string[],
+    options?: CreateSessionOptions,
+  ): SessionRecord;
+  updateStatus(id: string, status: SessionStatus, exitCode?: number | null): void;
+  listRecent(limit?: number): SessionRecord[];
+  get(id: string): SessionRecord | null;
+  findByToolSession(agentType: AgentType, toolSessionId: string): SessionRecord | null;
+}
+
+type DatabaseModule = typeof import('better-sqlite3');
+let cachedDatabase: DatabaseModule | null = null;
+
+function loadDatabase(): DatabaseModule {
+  if (cachedDatabase) return cachedDatabase;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    cachedDatabase = require('better-sqlite3');
+    return cachedDatabase;
+  } catch (err) {
+    throw new Error('better-sqlite3 native bindings are unavailable. Rebuild dependencies or set MANAGERD_STORAGE=memory.');
+  }
+}
+
+export class SqliteSessionStore implements SessionStore {
+  private db: import('better-sqlite3');
+
+  constructor(dbPath: string = DB_PATH) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const Database = loadDatabase();
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.migrate();
+  }
+
+  private 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: AgentType,
+    command: string,
+    args: string[],
+    options: CreateSessionOptions = {},
+  ): SessionRecord {
+    const id = randomUUID();
+    const now = 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: SessionStatus.Launching,
+        command,
+        args: JSON.stringify(args),
+        createdAt: now,
+        updatedAt: now,
+      });
+    return {
+      id,
+      agentType,
+      toolSessionId,
+      status: SessionStatus.Launching,
+      command,
+      args,
+      createdAt: now,
+      updatedAt: now,
+      exitCode: null,
+    };
+  }
+
+  updateStatus(id: string, status: SessionStatus, exitCode: number | null = null) {
+    this.db
+      .prepare(`
+        UPDATE local_sessions
+        SET status=@status, exit_code=@exitCode, updated_at=@updatedAt
+        WHERE id=@id
+      `)
+      .run({ id, status, exitCode, updatedAt: new Date().toISOString() });
+  }
+
+  listRecent(limit = 10): SessionRecord[] {
+    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: string): SessionRecord | null {
+    const row = this.db.prepare(`SELECT * FROM local_sessions WHERE id=? LIMIT 1`).get(id);
+    return row ? this.denormalize(row) : null;
+  }
+
+  private denormalize(row: any): SessionRecord {
+    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: AgentType, toolSessionId: string): SessionRecord | null {
+    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;
+  }
+}
+
+export class MemorySessionStore implements SessionStore {
+  private records = new Map<string, SessionRecord>();
+  private toolIndex = new Map<string, SessionRecord>();
+
+  createSession(
+    agentType: AgentType,
+    command: string,
+    args: string[],
+    options: CreateSessionOptions = {},
+  ): SessionRecord {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    const record: SessionRecord = {
+      id,
+      agentType,
+      toolSessionId: options.toolSessionId ?? id,
+      status: SessionStatus.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: string, status: SessionStatus, exitCode: number | null = null) {
+    const record = this.records.get(id);
+    if (!record) return;
+    record.status = status;
+    record.exitCode = exitCode;
+    record.updatedAt = new Date().toISOString();
+    this.toolIndex.set(this.toolKey(record.agentType, record.toolSessionId), record);
+  }
+
+  listRecent(limit = 10): SessionRecord[] {
+    return Array.from(this.records.values())
+      .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1))
+      .slice(0, limit);
+  }
+
+  get(id: string): SessionRecord | null {
+    return this.records.get(id) ?? null;
+  }
+
+  findByToolSession(agentType: AgentType, toolSessionId: string): SessionRecord | null {
+    return this.toolIndex.get(this.toolKey(agentType, toolSessionId)) ?? null;
+  }
+
+  private toolKey(agentType: AgentType, toolSessionId: string): string {
+    return `${agentType}:${toolSessionId}`;
+  }
+}
+
+export function createSessionStore(): SessionStore {
+  if (process.env.MANAGERD_STORAGE === 'memory') {
+    return new MemorySessionStore();
+  }
+  return new SqliteSessionStore();
+}
+
+export async function ensureBaseDirs(dir: string) {
+  await ensureDir(dir);
+  await ensureDir(path.join(dir, 'logs'));
+  await ensureDir(path.join(dir, 'sessions'));
+}

package/src/utils/fs.ts

@@ -0,0 +1,19 @@
+import fs from 'node:fs/promises';
+
+export async function ensureDir(dir: string): Promise<void> {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+export async function writeFileAtomic(filePath: string, contents: string): Promise<void> {
+  await fs.mkdir(require('node:path').dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, contents, 'utf8');
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,13 @@
+import pino from 'pino';
+import path from 'node:path';
+import fs from 'node:fs';
+import { DATA_DIRS } from '../constants.js';
+
+if (!fs.existsSync(DATA_DIRS.logs)) {
+  fs.mkdirSync(DATA_DIRS.logs, { recursive: true });
+}
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL ?? 'info',
+  base: undefined,
+}, pino.destination(path.join(DATA_DIRS.logs, 'managerd.log')));

package/src/watchers/gemini-log-watcher.ts

@@ -0,0 +1,141 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { SessionStore } from '../storage/session-store.js';
+import { GeminiIngestor, GeminiSessionPayload } from '../ingestion/gemini-ingestor.js';
+import { logger } from '../utils/logger.js';
+
+export interface GeminiLogWatcherOptions {
+  rootDir?: string;
+  intervalMs?: number;
+}
+
+export class GeminiLogWatcher {
+  #store: SessionStore;
+  #ingestor: GeminiIngestor;
+  #rootDir: string;
+  #interval: number;
+  #timer?: NodeJS.Timer;
+  #seen = new Map<string, number>();
+
+  constructor(store: SessionStore, ingestor: GeminiIngestor, options: GeminiLogWatcherOptions = {}) {
+    this.#store = store;
+    this.#ingestor = ingestor;
+    this.#rootDir = options.rootDir ?? process.env.MANAGER_GEMINI_LOG_ROOT ?? path.join(process.env.HOME || '', '.gemini', 'tmp');
+    this.#interval = options.intervalMs ?? 5000;
+  }
+
+  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 = undefined;
+  }
+
+  private async scan() {
+    let dirs: string[] = [];
+    try {
+      const rootEntries = await fs.readdir(this.#rootDir, { withFileTypes: true });
+      for (const entry of rootEntries) {
+        if (entry.isDirectory()) {
+          const chatsDir = path.join(this.#rootDir, entry.name, 'chats');
+          dirs.push(chatsDir);
+        }
+      }
+    } catch (err: any) {
+      if (err?.code !== 'ENOENT') {
+        logger.debug({ err }, 'gemini root not accessible');
+      }
+      return;
+    }
+
+    for (const dir of dirs) {
+      let files: string[] = [];
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        files = entries.filter((d) => d.isFile() && /session-.*\.(jsonl?|log)$/i.test(d.name)).map((d) => path.join(dir, d.name));
+      } catch (err: any) {
+        if (err?.code !== 'ENOENT') {
+          logger.debug({ err }, 'failed to read gemini chat dir');
+        }
+        continue;
+      }
+
+      for (const filePath of files) {
+        await this.processFile(filePath);
+      }
+    }
+  }
+
+  private async processFile(filePath: string) {
+    let stats;
+    try {
+      stats = await fs.stat(filePath);
+    } catch {
+      return;
+    }
+    const lastProcessed = this.#seen.get(filePath) ?? 0;
+    if (stats.mtimeMs <= lastProcessed) {
+      return;
+    }
+
+    let text: string;
+    try {
+      text = await fs.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: string): GeminiSessionPayload | null {
+  const trimmed = contents.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      return { messages: parsed };
+    }
+    return parsed as GeminiSessionPayload;
+  } catch {
+    const lines = trimmed.split(/\r?\n/).filter(Boolean);
+    const messages = [];
+    for (const line of lines) {
+      try {
+        messages.push(JSON.parse(line));
+      } catch {
+        // ignore malformed lines
+      }
+    }
+    if (!messages.length) return null;
+    return { messages };
+  }
+}
+
+function inferSessionIdFromPath(filePath: string): string {
+  const base = path.basename(filePath);
+  return base.replace(/\.[^.]+$/, '') || `gemini-${Date.now()}`;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "module": "esnext",
+    "target": "es2022",
+    "rootDir": "src",
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    environment: 'node',
+    coverage: {
+      reporter: ['text', 'lcov'],
+    },
+  },
+});