ompchamber 1.0.0 → 1.2.0

package/src/shared/lib/chat/attachments.ts

@@ -4,22 +4,32 @@
  */
 
 /**
- * Text-file attachment composition for the chat composer. Faithful port of
- * omp-web/lib/chat-attachments.ts: text files are inlined into the prompt as
- * fenced blocks so the model sees their full content.
+ * Attachment metadata and prompt composition for the chat composer.
+ *
+ * Two representations of the same attachment exist and the difference is the
+ * whole reason this module exists:
+ *
+ * - A LIVE attachment (just picked/pasted/dropped) carries `file: File`, so its
+ *   bytes are readable.
+ * - A REPLAYED attachment comes from the `queued_messages` row or from committed
+ *   history. `File` does not survive either trip (`JSON.stringify(new File(…))`
+ *   is `{}`), so only `name`/`type`/`size`/`preview`/`dataBase64`/`content`
+ *   remain.
+ *
+ * Every read of an attachment's metadata therefore goes through the accessors
+ * below, which read the display fields and fall back to the live `File` — never
+ * `a.file.name`, which throws on a replayed attachment and is what used to break
+ * queued delivery and retry.
  */
 
+import type { AgentImage, Attachment } from '@/shared/types';
+import { TEXT_FILE_EXTENSIONS, isTextMimeType } from '@/shared/lib/chat/text-file';
+
+export { looksLikeTextFile } from '@/shared/lib/chat/text-file';
+
 export const MAX_ATTACHED_TEXT_BYTES = 256 * 1024;
 export const MAX_ATTACHED_TEXT_FILES = 10;
 
