cross-agent-teams-mcp 0.2.0

package/src/storage/agents-repo.ts

@@ -0,0 +1,328 @@
+import type Database from 'better-sqlite3'
+import { randomUUID } from 'node:crypto'
+import {
+  parseDeliveryRow,
+  serializeDelivery,
+  type DeliverySpec,
+  type DeliveryRow,
+} from '../lib/delivery-spec.js'
+import type { ClientKind } from '../lib/client-kind.js'
+
+export interface RegisterInput {
+  client?: ClientKind
+  client_name?: string
+  model: string
+  name: string
+  role?: string
+  team?: string
+  tmux_pane_id?: string
+  delivery?: DeliverySpec
+  claude_ui_pid?: number
+  runtime_ui_pid?: number
+}
+
+export interface AgentRow {
+  agent_id: string
+  client: ClientKind | null
+  client_name: string | null
+  team: string
+  role: string
+  name: string
+  model: string | null
+  tmux_pane_id: string | null
+  delivery: DeliverySpec
+  channel_session_id: string | null
+  last_seen_at: string
+}
+
+export interface AgentListRow extends AgentRow {
+  online: boolean
+}
+
+export const ONLINE_MS = 5 * 60 * 1000
+
+type DbAgentRow = {
+  agent_id: string
+  client: ClientKind | null
+  client_name: string | null
+  team: string
+  role: string
+  name: string
+  model: string | null
+  tmux_pane_id: string | null
+  last_seen_at: string
+} & DeliveryRow
+
+function toAgentRow(row: DbAgentRow): AgentRow {
+  const delivery = parseDeliveryRow(row)
+  return {
+    agent_id: row.agent_id,
+    client: row.client,
+    client_name: row.client_name,
+    team: row.team,
+    role: row.role,
+    name: row.name,
+    model: row.model,
+    tmux_pane_id: row.tmux_pane_id,
+    delivery,
+    channel_session_id:
+      delivery.kind === 'claude-channel' ? delivery.channel_session_id : null,
+    last_seen_at: row.last_seen_at,
+  }
+}
+
+export class AgentsRepo {
+  constructor(private db: Database.Database) {}
+
+  findByIdentity(args: { team: string; name: string }): { agent_id: string } | undefined {
+    return this.db.prepare(
+      `SELECT agent_id FROM agents WHERE team=? AND name=?`
+    ).get(args.team, args.name) as { agent_id: string } | undefined
+  }
+
+  register(input: RegisterInput): {
+    agent_id: string
+    team: string
+  } {
+    const team = input.team ?? 'default'
+    const role = input.role ?? 'default'
+    const name = input.name
+    const now = new Date().toISOString()
+    const newId = randomUUID()
+    const delivery = input.delivery ?? { kind: 'none' }
+    const serialized = serializeDelivery(delivery)
+    const preserveExistingDelivery = input.delivery === undefined ? 1 : 0
+    const tx = this.db.transaction(() => {
+      this.writeAgentRow({
+        newId,
+        input,
+        team,
+        role,
+        name,
+        now,
+        serialized,
+        preserveExistingDelivery,
+      })
+      const rebindCsid =
+        role === '__channel_proxy__' &&
+        input.claude_ui_pid !== undefined &&
+        delivery.kind === 'claude-channel'
+          ? delivery.channel_session_id
+          : undefined
+      if (rebindCsid !== undefined) {
+        this.reactiveRebindHosts({
+          team,
+          claude_ui_pid: input.claude_ui_pid!,
+          new_csid: rebindCsid,
+        })
+      }
+    })
+    tx()
+    const row = this.db.prepare(`SELECT agent_id FROM agents WHERE team=? AND name=?`).get(team, name) as { agent_id: string }
+    return { agent_id: row.agent_id, team }
+  }
+
+  private writeAgentRow(args: {
+    newId: string
+    input: RegisterInput
+    team: string
+    role: string
+    name: string
+    now: string
+    serialized: ReturnType<typeof serializeDelivery>
+    preserveExistingDelivery: number
+  }): void {
+    const { newId, input, team, role, name, now, serialized, preserveExistingDelivery } = args
+    this.db.prepare(
+      `INSERT INTO agents (
+         agent_id, client, client_name, team, role, name, model, registered_at, last_seen_at,
+         tmux_pane_id, claude_ui_pid, runtime_ui_pid, delivery_kind, delivery_payload
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (team, name) DO UPDATE SET
+         client = excluded.client,
+         client_name = excluded.client_name,
+         role = excluded.role,
+         model = excluded.model,
+         last_seen_at = excluded.last_seen_at,
+         tmux_pane_id = COALESCE(excluded.tmux_pane_id, tmux_pane_id),
+         claude_ui_pid = COALESCE(excluded.claude_ui_pid, claude_ui_pid),
+         runtime_ui_pid = COALESCE(excluded.runtime_ui_pid, runtime_ui_pid),
+         delivery_kind = CASE
+           WHEN ? THEN delivery_kind
+           ELSE excluded.delivery_kind
+         END,
+         delivery_payload = CASE
+           WHEN ? THEN delivery_payload
+           ELSE excluded.delivery_payload
+         END`
+    ).run(
+      newId,
+      input.client ?? null,
+      input.client_name ?? null,
+      team,
+      role,
+      name,
+      input.model,
+      now,
+      now,
+      input.tmux_pane_id ?? null,
+      input.claude_ui_pid ?? null,
+      input.runtime_ui_pid ?? null,
+      serialized.delivery_kind,
+      serialized.delivery_payload,
+      preserveExistingDelivery,
+      preserveExistingDelivery,
+    )
+  }
+
+  private reactiveRebindHosts(args: {
+    team: string
+    claude_ui_pid: number
+    new_csid: string
+  }): void {
+    this.db.prepare(
+      `UPDATE agents
+       SET delivery_kind = 'claude-channel',
+           delivery_payload = json_object('channel_session_id', ?)
+       WHERE role != '__channel_proxy__'
+         AND runtime_ui_pid IS NOT NULL
+         AND runtime_ui_pid = ?
+         AND team = ?
+         AND (
+           delivery_kind = 'none'
+           OR (delivery_kind = 'claude-channel'
+               AND json_extract(delivery_payload,'$.channel_session_id') != ?)
+         )`
+    ).run(args.new_csid, args.claude_ui_pid, args.team, args.new_csid)
+  }
+
+  setDelivery(agent_id: string, spec: DeliverySpec): void {
+    const serialized = serializeDelivery(spec)
+    this.db.prepare(
+      `UPDATE agents
+       SET delivery_kind=?, delivery_payload=?
+       WHERE agent_id=?`
+    ).run(serialized.delivery_kind, serialized.delivery_payload, agent_id)
+  }
+
+  setClient(agent_id: string, client: ClientKind, client_name?: string | null): void {
+    this.db.prepare(
+      `UPDATE agents
+       SET client=?,
+           client_name=?
+       WHERE agent_id=?`
+    ).run(client, client_name ?? null, agent_id)
+  }
+
+  setRuntimeBinding(
+    agent_id: string,
+    args: {
+      tmux_pane_id: string
+      runtime_ui_pid: number | null
+      runtime_tty: string
+      runtime_verification_mode: string
+      runtime_bound_at?: string
+    }
+  ): void {
+    this.db.prepare(
+      `UPDATE agents
+       SET tmux_pane_id=?,
+           runtime_ui_pid=?,
+           runtime_tty=?,
+           runtime_verification_mode=?,
+           runtime_bound_at=?
+       WHERE agent_id=?`
+    ).run(
+      args.tmux_pane_id,
+      args.runtime_ui_pid,
+      args.runtime_tty,
+      args.runtime_verification_mode,
+      args.runtime_bound_at ?? new Date().toISOString(),
+      agent_id
+    )
+  }
+
+  list(args: { team: string }): AgentListRow[] {
+    const rows = this.db.prepare(
+      `SELECT
+         agent_id,
+         client,
+         client_name,
+         team,
+         role,
+         name,
+         model,
+         tmux_pane_id,
+         delivery_kind,
+         delivery_payload,
+         last_seen_at
+       FROM agents
+       WHERE team=?
+       ORDER BY registered_at ASC`
+    ).all(args.team) as DbAgentRow[]
+    const nowMs = Date.now()
+    return rows.map((row) => {
+      const agent = toAgentRow(row)
+      return {
+        ...agent,
+        online: nowMs - new Date(agent.last_seen_at).getTime() < ONLINE_MS,
+      }
+    })
+  }
+
+  touch(agent_id: string): void {
+    this.db.prepare(`UPDATE agents SET last_seen_at=? WHERE agent_id=?`).run(new Date().toISOString(), agent_id)
+  }
+
+  listClaimedInProgressTaskIds(args: { agent_id: string; team: string }): string[] {
+    const rows = this.db.prepare(
+      `SELECT id
+       FROM tasks
+       WHERE team=? AND claimed_by=? AND status='in_progress'
+       ORDER BY id ASC`
+    ).all(args.team, args.agent_id) as Array<{ id: string }>
+    return rows.map((row) => row.id)
+  }
+
+  deleteContractSubscriptions(args: { agent_id: string; team: string }): number {
+    const result = this.db.prepare(
+      `DELETE FROM contract_subscriptions
+       WHERE agent_id=? AND team=?`
+    ).run(args.agent_id, args.team)
+    return result.changes
+  }
+
+  deleteById(agent_id: string): boolean {
+    const result = this.db.prepare(
+      `DELETE FROM agents
+       WHERE agent_id=?`
+    ).run(agent_id)
+    return result.changes === 1
+  }
+
+  getById(agent_id: string): AgentRow | undefined {
+    const row = this.db.prepare(
+      `SELECT
+         agent_id,
+         client,
+         client_name,
+         team,
+         role,
+         name,
+         model,
+         tmux_pane_id,
+         delivery_kind,
+         delivery_payload,
+         last_seen_at
+       FROM agents
+       WHERE agent_id=?`
+    ).get(agent_id) as DbAgentRow | undefined
+    if (!row) return undefined
+    return toAgentRow(row)
+  }
+
+  findById(agent_id: string): AgentRow | undefined {
+    return this.getById(agent_id)
+  }
+}

