@agimon-ai/doompi-web 0.0.1-alpha.0

package/src/adapters/piHubService.ts

@@ -0,0 +1,129 @@
+import { PiClient } from '@earendil-works/pi-client';
+import { createUnixTransportFactory } from '@earendil-works/pi-client/unix';
+import type { SessionLease } from '@earendil-works/pi-client';
+import type { ModelMetadata, SessionMetadata } from '@earendil-works/pi-protocol';
+import { PiServerError } from '@earendil-works/pi-server';
+import type { CreateSessionOptions, PiServerService, PiSessionRuntime } from '@earendil-works/pi-server';
+import type { SessionRecord } from '../types/registry.ts';
+import type { SpawnSessionInput, SpawnOutcome } from './serverSpawner.ts';
+
+/** How long a created session has to publish its record before the client is told it failed. */
+const CREATE_TIMEOUT_MS = 10_000;
+const CREATE_POLL_MS = 100;
+
+export interface PiHubServiceOptions {
+  /** Every session the registry currently lists. */
+  records(): readonly SessionRecord[];
+  spawn(input: SpawnSessionInput): Promise<SpawnOutcome>;
+  onNotice?: (message: string) => void;
+}
+
+function toMetadata(record: SessionRecord): SessionMetadata {
+  const createdAt = Date.parse(record.createdAt);
+  return {
+    id: record.id,
+    createdAt: Number.isFinite(createdAt) ? createdAt : 0,
+    sessionName: record.name,
+    cwd: record.cwd,
+  };
+}
+
+/**
+ * Presents one live lease on a session's own server as a runtime.
+ *
+ * The hub owns no session state of its own here. It holds a connection open
+ * and forwards, so the snapshot a browser reads is the one the session server
+ * published rather than a copy the hub reduced for itself.
+ */
+function leaseRuntime(client: PiClient, lease: SessionLease): PiSessionRuntime {
+  const snapshot = () => {
+    const current = lease.snapshot;
+    if (!current) throw new PiServerError('not_found', 'The session has not published a snapshot yet');
+    return current;
+  };
+  return {
+    snapshot,
+    getPhase: () => snapshot().phase,
+    prompt: async (input) => void (await lease.prompt(input.text)),
+    steer: async (input) => void (await lease.steer(input.text)),
+    abort: async () => void (await lease.abort()),
+    setModel: async (model) => void (await lease.setModel(model)),
+    setThinking: async (level) => void (await lease.setThinking(level)),
+    subscribe(listener) {
+      const stopSnapshots = lease.subscribe(() => listener({ type: 'snapshot' }));
+      const stopEvents = lease.onEvent((event) => {
+        if (event.type === 'session_progress') listener({ type: 'progress', progress: event.progress });
+      });
+      return () => {
+        stopSnapshots();
+        stopEvents();
+      };
+    },
+    async dispose() {
+      // The upstream connection belongs to this hold, so both go together and
+      // the session server sees the detach it is waiting for.
+      await lease.dispose().catch(() => undefined);
+      await client.dispose().catch(() => undefined);
+    },
+  };
+}
+
+/**
+ * The cockpit's own protocol server, backed by every running session.
+ *
+ * Each session already serves the protocol on its own socket, so the hub does
+ * not reinterpret any of it: it lists what the registry knows and dials the
+ * session a browser asks for. That keeps one vocabulary from the agent all the
+ * way to the page.
+ */
+export function createPiHubService(options: PiHubServiceOptions): PiServerService {
+  const find = (sessionId: string): SessionRecord => {
+    const record = options.records().find((candidate) => candidate.id === sessionId);
+    if (!record) throw new PiServerError('not_found', `No session ${sessionId}`);
+    return record;
+  };
+
+  const open = async (record: SessionRecord): Promise<PiSessionRuntime> => {
+    if (!record.protocolSocketPath) {
+      throw new PiServerError('not_implemented', `Session ${record.id} predates the protocol socket`);
+    }
+    const client = new PiClient({
+      transportFactory: createUnixTransportFactory({ path: record.protocolSocketPath }),
+      onListenerError: (error) => options.onNotice?.(`session ${record.id} listener error: ${error.message}`),
+    });
+    await client.connect();
+    try {
+      return leaseRuntime(client, await client.attachSession(record.id));
+    } catch (error) {
+      await client.dispose().catch(() => undefined);
+      throw error;
+    }
+  };
+
+  return {
+    listSessions: async () => options.records().map(toMetadata),
+    listModels: async (): Promise<ModelMetadata[]> => [],
+
+    async createSession(create: CreateSessionOptions) {
+      if (!create.cwd) throw new PiServerError('invalid_request', 'A new session needs a working directory');
+      const outcome = await options.spawn({ cwd: create.cwd, ...(create.name ? { name: create.name } : {}) });
+      if (!outcome.ok) {
+        throw new PiServerError(outcome.code === 'invalid_request' ? 'invalid_request' : 'not_found', outcome.error);
+      }
+      // The spawner returns once the record lands, but the session's protocol
+      // socket is published a moment later; waiting here spares the caller a
+      // retry loop it has no way to bound.
+      const deadline = Date.now() + CREATE_TIMEOUT_MS;
+      for (;;) {
+        const record = options.records().find((candidate) => candidate.id === outcome.sessionId);
+        if (record?.protocolSocketPath) return open(record);
+        if (Date.now() >= deadline) {
+          throw new PiServerError('not_found', `Session ${outcome.sessionId} never published a protocol socket`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, CREATE_POLL_MS));
+      }
+    },
+
+    openSession: async (sessionId: string) => open(find(sessionId)),
+  };
+}