-const TEXT_FILE_EXTENSIONS: Record<string, true> = {
-  txt: true,
-  text: true,
-  md: true,
-  markdown: true,
-  mdx: true,
-};
-
 export interface AttachedTextFileData {
   name: string;
   mimeType: string;
@@ -27,19 +37,125 @@ export interface AttachedTextFileData {
   size: number;
 }
 
+/** An inlined text file plus the id of the attachment it came from. */
+export interface ReadTextAttachment extends AttachedTextFileData {
+  id: string;
+  /** True when no bytes could be read — the file is named but not carried. */
+  missing?: boolean;
+}
+
 function getFileExtension(name: string): string {
   return name.toLowerCase().replace(/\\/g, '/').split('/').pop()?.split('.').pop() ?? '';
 }
 
-export function isTextAttachmentFile(file: Pick<File, 'name' | 'type'>): boolean {
-  return file.type === 'text/plain'
-    || file.type === 'text/markdown'
-    || TEXT_FILE_EXTENSIONS[getFileExtension(file.name)] === true;
+/** Attachment display name, live file first, persisted name second. */
+export function attachmentName(att: Pick<Attachment, 'name' | 'file'>): string {
+  return att.name ?? att.file?.name ?? 'attachment';
+}
+
+/** Attachment MIME type, live file first, persisted type second. */
+export function attachmentType(att: Pick<Attachment, 'type' | 'file'>): string {
+  return att.type ?? att.file?.type ?? '';
+}
+
+/** Attachment byte size, live file first, persisted size second. */
+export function attachmentSize(att: Pick<Attachment, 'size' | 'file'>): number {
+  return att.file?.size ?? att.size ?? 0;
+}
+
+/** Whether this attachment's contents can be inlined into the prompt. */
+export function isTextAttachment(att: Pick<Attachment, 'name' | 'type' | 'file'>): boolean {
+  const type = attachmentType(att);
+  if (isTextMimeType(type)) return true;
+  // An image is never inlined, whatever its extension claims.
+  if (type.startsWith('image/')) return false;
+  return TEXT_FILE_EXTENSIONS[getFileExtension(attachmentName(att))] === true;
+}
+
+/** Whether this attachment is an image the model can receive. */
+export function isImageAttachment(att: Pick<Attachment, 'name' | 'type' | 'file'>): boolean {
+  return attachmentType(att).startsWith('image/');
+}
+
+/** Base64 image payload for the omp RPC, or null when there is nothing to send. */
+export function attachmentImage(
+  att: Pick<Attachment, 'type' | 'file' | 'dataBase64'>,
+): AgentImage | null {
+  if (!att.dataBase64 || !isImageAttachment(att)) return null;
+  return {
+    type: 'image',
+    data: att.dataBase64,
+    // A persisted attachment carries the authoritative type; the fallback keeps
+    // a provider from rejecting a payload whose type the browser left empty.
+    mimeType: attachmentType(att) || 'image/png',
+  };
+}
+
+export interface AttachmentBudget {
+  /** Files that fit the inline budget and may be attached. */
+  accepted: File[];
+  /** Text files refused because the budget was already spent. */
+  skipped: File[];
+}
+
+/** User-facing reason for a refusal, shared by every composer attach path. */
+export function describeAttachmentBudget(skipped: File[]): string {
+  const limit = `${MAX_ATTACHED_TEXT_FILES} text files / ${Math.round(MAX_ATTACHED_TEXT_BYTES / 1024)} KB total`;
+  if (skipped.length === 1) return `"${skipped[0].name}" was not attached — inline limit is ${limit}.`;
+  return `${skipped.length} text files were not attached — inline limit is ${limit}.`;
+}
+
+/**
+ * Gate a batch of incoming files against the text-inline budget.
+ *
+ * Only text files are gated: their contents are inlined into the prompt, so a
+ * directory drop can otherwise push megabytes into a single request. Images and
+ * other binaries travel as payloads and are capped by the caller's own limit.
+ *
+ * The budget spans the whole composer, not the batch — `existing` counts too,
+ * so three successive drops of four text files stop at ten.
+ */
+export function applyTextAttachmentBudget(
+  files: File[],
+  existing: { name?: string; type?: string; size?: number; file?: File }[],
+): AttachmentBudget {
+  const accepted: File[] = [];
+  const skipped: File[] = [];
+  let textFiles = existing.filter((a) => isTextAttachment(a)).length;
+  let textBytes = existing.reduce((total, a) => (isTextAttachment(a) ? attachmentSize(a) : total), 0);
+
+  for (const file of files) {
+    if (!isTextAttachment({ name: file.name, type: file.type, file })) {
+      accepted.push(file);
+      continue;
+    }
+    if (textFiles >= MAX_ATTACHED_TEXT_FILES || textBytes + file.size > MAX_ATTACHED_TEXT_BYTES) {
+      skipped.push(file);
+      continue;
+    }
+    textFiles += 1;
+    textBytes += file.size;
+    accepted.push(file);
+  }
+
+  return { accepted, skipped };
 }
 
 function languageForFile(name: string): string {
   const extension = getFileExtension(name);
   if (extension === 'md' || extension === 'markdown' || extension === 'mdx') return 'markdown';
+  if (extension === 'json' || extension === 'jsonc') return 'json';
+  if (extension === 'yaml' || extension === 'yml') return 'yaml';
+  if (extension === 'ts' || extension === 'tsx' || extension === 'mts' || extension === 'cts') return 'typescript';
+  if (extension === 'js' || extension === 'jsx' || extension === 'mjs' || extension === 'cjs') return 'javascript';
+  if (extension === 'py') return 'python';
+  if (extension === 'sh' || extension === 'bash' || extension === 'zsh') return 'bash';
+  if (extension === 'rs') return 'rust';
+  if (extension === 'go') return 'go';
+  if (extension === 'sql') return 'sql';
+  if (extension === 'html' || extension === 'htm') return 'html';
+  if (extension === 'css') return 'css';
+  if (extension === 'xml') return 'xml';
   return 'text';
 }
 
@@ -60,3 +176,72 @@ export function composeMessageWithTextAttachments(
   });
   return [message.trim(), ...blocks].filter(Boolean).join('\n\n');
 }
