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

package/src/web/lib/hubApi.ts

@@ -0,0 +1,86 @@
+import { DIRECTORIES_API_ROUTE, SESSIONS_API_ROUTE } from '../../types/hub.ts';
+
+export type CreateSessionResult = { sessionId: string } | { error: string };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Asks the hub to start a new doompi-server in the given directory.
+ *
+ * The one place the page talks REST to the hub; if creation ever moves onto
+ * the WebSocket, only this file changes.
+ */
+export async function createSession(input: { cwd: string; name?: string }): Promise<CreateSessionResult> {
+  let response: Response;
+  try {
+    response = await fetch(SESSIONS_API_ROUTE, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    });
+  } catch {
+    return { error: 'The cockpit hub is unreachable.' };
+  }
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    body = undefined;
+  }
+  if (response.ok && isRecord(body) && typeof body.sessionId === 'string') return { sessionId: body.sessionId };
+  const error = isRecord(body) && typeof body.error === 'string' ? body.error : `The hub answered ${response.status}.`;
+  return { error };
+}
+
+export type StopSessionResult = { ok: true } | { error: string };
+
+/** Asks the hub to stop a session's server; the rail card leaves once the server withdraws its record. */
+export async function stopSession(sessionId: string): Promise<StopSessionResult> {
+  let response: Response;
+  try {
+    response = await fetch(`${SESSIONS_API_ROUTE}/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+  } catch {
+    return { error: 'The cockpit hub is unreachable.' };
+  }
+  if (response.ok) return { ok: true };
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    body = undefined;
+  }
+  const error = isRecord(body) && typeof body.error === 'string' ? body.error : `The hub answered ${response.status}.`;
+  return { error };
+}
+
+/** File paths under a session's cwd matching the query, for @ completion. */
+export async function searchSessionFiles(sessionId: string, query: string): Promise<string[]> {
+  try {
+    const response = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}/files?q=${encodeURIComponent(query)}`);
+    if (!response.ok) return [];
+    const body = (await response.json()) as { files?: unknown };
+    return Array.isArray(body.files) ? body.files.filter((file): file is string => typeof file === 'string') : [];
+  } catch {
+    return []; // Completion is a convenience; a failed lookup just shows nothing.
+  }
+}
+
+/**
+ * Directories the typed path could complete to, for the new-session picker.
+ * The hub lists the parent directory's children and filters them by the
+ * trailing segment as a regular expression.
+ */
+export async function searchDirectories(query: string): Promise<string[]> {
+  try {
+    const response = await fetch(`${DIRECTORIES_API_ROUTE}?q=${encodeURIComponent(query)}`);
+    if (!response.ok) return [];
+    const body = (await response.json()) as { directories?: unknown };
+    return Array.isArray(body.directories)
+      ? body.directories.filter((directory): directory is string => typeof directory === 'string')
+      : [];
+  } catch {
+    return []; // Suggestions are a convenience; a failed lookup just shows nothing.
+  }
+}

package/src/web/lib/leaderTree.ts