package/src/adapters/piWebSocketListener.ts

@@ -0,0 +1,98 @@
+import type { PiServerListener } from '@earendil-works/pi-server';
+
+// pi-server names these in PiServerListener's signature but does not export
+// them from its root, so they are recovered from the type that does.
+type ByteConnectionAcceptor = Parameters<PiServerListener['start']>[0];
+type ByteConnection = Parameters<ByteConnectionAcceptor>[0];
+type ByteConnectionHandler = ReturnType<ByteConnectionAcceptor>;
+
+/** The minimum of a WebSocket this listener drives, so a test needs no real socket. */
+export interface ListenerSocket {
+  send(data: ArrayBufferLike | Uint8Array): void;
+  close(): void;
+  readonly readyState?: number;
+}
+
+const OPEN = 1;
+
+export interface PiWebSocketListener extends PiServerListener {
+  /**
+   * Hands an already-upgraded socket to the server.
+   *
+   * The transport authenticates during the HTTP upgrade, so a socket only
+   * reaches here once the request that opened it was allowed.
+   */
+  accept(socket: ListenerSocket): ByteConnectionHandler | undefined;
+}
+
+/**
+ * Feeds PiServer the browser's connections.
+ *
+ * Pi ships only a Unix listener, where the file mode is the access control.
+ * A browser cannot open one, so the cockpit terminates the protocol over a
+ * WebSocket instead and keeps the same contract: bytes in order, closure
+ * reported once, and no protocol knowledge in the transport itself.
+ */
+export function createPiWebSocketListener(options: { onError?: (error: Error) => void } = {}): PiWebSocketListener {
+  let acceptor: ByteConnectionAcceptor | undefined;
+  const open = new Set<ListenerSocket>();
+
+  return {
+    address: 'websocket',
+
+    async start(accept) {
+      acceptor = accept;
+    },
+
+    async close() {
+      acceptor = undefined;
+      for (const socket of open) {
+        try {
+          socket.close();
+        } catch (error) {
+          options.onError?.(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      open.clear();
+    },
+
+    accept(socket) {
+      // A socket that arrives before start, or after close, has no server to
+      // talk to. Closing it is the honest answer.
+      if (!acceptor) {
+        socket.close();
+        return undefined;
+      }
+      open.add(socket);
+      let closed = false;
+      const connection: ByteConnection = {
+        get closed() {
+          return closed || (socket.readyState !== undefined && socket.readyState !== OPEN);
+        },
+        async send(chunk) {
+          socket.send(chunk);
+        },
+        close(finalChunk) {
+          if (finalChunk) socket.send(finalChunk);
+          closed = true;
+          open.delete(socket);
+          socket.close();
+        },
+      };
+      const handler = acceptor(connection);
+      return {
+        onData: (chunk) => handler.onData(chunk),
+        onClose: () => {
+          closed = true;
+          open.delete(socket);
+          handler.onClose();
+        },
+        onError: (error) => {
+          closed = true;
+          open.delete(socket);
+          handler.onError(error);
+        },
+      };
+    },
+  };
+}

package/src/adapters/providerAuth.ts

@@ -0,0 +1,181 @@
+import crypto from 'node:crypto';
+import { createLoginFlow, type LoginFlow } from '../services/loginFlow.ts';
+import type {
+  AuthMethodType,
+  AuthRuntime,
+  AuthRuntimeProvider,
+  LoginFlowSnapshot,
+  ProviderAuthMethod,
+  ProviderAuthSummary,
+} from '../types/auth.ts';
+
+/** Matches the timeout Pi's own /logout gives the credential store. */
+const LOGOUT_TIMEOUT_MS = 15_000;
+
+export type StartLoginOutcome =
+  | { ok: true; flow: LoginFlowSnapshot }
+  | { ok: false; code: 'unknown_provider' | 'unsupported_method' | 'busy'; error: string };
+
+export type LogoutOutcome = { ok: true } | { ok: false; code: 'unknown_provider' | 'runtime'; error: string };
+
+export type AnswerOutcome = 'answered' | 'unknown_flow' | 'not_waiting';
+
+/** Provider credentials as the settings page sees them, backed by one Pi runtime. */
+export interface ProviderAuth {
+  /** Every provider Pi knows, with its current auth state; re-read from disk each call. */
+  listProviders(): Promise<ProviderAuthSummary[]>;
+  startLogin(providerId: string, type: AuthMethodType): Promise<StartLoginOutcome>;
+  getLogin(flowId: string): LoginFlowSnapshot | undefined;
+  answerLogin(flowId: string, promptId: string, value: string): AnswerOutcome;
+  /** Cancels the flow and returns how it stands, or undefined for an unknown flow. */
+  cancelLogin(flowId: string): LoginFlowSnapshot | undefined;
+  logout(providerId: string): Promise<LogoutOutcome>;
+  /** Abandons every running flow; the hub is shutting down. */
+  close(): void;
+}
+
+export interface ProviderAuthOptions {
+  /** Test seam over Pi's ModelRuntime; the default loads the real one over auth.json. */
+  runtime?: () => Promise<AuthRuntime>;
+  onNotice?: (message: string) => void;
+}
+
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Pi's runtime, imported on first use: the hub should come up without paying
+ * for the provider catalog, and a machine without Pi installed still serves
+ * sessions, just not the providers page.
+ */
+async function loadPiRuntime(): Promise<AuthRuntime> {
+  const { ModelRuntime } = await import('@earendil-works/pi-coding-agent');
+  return ModelRuntime.create();
+}
+
+/** The methods a page can start, in the order the TUI's selector lists them. */
+function methodsOf(provider: AuthRuntimeProvider): ProviderAuthMethod[] {
+  const methods: ProviderAuthMethod[] = [];
+  const { oauth, apiKey } = provider.auth;
+  if (oauth) methods.push({ type: 'oauth', label: oauth.loginLabel ?? oauth.name });
+  if (apiKey?.login) methods.push({ type: 'api_key', label: apiKey.name });
+  return methods;
+}
+
+/** Mirrors the status the TUI's login selector shows beside each provider. */
+function summarize(runtime: AuthRuntime, provider: AuthRuntimeProvider): ProviderAuthSummary {
+  const summary: ProviderAuthSummary = { id: provider.id, name: provider.name, methods: methodsOf(provider) };
+  const status = runtime.getProviderAuthStatus(provider.id);
+  if (status.configured) {
+    summary.authenticated = {
+      type: runtime.isUsingOAuth(provider.id) ? 'oauth' : 'api_key',
+      source: status.label ?? status.source,
+    };
+  }
+  return summary;
+}
+
+export function createProviderAuth(options: ProviderAuthOptions = {}): ProviderAuth {
+  const notice = options.onNotice ?? ((): void => {});
+  const load = options.runtime ?? loadPiRuntime;
+  const flows = new Map<string, LoginFlow>();
+  let loading: Promise<AuthRuntime> | undefined;
+
+  // A failed load is forgotten so the next request tries again rather than
+  // pinning the page on a startup error.
+  const runtime = (): Promise<AuthRuntime> => {
+    loading ??= load().catch((error: unknown) => {
+      loading = undefined;
+      throw error;
+    });
+    return loading;
+  };
+
+  const findProvider = (current: AuthRuntime, providerId: string): AuthRuntimeProvider | undefined =>
+    current.getProviders().find((provider) => provider.id === providerId);
+
+  const runningFor = (providerId: string): LoginFlow | undefined =>
+    [...flows.values()].find((flow) => flow.providerId === providerId && flow.snapshot().status === 'running');
+
+  return {
+    async listProviders() {
+      const current = await runtime();
+      // Another client may have stored a credential since the last look (a
+      // TUI /login, a hand-edited auth.json); the stale snapshot still lists
+      // on a failed refresh, which the notice explains.
+      try {
+        await current.refresh({ allowNetwork: false });
+      } catch (error) {
+        notice(`provider auth refresh failed: ${describe(error)}`);
+      }
+      return current
+        .getProviders()
+        .map((provider) => summarize(current, provider))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    },
+
+    async startLogin(providerId, type) {
+      const current = await runtime();
+      const provider = findProvider(current, providerId);
+      if (!provider) return { ok: false, code: 'unknown_provider', error: `Unknown provider: ${providerId}` };
+      if (!methodsOf(provider).some((method) => method.type === type)) {
+        return { ok: false, code: 'unsupported_method', error: `${provider.name} has no ${type} login.` };
+      }
+      if (runningFor(providerId)) {
+        return { ok: false, code: 'busy', error: `A login for ${provider.name} is already in progress.` };
+      }
+      // Finished flows live until the next start: long enough for the page to
+      // read how they ended, short enough that the map never grows.
+      for (const [id, flow] of flows) if (flow.snapshot().status !== 'running') flows.delete(id);
+
+      const flow = createLoginFlow({ id: crypto.randomUUID(), providerId, providerName: provider.name, type });
+      flows.set(flow.id, flow);
+      current.login(providerId, type, flow.interaction).then(
+        () => {
+          flow.settle({ ok: true });
+          notice(`signed in to ${provider.name} (${type})`);
+        },
+        (error: unknown) => {
+          flow.settle({ ok: false, error: describe(error) });
+        },
+      );
+      return { ok: true, flow: flow.snapshot() };
+    },
+
+    getLogin(flowId) {
+      return flows.get(flowId)?.snapshot();
+    },
+
+    answerLogin(flowId, promptId, value) {
+      const flow = flows.get(flowId);
+      if (!flow) return 'unknown_flow';
+      return flow.answer(promptId, value) ? 'answered' : 'not_waiting';
+    },
+
+    cancelLogin(flowId) {
+      const flow = flows.get(flowId);
+      if (!flow) return undefined;
+      flow.cancel();
+      return flow.snapshot();
+    },
+
+    async logout(providerId) {
+      const current = await runtime();
+      const provider = findProvider(current, providerId);
+      if (!provider) return { ok: false, code: 'unknown_provider', error: `Unknown provider: ${providerId}` };
+      try {
+        await current.logout(providerId, { signal: AbortSignal.timeout(LOGOUT_TIMEOUT_MS) });
+      } catch (error) {
+        return { ok: false, code: 'runtime', error: describe(error) };
+      }
+      notice(`signed out of ${provider.name}`);
+      return { ok: true };
+    },
+
+    close() {
+      for (const flow of flows.values()) flow.cancel();
+      flows.clear();
+    },
+  };
+}

package/src/adapters/registryWatcher.ts

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isRecordFileName, parseSessionRecord, sessionRecordsDir } from '../services/registryStore.ts';
+import type { SessionRecord } from '../types/registry.ts';
+
+const POLL_MS = 2000;
+const DEBOUNCE_MS = 50;
+
+/** Where the hub learns which sessions exist: a watcher in hub mode, a fixed record otherwise. */
+export interface RecordSource {
+  /** Calls back with the full current record set, immediately and on every change. */
+  subscribe(listener: (records: SessionRecord[]) => void): void;
+  close(): void;
+}
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM means the pid exists but belongs to someone else; only ESRCH
+    // proves the server is gone.
+    return (error as NodeJS.ErrnoException).code !== 'ESRCH';
+  }
+}
+
+/**
+ * Watches the registry directory for session records.
+ *
+ * The 2s poll is the source of truth; fs.watch merely accelerates it, because
+ * on macOS watch events around atomic renames are best-effort. Records whose
+ * pid is gone are stale by definition (a crashed server cannot withdraw its
+ * own record) and are deleted here, the one janitor in the system.
+ */
+export function watchRegistry(registryDir: string, onNotice?: (message: string) => void): RecordSource {
+  const recordsDir = sessionRecordsDir(registryDir);
+  let listener: ((records: SessionRecord[]) => void) | undefined;
+  let watcher: fs.FSWatcher | undefined;
+  let debounce: NodeJS.Timeout | undefined;
+  let poll: NodeJS.Timeout | undefined;
+  let closed = false;
+
+  const scan = (): SessionRecord[] => {
+    let names: string[];
+    try {
+      names = fs.readdirSync(recordsDir);
+    } catch {
+      // The directory appears with the first server; an empty registry is not
+      // an error.
+      return [];
+    }
+    const records: SessionRecord[] = [];
+    for (const name of names.filter(isRecordFileName)) {
+      let raw: string;
+      try {
+        raw = fs.readFileSync(path.join(recordsDir, name), 'utf8');
+      } catch {
+        continue; // Withdrawn between readdir and read; the next scan settles it.
+      }
+      const record = parseSessionRecord(raw);
+      if (!record) continue;
+      if (!pidAlive(record.pid)) {
+        fs.rmSync(path.join(recordsDir, name), { force: true });
+        onNotice?.(`removed stale record for session ${record.id}`);
+        continue;
+      }
+      records.push(record);
+    }
+    return records.sort(
+      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),
+    );
+  };
+
+  const emit = (): void => {
+    if (!closed) listener?.(scan());
+  };
+
+  const ensureWatcher = (): void => {
+    if (watcher || closed) return;
+    try {
+      watcher = fs.watch(recordsDir, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(emit, DEBOUNCE_MS);
+      });
+      watcher.on('error', () => {
+        watcher?.close();
+        watcher = undefined; // The poll re-establishes it once the dir is back.
+      });
+    } catch {
+      // The directory does not exist yet; the poll keeps trying.
+    }
+  };
+
+  return {
+    subscribe(next) {
+      listener = next;
+      ensureWatcher();
+      emit();
+      poll = setInterval(() => {
+        ensureWatcher();
+        emit();
+      }, POLL_MS);
+    },
+    close() {
+      closed = true;
+      if (debounce) clearTimeout(debounce);
+      if (poll) clearInterval(poll);
+      watcher?.close();
+      listener = undefined;
+    },
+  };
+}