pi-subagents-j0k3r 1.0.0

package/src/history.ts

@@ -0,0 +1,254 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { boundThreadSnapshot } from './thread-view.js';
+import type { SubagentTask, SubagentThreadSnapshot } from './types.js';
+
+const require = createRequire(import.meta.url);
+
+type Db = {
+  exec(sql: string): void;
+  prepare(sql: string): {
+    run(...args: unknown[]): unknown;
+    all(...args: unknown[]): unknown[];
+  };
+};
+
+export function resolveSubagentsHistoryHome(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.PI_SUBAGENTS_HISTORY_HOME) return path.resolve(env.PI_SUBAGENTS_HISTORY_HOME);
+  const xdg = env.XDG_DATA_HOME;
+  return xdg ? path.join(xdg, 'pi', 'subagents') : path.join(os.homedir(), '.local', 'share', 'pi', 'subagents');
+}
+
+export function resolveSubagentHistoryDbPath(env: NodeJS.ProcessEnv = process.env): string {
+  if (env.PI_SUBAGENTS_HISTORY_DB_PATH) return path.resolve(env.PI_SUBAGENTS_HISTORY_DB_PATH);
+  return path.join(resolveSubagentsHistoryHome(env), 'subagents-history.sqlite');
+}
+
+function value(text: string | undefined): string | null { return text ?? null; }
+function snapshotJson(snapshot: SubagentTask['thread_snapshot']): string | null {
+  const bounded = boundThreadSnapshot(snapshot);
+  return bounded ? JSON.stringify(bounded) : null;
+}
+function parseSnapshotJson(text: unknown): SubagentThreadSnapshot | undefined {
+  if (typeof text !== 'string' || !text.trim()) return undefined;
+  try {
+    return boundThreadSnapshot(JSON.parse(text));
+  } catch {
+    return undefined;
+  }
+}
+type HistoryReadOptions = { includeSnapshots?: boolean };
+
+function ensureColumn(db: Db, table: string, column: string, definition: string): void {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>;
+  if (!columns.some((row) => row.name === column)) db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}
+
+function configureHistoryDb(db: Db): void {
+  db.exec('PRAGMA busy_timeout = 2000');
+  try { db.exec('PRAGMA journal_mode = WAL'); } catch {}
+  try { db.exec('PRAGMA synchronous = NORMAL'); } catch {}
+}
+
+export class SubagentHistoryStore {
+  private dbs = new Map<string, Db>();
+
+  private db(_cwd: string): Db {
+    const file = resolveSubagentHistoryDbPath();
+    const existing = this.dbs.get(file);
+    if (existing) return existing;
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    try { fs.chmodSync(path.dirname(file), 0o700); } catch {}
+    const { DatabaseSync } = require('node:sqlite') as any;
+    const db = new DatabaseSync(file) as Db;
+    try { fs.chmodSync(file, 0o600); } catch {}
+    configureHistoryDb(db);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS subagent_tasks (
+        id TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        agent TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL,
+        task TEXT NOT NULL,
+        context TEXT,
+        created_at TEXT NOT NULL,
+        session_id TEXT,
+        started_at TEXT,
+        ended_at TEXT,
+        last_activity_at TEXT,
+        last_activity TEXT,
+        output_preview TEXT,
+        prompt TEXT,
+        system_prompt TEXT,
+        transcript TEXT,
+        usage_input INTEGER,
+        usage_output INTEGER,
+        usage_cache_read INTEGER,
+        usage_cache_write INTEGER,
+        usage_cost REAL,
+        usage_context_tokens INTEGER,
+        usage_turns INTEGER,
+        model TEXT,
+        effort TEXT,
+        model_source TEXT,
+        effort_source TEXT,
+        fallback_used INTEGER,
+        error TEXT,
+        result TEXT,
+        thread_snapshot_json TEXT
+      );
+      CREATE TABLE IF NOT EXISTS subagent_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        task_id TEXT NOT NULL,
+        cwd TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        status TEXT NOT NULL,
+        activity TEXT NOT NULL,
+        output_preview TEXT,
+        FOREIGN KEY(task_id) REFERENCES subagent_tasks(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_subagent_tasks_created ON subagent_tasks(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_subagent_events_task ON subagent_events(task_id, created_at);
+    `);
+    ensureColumn(db, 'subagent_tasks', 'system_prompt', 'TEXT');
+    this.dbs.set(file, db);
+    return db;
+  }
+
+  upsertTask(cwd: string, task: SubagentTask): void {
+    this.db(cwd).prepare(`
+      INSERT INTO subagent_tasks (
+        id, cwd, agent, mode, status, task, context, created_at, session_id, started_at, ended_at,
+        last_activity_at, last_activity, output_preview, prompt, system_prompt, transcript,
+        usage_input, usage_output, usage_cache_read, usage_cache_write, usage_cost, usage_context_tokens, usage_turns,
+        model, effort, model_source, effort_source, fallback_used, error, result, thread_snapshot_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        status=excluded.status,
+        session_id=excluded.session_id,
+        started_at=excluded.started_at,
+        ended_at=excluded.ended_at,
+        last_activity_at=excluded.last_activity_at,
+        last_activity=excluded.last_activity,
+        output_preview=excluded.output_preview,
+        prompt=excluded.prompt,
+        system_prompt=excluded.system_prompt,
+        transcript=excluded.transcript,
+        usage_input=excluded.usage_input,
+        usage_output=excluded.usage_output,
+        usage_cache_read=excluded.usage_cache_read,
+        usage_cache_write=excluded.usage_cache_write,
+        usage_cost=excluded.usage_cost,
+        usage_context_tokens=excluded.usage_context_tokens,
+        usage_turns=excluded.usage_turns,
+        model=excluded.model,
+        effort=excluded.effort,
+        model_source=excluded.model_source,
+        effort_source=excluded.effort_source,
+        fallback_used=excluded.fallback_used,
+        error=excluded.error,
+        result=excluded.result,
+        thread_snapshot_json=excluded.thread_snapshot_json
+    `).run(
+      task.id,
+      cwd,
+      task.agent,
+      task.mode,
+      task.status,
+      task.task,
+      value(task.context),
+      task.created_at,
+      value(task.session_id),
+      value(task.started_at),
+      value(task.ended_at),
+      value(task.last_activity_at),
+      value(task.last_activity),
+      value(task.output_preview),
+      value(task.prompt),
+      value(task.system_prompt),
+      value(task.transcript),
+      task.usage?.input ?? null,
+      task.usage?.output ?? null,
+      task.usage?.cacheRead ?? null,
+      task.usage?.cacheWrite ?? null,
+      task.usage?.cost ?? null,
+      task.usage?.contextTokens ?? null,
+      task.usage?.turns ?? null,
+      value(task.model),
+      value(task.effort),
+      value(task.model_source),
+      value(task.effort_source),
+      task.fallback_used === undefined ? null : task.fallback_used ? 1 : 0,
+      value(task.error),
+      value(task.result),
+      snapshotJson(task.thread_snapshot),
+    );
+  }
+
+  addEvent(cwd: string, task: SubagentTask, activity: string): void {
+    this.db(cwd).prepare(`
+      INSERT INTO subagent_events (task_id, cwd, created_at, status, activity, output_preview)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(task.id, cwd, task.last_activity_at ?? new Date().toISOString(), task.status, activity, value(task.output_preview));
+  }
+
+  getTask(cwd: string, id: string, options: HistoryReadOptions = {}): SubagentTask | undefined {
+    const rows = this.db(cwd).prepare(`
+      SELECT * FROM subagent_tasks WHERE cwd = ? AND id = ? LIMIT 1
+    `).all(cwd, id);
+    return rows.length ? rowToTask(rows[0], options) : undefined;
+  }
+
+  listTasks(cwd: string, limit = 100, options: HistoryReadOptions = {}): SubagentTask[] {
+    return this.db(cwd).prepare(`
+      SELECT * FROM subagent_tasks WHERE cwd = ? ORDER BY created_at DESC LIMIT ?
+    `).all(cwd, limit).map((row) => rowToTask(row, options));
+  }
+
+  listSessionTasks(cwd: string, sessionId: string, limit = 100, options: HistoryReadOptions = {}): SubagentTask[] {
+    return this.db(cwd).prepare(`
+      SELECT * FROM subagent_tasks WHERE cwd = ? AND session_id = ? ORDER BY created_at DESC LIMIT ?
+    `).all(cwd, sessionId, limit).map((row) => rowToTask(row, options));
+  }
+}
+
+function rowToTask(row: any, options: HistoryReadOptions = {}): SubagentTask {
+  return {
+    id: row.id,
+    agent: row.agent,
+    mode: row.mode,
+    status: row.status,
+    task: row.task,
+    context: row.context ?? undefined,
+    created_at: row.created_at,
+    session_id: row.session_id ?? undefined,
+    started_at: row.started_at ?? undefined,
+    ended_at: row.ended_at ?? undefined,
+    last_activity_at: row.last_activity_at ?? undefined,
+    last_activity: row.last_activity ?? undefined,
+    output_preview: row.output_preview ?? undefined,
+    prompt: row.prompt ?? undefined,
+    system_prompt: row.system_prompt ?? undefined,
+    transcript: row.transcript ?? undefined,
+    usage: row.usage_input === null && row.usage_output === null && row.usage_cache_read === null && row.usage_cache_write === null && row.usage_cost === null && row.usage_context_tokens === null && row.usage_turns === null ? undefined : {
+      input: row.usage_input ?? 0,
+      output: row.usage_output ?? 0,
+      cacheRead: row.usage_cache_read ?? 0,
+      cacheWrite: row.usage_cache_write ?? 0,
+      cost: row.usage_cost ?? 0,
+      contextTokens: row.usage_context_tokens ?? 0,
+      turns: row.usage_turns ?? 0,
+    },
+    model: row.model ?? undefined,
+    effort: row.effort ?? undefined,
+    model_source: row.model_source ?? undefined,
+    effort_source: row.effort_source ?? undefined,
+    fallback_used: row.fallback_used === null || row.fallback_used === undefined ? undefined : Boolean(row.fallback_used),
+    error: row.error ?? undefined,
+    result: row.result ?? undefined,
+    thread_snapshot: options.includeSnapshots === false ? undefined : parseSnapshotJson(row.thread_snapshot_json),
+  };
+}

package/src/interaction-channel.ts

@@ -0,0 +1,197 @@
+import { randomUUID } from 'node:crypto';
+
+export type InteractionStatus = 'answered' | 'cancelled' | 'failed';
+
+export type InteractionRequester = {
+  subagentId?: string;
+  subagentName?: string;
+  taskId?: string;
+  description?: string;
+  [key: string]: unknown;
+};
+
+export type InteractionPrompt = {
+  title?: string;
+  message?: string;
+  choices?: string[];
+  defaultValue?: string;
+  placeholder?: string;
+  safeTarget?: string;
+  safeCommandSummary?: string;
+  workspaceRoot?: string;
+  limitations?: string[];
+  [key: string]: unknown;
+};
+
+export type InteractionResponseExpectation = {
+  expected?: 'boolean' | 'choice' | 'string' | 'json' | 'unknown';
+  required?: boolean;
+  instructions?: string;
+  [key: string]: unknown;
+};
+
+export type SubagentInteractionRequest = {
+  type: 'interaction_required';
+  requestId: string;
+  kind: string;
+  origin?: string;
+  requester?: InteractionRequester;
+  reason?: string;
+  reasonCode?: string;
+  riskLevel?: string;
+  prompt?: InteractionPrompt;
+  payload?: unknown;
+  response?: InteractionResponseExpectation;
+  [key: string]: unknown;
+};
+
+export type SubagentInteractionResponse = {
+  type: 'interaction_response';
+  requestId: string;
+  status: InteractionStatus;
+  value?: unknown;
+  error?: string;
+  responder?: 'parent' | string;
+  answeredAt?: string;
+  [key: string]: unknown;
+};
+
+export interface PublishedInteractionRequest {
+  handle: string;
+  payload: SubagentInteractionRequest;
+  createdAt: string;
+  consumed?: boolean;
+}
+
+const INTERACTION_CHANNEL_KEY = Symbol.for('pi.subagents.interactionChannel');
+const INTERACTION_RESPONSE_CHANNEL_KEY = Symbol.for('pi.subagents.interactionResponses');
+
+function requestRegistry(): Map<string, PublishedInteractionRequest> {
+  const holder = globalThis as Record<symbol, unknown>;
+  const existing = holder[INTERACTION_CHANNEL_KEY];
+  if (existing instanceof Map) return existing as Map<string, PublishedInteractionRequest>;
+  const registry = new Map<string, PublishedInteractionRequest>();
+  holder[INTERACTION_CHANNEL_KEY] = registry;
+  return registry;
+}
+
+function responseRegistry(): Map<string, SubagentInteractionResponse> {
+  const holder = globalThis as Record<symbol, unknown>;
+  const existing = holder[INTERACTION_RESPONSE_CHANNEL_KEY];
+  if (existing instanceof Map) return existing as Map<string, SubagentInteractionResponse>;
+  const registry = new Map<string, SubagentInteractionResponse>();
+  holder[INTERACTION_RESPONSE_CHANNEL_KEY] = registry;
+  return registry;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requestIdFrom(value: Record<string, unknown>): string | undefined {
+  const requestId = value.requestId ?? value.request_id;
+  return typeof requestId === 'string' && requestId.length > 0 ? requestId : undefined;
+}
+
+function promptFrom(value: Record<string, unknown>): InteractionPrompt | undefined {
+  return isRecord(value.prompt) ? value.prompt as InteractionPrompt : undefined;
+}
+
+function findInteractionRequest(value: unknown, seen: Set<unknown>): SubagentInteractionRequest | undefined {
+  if (!isRecord(value) || seen.has(value)) return undefined;
+  seen.add(value);
+
+  const directRequestId = requestIdFrom(value);
+  if (value.type === 'interaction_required' && directRequestId) {
+    return {
+      ...value,
+      type: 'interaction_required',
+      requestId: directRequestId,
+      kind: typeof value.kind === 'string' && value.kind.length > 0 ? value.kind : 'custom',
+      prompt: promptFrom(value),
+      requester: isRecord(value.requester) ? value.requester as InteractionRequester : undefined,
+    } as SubagentInteractionRequest;
+  }
+
+  const handle = value.handle;
+  if (typeof handle === 'string') {
+    const resolved = resolveInteractionRequest(handle);
+    if (resolved) return resolved;
+  }
+
+  for (const child of Object.values(value)) {
+    const found = findInteractionRequest(child, seen);
+    if (found) return found;
+  }
+
+  return undefined;
+}
+
+export function interactionRequestFromCandidate(value: unknown): SubagentInteractionRequest | undefined {
+  return findInteractionRequest(value, new Set());
+}
+
+export function publishInteractionRequest(payload: SubagentInteractionRequest): PublishedInteractionRequest {
+  const published: PublishedInteractionRequest = {
+    handle: `interaction_${randomUUID().replace(/-/g, '')}`,
+    payload,
+    createdAt: new Date().toISOString(),
+  };
+  requestRegistry().set(published.handle, published);
+  return published;
+}
+
+export function resolveInteractionRequest(handle: string): SubagentInteractionRequest | undefined {
+  return requestRegistry().get(handle)?.payload;
+}
+
+export function consumeInteractionRequest(handle: string): SubagentInteractionRequest | undefined {
+  const registry = requestRegistry();
+  const published = registry.get(handle);
+  if (!published) return undefined;
+  registry.delete(handle);
+  return published.payload;
+}
+
+export function consumeLatestInteractionRequest(options: { maxAgeMs?: number; origin?: string } = {}): SubagentInteractionRequest | undefined {
+  const maxAgeMs = options.maxAgeMs ?? 30_000;
+  const now = Date.now();
+  const candidates = [...requestRegistry().entries()]
+    .map(([handle, published]) => ({ handle, published, timestamp: Date.parse(published.createdAt) }))
+    .filter(({ published, timestamp }) => Number.isFinite(timestamp)
+      && now - timestamp <= maxAgeMs
+      && (!options.origin || published.payload.origin === options.origin))
+    .sort((a, b) => b.timestamp - a.timestamp);
+  const latest = candidates[0];
+  if (!latest) return undefined;
+  requestRegistry().delete(latest.handle);
+  return latest.published.payload;
+}
+
+export function publishInteractionResponse(response: SubagentInteractionResponse): SubagentInteractionResponse {
+  const normalized: SubagentInteractionResponse = {
+    responder: 'parent',
+    answeredAt: new Date().toISOString(),
+    ...response,
+    type: 'interaction_response',
+  };
+  responseRegistry().set(normalized.requestId, normalized);
+  return normalized;
+}
+
+export function resolveInteractionResponse(requestId: string): SubagentInteractionResponse | undefined {
+  return responseRegistry().get(requestId);
+}
+
+export function consumeInteractionResponse(requestId: string): SubagentInteractionResponse | undefined {
+  const registry = responseRegistry();
+  const response = registry.get(requestId);
+  if (!response) return undefined;
+  registry.delete(requestId);
+  return response;
+}
+
+export function sanitizeInteractionTransportText(text: string): string {
+  if (!text) return text;
+  return text.replace(/interaction_required:[^\r\n]*/g, '[interaction request hidden]');
+}