@@ -0,0 +1,159 @@
+import type { LeaderBindingContribution } from '@agimon-ai/doompi-web-contracts';
+
+export interface LeaderOption {
+  key: string;
+  label: string;
+  detail: string;
+  /** A group opens the next level; a leaf carries the binding that fires. */
+  binding?: LeaderBindingContribution;
+  /** The keys one level down, for a group's preview; empty for a leaf. */
+  children: LeaderOption[];
+}
+
+export interface LeaderGroup {
+  /** The label of the segment that opened this level; 'leader' at the root. */
+  label: string;
+  options: LeaderOption[];
+}
+
+interface LeaderNode {
+  key: string;
+  label: string;
+  detail: string;
+  binding?: LeaderBindingContribution;
+  children: Map<string, LeaderNode>;
+}
+
+const ROOT_LABEL = 'leader';
+
+/**
+ * Inserts one binding the way the TUI registry does: a group segment keeps
+ * the label of whoever registered it first (adopting a detail if it had
+ * none), and a leaf that is already bound is taken over by the newcomer,
+ * along with any group that stood where the leaf now goes.
+ */
+function insert(root: LeaderNode, binding: LeaderBindingContribution): void {
+  let current = root;
+  for (const [index, segment] of binding.path.entries()) {
+    const isLeaf = index === binding.path.length - 1;
+    let node = current.children.get(segment.key);
+    if (!node) {
+      node = { key: segment.key, label: segment.label, detail: segment.detail ?? '', children: new Map() };
+      current.children.set(segment.key, node);
+    } else if (!node.detail && segment.detail) {
+      node.detail = segment.detail;
+    }
+    if (isLeaf) {
+      node.children.clear();
+      node.binding = binding;
+      node.label = segment.label;
+      node.detail = segment.detail ?? '';
+    } else if (node.binding) {
+      delete node.binding;
+    }
+    current = node;
+  }
+}
+
+export interface LeaderConflict {
+  /** A later binding took a bound leaf (or a whole group) over, or a group segment was worded differently. */
+  kind: 'leaf-override' | 'group-label';
+  /** The keys of the contested segment, space separated. */
+  path: string;
+  /** The binding the tree keeps: the later one for a leaf, the first namer for a group label. */
+  winner: LeaderBindingContribution;
+  loser: LeaderBindingContribution;
+}
+
+function leavesUnder(node: LeaderNode): LeaderBindingContribution[] {
+  const leaves: LeaderBindingContribution[] = [];
+  if (node.binding) leaves.push(node.binding);
+  for (const child of node.children.values()) leaves.push(...leavesUnder(child));
+  return leaves;
+}
+
+/**
+ * Every place `insert` would silently prefer one binding over another, in
+ * the same order insert walks them: a leaf landing on a bound leaf or over a
+ * group displaces those bindings, a group segment crossing a bound leaf
+ * displaces it, and a group segment worded differently from the first namer
+ * keeps the first wording.
+ */
+export function leaderConflicts(bindings: readonly LeaderBindingContribution[]): LeaderConflict[] {
+  const conflicts: LeaderConflict[] = [];
+  const root: LeaderNode = { key: '', label: ROOT_LABEL, detail: '', children: new Map() };
+  const namers = new Map<LeaderNode, LeaderBindingContribution>();
+  for (const binding of bindings) {
+    let current = root;
+    const keys: string[] = [];
+    for (const [index, segment] of binding.path.entries()) {
+      keys.push(segment.key);
+      const path = keys.join(' ');
+      const isLeaf = index === binding.path.length - 1;
+      let node = current.children.get(segment.key);
+      if (node) {
+        if (isLeaf) {
+          for (const loser of leavesUnder(node)) {
+            if (loser !== binding) conflicts.push({ kind: 'leaf-override', path, winner: binding, loser });
+          }
+        } else {
+          if (node.binding && node.binding !== binding) {
+            conflicts.push({ kind: 'leaf-override', path, winner: binding, loser: node.binding });
+          }
+          const namer = namers.get(node);
+          if (namer !== undefined && namer !== binding && node.label !== segment.label) {
+            conflicts.push({ kind: 'group-label', path, winner: namer, loser: binding });
+          }
+        }
+      } else {
+        node = { key: segment.key, label: segment.label, detail: '', children: new Map() };
+        current.children.set(segment.key, node);
+        namers.set(node, binding);
+      }
+      if (isLeaf) {
+        node.children.clear();
+        node.binding = binding;
+        node.label = segment.label;
+        namers.set(node, binding);
+      } else if (node.binding) {
+        delete node.binding;
+      }
+      current = node;
+    }
+  }
+  return conflicts;
+}
+
+function toOption(node: LeaderNode): LeaderOption {
+  const children = [...node.children.values()]
+    .sort((left, right) => left.key.localeCompare(right.key))
+    .map((child) => ({ key: child.key, label: child.label, detail: child.detail, children: [] }));
+  return {
+    key: node.key,
+    label: node.label,
+    detail: node.detail,
+    ...(node.binding ? { binding: node.binding } : {}),
+    children,
+  };
+}
+
+/**
+ * The options one level of Leader Space offers, keyed by what the reader
+ * would press, sorted by key. Undefined when the path runs off the tree or
+ * lands on a leaf, which is how the palette knows a path is no longer a group.
+ */
+export function leaderGroup(
+  bindings: readonly LeaderBindingContribution[],
+  path: readonly string[],
+): LeaderGroup | undefined {
+  const root: LeaderNode = { key: '', label: ROOT_LABEL, detail: '', children: new Map() };
+  for (const binding of bindings) insert(root, binding);
+  let current = root;
+  for (const key of path) {
+    const next = current.children.get(key);
+    if (!next || next.binding) return undefined;
+    current = next;
+  }
+  const options = [...current.children.values()].sort((left, right) => left.key.localeCompare(right.key)).map(toOption);
+  return { label: current.label, options };
+}

