@saadnvd1/agent-os 0.3.770 → 0.3.777

package/lib/artifacts/match.ts

@@ -0,0 +1,64 @@
+// Finds which earlier page a new render is a revision of, by its visible text.
+// Used when an agent retitles a page without passing `update`.
+
+// Word-5-gram overlap (Jaccard) of the visible text. A revision keeps most of
+// its sentences, so it stays well above 0.6; two pages that only share a
+// template (nav, footer, same CSS) have different text and land far below.
+export const MATCH_THRESHOLD = 0.6;
+// A clear winner: the runner-up must trail by this much, else it is a tie.
+export const MATCH_MARGIN = 0.1;
+// Too little text to tell documents apart.
+export const MIN_TOKENS = 12;
+export const SHINGLE = 5;
+export const MAX_CANDIDATES = 20;
+
+export function visibleText(html: string): string {
+  return html
+    .replace(/<!--[\s\S]*?-->/g, " ")
+    .replace(/<(script|style|noscript|template|svg)\b[\s\S]*?<\/\1\s*>/gi, " ")
+    .replace(/<[^>]*>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+export function tokens(html: string): string[] {
+  return visibleText(html).match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+
+function shingles(toks: string[]): Set<string> {
+  const out = new Set<string>();
+  const n = Math.min(SHINGLE, toks.length);
+  for (let i = 0; i + n <= toks.length; i++)
+    out.add(toks.slice(i, i + n).join(" "));
+  return out;
+}
+
+export function similarity(a: string, b: string): number {
+  const ta = tokens(a);
+  const tb = tokens(b);
+  if (ta.length < MIN_TOKENS || tb.length < MIN_TOKENS) return 0;
+  const sa = shingles(ta);
+  const sb = shingles(tb);
+  let shared = 0;
+  for (const s of sa) if (sb.has(s)) shared++;
+  const union = sa.size + sb.size - shared;
+  return union ? shared / union : 0;
+}
+
+// The id of the one candidate that clearly is the same document, if any.
+export function findRevisionOf<T extends { key: string; html: string }>(
+  html: string,
+  candidates: T[]
+): string | undefined {
+  const scored = candidates
+    .slice(0, MAX_CANDIDATES)
+    .map((c) => ({ key: c.key, score: similarity(html, c.html) }))
+    .sort((a, b) => b.score - a.score);
+  const [best, next] = scored;
+  if (!best || best.score < MATCH_THRESHOLD) return undefined;
+  if (next && best.score - next.score < MATCH_MARGIN) return undefined;
+  return best.key;
+}

package/lib/artifacts/store.ts

@@ -8,6 +8,7 @@ import fs from "fs";
 import path from "path";
 import { createHash, randomUUID } from "crypto";
 import { db } from "../db";
+import { findRevisionOf, MAX_CANDIDATES } from "./match";
 
 export interface Artifact {
   id: string;
@@ -29,6 +30,9 @@ export interface SaveOptions {
   update?: string;
   // With no update, the newest page in this session with the same title.
   sameTitle?: boolean;
+  // With no update and no title match, the page in this session whose latest
+  // version has clearly the same text (see match.ts).
+  matchContent?: boolean;
   note?: string;
 }
 
@@ -78,16 +82,18 @@ export function saveArtifact(
   if (bytes > MAX_HTML_BYTES)
     throw new Error("The page is over 2 MB; make it smaller.");
   const clean = oneLine(title, MAX_TITLE_CHARS) || "Untitled";
-  const note = opts.note ? oneLine(opts.note, MAX_NOTE_CHARS) || null : null;
+  let note = opts.note ? oneLine(opts.note, MAX_NOTE_CHARS) || null : null;
   const sha256 = createHash("sha256").update(html).digest("hex");
   const id = randomUUID();
   const dir = sessionDir(sessionId);
   const file = path.join(dir, `${id}.html`);
   return db.transaction((): Saved => {
-    const pageId = resolvePage(sessionId, clean, opts);
+    const { pageId, fuzzy } = resolvePage(sessionId, clean, html, opts);
     const latest = pageId ? latestVersion(pageId) : undefined;
     if (latest && latest.sha256 === sha256)
       return { artifact: latest, created: false };
+    if (fuzzy && latest && !note && latest.title !== clean)
+      note = oneLine(`Retitled from '${latest.title}'`, MAX_NOTE_CHARS);
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     fs.writeFileSync(file, html, { mode: 0o600 });
     db.prepare(
@@ -111,24 +117,47 @@ export function saveArtifact(
 function resolvePage(
   sessionId: string,
   title: string,
+  html: string,
   opts: SaveOptions
-): string | undefined {
+): { pageId?: string; fuzzy?: boolean } {
   if (opts.update) {
     const base = getArtifact(opts.update);
     if (!base || base.session_id !== sessionId)
       throw new Error(
         `No page ${opts.update} in this chat; leave out update to show a new page.`
       );
-    return base.page_id;
+    return { pageId: base.page_id };
+  }
+  if (!opts.sameTitle && !opts.matchContent) return {};
+  // A page is named by its latest version, so an older title no longer finds it.
+  const latest = latestPerPage(sessionId, MAX_CANDIDATES);
+  if (opts.sameTitle) {
+    const lower = title.toLowerCase();
+    const same = latest.find((a) => a.title.toLowerCase() === lower);
+    if (same) return { pageId: same.page_id };
   }
-  if (!opts.sameTitle) return undefined;
-  const row = db
+  if (!opts.matchContent) return {};
+  const candidates = latest.flatMap((a) => {
+    try {
+      return [{ key: a.page_id, html: fs.readFileSync(a.path, "utf8") }];
+    } catch {
+      return [];
+    }
+  });
+  const pageId = findRevisionOf(html, candidates);
+  return pageId ? { pageId, fuzzy: true } : {};
+}
+
+// The newest version of each page in a session, most recently shown first.
+function latestPerPage(sessionId: string, limit: number): Artifact[] {
+  return db
     .prepare(
-      `SELECT page_id FROM artifacts WHERE session_id = ? AND lower(title) = lower(?)
-       ORDER BY created_at DESC, rowid DESC LIMIT 1`
+      `SELECT a.* FROM artifacts a
+        WHERE a.session_id = ?
+          AND a.version = (SELECT MAX(version) FROM artifacts WHERE page_id = a.page_id)
+        ORDER BY a.created_at DESC, a.rowid DESC LIMIT ?`
     )
-    .get(sessionId, title) as { page_id: string } | undefined;
-  return row?.page_id;
+    .all(sessionId, limit) as Artifact[];
 }
 
 // Every version of a page, oldest first.

package/lib/artifacts/tools.ts

@@ -100,7 +100,12 @@ export async function renderPage(
       ctx.sessionId,
       args.title,
       readSource(args, ctx.cwd),
-      { update: args.update, note: args.note, sameTitle: true }
+      {
+        update: args.update,
+        note: args.note,
+        sameTitle: true,
+        matchContent: true,
+      }
     );
     if (created) {
       ctx.onRender(artifact, args.height);
@@ -112,7 +117,7 @@ export async function renderPage(
         {
           type: "text",
           text: created
-            ? `Shown in the chat as ${name} (artifact ${artifact.id}). To change it, call html_render again with update: "${artifact.id}"; every version is kept.`
+            ? `Shown in the chat as ${name} (artifact ${artifact.id}). To revise this page, pass update: "${artifact.id}" to html_render, even if the title changes; every version is kept.`
             : `Unchanged: the page is the same as ${name} (artifact ${artifact.id}), already in the chat.`,
         },
       ],
@@ -191,7 +196,7 @@ export function visualsTools(
             .string()
             .optional()
             .describe(
-              "The artifact id of a page you already showed in this chat, to show a new version of it. A page with the same title is updated too. Every version is kept."
+              "When revising a page you already showed, pass its artifact id, even if the title changes, to show a new version of it. Without it a page is matched by title or similar content, and otherwise saved as a new page. Every version is kept."
             ),
           note: z
             .string()
@@ -207,7 +212,7 @@ export function visualsTools(
 
 export const VISUALS_BRIEF = `## Showing visuals
 
-When a chart, table, diagram or mockup would say more than prose, build a self-contained HTML page (a chart is an HTML page; a CDN library such as Chart.js is fine), check it with \`html_preview\` and fix what the screenshot and console show, then show it with \`html_render\` before your final reply. The reader sees the page above that reply, so add only what the page doesn't say. An SVG or image file you write shows inline when your reply links to it by its absolute path, as ![name](/abs/path.svg).`;
+When a chart, table, diagram or mockup would say more than prose, build a self-contained HTML page (a chart is an HTML page; a CDN library such as Chart.js is fine), check it with \`html_preview\` and fix what the screenshot and console show, then show it with \`html_render\` before your final reply. The reader sees the page above that reply, so add only what the page doesn't say. To revise a page you already showed, call \`html_render\` again with \`update\` set to its artifact id (even if the title changes), so it becomes the next version, not a second page. An SVG or image file you write shows inline when your reply links to it by its absolute path, as ![name](/abs/path.svg).`;
 
 // An orchestrator reads other sessions' text, so it gets the short form and
 // is told what to keep out of a page.

package/lib/artifacts/versions.ts

@@ -66,8 +66,9 @@ export function pageVersions(
   const versions = listVersions(a.page_id).map(toVersion);
   return {
     pageId: a.page_id,
+    title: versions[versions.length - 1]?.title ?? a.title,
     latestId: versions[versions.length - 1]?.id ?? a.id,
     versions,
-    actions: pageActions(ctx),
+    actions: pageActions({ ...ctx, versions: versions.length }),
   };
 }

package/lib/chat/events.ts

@@ -81,7 +81,10 @@ export type ChatOriginKind =
   // The reader's own decision, made outside the composer (a plan carried out).
   | "decision"
   // The reader's phone: a shake report or something shared to AgentOS.
-  | "device";
+  | "device"
+  // A suggestion from a guest on a live link, sent by the reader after
+  // reading it. Its label is the guest's name.
+  | "guest";
 
 export interface ChatOrigin {
   kind: ChatOriginKind;

package/lib/chat/registry.ts

@@ -85,6 +85,8 @@ interface Registry {
   caps: Map<string, Capabilities>;
   // Told of every finished turn (lib/analyst), set by the server.
   turnEndHook?: TurnEndHook;
+  // Read-only taps on every message of every conversation (lib/live).
+  taps?: Set<(sessionId: string, m: ChatServerMessage) => void>;
 }
 
 export type TurnEndHook = (
@@ -96,6 +98,13 @@ export function setTurnEndHook(fn: TurnEndHook): void {
   registry.turnEndHook = fn;
 }
 
+export function addTap(
+  fn: (sessionId: string, m: ChatServerMessage) => void
+): () => void {
+  (registry.taps ??= new Set()).add(fn);
+  return () => registry.taps?.delete(fn);
+}
+
 // Shared across every module instance in the process (custom server and the
 // Next.js route bundles each load their own copy of this file).
 const g = globalThis as unknown as { __agentosChat?: Registry };
@@ -120,6 +129,7 @@ export function emit(sessionId: string, m: ChatServerMessage): void {
     touchActive(sessionId);
   if (m.type === "item" && m.item.kind === "turn_end")
     registry.turnEndHook?.(sessionId, m.item);
+  registry.taps?.forEach((tap) => tap(sessionId, m));
   registry.listeners.get(sessionId)?.forEach((fn) => fn(m));
   // Idle, running, waiting and back, and a finished turn (unread): the
   // sidebar hears at once.

package/lib/connect/control-api.ts

@@ -471,3 +471,47 @@ export async function revokeShare(
   );
   return shareFrom(await res.json().catch(() => null));
 }
+
+export type LiveExpiry = "1h" | "session";
+
+export interface LiveShare {
+  id: string;
+  url: string;
+  title: string;
+  status: ShareStatus;
+  expires_at: string | null;
+  ends_with_session: boolean;
+  max_guests: number;
+}
+
+/** Mints a live link for one session; the answer carries the link, once. */
+export async function createLiveShare(
+  config: ConnectConfig,
+  privateKey: string,
+  share: { title: string; expiresIn: LiveExpiry }
+): Promise<LiveShare> {
+  const res = await signed(config, privateKey)(
+    "POST",
+    `/api/v1/machines/${config.machineId}/live-shares`,
+    { title: share.title, expires_in: share.expiresIn }
+  );
+  const r = (await res.json().catch(() => null)) as Record<
+    string,
+    unknown
+  > | null;
+  if (
+    typeof r?.id !== "string" ||
+    typeof r.url !== "string" ||
+    !/^https:\/\//.test(r.url)
+  )
+    throw new Error("the Connect service sent no link");
+  return {
+    id: r.id,
+    url: r.url,
+    title: typeof r.title === "string" ? r.title : share.title,
+    status: (r.status as ShareStatus) ?? "active",
+    expires_at: typeof r.expires_at === "string" ? r.expires_at : null,
+    ends_with_session: r.ends_with_session === true,
+    max_guests: typeof r.max_guests === "number" ? r.max_guests : 0,
+  };
+}

package/lib/db/migrations/20261029T1400_live_shares.ts

@@ -0,0 +1,42 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261029T1400_live_shares",
+  up: (db) => {
+    // One row per live link this machine minted. The id is Connect's share id.
+    db.exec(
+      `CREATE TABLE IF NOT EXISTS live_shares (
+         id TEXT PRIMARY KEY,
+         session_id TEXT NOT NULL,
+         title TEXT NOT NULL,
+         url TEXT NOT NULL,
+         ends_with_session INTEGER NOT NULL DEFAULT 0,
+         max_guests INTEGER NOT NULL DEFAULT 0,
+         created_at TEXT NOT NULL,
+         expires_at TEXT,
+         ended_at TEXT
+       )`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_live_shares_session ON live_shares(session_id)`
+    );
+    // What happened on a share, kept on this machine only: who asked to join,
+    // who was let in, and each suggestion with the text actually sent.
+    db.exec(
+      `CREATE TABLE IF NOT EXISTS live_share_log (
+         id INTEGER PRIMARY KEY AUTOINCREMENT,
+         share_id TEXT NOT NULL,
+         at INTEGER NOT NULL,
+         kind TEXT NOT NULL,
+         guest_id TEXT,
+         guest_name TEXT,
+         ref TEXT,
+         text TEXT,
+         sent_text TEXT
+       )`
+    );
+    db.exec(
+      `CREATE INDEX IF NOT EXISTS idx_live_share_log_share ON live_share_log(share_id, id)`
+    );
+  },
+} satisfies Migration;

package/lib/live/clean.ts

@@ -0,0 +1,54 @@
+/**
+ * Text from a guest is cleaned here again, on this machine, whatever Connect
+ * did to it: nothing from the wire is shown on a card or reaches the agent
+ * without passing through. Mirrors Connect's Live::Text.
+ */
+
+const INVISIBLE =
+  /[\p{Cf}\p{Default_Ignorable_Code_Point}\p{Zl}\p{Zp}⠀\u{1D159}\u{E0000}-\u{E0FFF}]/gu;
+const SPACES = /\p{Zs}/gu;
+const CONTROL = /[\u0000-\u001F\u007F-\u009F]/g;
+const CONTROL_KEEPING_NEWLINE = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+const MARK_RUN = /\p{M}{3,}/u;
+const SCRIPTS = [
+  /\p{Script=Latin}/u,
+  /\p{Script=Cyrillic}/u,
+  /\p{Script=Greek}/u,
+];
+
+export const MAX_NAME = 40;
+export const MAX_SUGGESTION = 2000;
+
+const wellFormed = (s: string) => s.isWellFormed();
+
+/** A guest's name: one line, 1-40 characters, or null. */
+export function cleanName(input: unknown): string | null {
+  if (typeof input !== "string" || !wellFormed(input)) return null;
+  if (input.length > MAX_NAME * 8) return null;
+  const s = input
+    .normalize("NFC")
+    .replace(SPACES, " ")
+    .replace(INVISIBLE, "")
+    .replace(CONTROL, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!s || [...s].length > MAX_NAME || !/[\p{L}\p{N}]/u.test(s)) return null;
+  if (MARK_RUN.test(s) || SCRIPTS.filter((r) => r.test(s)).length > 1)
+    return null;
+  return s;
+}
+
+/** A block of text (a suggestion): newlines and tabs kept, or null. */
+export function cleanBody(input: unknown, max = MAX_SUGGESTION): string | null {
+  if (typeof input !== "string" || !wellFormed(input)) return null;
+  if (input.length > max * 8) return null;
+  const s = input
+    .normalize("NFC")
+    .replace(/\r/g, "")
+    .replace(SPACES, " ")
+    .replace(INVISIBLE, "")
+    .replace(CONTROL_KEEPING_NEWLINE, "")
+    .trim();
+  if (!s || [...s].length > max) return null;
+  return s;
+}

package/lib/live/frames.ts

@@ -0,0 +1,132 @@
+/**
+ * What goes up to Connect for one chat item, or nothing. Which items a
+ * guest may see is decided by the shared snapshot rules (toRaw); this only
+ * shapes them into frames. Text is redacted whole, never as a delta.
+ */
+
+import type { ChatItem, ChatState } from "../chat/events";
+import { isSecretPath } from "../secret-paths";
+import { toRaw, strings } from "../share/snapshot";
+import { redactForShare, type ShareContext } from "./../share/redact";
+
+export type ItemFrame =
+  | {
+      id: string;
+      kind: "user" | "assistant" | "note";
+      text: string;
+      from?: string;
+      at: number;
+    }
+  | {
+      id: string;
+      kind: "tool";
+      name: string;
+      summary: string;
+      status: "running" | "done" | "error";
+      at: number;
+    };
+
+export type LiveState = "working" | "idle" | "waiting_on_host";
+
+export const MAX_TEXT_BYTES = 24 * 1024;
+export const MAX_SUMMARY_BYTES = 200;
+const MAX_NAME_BYTES = 64;
+const MAX_ID = 64;
+
+/** The longest prefix of `s` that fits in `max` bytes, cut on a character. */
+export function clipBytes(s: string, max: number): string {
+  if (Buffer.byteLength(s) <= max) return s;
+  let out = "";
+  let size = 0;
+  for (const ch of s) {
+    const n = Buffer.byteLength(ch);
+    if (size + n > max) break;
+    out += ch;
+    size += n;
+  }
+  return out;
+}
+
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim();
+
+export function stateOf(state: ChatState): LiveState {
+  if (state === "running") return "working";
+  if (state === "waiting") return "waiting_on_host";
+  return "idle";
+}
+
+// Messages that were not typed by the reader (the agent bus, schedules,
+// AgentOS itself) stay on this machine; a sent suggestion is the reader's.
+function userFrom(item: Extract<ChatItem, { kind: "user" }>): string | null {
+  const o = item.origin;
+  if (!o) return item.peer || item.from ? null : "host";
+  if (o.kind === "guest") return `guest:${o.label}`;
+  if (o.kind === "decision") return "host";
+  return null;
+}
+
+export interface ItemMapper {
+  /** `text` replaces the item's own text (an assistant turn still streaming). */
+  (item: ChatItem, text?: string): ItemFrame | null;
+}
+
+export function itemMapper(ctx: ShareContext): ItemMapper {
+  const take = (s: string) => redactForShare(s, ctx).text;
+  return (item, text) => {
+    const at = item.createdAt ?? Date.now();
+    const id = item.id.slice(0, MAX_ID);
+    if (item.kind === "tool") {
+      const secret = strings(item.input).some(isSecretPath);
+      const label = secret ? item.name : item.title || item.name;
+      const status =
+        item.status === "running"
+          ? "running"
+          : item.status === "done"
+            ? "done"
+            : "error";
+      return {
+        id,
+        kind: "tool",
+        name: clipBytes(oneLine(take(item.name)), MAX_NAME_BYTES),
+        summary: clipBytes(oneLine(take(label)), MAX_SUMMARY_BYTES),
+        status,
+        at,
+      };
+    }
+    if (item.kind === "todos") {
+      const done = item.todos.filter((t) => t.status === "completed").length;
+      return {
+        id,
+        kind: "note",
+        text: `To do: ${done} of ${item.todos.length} done`,
+        at,
+      };
+    }
+    let from: string | undefined;
+    if (item.kind === "user") {
+      const f = userFrom(item);
+      if (!f) return null;
+      from = f;
+    }
+    const raw = toRaw(item);
+    if (!raw || raw.tools || raw.type === "artifact") return null;
+    const body = clipBytes(take(text ?? raw.text), MAX_TEXT_BYTES);
+    if (item.kind === "user")
+      return {
+        id,
+        kind: "user",
+        text: body,
+        from,
+        at,
+      };
+    if (item.kind === "assistant")
+      return body.trim() ? { id, kind: "assistant", text: body, at } : null;
+    // Plans, errors and the compaction divider are one-line notes.
+    return {
+      id,
+      kind: "note",
+      text: clipBytes(oneLine(body), 400) || "…",
+      at,
+    };
+  };
+}