@saadnvd1/agent-os 0.3.672 → 0.3.678

package/lib/db/migrations/20261019T1200_chat_queue_files.ts

@@ -0,0 +1,14 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261019T1200_chat_queue_files",
+  up: (db) => {
+    // Files attached to a queued message, as a JSON list of references to
+    // the session's attachments folder (never the bytes).
+    const cols = db.prepare(`PRAGMA table_info(chat_queue)`).all() as {
+      name: string;
+    }[];
+    if (!cols.some((c) => c.name === "files"))
+      db.exec(`ALTER TABLE chat_queue ADD COLUMN files TEXT`);
+  },
+} satisfies Migration;

package/lib/db/migrations/20261019T1500_conversation_search.ts

@@ -0,0 +1,12 @@
+import type { Migration } from "../migration-types";
+import { createConversationSearch } from "../../search/conversations/schema";
+
+export default {
+  key: "20261019T1500_conversation_search",
+  up: (db) => {
+    // The index and the triggers that keep it current. Existing chats are
+    // indexed in the background after startup (lib/search/conversations/backfill.ts),
+    // never in this migration, so a big database doesn't hold up the boot.
+    createConversationSearch(db);
+  },
+} satisfies Migration;

package/lib/file-upload.ts

@@ -1,34 +1,68 @@
-/**
- * Upload a file to temporary storage and return its path.
- * Converts the file to base64 and POSTs to /api/files/upload-temp.
- *
- * @param file - The file to upload
- * @returns The path to the uploaded file, or null if upload failed
- */
-export async function uploadFileToTemp(file: File): Promise<string | null> {
-  const buffer = await file.arrayBuffer();
-  const base64 = btoa(
-    new Uint8Array(buffer).reduce(
-      (data, byte) => data + String.fromCharCode(byte),
-      ""
-    )
-  );
+import type { AttachmentKind } from "./attachments/policy";
+import type { ChatFile } from "./attachments/types";
 
-  const res = await fetch("/api/files/upload-temp", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      filename: file.name || `file-${Date.now()}`,
-      base64,
-      mimeType: file.type || "application/octet-stream",
-    }),
+export type UploadResult =
+  | { ok: true; file: ChatFile; kind: AttachmentKind }
+  | { ok: false; error: string };
+
+function toBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result).split(",")[1] ?? "");
+    reader.onerror = () => reject(reader.error);
+    reader.readAsDataURL(file);
   });
+}
 
-  const data = await res.json();
-  if (data.path) {
-    return data.path;
+/**
+ * Upload a file through /api/files/upload-temp. With a `sessionId` (or
+ * "draft") the server checks it against its attachment limits and keeps it in
+ * that session's attachments folder; without one it goes to temp storage.
+ * The error is the server's own message, ready to show.
+ */
+export async function uploadFile(
+  file: File,
+  sessionId?: string
+): Promise<UploadResult> {
+  try {
+    const res = await fetch("/api/files/upload-temp", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        filename: file.name || `file-${Date.now()}`,
+        base64: await toBase64(file),
+        mimeType: file.type || "application/octet-stream",
+        sessionId,
+      }),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (res.ok && data.path)
+      return {
+        ok: true,
+        kind: data.kind,
+        file: {
+          path: data.path,
+          name: data.name,
+          size: data.size,
+          mediaType: data.mediaType,
+        },
+      };
+    return {
+      ok: false,
+      error: data.error ?? `Couldn't upload ${file.name} (${res.status})`,
+    };
+  } catch {
+    return { ok: false, error: `Couldn't upload ${file.name}` };
   }
+}
 
-  console.error("Upload failed:", data.error);
+/** The saved path, or null when the upload failed (terminal and picker). */
+export async function uploadFileToTemp(
+  file: File,
+  sessionId?: string
+): Promise<string | null> {
+  const r = await uploadFile(file, sessionId);
+  if (r.ok) return r.file.path;
+  console.error("Upload failed:", r.error);
   return null;
 }

package/lib/intake/intake.ts

@@ -8,6 +8,7 @@ import { getWorkspace } from "../workspaces";
 import { INTAKE_LIMITS, MAX_INLINE_IMAGE_BYTES } from "./limits";
 import { buildIntakeMessage, type IntakeMeta } from "./message";
 import { sniff } from "./sniff";