package/src/storage/db.ts

@@ -0,0 +1,13 @@
+import Database from 'better-sqlite3'
+import { mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export function openDb(path: string): Database.Database {
+  mkdirSync(dirname(path), { recursive: true })
+  const db = new Database(path)
+  db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
+  db.pragma('synchronous = NORMAL')
+  db.pragma('foreign_keys = ON')
+  return db
+}

package/src/storage/events-outbox.ts

@@ -0,0 +1,44 @@
+import type Database from 'better-sqlite3'
+
+export interface EventRow {
+  event_id: number
+  from_team: string
+  to_team: string
+  event_type: string
+  actor_agent_id: string | null
+  payload: string
+  created_at: string
+}
+
+export class EventsOutbox {
+  constructor(private db: Database.Database) {}
+
+  append(args: {
+    from_team: string
+    to_team: string
+    event_type: string
+    actor_agent_id?: string | null
+    payload: unknown
+  }): number {
+    const stmt = this.db.prepare(
+      `INSERT INTO events (from_team, to_team, event_type, actor_agent_id, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    )
+    const info = stmt.run(
+      args.from_team,
+      args.to_team,
+      args.event_type,
+      args.actor_agent_id ?? null,
+      JSON.stringify(args.payload),
+      new Date().toISOString()
+    )
+    return Number(info.lastInsertRowid)
+  }
+
+  since(args: { team: string; since_event_id: number; limit?: number }): EventRow[] {
+    const limit = Math.min(args.limit ?? 100, 500)
+    return this.db.prepare(
+      `SELECT * FROM events WHERE to_team = ? AND event_id > ? ORDER BY event_id ASC LIMIT ?`
+    ).all(args.team, args.since_event_id, limit) as EventRow[]
+  }
+}

package/src/storage/schema.ts

@@ -0,0 +1,180 @@
+import type Database from 'better-sqlite3'
+
+const DDL = [
+  `CREATE TABLE IF NOT EXISTS events (
+    event_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_team TEXT NOT NULL,
+    to_team TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    actor_agent_id TEXT,
+    payload TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_events_from_team_eventid ON events(from_team, event_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_events_to_team_eventid ON events(to_team, event_id)`,
+  `CREATE TABLE IF NOT EXISTS agents (
+    agent_id TEXT PRIMARY KEY,
+    client TEXT,
+    client_name TEXT,
+    team TEXT NOT NULL,
+    role TEXT NOT NULL,
+    name TEXT NOT NULL,
+    model TEXT,
+    registered_at TEXT NOT NULL,
+    last_seen_at TEXT NOT NULL,
+    last_processed_event_id INTEGER NOT NULL DEFAULT 0,
+    tmux_pane_id TEXT,
+    claude_ui_pid INTEGER,
+    runtime_ui_pid INTEGER,
+    runtime_tty TEXT,
+    runtime_verification_mode TEXT,
+    runtime_bound_at TEXT,
+    channel_session_id TEXT,
+    delivery_kind TEXT NOT NULL DEFAULT 'none',
+    delivery_payload TEXT
+  )`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS agents_identity_idx ON agents(team, name)`,
+  `CREATE TABLE IF NOT EXISTS messages (
+    id TEXT PRIMARY KEY,
+    event_id INTEGER NOT NULL REFERENCES events(event_id),
+    from_team TEXT NOT NULL,
+    to_team TEXT NOT NULL,
+    from_agent_id TEXT NOT NULL,
+    to_agent_id TEXT,
+    to_role TEXT,
+    subject TEXT,
+    body TEXT NOT NULL,
+    need_reply INTEGER NOT NULL DEFAULT 1,
+    sent_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS message_delivery_status (
+    message_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    wake_status TEXT NOT NULL CHECK(wake_status IN ('delivered','retrying','skipped','failed')),
+    skip_reason TEXT,
+    retry_attempts INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL,
+    delivered_at TEXT,
+    PRIMARY KEY (message_id, agent_id)
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_message_delivery_status_message ON message_delivery_status(message_id)`,
+  `CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    team TEXT NOT NULL,
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL CHECK(status IN ('pending','in_progress','completed')),
+    depends_on TEXT NOT NULL,
+    claimed_by TEXT,
+    claimed_at TEXT,
+    completed_at TEXT,
+    result TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS contracts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    team TEXT NOT NULL,
+    name TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    format TEXT NOT NULL CHECK(format='jsonschema'),
+    schema TEXT NOT NULL,
+    note TEXT,
+    registered_by TEXT NOT NULL,
+    registered_at TEXT NOT NULL,
+    UNIQUE(team, name, version)
+  )`,
+  `CREATE TABLE IF NOT EXISTS contract_subscriptions (
+    agent_id TEXT NOT NULL,
+    team TEXT NOT NULL,
+    contract_name TEXT NOT NULL,
+    subscribed_at TEXT NOT NULL,
+    PRIMARY KEY (agent_id, team, contract_name)
+  )`,
+  `CREATE TABLE IF NOT EXISTS codex_pane_pre_registrations (
+    pane_id TEXT PRIMARY KEY,
+    xats_agent_id TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+  )`
+]
+
+function migrateAgentsDeliveryColumns(db: Database.Database): void {
+  const tableExists = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='agents'`)
+    .get() as { name: string } | undefined
+  if (!tableExists) return
+  const cols = db.pragma('table_info(agents)') as Array<{ name: string }>
+  const existing = new Set(cols.map(c => c.name))
+  const needClient = !existing.has('client')
+  const needClientName = !existing.has('client_name')
+  const needKind = !existing.has('delivery_kind')
+  const needPayload = !existing.has('delivery_payload')
+  const needRuntimeUiPid = !existing.has('runtime_ui_pid')
+  const needRuntimeTty = !existing.has('runtime_tty')
+  const needRuntimeVerificationMode = !existing.has('runtime_verification_mode')
+  const needRuntimeBoundAt = !existing.has('runtime_bound_at')
+  const needClaudeUiPid = !existing.has('claude_ui_pid')
+  if (
+    !needClient &&
+    !needClientName &&
+    !needKind &&
+    !needPayload &&
+    !needRuntimeUiPid &&
+    !needRuntimeTty &&
+    !needRuntimeVerificationMode &&
+    !needRuntimeBoundAt &&
+    !needClaudeUiPid
+  ) return
+  const tx = db.transaction(() => {
+    if (needClient) {
+      db.exec(`ALTER TABLE agents ADD COLUMN client TEXT`)
+    }
+    if (needClientName) {
+      db.exec(`ALTER TABLE agents ADD COLUMN client_name TEXT`)
+    }
+    if (needKind) {
+      db.exec(`ALTER TABLE agents ADD COLUMN delivery_kind TEXT NOT NULL DEFAULT 'none'`)
+    }
+    if (needPayload) {
+      db.exec(`ALTER TABLE agents ADD COLUMN delivery_payload TEXT`)
+    }
+    if (needRuntimeUiPid) {
+      db.exec(`ALTER TABLE agents ADD COLUMN runtime_ui_pid INTEGER`)
+    }
+    if (needRuntimeTty) {
+      db.exec(`ALTER TABLE agents ADD COLUMN runtime_tty TEXT`)
+    }
+    if (needRuntimeVerificationMode) {
+      db.exec(`ALTER TABLE agents ADD COLUMN runtime_verification_mode TEXT`)
+    }
+    if (needRuntimeBoundAt) {
+      db.exec(`ALTER TABLE agents ADD COLUMN runtime_bound_at TEXT`)
+    }
+    if (needClaudeUiPid) {
+      db.exec(`ALTER TABLE agents ADD COLUMN claude_ui_pid INTEGER`)
+    }
+    if (needKind || needPayload) {
+      db.exec(`UPDATE agents
+        SET delivery_kind = 'claude-channel',
+            delivery_payload = json_object('channel_session_id', channel_session_id)
+        WHERE channel_session_id IS NOT NULL AND delivery_kind = 'none'`)
+    }
+  })
+  tx()
+}
+
+function migrateMessagesNeedReplyColumn(db: Database.Database): void {
+  const tableExists = db
+    .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='messages'`)
+    .get() as { name: string } | undefined
+  if (!tableExists) return
+  const cols = db.pragma('table_info(messages)') as Array<{ name: string }>
+  const existing = new Set(cols.map(c => c.name))
+  if (existing.has('need_reply')) return
+  db.exec(`ALTER TABLE messages ADD COLUMN need_reply INTEGER NOT NULL DEFAULT 1`)
+}
+
+export function applySchema(db: Database.Database): void {
+  for (const sql of DDL) db.exec(sql)
+  migrateAgentsDeliveryColumns(db)
+  migrateMessagesNeedReplyColumn(db)
+}