@saadnvd1/agent-os 0.3.770 → 0.3.777

package/lib/share/range.ts

@@ -0,0 +1,189 @@
+// Which part of a chat a share covers. Pure, imports nothing outside itself,
+// so the dialog and the server resolve a range the same way.
+
+/** A range of messages by id, both ends included. */
+export interface ShareRange {
+  fromId: string;
+  toId: string;
+}
+
+export interface RangeRow {
+  id: string;
+  type: string;
+  createdAt?: number;
+}
+
+export type RangePreset = "last" | "last5" | "today" | "all";
+
+export const PRESETS: { id: RangePreset; label: string }[] = [
+  { id: "last", label: "Last exchange" },
+  { id: "last5", label: "Last 5 exchanges" },
+  { id: "today", label: "Today" },
+  { id: "all", label: "Whole chat" },
+];
+
+export const EARLIER_NOT_SHARED = "Earlier messages not shared";
+export const LATER_NOT_SHARED = "Later messages not shared";
+
+export const DEFAULT_PRESET: RangePreset = "last";
+
+/** Positions in `ids` that a range covers, or null when an end isn't there or they're backwards. A missing end means the chat's own start or end. */
+export function windowOf(
+  ids: string[],
+  fromId?: string,
+  toId?: string
+): { start: number; end: number } | null {
+  const start = fromId === undefined ? 0 : ids.indexOf(fromId);
+  const end = toId === undefined ? ids.length - 1 : ids.indexOf(toId);
+  if (start < 0 || end < 0 || start > end) return null;
+  return { start, end };
+}
+
+/** Where each exchange begins: a user prompt. Rows before the first prompt are an exchange of their own. */
+export function exchangeStarts(rows: RangeRow[]): number[] {
+  const starts = rows.flatMap((r, i) => (r.type === "user" ? [i] : []));
+  if (rows.length && starts[0] !== 0) starts.unshift(0);
+  return starts;
+}
+
+const startOfDay = (now: Date) =>
+  new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+
+/** The range a preset means, or null when it has nothing to pick (no messages today). */
+export function presetRange(
+  rows: RangeRow[],
+  preset: RangePreset,
+  now: Date
+): ShareRange | null {
+  if (!rows.length) return null;
+  const last = rows[rows.length - 1].id;
+  const starts = exchangeStarts(rows);
+  let from: number;
+  switch (preset) {
+    case "last":
+      from = starts[starts.length - 1];
+      break;
+    case "last5":
+      from = starts[Math.max(0, starts.length - 5)];
+      break;
+    case "all":
+      from = 0;
+      break;
+    case "today": {
+      const day = startOfDay(now);
+      const todays = rows
+        .map((r, i) => ({ r, i }))
+        .filter(({ r }) => (r.createdAt ?? 0) >= day);
+      if (!todays.length) return null;
+      from = (todays.find(({ r }) => r.type === "user") ?? todays[0]).i;
+      break;
+    }
+  }
+  return { fromId: rows[from].id, toId: last };
+}
+
+/** The preset a range equals, or null for a custom one. */
+export function activePreset(
+  rows: RangeRow[],
+  range: ShareRange | null,
+  now: Date
+): RangePreset | null {
+  if (!range) return null;
+  return (
+    PRESETS.find((p) => {
+      const r = presetRange(rows, p.id, now);
+      return r && r.fromId === range.fromId && r.toId === range.toId;
+    })?.id ?? null
+  );
+}
+
+/** From a message to the latest one. */
+export function rangeFromHere(rows: RangeRow[], id: string): ShareRange | null {
+  return rows.some((r) => r.id === id)
+    ? { fromId: id, toId: rows[rows.length - 1].id }
+    : null;
+}
+
+/** A click sets the range to one message; shift-click stretches it from the anchor to the clicked one, either direction. */
+export function clickRange(
+  rows: RangeRow[],
+  anchorId: string | null,
+  clickedId: string,
+  extend: boolean
+): ShareRange {
+  const a = extend && anchorId ? rows.findIndex((r) => r.id === anchorId) : -1;
+  const b = rows.findIndex((r) => r.id === clickedId);
+  if (a < 0 || b < 0) return { fromId: clickedId, toId: clickedId };
+  const [lo, hi] = a <= b ? [a, b] : [b, a];
+  return { fromId: rows[lo].id, toId: rows[hi].id };
+}
+
+/** Rows the range covers (all of them when there is none yet). */
+export function inRange<T extends RangeRow>(
+  rows: T[],
+  range: ShareRange | null
+): T[] {
+  if (!range) return rows;
+  const w = windowOf(
+    rows.map((r) => r.id),
+    range.fromId,
+    range.toId
+  );
+  return w ? rows.slice(w.start, w.end + 1) : [];
+}
+
+const clock = (d: Date) => {
+  const h = d.getHours();
+  const m = String(d.getMinutes()).padStart(2, "0");
+  return { text: `${h % 12 || 12}:${m}`, ampm: h < 12 ? "AM" : "PM" };
+};
+
+const sameDay = (a: Date, b: Date) =>
+  a.getFullYear() === b.getFullYear() &&
+  a.getMonth() === b.getMonth() &&
+  a.getDate() === b.getDate();
+
+const MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+const dayLabel = (d: Date) => `${MONTHS[d.getMonth()]} ${d.getDate()}`;
+
+/** "2:14–2:40 PM", "11:50 AM–12:10 PM", or with dates when it crosses a day. */
+export function timeSpan(from: number, to: number): string {
+  const a = new Date(from);
+  const b = new Date(to);
+  const ca = clock(a);
+  const cb = clock(b);
+  if (!sameDay(a, b))
+    return `${dayLabel(a)}, ${ca.text} ${ca.ampm} – ${dayLabel(b)}, ${cb.text} ${cb.ampm}`;
+  if (ca.text === cb.text && ca.ampm === cb.ampm)
+    return `${ca.text} ${ca.ampm}`;
+  return ca.ampm === cb.ampm
+    ? `${ca.text}–${cb.text} ${cb.ampm}`
+    : `${ca.text} ${ca.ampm}–${cb.text} ${cb.ampm}`;
+}
+
+/** "Sharing 6 of 120 messages · 2:14–2:40 PM". */
+export function rangeSummary(total: number, shared: RangeRow[]): string {
+  if (!shared.length) return "Nothing selected to share";
+  const noun = total === 1 ? "message" : "messages";
+  const times = shared
+    .map((r) => r.createdAt)
+    .filter((t): t is number => typeof t === "number" && t > 0);
+  const base = `Sharing ${shared.length} of ${total} ${noun}`;
+  return times.length
+    ? `${base} · ${timeSpan(Math.min(...times), Math.max(...times))}`
+    : base;
+}