+import { safeName } from "../attachments/store";
 
 export class IntakeError extends Error {
   constructor(
@@ -39,23 +40,7 @@ const day = (t: number) => new Date(t).toISOString().slice(0, 10);
 const workspaceRoot = (workspaceId: string) =>
   path.join(dataRoot(), "intake", segment(workspaceId));
 
-/** A phone's filename as one safe path segment. */
-export function safeName(name: string, taken: Set<string>, n: number): string {
-  let base = path.basename(name.replace(/\\/g, "/"));
-  base = base
-    .replace(/[^a-zA-Z0-9.-]/g, "_")
-    .replace(/^\.+/, "")
-    .slice(0, 80);
-  if (!base) base = `file-${n}`;
-  let out = base;
-  for (let i = 2; taken.has(out); i++) {
-    const dot = base.lastIndexOf(".");
-    out =
-      dot > 0 ? `${base.slice(0, dot)}-${i}${base.slice(dot)}` : `${base}-${i}`;
-  }
-  taken.add(out);
-  return out;
-}
+export { safeName };
 
 function checkMeta(meta: IntakeMeta) {
   if (!meta || typeof meta !== "object") throw new IntakeError(400, "Bad meta");

package/lib/intake/sniff.ts

@@ -9,7 +9,7 @@ const BLOCKED_NAME =
 const starts = (b: Buffer, sig: number[], at = 0) =>
   sig.every((v, i) => b[at + i] === v);
 
-function isText(b: Buffer): boolean {
+export function isText(b: Buffer): boolean {
   const head = b.subarray(0, 8192);
   if (head.includes(0)) return false;
   try {

package/lib/orchestrator/read.ts

@@ -10,6 +10,7 @@ import { hostLink } from "../hosts/remote-api";
 import { peerPane } from "../hosts/peer-sessions";
 import { workspaceSessions } from "./facts";
 import { untrusted } from "./untrusted";
+import { grepText } from "../bus/condense";
 import { heldChatTail, isHeldRemote } from "../tasks/contract/held-calls";
 import {
   findExternalSession,
@@ -55,7 +56,10 @@ export function findWorkspaceSession(
 // A session AgentOS didn't start: its screen, read the way the sidebar
 // reads one (a linked machine's only through its AgentOS, which doesn't
 // serve a screen it didn't start).
-async function readExternal(s: ExternalSession, n: number): Promise<string> {
+export async function readExternal(
+  s: ExternalSession,
+  n: number
+): Promise<string> {
   const head = `${s.ref} (external terminal on ${s.host}, not started by AgentOS)`;
   if (hostLink(s.hostId))
     return `${head}: its screen is on that machine and isn't served to this one.`;
@@ -127,6 +131,16 @@ export async function readSession(
     if (!external) throw error;
     return readExternal(external, n);
   }
+  return readResolved(s, n);
+}
+
+// One session's recent conversation or screen, whichever it has.
+export async function readResolved(
+  s: Session,
+  n: number,
+  grep?: string
+): Promise<string> {
+  const cut = (text: string) => tail(grep ? grepText(text, grep) : text, n);
   const link = hostLink(s.host_id);
   if (s.view === "chat" && link) {
     // Its orchestrator's task is read through the machine that holds it.
@@ -137,12 +151,12 @@ export async function readSession(
   }
   if (s.view === "chat") {
     const text = chatText(lastItems(s.id, n * 2));
-    const body = text ? untrusted(s.name, tail(text, n)) : "(no messages yet)";
+    const body = text ? untrusted(s.name, cut(text)) : "(no messages yet)";
     return `${s.name} (chat), last ${n} lines:\n${body}`;
   }
   if (link) {
     const lines = await peerPane(link, s.id);
-    const body = lines ? tail(lines.join("\n"), n) : "";
+    const body = lines ? cut(lines.join("\n")) : "";
     return `${s.name} (terminal on ${link.hostName}), last ${n} lines:\n${body ? untrusted(s.name, body) : "(couldn't be read)"}`;
   }
   await statusDetector.refreshCache();
@@ -152,6 +166,6 @@ export async function readSession(
     s.host_id || "local",
     `tmux capture-pane -t ${shellQuote(`=${s.tmux_name}:`)} -p -J -S -${n}`
   );
-  const body = tail(pane, n);
+  const body = cut(pane);
   return `${s.name} (terminal), last ${n} lines:\n${body ? untrusted(s.name, body) : "(empty)"}`;
 }

package/lib/palette/registry.ts

@@ -12,6 +12,10 @@ export interface PaletteCommand {
   keywords?: string[];
   // Shown beside it, e.g. ⌘K.
   hint?: string;
+  // A line under the title (what a conversation hit said).
+  detail?: string;
+  // Running it leaves the palette open (it changes the palette itself).
+  keepOpen?: boolean;
   icon?: unknown;
   run: () => void;
 }

package/lib/resurrect/index.ts

@@ -46,6 +46,7 @@ import { planFromTranscript } from "./plan";
 import { dropSnapshot, restoreWorktree, type RestoredAs } from "./snapshot";
 import { restoreSwept, sweptNote } from "./swept";
 import { forgetSwept } from "../worktree-sweep/store";
+import { isRestorableTask } from "../tasks/restorable";
 import { setPr, setTask } from "../db/session-parts";
 
 export interface ResurrectOptions {
@@ -66,8 +67,6 @@ export interface ResurrectOutcome {
 const row = (id: string) =>
   queries.getSession(db).get(id) as Session | undefined;
 
-const ENDED_TASK = new Set(["dropped", "done"]);
-
 // Restores in flight here, so two clicks can't both build a worktree.
 const g = globalThis as unknown as { __agentosResurrecting?: Set<string> };
 const inFlight = (g.__agentosResurrecting ??= new Set());
@@ -113,7 +112,7 @@ export async function resurrectSession(
     throw new Error(`${s.name} runs on ${peer.hostName}: restore it there.`);
   if (isMirror(s)) return onItsMachine(s);
 
-  const endedTask = !!s.task_status && ENDED_TASK.has(s.task_status);
+  const endedTask = isRestorableTask(s.task_status);
   if (s.task_status === "merged")
     throw new Error(
       `${s.name} was merged: its work is in the base branch. Start a new task to continue it.`

package/lib/search/conversations/backfill.ts

@@ -0,0 +1,117 @@
+import type Database from "better-sqlite3";
+import { getDb } from "@/lib/db";
+import { SCHEMA_VERSION, SEARCHED_KINDS } from "./schema";
+
+const BATCH = 500;
+
+interface State {
+  version: number;
+  cursor: number;
+  backfill_to: number;
+  done: number;
+}
+
+const stateOf = (db: Database.Database): State | undefined =>
+  db.prepare(`SELECT * FROM chat_search_state WHERE id = 1`).get() as
+    | State
+    | undefined;
+
+// Starts the index over: the stored version is not this build's.
+function reset(db: Database.Database): void {
+  db.transaction(() => {
+    db.exec(`DELETE FROM chat_search; DELETE FROM chat_search_keys`);
+    db.prepare(
+      `UPDATE chat_search_state SET version = ?, cursor = 0, done = 0,
+         backfill_to = (SELECT COALESCE(MAX(rowid), 0) FROM chat_items)
+       WHERE id = 1`
+    ).run(SCHEMA_VERSION);
+  })();
+}
+
+// Indexes one batch of the chats that were already there when the index was
+// made, in rowid order, and records where it got to in the same transaction:
+// stopped at any point, the next call carries on. Returns true when finished.
+export function backfillStep(db: Database.Database, batch = BATCH): boolean {
+  const state = stateOf(db);
+  if (!state) return true;
+  if (state.version !== SCHEMA_VERSION) reset(db);
+  else if (state.done) return true;
+  const { cursor, backfill_to } = stateOf(db)!;
+  const kinds = SEARCHED_KINDS.map(() => "?").join(", ");
+  return db.transaction(() => {
+    // Rowids are not dense (tool calls are most rows), so the batch is
+    // counted in rows of the kinds searched and the cursor moves to the last.
+    const rows = db
+      .prepare(
+        `SELECT rowid AS rid, session_id, item_id,
+                json_extract(data, '$.text') AS text
+         FROM chat_items
+         WHERE rowid > ? AND rowid <= ? AND kind IN (${kinds})
+         ORDER BY rowid LIMIT ?`
+      )
+      .all(cursor, backfill_to, ...SEARCHED_KINDS, batch) as {
+      rid: number;
+      session_id: string;
+      item_id: string;
+      text: string | null;
+    }[];
+    const key = db.prepare(
+      `SELECT id FROM chat_search_keys WHERE session_id = ? AND item_id = ?`
+    );
+    const del = db.prepare(`DELETE FROM chat_search WHERE rowid = ?`);
+    const mk = db.prepare(
+      `INSERT OR IGNORE INTO chat_search_keys (session_id, item_id) VALUES (?, ?)`
+    );
+    const put = db.prepare(
+      `INSERT INTO chat_search (rowid, body) VALUES (?, ?)`
+    );
+    for (const r of rows) {
+      if (!r.text) continue;
+      const have = key.get(r.session_id, r.item_id) as
+        | { id: number }
+        | undefined;
+      if (have) del.run(have.id);
+      else mk.run(r.session_id, r.item_id);
+      const id = (key.get(r.session_id, r.item_id) as { id: number }).id;
+      put.run(id, r.text);
+    }
+    const finished = rows.length < batch;
+    const next = finished ? backfill_to : rows[rows.length - 1].rid;
+    db.prepare(
+      `UPDATE chat_search_state SET cursor = ?, done = ? WHERE id = 1`
+    ).run(next, finished ? 1 : 0);
+    return finished;
+  })();
+}
+
+// 0..1 while the first index is being built; null once it is complete.
+export function indexProgress(): number | null {
+  const s = stateOf(getDb());
+  if (!s || (s.done && s.version === SCHEMA_VERSION)) return null;
+  return s.backfill_to ? Math.min(1, s.cursor / s.backfill_to) : 0;
+}
+
+let running = false;
+
+// Runs batches until done, giving the event loop back between them, so a
+// large history never holds up a request or the boot.
+export function startConversationBackfill(): void {
+  if (running) return;
+  running = true;
+  const t0 = Date.now();
+  const tick = () => {
+    try {
+      if (backfillStep(getDb())) {
+        running = false;
+        console.log(`Conversation search index ready (${Date.now() - t0} ms)`);
+        return;
+      }
+    } catch (error) {
+      running = false;
+      console.error("Indexing conversations for search failed:", error);
+      return;
+    }
+    setImmediate(tick);
+  };
+  setImmediate(tick);
+}

package/lib/search/conversations/buildMatchQuery.ts

@@ -0,0 +1,31 @@
+export interface MatchQuery {
+  // An FTS5 MATCH expression.
+  match: string;
+  // The words typed, lowercased, for marking a preview.
+  terms: string[];
+}
+
+const HAS_WORD = /[\p{L}\p{N}]/u;
+const WORDS = /[\p{L}\p{N}_]+/gu;
+// A quoted phrase (possibly still being typed) or a bare word.
+const TOKEN = /"([^"]*)(")?|[^\s"]+/g;
+
+// What was typed as an FTS5 expression. Every piece goes in as a quoted
+// string, so FTS syntax typed by hand (AND, NEAR, *, :, -, parentheses) is
+// plain text. Bare words match as prefixes, so a word being typed finds its
+// completions; a closed "phrase" is exact, an open one is a prefix on its last
+// word. Null when nothing searchable was typed.
+export function buildMatchQuery(input: string): MatchQuery | null {
+  const parts: string[] = [];
+  const terms: string[] = [];
+  for (const m of input.matchAll(TOKEN)) {
+    const quoted = m[1] !== undefined;
+    const text = (quoted ? m[1] : m[0]).trim();
+    if (!HAS_WORD.test(text)) continue;
+    const prefix = !quoted || !m[2];
+    parts.push(`"${text}"${prefix ? "*" : ""}`);
+    for (const w of text.toLowerCase().match(WORDS) ?? []) terms.push(w);
+  }
+  if (!parts.length || terms.join("").length < 2) return null;
+  return { match: parts.join(" "), terms };
+}

package/lib/search/conversations/index.ts

@@ -0,0 +1,9 @@
+export { buildMatchQuery } from "./buildMatchQuery";
+export { searchConversations } from "./searchConversations";
+export { getMessageContext } from "./messageContext";
+export {
+  startConversationBackfill,
+  backfillStep,
+  indexProgress,
+} from "./backfill";
+export type * from "./types";

package/lib/search/conversations/messageContext.ts

@@ -0,0 +1,45 @@
+import { getDb } from "@/lib/db";
+import type { ContextItem } from "./types";
+
+interface Row {
+  item_id: string;
+  kind: "user" | "assistant";
+  text: string | null;
+  created_at: number | null;
+  seq: number;
+}
+
+const COLS = `item_id, kind, seq, json_extract(data, '$.text') AS text,
+              json_extract(data, '$.createdAt') AS created_at`;
+
+// A message and the ones said just before and after it, in order. Null when
+// the message is gone. Only text: images and files stay out of a preview.
+export function getMessageContext(
+  sessionId: string,
+  itemId: string,
+  around = 3
+): ContextItem[] | null {
+  const db = getDb();
+  const hit = db
+    .prepare(
+      `SELECT ${COLS} FROM chat_items WHERE session_id = ? AND item_id = ?`
+    )
+    .get(sessionId, itemId) as Row | undefined;
+  if (!hit) return null;
+  const side = (op: "<" | ">", order: "ASC" | "DESC") =>
+    db
+      .prepare(
+        `SELECT ${COLS} FROM chat_items
+         WHERE session_id = ? AND kind IN ('user', 'assistant') AND seq ${op} ?
+         ORDER BY seq ${order} LIMIT ?`
+      )
+      .all(sessionId, hit.seq, around) as Row[];
+  const rows = [...side("<", "DESC").reverse(), hit, ...side(">", "ASC")];
+  return rows.map((r) => ({
+    id: r.item_id,
+    role: r.kind,
+    text: r.text ?? "",
+    createdAt: r.created_at,
+    hit: r.item_id === itemId,
+  }));
+}

package/lib/search/conversations/schema.ts

@@ -0,0 +1,71 @@
+import type Database from "better-sqlite3";
+
+// Bump to rebuild the index from scratch (a different set of kinds, a new
+// tokenizer); the next start's backfill does it.
+export const SCHEMA_VERSION = 1;
+
+// The item kinds whose text is searched. Tool calls and their output are
+// most of the rows and mostly noise.
+export const SEARCHED_KINDS = ["user", "assistant"] as const;
+
+const KINDS_SQL = SEARCHED_KINDS.map((k) => `'${k}'`).join(", ");
+
+// An item worth indexing: a searched kind with some text.
+const eligible = `new.kind IN (${KINDS_SQL}) AND COALESCE(json_extract(new.data, '$.text'), '') <> ''`;
+
+// The item's own key: the FTS rowid. chat_items has no integer primary key,
+// so its rowids can be renumbered by a VACUUM.
+const keyOf = (row: "new" | "old") =>
+  `(SELECT id FROM chat_search_keys WHERE session_id = ${row}.session_id AND item_id = ${row}.item_id)`;
+
+const reindexItem = `
+  DELETE FROM chat_search WHERE rowid = ${keyOf("old")};
+  DELETE FROM chat_search_keys WHERE session_id = old.session_id AND item_id = old.item_id;
+  INSERT INTO chat_search_keys (session_id, item_id)
+    SELECT new.session_id, new.item_id WHERE ${eligible};
+  INSERT INTO chat_search (rowid, body)
+    SELECT ${keyOf("new")}, json_extract(new.data, '$.text') WHERE ${eligible};`;
+
+// Every writer of chat_items (the server, the chat worker, an import) is
+// indexed by these, so no code path can forget.
+export function createConversationSearch(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_search_keys (
+      id INTEGER PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      item_id TEXT NOT NULL,
+      UNIQUE (session_id, item_id)
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS chat_search USING fts5(
+      body,
+      tokenize = "unicode61 remove_diacritics 2 tokenchars '_'",
+      prefix = '2 3'
+    );
+    CREATE TABLE IF NOT EXISTS chat_search_state (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      version INTEGER NOT NULL,
+      cursor INTEGER NOT NULL DEFAULT 0,
+      backfill_to INTEGER NOT NULL DEFAULT 0,
+      done INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT OR IGNORE INTO chat_search_state (id, version, backfill_to, done)
+      SELECT 1, ${SCHEMA_VERSION}, COALESCE(MAX(rowid), 0), MAX(rowid) IS NULL
+      FROM chat_items;
+    CREATE TRIGGER IF NOT EXISTS chat_search_ai AFTER INSERT ON chat_items
+    BEGIN
+      DELETE FROM chat_search WHERE rowid = ${keyOf("new")};
+      INSERT OR IGNORE INTO chat_search_keys (session_id, item_id)
+        SELECT new.session_id, new.item_id WHERE ${eligible};
+      INSERT INTO chat_search (rowid, body)
+        SELECT ${keyOf("new")}, json_extract(new.data, '$.text') WHERE ${eligible};
+    END;
+    CREATE TRIGGER IF NOT EXISTS chat_search_au AFTER UPDATE OF data ON chat_items
+    BEGIN${reindexItem}
+    END;
+    CREATE TRIGGER IF NOT EXISTS chat_search_ad AFTER DELETE ON chat_items
+    BEGIN
+      DELETE FROM chat_search WHERE rowid = ${keyOf("old")};
+      DELETE FROM chat_search_keys WHERE session_id = old.session_id AND item_id = old.item_id;
+    END;
+  `);
+}