pi-optchat 0.5.0

package/src/usage.ts

@@ -0,0 +1,103 @@
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { AssistantMessage, Usage } from '@earendil-works/pi-ai';
+import type { SessionEntry } from '@earendil-works/pi-coding-agent';
+import { record } from './cache.ts';
+import { appendJson } from './memory.ts';
+
+export type UsageRole = 'main' | 'subagent' | 'compactor' | 'import';
+export const ranges = ['This session', 'Last hour', 'Today', 'Last 7 days', 'All time'] as const;
+export type UsageRange = typeof ranges[number];
+export interface UsageEntry {
+  id?: string; date: string; role: UsageRole; model: string; provider?: string;
+  session?: string; runId?: string; usage: Usage;
+}
+const nonnegative = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+function validUsage(value: unknown): value is Usage {
+  if (!record(value) || !record(value.cost)) return false;
+  const cost = value.cost;
+  return ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'].every(k => nonnegative(value[k]))
+    && ['input', 'output', 'cacheRead', 'cacheWrite', 'total'].every(k => nonnegative(cost[k]));
+}
+function validEntry(value: unknown): value is UsageEntry {
+  return record(value) && typeof value.date === 'string' && Number.isFinite(Date.parse(value.date))
+    && ['main', 'subagent', 'compactor', 'import'].includes(String(value.role)) && typeof value.model === 'string'
+    && ['id', 'provider', 'session', 'runId'].every(k => value[k] === undefined || typeof value[k] === 'string') && validUsage(value.usage);
+}
+export function emptyUsage(): Usage {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+}
+export function addUsage(total: Usage, usage: Usage) {
+  for (const key of ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'] as const) total[key] += usage[key];
+  for (const key of ['input', 'output', 'cacheRead', 'cacheWrite', 'total'] as const) total.cost[key] += usage.cost[key];
+}
+
+/** One profile's ledger. Stable message IDs make resume/backfill idempotent. */
+export class UsageLedger {
+  readonly entries: UsageEntry[] = [];
+  readonly warnings: string[] = [];
+  private readonly ids = new Set<string>();
+  private readonly cursors = new Map<string, number>();
+  private readonly file: string;
+  constructor(directory: string) {
+    this.file = join(directory, 'usage.jsonl');
+    let invalid = 0;
+    const contents = existsSync(this.file) ? readFileSync(this.file, 'utf8') : '';
+    for (const line of contents.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const entry: unknown = JSON.parse(line);
+        if (!validEntry(entry)) { invalid++; continue; }
+        if (entry.id && this.ids.has(entry.id)) continue;
+        this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
+      } catch { invalid++; }
+    }
+    if (invalid) this.warnings.push(`${invalid} unreadable usage records excluded; totals may be incomplete.`);
+    if (contents && !contents.endsWith('\n')) appendFileSync(this.file, '\n');
+  }
+  add(entry: UsageEntry) {
+    if (entry.id && this.ids.has(entry.id)) return;
+    appendJson(this.file, entry);
+    this.entries.push(entry); if (entry.id) this.ids.add(entry.id);
+  }
+  compression(message: AssistantMessage, role: 'compactor' | 'import', session: string) {
+    this.add({ id: randomUUID(), date: new Date().toISOString(), role, session, provider: message.provider, model: message.model, usage: message.usage });
+  }
+  backfill(entries: SessionEntry[], session: string, role: 'main' | 'subagent' = 'main', runId?: string) {
+    const cursorKey = `${session}:${runId ?? ''}`;
+    const cursor = this.cursors.get(cursorKey) ?? 0;
+    for (const entry of entries.slice(cursor <= entries.length ? cursor : 0)) {
+      // Pi forks preserve entry IDs/timestamps. Never count inherited responses twice.
+      const id = `entry:${entry.id}:${entry.timestamp}`;
+      if (entry.type === 'message') {
+        const message = entry.message;
+        if ((message.role === 'assistant' || message.role === 'toolResult') && message.usage) this.add({ id,
+          date: new Date(message.timestamp).toISOString(), role, session, runId,
+          provider: message.role === 'assistant' ? message.provider : undefined,
+          model: message.role === 'assistant' ? message.model : 'tool usage (model unavailable)', usage: message.usage });
+      }
+      else if ((entry.type === 'usage' || entry.type === 'compaction' || entry.type === 'branch_summary') && entry.usage) {
+        this.add({ id, date: entry.timestamp, role, session, runId, model: 'session overhead', usage: entry.usage });
+      }
+    }
+    this.cursors.set(cursorKey, entries.length);
+  }
+  select(range: UsageRange, session: string, now = Date.now()) {
+    const today = new Date(now); today.setHours(0, 0, 0, 0);
+    const since = range === 'Last hour' ? now - 3600_000 : range === 'Today' ? today.getTime() : range === 'Last 7 days' ? now - 7 * 86400_000 : 0;
+    return this.entries.filter(e => range === 'This session' ? e.session === session : Date.parse(e.date) >= since && Date.parse(e.date) <= now);
+  }
+}
+
+export function summarizeUsage(entries: UsageEntry[]) {
+  const total = emptyUsage(), groups = new Map<string, { role: UsageRole; model: string; requests: number; usage: Usage }>();
+  for (const entry of entries) {
+    const model = entry.provider ? `${entry.provider}/${entry.model}` : entry.model;
+    const key = `${entry.role}:${model}`;
+    let group = groups.get(key);
+    if (!group) { group = { role: entry.role, model, requests: 0, usage: emptyUsage() }; groups.set(key, group); }
+    group.requests++; addUsage(group.usage, entry.usage); addUsage(total, entry.usage);
+  }
+  return { total, groups: [...groups.values()] };
+}