package/lib/share/redact.ts

@@ -18,6 +18,15 @@ import {
   BASE64_RUN,
   looksRandom,
 } from "@/lib/orchestrator/untrusted";
+import {
+  BASIC_AUTH,
+  CLI_FLAG,
+  DATA_URI,
+  KEY_VALUE,
+  MYSQL_P,
+  TOKEN_RUN,
+  isHighEntropyToken,
+} from "./secret-patterns";
 import { HOME } from "@/lib/session-audit/normalize";
 
 export type Kind = "secret" | "path" | "ip" | "host" | "email";
@@ -59,7 +68,8 @@ const SECRET = "[secret]";
 const BEARER = /(\bbearer\s+)(?!\[secret\])[A-Za-z0-9._~+/=-]{8,}/gi;
 const INLINE_ASSIGNMENT =
   /(\b[A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD|PASS|PWD|CREDENTIALS?|AUTH)[A-Z0-9_]*=)(?!\[secret\])[^\s'"]+/g;
-const LONG_HEX = /\b[a-fA-F0-9]{40,}\b/g;
+// Up to 64 hex characters is a git sha or a hash, not a key.
+const LONG_HEX = /\b[a-fA-F0-9]{65,}\b/g;
 
 const IPV4 =
   /(?<![\w.])(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|1?\d?\d)(?![\w.]*\w)/g;
@@ -104,6 +114,10 @@ export function redactForShare(
   let t = input;
   const on = (k: Kind) => !opts.only || opts.only.includes(k);
 
+  // Inline base64 (images) is content, not a credential: set aside, put back.
+  const uris: string[] = [];
+  t = t.replace(DATA_URI, (m) => `\u0000${uris.push(m) - 1}\u0000`);
+
   // 1. Credentials by shape.
   t = sub(t, PRIVATE_KEY_BLOCK, SECRET, hits, "secret");
   t = sub(
@@ -132,9 +146,16 @@ export function redactForShare(
     "secret",
     (m) => m.endsWith(SECRET)
   );
+  const keepValue = (_m: string, k: string, v: string) =>
+    `${k}${/^["']/.test(v) ? v[0] + SECRET + v[0] : SECRET}`;
+  t = sub(t, KEY_VALUE, keepValue, hits, "secret");
+  t = sub(t, CLI_FLAG, keepValue, hits, "secret");
+  t = sub(t, MYSQL_P, (_m, k) => `${k}${SECRET}`, hits, "secret");
+  t = sub(t, BASIC_AUTH, (_m, k) => `${k}${SECRET}`, hits, "secret");
   for (const re of SECRET_TOKENS) t = sub(t, re, SECRET, hits, "secret");
   t = sub(t, LONG_HEX, SECRET, hits, "secret");
   t = sub(t, BASE64_RUN, SECRET, hits, "secret", (m) => !looksRandom(m));
+  t = sub(t, TOKEN_RUN, SECRET, hits, "secret", (m) => !isHighEntropyToken(m));
 
   // 2. This machine's own secrets, wherever they appear.
   for (const value of ctx.secrets) {
@@ -192,5 +213,6 @@ export function redactForShare(
   // 6. Email addresses.
   if (on("email")) t = sub(t, EMAIL, "[email]", hits, "email");
 
+  t = t.replace(/\u0000(\d+)\u0000/g, (_m, i) => uris[Number(i)]);
   return { text: t, hits };
 }

package/lib/share/render.tsx

@@ -14,6 +14,7 @@ import remarkGfm from "remark-gfm";
 import { Prism as Highlighter } from "react-syntax-highlighter";
 import type { Snapshot, SnapshotItem } from "./snapshot";
 import { STYLES } from "./styles";
+import { EARLIER_NOT_SHARED, LATER_NOT_SHARED } from "./range";
 
 export const MAX_SHARE_BYTES = 5 * 1024 * 1024;
 
@@ -123,9 +124,11 @@ export function renderChatSnapshot(
 ): string {
   const body = renderToStaticMarkup(
     <>
+      {snapshot.cutBefore && <div className="cut">{EARLIER_NOT_SHARED}</div>}
       {snapshot.items.map((item) => (
         <Item key={item.id} item={item} />
       ))}
+      {snapshot.cutAfter && <div className="cut">{LATER_NOT_SHARED}</div>}
     </>
   );
   const date = opts.sharedAt.slice(0, 10);

package/lib/share/secret-patterns.ts

@@ -0,0 +1,77 @@
+/**
+ * Generic credential shapes for redactForShare: key/value secrets in any
+ * syntax, Basic auth headers, mysql -p, and high-entropy tokens. Pure data
+ * and predicates; redact.ts applies them and counts the hits.
+ */
+
+const WORDS =
+  "password|passwd|pwd|secret|token|api[_-]?key|apikey|access[_-]?key|client[_-]?secret|auth|private[_-]?key";
+
+// A value that is a type, a placeholder or a call, not a credential.
+const NOT_A_VALUE =
+  "(?![\"']?\\[secret\\])" +
+  "(?!(?:string|number|boolean|any|unknown|null|undefined|true|false|none|void|required|optional)\\b)" +
+  "(?![$<{(\\[%]|\\.\\.\\.)(?![\\w.]+\\()";
+
+/**
+ * `password=x`, `"api_key": "x"`, `token: x`, `export DB_PASSWORD=x`,
+ * `--password=x`. The key may carry any prefix (GITHUB_TOKEN) but must end
+ * in the word, so `author` and `max_tokens` stay. Group 1 is kept.
+ */
+export const KEY_VALUE = new RegExp(
+  `((?<![\\w.-])[\\w.-]*(?:${WORDS})["']?[ \\t]*[:=][ \\t]*)` +
+    `${NOT_A_VALUE}("[^"\\n]*"|'[^'\\n]*'|[^\\s,;'"&}\\])]+)`,
+  "gi"
+);
+
+/** `--password value`, `--api-key value` (space separated). */
+export const CLI_FLAG = new RegExp(
+  `(--[\\w-]*?(?:${WORDS})[ \\t]+)(?!-)${NOT_A_VALUE}("[^"\\n]*"|'[^'\\n]*'|\\S+)`,
+  "gi"
+);
+
+/**
+ * mysql-family `-pSECRET` (attached: `-p secret` would be a database name).
+ * psql's -p is a port, so it is left alone.
+ */
+export const MYSQL_P =
+  /(\b(?:mysql|mysqldump|mysqladmin|mariadb)\b[^\n|;&]*?\s-p)(?=\S)(\S+)/gi;
+
+/** `Authorization: Basic <x>` (Bearer is handled in redact.ts). */
+export const BASIC_AUTH =
+  /(\bauthorization["']?\s*[:=]\s*["']?basic\s+)[A-Za-z0-9+/=._~-]{4,}/gi;
+
+/** A base64 data URI, such as an inline image. Kept as is: not a credential. */
+export const DATA_URI =
+  /data:[\w.+-]+\/[\w.+-]+(?:;[\w=.-]+)*;base64,[A-Za-z0-9+/=_-]+/g;
+
+/** Candidate runs for the entropy test. */
+export const TOKEN_RUN = /(?<![A-Za-z0-9_\-+/=])[A-Za-z0-9_\-+/=]{32,}/g;
+
+export const ENTROPY_MIN = 4.0;
+
+export function shannon(s: string): number {
+  const counts = new Map<string, number>();
+  for (const c of s) counts.set(c, (counts.get(c) ?? 0) + 1);
+  let h = 0;
+  for (const n of counts.values())
+    h -= (n / s.length) * Math.log2(n / s.length);
+  return h;
+}
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function looksLikePath(s: string): boolean {
+  if (/^(?:\.{0,2}\/|~\/)/.test(s)) return true;
+  const parts = s.split("/");
+  return parts.length > 2 && parts.every((p) => p.length >= 2);
+}
+
+/** True when a run is a random-looking token rather than prose, a hash or a path. */
+export function isHighEntropyToken(s: string): boolean {
+  if (/^[0-9a-f]+$/i.test(s) && s.length <= 64) return false; // git sha, md5/sha256
+  if (UUID.test(s)) return false;
+  if (looksLikePath(s)) return false;
+  if (!/[a-z]/.test(s) || !/[A-Z]/.test(s) || !/[0-9]/.test(s)) return false;
+  return shannon(s) > ENTROPY_MIN;
+}

package/lib/share/service.ts

@@ -16,7 +16,11 @@ import {
   renderChatSnapshot,
 } from "./render";
 import { artifactToMarkdown, chatToMarkdown } from "./markdown";
-import { buildArtifactSnapshot, buildChatSnapshot } from "./snapshot";
+import {
+  RangeGone,
+  buildArtifactSnapshot,
+  buildChatSnapshot,
+} from "./snapshot";
 
 export interface ShareRequest {
   kind: "chat" | "artifact";
@@ -25,6 +29,9 @@ export interface ShareRequest {
   includeTools: boolean;
   /** Messages the reader left out in the preview. */
   dropIds?: string[];
+  /** The part of the chat shared: from this message to that one, ends included. */
+  fromId?: string;
+  toId?: string;
   follow?: "latest";
   sharedAt: string;
 }
@@ -34,6 +41,7 @@ export interface ItemRow {
   type: string;
   tools: boolean;
   excerpt: string;
+  createdAt?: number;
 }
 
 export interface Page {
@@ -87,6 +95,15 @@ export function parseRequest(raw: unknown, sharedAt?: unknown): ShareRequest {
       throw new BadShare("dropIds must be a list of ids", 400);
     dropIds = b.dropIds as string[];
   }
+  const end = (key: "fromId" | "toId") => {
+    const v = b[key];
+    if (v === undefined) return undefined;
+    if (typeof v !== "string" || !v || v.length > 200)
+      throw new BadShare(`${key} must be a message id`, 400);
+    return v;
+  };
+  const fromId = end("fromId");
+  const toId = end("toId");
   if (b.follow !== undefined && b.follow !== "latest")
     throw new BadShare("follow must be latest", 400);
   if (b.follow && kind !== "artifact")
@@ -100,11 +117,41 @@ export function parseRequest(raw: unknown, sharedAt?: unknown): ShareRequest {
     artifactId,
     includeTools: b.includeTools === true,
     dropIds,
+    fromId,
+    toId,
     follow: b.follow === "latest" ? "latest" : undefined,
     sharedAt: at,
   };
 }
 
+const rowOf = ({ id, type, tools, excerpt, createdAt }: ItemRow): ItemRow => ({
+  id,
+  type,
+  tools,
+  excerpt,
+  createdAt,
+});
+
+function chatSession(sessionId: string) {
+  let session;
+  try {
+    session = getSession(sessionId);
+  } catch {
+    throw new BadShare("No such chat", 404);
+  }
+  if (session.view !== "chat")
+    throw new BadShare("Only chats can be shared", 400);
+}
+
+/** Every shareable message of a chat, tool rows included, in order. */
+export async function listChatItems(req: ShareRequest): Promise<ItemRow[]> {
+  chatSession(req.sessionId!);
+  const all = await buildChatSnapshot(req.sessionId!, shareContext(), {
+    includeTools: true,
+  });
+  return all.items.map(rowOf);
+}
+
 const sha256 = (s: string) => createHash("sha256").update(s).digest("hex");
 
 /** Binds both parts: neither can change without the hash changing. */
@@ -120,29 +167,27 @@ export async function buildPage(req: ShareRequest): Promise<Page> {
   let items: ItemRow[] = [];
 
   if (req.kind === "chat") {
-    let session;
-    try {
-      session = getSession(req.sessionId!);
-    } catch {
-      throw new BadShare("No such chat", 404);
-    }
-    if (session.view !== "chat")
-      throw new BadShare("Only chats can be shared", 400);
+    chatSession(req.sessionId!);
     const all = await buildChatSnapshot(req.sessionId!, ctx, {
       includeTools: req.includeTools,
     });
-    items = all.items.map(({ id, type, tools, excerpt }) => ({
-      id,
-      type,
-      tools,
-      excerpt,
-    }));
-    const snap = req.dropIds?.length
-      ? await buildChatSnapshot(req.sessionId!, ctx, {
+    items = all.items.map(rowOf);
+    const narrowed =
+      req.dropIds?.length || req.fromId !== undefined || req.toId !== undefined;
+    let snap = all;
+    if (narrowed) {
+      try {
+        snap = await buildChatSnapshot(req.sessionId!, ctx, {
           includeTools: req.includeTools,
           dropIds: req.dropIds,
-        })
-      : all;
+          fromId: req.fromId,
+          toId: req.toId,
+        });
+      } catch (err) {
+        if (err instanceof RangeGone) throw new BadShare(err.message, 409);
+        throw err;
+      }
+    }
     if (!snap.items.length)
       throw new BadShare("Nothing to share: every message is left out", 400);
     html = renderChatSnapshot(snap, { sharedAt: req.sharedAt });

package/lib/share/snapshot.ts

@@ -15,6 +15,7 @@ import {
   type Hits,
   type ShareContext,
 } from "./redact";
+import { windowOf } from "./range";
 
 export type SnapshotType =
   "user" | "assistant" | "plan" | "error" | "divider" | "artifact" | "detail";
@@ -32,6 +33,7 @@ export interface SnapshotItem {
   excerpt: string;
   /** Hidden unless "include tool calls and thinking" is on. */
   tools: boolean;
+  createdAt?: number;
 }
 
 export interface Snapshot {
@@ -39,9 +41,19 @@ export interface Snapshot {
   items: SnapshotItem[];
   /** Whether the tools group was left out, to say so on the page. */
   toolsHidden: boolean;
+  /** Messages before / after the shared range were left out, to say so. */
+  cutBefore?: boolean;
+  cutAfter?: boolean;
   hits: Hits;
 }
 
+/** The range names a message that is no longer in the chat. */
+export class RangeGone extends Error {
+  constructor() {
+    super("That part of the chat changed; pick the range again.");
+  }
+}
+
 export const MAX_TOOL_INPUT = 4_000;
 export const MAX_TOOL_OUTPUT = 20_000;
 export const HIDDEN_FILE = "[contents of a secret file hidden]";
@@ -189,7 +201,12 @@ export function toRaw(item: ChatItem): Raw | null {
 export async function buildChatSnapshot(
   sessionId: string,
   ctx: ShareContext,
-  opts: { includeTools: boolean; dropIds?: string[] }
+  opts: {
+    includeTools: boolean;
+    dropIds?: string[];
+    fromId?: string;
+    toId?: string;
+  }
 ): Promise<Snapshot> {
   const session = getSession(sessionId);
   const dropped = new Set(opts.dropIds ?? []);
@@ -201,13 +218,31 @@ export async function buildChatSnapshot(
   };
 
   const items: SnapshotItem[] = [];
-  for (const item of visible(listItems(sessionId))) {
+  const all = visible(listItems(sessionId));
+  let window: { start: number; end: number } | null = null;
+  if (opts.fromId !== undefined || opts.toId !== undefined) {
+    window = windowOf(
+      all.map((i) => i.id),
+      opts.fromId,
+      opts.toId
+    );
+    if (!window) throw new RangeGone();
+  }
+  let cutBefore = false;
+  let cutAfter = false;
+  for (const [at, item] of all.entries()) {
     const raw = toRaw(item);
     if (!raw) continue;
     if (raw.tools && !opts.includeTools) continue;
+    if (window && (at < window.start || at > window.end)) {
+      if (at < window.start) cutBefore = true;
+      else cutAfter = true;
+      continue;
+    }
     if (dropped.has(raw.id)) continue;
     const row: SnapshotItem = {
       ...raw,
+      createdAt: item.createdAt,
       label: raw.label === undefined ? undefined : take(raw.label),
       text: take(raw.text),
       excerpt: "",
@@ -225,6 +260,8 @@ export async function buildChatSnapshot(
     title: take(session.name).slice(0, 120) || "Chat",
     items,
     toolsHidden: !opts.includeTools,
+    cutBefore,
+    cutAfter,
     hits,
   };
 }

package/lib/share/styles.ts

@@ -56,6 +56,8 @@ h1.title{margin:0 0 4px;font-size:20px;line-height:1.3}
 .plan>.kicker{margin-top:12px}
 .kicker{font-size:12px;font-weight:600;color:hsl(var(--muted-foreground));text-transform:uppercase;letter-spacing:.04em}
 .error{color:hsl(var(--destructive));border:1px solid hsl(var(--destructive)/.4);border-radius:10px;padding:8px 14px;white-space:pre-wrap;overflow-wrap:anywhere}
+.cut{display:flex;align-items:center;gap:12px;color:hsl(var(--muted-foreground));font-size:12px;font-style:italic}
+.cut::before,.cut::after{content:"";flex:1;border-top:1px dashed hsl(var(--border))}
 .divider{display:flex;align-items:center;gap:12px;color:hsl(var(--muted-foreground));font-size:12px}
 .divider::before,.divider::after{content:"";flex:1;border-top:1px solid hsl(var(--border))}
 details.tool{border:1px solid hsl(var(--border));border-radius:10px;background:hsl(var(--card))}

package/lib/share/view.ts

@@ -15,6 +15,11 @@ export interface PreviewRequest extends ShareTarget {
   includeTools: boolean;
   /** Messages left out of the share. */
   dropIds?: string[];
+  /** Only the messages from this one to `toId`, both included; either end open when absent. */
+  fromId?: string;
+  toId?: string;
+  /** Just the list of messages, no page: what the range picker needs first. */
+  listOnly?: boolean;
 }
 
 export interface PreviewItem {
@@ -22,11 +27,17 @@ export interface PreviewItem {
   type: string;
   tools: boolean;
   excerpt: string;
+  createdAt?: number;
 }
 
 /** Download formats a server can make; the client lists what it is told. */
 export type ShareFormat = "pdf" | "html" | "md";
 
+export interface MessageList {
+  /** Every shareable message in order, tool rows included. */
+  items: PreviewItem[];
+}
+
 export interface SharePreview {
   html: string;
   markdown: string;

package/lib/sidebar/row-menu.ts

@@ -17,6 +17,7 @@ export type RowMenuItem =
   | "copy-link"
   | "share"
   | "export"
+  | "invite-live"
   | "fork"
   | "fresh-start"
   | "new-conversation"
@@ -127,6 +128,7 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
     ...group("share", [
       "copy-link",
       s.view === "chat" && "share",
+      s.view === "chat" && "invite-live",
       s.view === "chat" && "export",
     ]),
     ...group("restart", [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.770",
+  "version": "0.3.777",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/server.ts

@@ -54,6 +54,7 @@ import {
 import { lanEnabled } from "./lib/security/network-settings";
 import { handlePeerRpc, isPeerRpc, rpcDeps } from "./lib/peer/rpc-server";
 import { startConnect } from "./lib/connect/serve";
+import { startLive } from "./lib/live/service";
 import { serverPort } from "./lib/connect/config";
 import { startUpdateChecks, updateChecksEnabled } from "./lib/updates/check";
 import {
@@ -399,6 +400,7 @@ app.prepare().then(async () => {
     ? { hostname: () => null }
     : startConnect({ onRequest, onUpgrade }, port);
   policy.machineHost = () => connect.hostname();
+  if (!demo) startLive();
   // HTTPS on the tailnet (its own port) for passkeys and other secure-origin APIs.
   if (
     !demo &&

package/stores/liveUi.ts

@@ -0,0 +1,17 @@
+import { proxy } from "valtio";
+
+// The invite dialog: which chat it is open on, started from a menu.
+export const liveUi = proxy<{
+  target: { sessionId: string; title: string } | null;
+}>({
+  target: null,
+});
+
+export const liveUiActions = {
+  open: (sessionId: string, title: string) => {
+    liveUi.target = { sessionId, title };
+  },
+  close: () => {
+    liveUi.target = null;
+  },
+};