+
+/**
+ * Snapshot attachments for storage in the queue row, where a `File` cannot
+ * survive. Reads text contents while the live handle still exists, so delivery
+ * can inline them, and keeps every display field the chip renderer needs.
+ */
+export async function prepareQueuedAttachments(attachments: Attachment[]): Promise<Attachment[]> {
+  const textFiles = await readTextAttachments(attachments);
+  const contentById = new Map(textFiles.map((file) => [file.id, file.content]));
+  return attachments.map((att) => ({
+    id: att.id,
+    name: attachmentName(att),
+    type: attachmentType(att),
+    size: attachmentSize(att),
+    // The blob URL dies with the page; the data URL survives in the row.
+    preview: att.dataBase64 ? `data:${attachmentType(att)};base64,${att.dataBase64}` : att.preview,
+    ...(att.dataBase64 ? { dataBase64: att.dataBase64 } : {}),
+    ...(contentById.has(att.id) ? { content: contentById.get(att.id) } : {}),
+    ...(att.sniffedText ? { sniffedText: true } : {}),
+  }));
+}
+
+/**
+ * The inline-able text files of a batch, reading live `File` bytes where
+ * present and persisted `content` otherwise. Returns [] when nothing qualifies.
+ *
+ * Each entry carries the source attachment's `id`, so the caller can map a file
+ * back to the attachment it came from without re-deriving the filter.
+ *
+ * An attachment with NO readable bytes is returned with `missing: true` rather
+ * than dropped: silently omitting it sent a prompt that named a file the model
+ * never received, with nothing in the UI to say so. The caller decides whether
+ * to warn or to send anyway.
+ */
+export async function readTextAttachments(
+  attachments: Attachment[],
+): Promise<ReadTextAttachment[]> {
+  // An attachment that already carries `content` was read at attach time — for
+  // an unclassified file that read only happened because the sniffer cleared it.
+  // Anything else must still classify from metadata, so a binary that happens to
+  // have a stray `content` string cannot smuggle itself into the prompt.
+  const textAttachments = attachments.filter((a) => isTextAttachment(a) || a.sniffedText === true);
+  const contents = await Promise.all(
+    textAttachments.map(async (att): Promise<{ content: string | null; missing: boolean }> => {
+      // The persisted copy wins: it was read at attach time through
+      // `FileReader`, which is the read that waits for another app's file to
+      // materialize. Re-reading the live handle here is what returned an empty
+      // body for a file whose bytes had already been captured.
+      if (typeof att.content === 'string') return { content: att.content, missing: false };
+      if (att.file) {
+        try {
+          return { content: await att.file.text(), missing: false };
+        } catch {
+          // Fall through to the persisted copy, if any.
+        }
+      }
+      if (typeof att.content === 'string') return { content: att.content, missing: false };
+      return { content: null, missing: true };
+    }),
+  );
+  return textAttachments.map((att, index) => ({
+    id: att.id,
+    name: attachmentName(att),
+    mimeType: attachmentType(att),
+    content: contents[index].content ?? '',
+    size: attachmentSize(att),
+    missing: contents[index].missing,
+  }));
+}

package/src/shared/lib/chat/btw/client.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Client for a session's BTW API: the frame stream, plus the commands that
+ * create, continue, cancel and promote a side question.
+ *
+ * The stream reuses the generic JSON connectors the agent stream introduced
+ * (they are transport-only: URL in, decoded frames out), so a session's side
+ * questions follow the same transport setting — WebSocket by default, SSE
+ * where the upgrade is blocked — instead of forking a third stream flavour.
+ */
+
+import type { AgentImage, BtwFrame, BtwState, StreamTransport } from '@/shared/types';
+import { connectEvents } from '@/shared/lib/chat/omp/sse';
+import { connectSocket } from '@/shared/lib/chat/omp/socket';
+import { btwEventsUrl, btwSocketUrl } from '@/shared/lib/chat/omp/transport';
+import type { StreamConnection, StreamHandlers } from '@/shared/lib/chat/omp/transport';
+
+export type BtwStreamHandlers = StreamHandlers<BtwFrame>;
+
+/** A rejected command, carrying the server's machine-readable reason. */
+export class BtwRequestError extends Error {
+  readonly code?: string;
+
+  constructor(message: string, code?: string) {
+    super(message);
+    this.name = 'BtwRequestError';
+    this.code = code;
+  }
+}
+
+export function connectBtwStream(
+  sessionId: string,
+  transport: StreamTransport,
+  handlers: BtwStreamHandlers,
+): StreamConnection {
+  return transport === 'sse' ? connectEvents(btwEventsUrl(sessionId), handlers) : connectSocket(btwSocketUrl(sessionId), handlers);
+}
+
+interface BtwResponseBody {
+  success?: boolean;
+  data?: unknown;
+  error?: string;
+  code?: string;
+}
+
+async function requestBtw<T>(sessionId: string, method: 'GET' | 'POST', body?: Record<string, unknown>): Promise<T> {
+  const response = await fetch(`/api/btw/${encodeURIComponent(sessionId)}`, {
+    method,
+    ...(body
+      ? { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }
+      : {}),
+  });
+  const payload = (await response.json().catch(() => null)) as BtwResponseBody | null;
+  if (!response.ok || !payload?.success) {
+    throw new BtwRequestError(payload?.error ?? `Side question request failed (${response.status})`, payload?.code);
+  }
+  return payload.data as T;
+}
+
+/** The session's side questions as the server sees them. */
+export function fetchBtwState(sessionId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'GET');
+}
+
+export interface AskBtwInput {
+  topicId?: string;
+  question: string;
+  images?: AgentImage[];
+}
+
+export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', {
+    action: 'ask',
+    question: input.question,
+    ...(input.topicId ? { topicId: input.topicId } : {}),
+    ...(input.images?.length ? { images: input.images } : {}),
+  });
+}
+
+export function abortBtwQuestion(sessionId: string, topicId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', { action: 'abort', topicId });
+}
+
+export function promoteBtwTopic(sessionId: string, topicId: string): Promise<{ sessionId: string }> {
+  return requestBtw<{ sessionId: string }>(sessionId, 'POST', { action: 'promote', topicId });
+}
+
+export function deleteBtwTopic(sessionId: string, topicId: string): Promise<BtwState> {
+  return requestBtw<BtwState>(sessionId, 'POST', { action: 'delete', topicId });
+}