package/src/window-bridge.ts

@@ -0,0 +1,170 @@
+import { chmodSync, existsSync, unlinkSync } from 'node:fs';
+import { createConnection, createServer, type Socket } from 'node:net';
+import type { Children } from './agents.ts';
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import { record } from './cache.ts';
+import { profileSocket } from './profiles.ts';
+import { textContent } from './transcript.ts';
+
+type Action = 'start' | 'say' | 'tell-main' | 'complete';
+interface Request { kind: 'request'; id: number; action: Action; text?: string; cwd?: string }
+interface Reply { kind: 'reply'; id: number; error?: string }
+/** `from` marks the conversation itself (your messages and the agent's replies); other messages have no `from`. */
+export interface WindowEvent { kind: 'event'; name: 'started' | 'message' | 'status' | 'finished'; text: string; from?: 'user' | 'agent' }
+type Frame = Request | Reply | WindowEvent;
+const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
+function parse(value: unknown): Frame {
+  if (!record(value)) throw new Error('Invalid window message');
+  const name = value.name, action = value.action, from = value.from;
+  if (value.kind === 'event' && (name === 'started' || name === 'message' || name === 'status' || name === 'finished') && typeof value.text === 'string')
+    return { kind: 'event', name, text: value.text, from: from === 'user' || from === 'agent' ? from : undefined };
+  if (typeof value.id !== 'number' || !Number.isSafeInteger(value.id)) throw new Error('Invalid request ID');
+  if (value.kind === 'reply' && (value.error === undefined || typeof value.error === 'string')) return { kind: 'reply', id: value.id, error: value.error };
+  if (value.kind === 'request' && (action === 'start' || action === 'say' || action === 'tell-main' || action === 'complete')
+    && (value.text === undefined || typeof value.text === 'string') && (value.cwd === undefined || typeof value.cwd === 'string'))
+    return { kind: 'request', id: value.id, action, text: value.text, cwd: value.cwd };
+  throw new Error('Invalid window message');
+}
+/** Local JSONL protocol, bounded before parsing; the socket is accessible only by its OS user. */
+function wire(socket: Socket, receive: (frame: Frame) => void) {
+  let buffer = '';
+  socket.setEncoding('utf8');
+  socket.on('error', () => {});
+  socket.on('data', (text: string) => {
+    buffer += text;
+    if (buffer.length > 4_000_000) { socket.destroy(); return; }
+    let newline: number;
+    while ((newline = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
+      try { receive(parse(JSON.parse(line))); } catch { socket.destroy(); return; }
+    }
+  });
+  return (frame: Frame) => {
+    if (socket.destroyed) return;
+    if (socket.writableLength > 4_000_000) { socket.destroy(); return; }
+    socket.write(JSON.stringify(frame) + '\n');
+  };
+}
+
+/** Call only while holding the profile lock. The owner hosts every child session. */
+export async function serveWindows(directory: string, children: Children, available: () => boolean,
+  report: (text: string) => Promise<void>) {
+  const path = profileSocket(directory, 'windows');
+  if (existsSync(path)) unlinkSync(path); // A previous owner can no longer hold the profile lock.
+  const connections = new Set<Socket>();
+  const work = new Set<Promise<void>>();
+  let closing = false;
+  const server = createServer(socket => {
+    if (closing) { socket.destroy(); return; }
+    connections.add(socket);
+    let child: string | undefined, cursor = 0, firstUser = true, lastStatus = '', ending = false;
+    const said = new Set<string>(); // Main-agent guidance and child reports reach the session as user messages too.
+    const controller = new AbortController();
+    let queue = Promise.resolve();
+    const track = (promise: Promise<void>) => { work.add(promise); void promise.finally(() => work.delete(promise)).catch(() => {}); };
+    const send = wire(socket, frame => {
+      if (frame.kind !== 'request') { socket.destroy(); return; }
+      queue = queue.then(async () => {
+        try {
+          if (socket.destroyed || ending) throw new Error('Conversation is closing');
+          if (frame.action === 'start') {
+            if (child) throw new Error('This window already has a conversation');
+            if (!available()) throw new Error('Profile is importing or shutting down; try again when it is ready');
+            if (!frame.text?.trim() || !frame.cwd) throw new Error('A request and working directory are required');
+            [child] = await children.spawn([{ task: frame.text, cwd: frame.cwd }], frame.cwd, controller.signal, undefined, true);
+            if (socket.destroyed) { await children.finish(child, closing ? 'owner-stopped' : 'disconnected'); return; }
+            send({ kind: 'event', name: 'started', text: child });
+          } else {
+            if (!child) throw new Error('Send your first request to start a conversation');
+            if (frame.action === 'complete') {
+              const live = children.live(child);
+              if (live) drainMessages(live.session.messages, live.info.task);
+              ending = true;
+              track(children.finish(child, 'complete').then(() => {}));
+              send({ kind: 'event', name: 'finished', text: 'Conversation ended by you. The original window is stopping remaining work and preparing the handoff.' });
+            } else {
+              if (!frame.text?.trim()) throw new Error('Message is empty');
+              if (frame.action === 'say') { said.add(frame.text.trim()); await children.tell(child, frame.text, 'user'); }
+              else await report(`[${child}] User message from connected window: ${frame.text}`);
+            }
+          }
+          send({ kind: 'reply', id: frame.id });
+        } catch (error) { send({ kind: 'reply', id: frame.id, error: errorText(error) }); }
+      });
+      track(queue);
+    });
+    const drainMessages = (messages: AgentMessage[], task: string) => {
+      const displayable = messages.filter(message => message.role === 'user' || message.role === 'assistant');
+      while (cursor < displayable.length) {
+        const message = displayable[cursor++];
+        let text = textContent(message.content);
+        if (message.role === 'user' && firstUser) { text = task; firstUser = false; said.add(task.trim()); }
+        const from = message.role === 'assistant' ? 'agent' : said.has(text.trim()) ? 'user' : undefined;
+        if (text) send({ kind: 'event', name: 'message', from, text: `${text.slice(0, 200_000)}${text.length > 200_000 ? '\n[Display shortened; full text is saved in the transcript.]' : ''}` });
+      }
+    };
+    const timer = setInterval(() => {
+      if (!child || socket.destroyed || ending) return;
+      const live = children.live(child), info = children.history.records.get(child);
+      if (!info) return;
+      if (live) drainMessages(live.session.messages, info.task);
+      const preview = live?.streaming && 'content' in live.streaming ? textContent(live.streaming.content).slice(-2000) : '';
+      const status = `${info.state === 'waiting' ? 'Awaiting user or child reports' : info.state} · ${info.model}\n${live ? [...live.tools.values()].map(t => t.name).join(', ') : ''}\n${preview}`;
+      if (status !== lastStatus) { lastStatus = status; send({ kind: 'event', name: 'status', text: status }); }
+      if (!live && info.handoff?.delivered) {
+        try { drainMessages(children.messages(child), info.task); }
+        catch (error) { send({ kind: 'event', name: 'message', text: `Could not read the final transcript: ${errorText(error)}` }); }
+        ending = true;
+        send({ kind: 'event', name: 'finished', text: info.handoff.text ?? 'Conversation ended.' });
+      }
+    }, 150);
+    socket.on('close', () => {
+      clearInterval(timer); controller.abort(); connections.delete(socket);
+      const cleanup = queue.then(async () => { if (child) await children.finish(child, closing ? 'owner-stopped' : 'disconnected'); });
+      track(cleanup);
+    });
+  });
+  await new Promise<void>((resolve, reject) => { server.once('error', reject); server.listen(path, () => { server.off('error', reject); resolve(); }); });
+  chmodSync(path, 0o600);
+  return async () => {
+    closing = true;
+    const closed = new Promise<void>(resolve => server.close(() => resolve()));
+    for (const socket of connections) socket.destroy();
+    await closed;
+    await Promise.allSettled([...work]);
+  };
+}
+
+export async function connectWindow(directory: string, event: (event: WindowEvent) => void, disconnected: () => void) {
+  const socket = createConnection(profileSocket(directory, 'windows'));
+  let next = 0;
+  const pending = new Map<number, { resolve: () => void; reject: (error: Error) => void; timer: NodeJS.Timeout }>();
+  const send = wire(socket, frame => {
+    if (frame.kind === 'event') { event(frame); return; }
+    if (frame.kind !== 'reply') { socket.destroy(); return; }
+    const request = pending.get(frame.id); if (!request) return;
+    clearTimeout(request.timer); pending.delete(frame.id);
+    if (frame.error) request.reject(new Error(frame.error)); else request.resolve();
+  });
+  socket.on('close', () => {
+    for (const request of pending.values()) { clearTimeout(request.timer); request.reject(new Error('Connection to the original Pi window was lost')); }
+    pending.clear(); disconnected();
+  });
+  await new Promise<void>((resolve, reject) => {
+    socket.once('connect', resolve); socket.once('error', reject);
+    socket.setTimeout(5000, () => socket.destroy(new Error('Profile owner did not respond')));
+  });
+  socket.setTimeout(0);
+  return {
+    async request(action: Action, text?: string, cwd?: string) {
+      if (socket.destroyed) throw new Error('The original Pi window is disconnected');
+      if (text && text.length > 256_000) throw new Error('Connected-window messages are limited to 256,000 characters');
+      const id = next++;
+      await new Promise<void>((resolve, reject) => {
+        const timer = setTimeout(() => { pending.delete(id); reject(new Error('Owner response timed out; closing this connection')); socket.destroy(); }, 120_000);
+        pending.set(id, { resolve, reject, timer }); send({ kind: 'request', id, action, text, cwd });
+      });
+    },
+    close() { socket.destroy(); },
+  };
+}