package/src/web/lib/piTransport.ts

@@ -0,0 +1,61 @@
+import type { ByteTransport, ByteTransportFactory, ByteTransportHandlers } from '@earendil-works/pi-client';
+
+const PROTOCOL_PATH = '/api/pi';
+const SECURE_PAGE = 'https:';
+const SECURE_SOCKET = 'wss:';
+const PLAIN_SOCKET = 'ws:';
+
+/** The cockpit's protocol endpoint for this page. */
+export function protocolSocketUrl(location: Location): string {
+  const scheme = location.protocol === SECURE_PAGE ? SECURE_SOCKET : PLAIN_SOCKET;
+  return `${scheme}//${location.host}${PROTOCOL_PATH}`;
+}
+
+/**
+ * Carries Pi's protocol to the browser.
+ *
+ * Pi ships a Unix transport, which a page cannot open, but the client only
+ * asks for ordered bytes and a closure signal. A WebSocket in binary mode is
+ * exactly that, so the page runs the same client the terminal would.
+ */
+export function createProtocolTransport(url: string): ByteTransportFactory {
+  return async (handlers: ByteTransportHandlers): Promise<ByteTransport> => {
+    const socket = new WebSocket(url);
+    socket.binaryType = 'arraybuffer';
+
+    await new Promise<void>((resolve, reject) => {
+      const onOpen = (): void => {
+        socket.removeEventListener('error', onError);
+        resolve();
+      };
+      const onError = (): void => {
+        socket.removeEventListener('open', onOpen);
+        reject(new Error('The cockpit protocol socket failed to open'));
+      };
+      socket.addEventListener('open', onOpen, { once: true });
+      socket.addEventListener('error', onError, { once: true });
+    });
+
+    socket.addEventListener('message', (event: MessageEvent<ArrayBuffer | Blob | string>) => {
+      const data = event.data;
+      // A text frame is not protocol traffic; the codec would reject it, so it
+      // is dropped rather than handed on as bytes it never produced.
+      if (typeof data === 'string') return;
+      if (data instanceof ArrayBuffer) handlers.onData(new Uint8Array(data));
+      else void data.arrayBuffer().then((buffer) => handlers.onData(new Uint8Array(buffer)));
+    });
+    socket.addEventListener('close', () => handlers.onClose());
+    socket.addEventListener('error', () => handlers.onError(new Error('The cockpit protocol socket failed')));
+
+    return {
+      async send(chunk) {
+        // Copied into a plain ArrayBuffer: the protocol codec may hand back a
+        // view onto a shared buffer, which send() will not take.
+        socket.send(chunk.slice().buffer as ArrayBuffer);
+      },
+      close() {
+        socket.close();
+      },
+    };
+  };
+}