package/src/shared/lib/chat/composer/client.test.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The popup's command pool has two sources with different owners: omp's
+ * `get_available_commands` and the chamber's own commands. `/btw` exists only
+ * in the second — omp's registry entry for it is TUI-only, so RPC never
+ * advertises it — and the composer intercepts the token on send. If the entry
+ * ever disappears, the popup offers every command except the one being typed,
+ * and the user is left guessing why `/btw` matches nothing but `browser` by
+ * description.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { CommandItem } from '@/shared/types';
+import { mergeCommandAndSkillItems } from '@/shared/lib/chat/composer/client';
+
+function command(over: Partial<CommandItem> & { name: string }): CommandItem {
+  return {
+    id: `cmd-${over.name}`,
+    description: '',
+    scope: 'system',
+    template: '',
+    ...over,
+  };
+}
+
+describe('mergeCommandAndSkillItems', () => {
+  test('offers the chamber-owned /btw with omp metadata', () => {
+    const items = mergeCommandAndSkillItems([command({ name: 'model', description: 'Show current model selection' })], []);
+
+    const btw = items.find((item) => item.name === 'btw');
+    expect(btw).toBeDefined();
+    expect(btw?.token).toBe('/btw');
+    expect(btw?.kind).toBe('command');
+    // The hint is folded into the description exactly as the popup renders it.
+    expect(btw?.description).toBe("[question] - Ask a side question, or browse this session's BTW history");
+  });
+
+  test('keeps the chamber entry when omp advertises the same name', () => {
+    const items = mergeCommandAndSkillItems([command({ name: 'btw', description: 'something else entirely' })], []);
+
+    const matching = items.filter((item) => item.name === 'btw');
+    expect(matching.length).toBe(1);
+    expect(matching[0].description).toContain('Ask a side question');
+  });
+});

package/src/shared/lib/chat/composer/client.ts

@@ -1,4 +1,5 @@
 import type { AgentItem, CommandItem, ComposerPickItem, ComposerPickKind, FsFileEntry, SkillItem } from '@/shared/types';
+import { CHAMBER_COMMANDS } from '@/shared/lib/chat/composer/trigger';
 
 const CACHE_TTL_MS = 300_000;
 
@@ -56,24 +57,37 @@ export function toFilePickItems(files: FsFileEntry[]): ComposerPickItem[] {
 }
 
 /**
- * Combine commands (`/name`) then skills (`/skill:name`). A skill is skipped
- * when a command already covers its plain name or `skill:<name>`; commands win.
+ * Combine live command items (`/name`, including omp's own `skill:<name>`
+ * entries) with the chamber's skill list. Commands win: a skill whose plain or
+ * `skill:`-namespaced name a command already covers is skipped, so the two
+ * sources never double-list the same skill.
+ *
+ * The chamber's own commands (`CHAMBER_COMMANDS`) lead, so a same-named entry
+ * from omp can never advertise behavior the composer overrides on send — `/btw`
+ * is reserved by omp in the TUI for the same reason.
+ *
+ * The description carries the argument hint exactly as oh-my-pi renders it
+ * (`[on|off|status] - Toggle fast mode`) so the popup matches the CLI.
  */
 export function mergeCommandAndSkillItems(commands: CommandItem[], skills: SkillItem[]): ComposerPickItem[] {
   const result: ComposerPickItem[] = [];
   const seen = new Set<string>();
 
-  for (const command of commands) {
+  for (const command of [...CHAMBER_COMMANDS, ...commands]) {
     const key = command.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
+    const description = command.description ?? '';
     result.push({
       id: `command-${command.name}`,
       name: command.name,
-      description: command.description,
-      kind: 'command',
-      source: 'command',
+      description: command.inputHint ? (description ? `${command.inputHint} - ${description}` : command.inputHint) : description,
+      kind: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
+      source: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
       token: `/${command.name}`,
+      ...(command.aliases?.length ? { aliases: command.aliases } : {}),
+      ...(command.subcommands?.length ? { subcommands: command.subcommands } : {}),
+      ...(command.inputHint ? { inputHint: command.inputHint } : {}),
     });
   }
 
@@ -84,11 +98,11 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
     seen.add(prefixed);
     result.push({
       id: `skill-${skill.name}`,
-      name: skill.name,
+      name: prefixed,
       description: skill.description,
-      kind: 'command',
+      kind: 'skill',
       source: 'skill',
-      token: `/skill:${skill.name}`,
+      token: `/${prefixed}`,
     });
   }