@saadnvd1/agent-os 0.3.770 → 0.3.777

package/lib/live/store.ts

@@ -0,0 +1,149 @@
+import { db } from "../db";
+
+export interface LiveShareRow {
+  id: string;
+  session_id: string;
+  title: string;
+  url: string;
+  ends_with_session: number;
+  max_guests: number;
+  created_at: string;
+  expires_at: string | null;
+  ended_at: string | null;
+}
+
+export type LogKind =
+  | "join_request"
+  | "admit"
+  | "deny"
+  | "kick"
+  | "suggestion"
+  | "sent"
+  | "dismissed";
+
+export interface LogRow {
+  id: number;
+  share_id: string;
+  at: number;
+  kind: LogKind;
+  guest_id: string | null;
+  guest_name: string | null;
+  ref: string | null;
+  text: string | null;
+  sent_text: string | null;
+}
+
+export function insertLiveShare(row: LiveShareRow): void {
+  db.prepare(
+    `INSERT INTO live_shares
+       (id, session_id, title, url, ends_with_session, max_guests, created_at, expires_at, ended_at)
+     VALUES (@id, @session_id, @title, @url, @ends_with_session, @max_guests, @created_at, @expires_at, @ended_at)`
+  ).run(row);
+}
+
+export function getLiveShare(id: string): LiveShareRow | undefined {
+  return db.prepare(`SELECT * FROM live_shares WHERE id = ?`).get(id) as
+    LiveShareRow | undefined;
+}
+
+/** Shares this machine still holds: not ended, not past their time. */
+export function activeLiveShares(now = Date.now()): LiveShareRow[] {
+  return (
+    db
+      .prepare(
+        `SELECT * FROM live_shares WHERE ended_at IS NULL ORDER BY created_at, rowid`
+      )
+      .all() as LiveShareRow[]
+  ).filter((s) => !s.expires_at || Date.parse(s.expires_at) > now);
+}
+
+export function activeLiveShareFor(
+  sessionId: string,
+  now = Date.now()
+): LiveShareRow | undefined {
+  return activeLiveShares(now).find((s) => s.session_id === sessionId);
+}
+
+export function markLiveEnded(id: string): void {
+  db.prepare(
+    `UPDATE live_shares SET ended_at = COALESCE(ended_at, ?) WHERE id = ?`
+  ).run(new Date().toISOString(), id);
+}
+
+export function logLive(
+  row: Omit<LogRow, "id" | "at"> & { at?: number }
+): void {
+  db.prepare(
+    `INSERT INTO live_share_log (share_id, at, kind, guest_id, guest_name, ref, text, sent_text)
+     VALUES (@share_id, @at, @kind, @guest_id, @guest_name, @ref, @text, @sent_text)`
+  ).run({ ...row, at: row.at ?? Date.now() });
+}
+
+export function listLog(shareId: string): LogRow[] {
+  return db
+    .prepare(`SELECT * FROM live_share_log WHERE share_id = ? ORDER BY id`)
+    .all(shareId) as LogRow[];
+}
+
+export interface OpenSuggestion {
+  id: string;
+  guestId: string;
+  guestName: string;
+  text: string;
+  at: number;
+}
+
+/** Suggestions with no sent or dismissed line yet, oldest first. */
+export function openSuggestions(shareId: string): OpenSuggestion[] {
+  const rows = db
+    .prepare(
+      `SELECT s.ref, s.guest_id, s.guest_name, s.text, s.at FROM live_share_log s
+       WHERE s.share_id = ? AND s.kind = 'suggestion' AND NOT EXISTS (
+         SELECT 1 FROM live_share_log d
+         WHERE d.share_id = s.share_id AND d.ref = s.ref AND d.kind IN ('sent', 'dismissed'))
+       ORDER BY s.id`
+    )
+    .all(shareId) as {
+    ref: string;
+    guest_id: string;
+    guest_name: string;
+    text: string;
+    at: number;
+  }[];
+  return rows.map((r) => ({
+    id: r.ref,
+    guestId: r.guest_id,
+    guestName: r.guest_name,
+    text: r.text,
+    at: r.at,
+  }));
+}
+
+/** Guests this machine admitted and has not removed since. */
+export function admittedGuestIds(shareId: string): Set<string> {
+  const out = new Set<string>();
+  for (const l of listLog(shareId)) {
+    if (!l.guest_id) continue;
+    if (l.kind === "admit") out.add(l.guest_id);
+    else if (l.kind === "kick" || l.kind === "deny") out.delete(l.guest_id);
+  }
+  return out;
+}
+
+/** Whether a suggestion with this id was ever logged for the share. */
+export function hasSuggestion(shareId: string, ref: string): boolean {
+  return !!db
+    .prepare(
+      `SELECT 1 FROM live_share_log WHERE share_id = ? AND kind = 'suggestion' AND ref = ? LIMIT 1`
+    )
+    .get(shareId, ref);
+}
+
+/** Whether a join request from this guest was already logged. */
+export function hasJoinRequest(shareId: string, guestId: string): boolean {
+  return !!db
+    .prepare(
+      `SELECT 1 FROM live_share_log WHERE share_id = ? AND kind = 'join_request' AND guest_id = ? LIMIT 1`
+    )
+    .get(shareId, guestId);
+}

package/lib/live/types.ts

@@ -0,0 +1,39 @@
+// What the host's screens show of a live share (served by /api/live-shares).
+export interface LiveView {
+  id: string;
+  sessionId: string;
+  title: string;
+  url: string;
+  expiresAt: string | null;
+  endsWithSession: boolean;
+  maxGuests: number;
+  connected: boolean;
+  notice: string | null;
+  guests: {
+    id: string;
+    name: string;
+    status: "pending" | "admitted";
+    online: boolean;
+    /** Another guest here has the same name. */
+    duplicateName: boolean;
+  }[];
+  suggestions: {
+    id: string;
+    guestId: string;
+    guestName: string;
+    text: string;
+    at: number;
+  }[];
+}
+
+export type LiveExpiry = "1h" | "session";
+
+export const EXPIRY_LABEL: Record<LiveExpiry, string> = {
+  "1h": "1 hour",
+  session: "Until the session ends",
+};
+
+export interface LiveResponse {
+  linked: boolean;
+  shares: LiveView[];
+}

package/lib/palette/registry.ts

@@ -3,6 +3,36 @@
  * take them back the same way, so the palette itself knows no feature.
  */
 
+export type PaletteTab =
+  "all" | "sessions" | "commands" | "settings" | "conversations";
+
+export const PALETTE_TABS: { id: PaletteTab; label: string }[] = [
+  { id: "all", label: "All" },
+  { id: "sessions", label: "Sessions" },
+  { id: "commands", label: "Commands" },
+  { id: "settings", label: "Settings" },
+  { id: "conversations", label: "Conversations" },
+];
+
+// Which tab each heading's commands are found under; a heading not listed is
+// a command. A command can name its own tab instead.
+const GROUP_TAB: Record<string, PaletteTab> = {
+  Sessions: "sessions",
+  Settings: "settings",
+  Conversations: "conversations",
+};
+
+// Headings whose commands act on the focused session.
+const SESSION_GROUPS = new Set(["Chat", "Task"]);
+
+export function tabOf(c: PaletteCommand): PaletteTab {
+  return c.tab ?? GROUP_TAB[c.group] ?? "commands";
+}
+
+export function actsOnFocusedSession(c: PaletteCommand): boolean {
+  return SESSION_GROUPS.has(c.group);
+}
+
 export interface PaletteCommand {
   id: string;
   title: string;
@@ -14,6 +44,10 @@ export interface PaletteCommand {
   hint?: string;
   // A line under the title (what a conversation hit said).
   detail?: string;
+  // Overrides the tab its group maps to.
+  tab?: PaletteTab;
+  // A session that is working or waiting on the user.
+  status?: "running" | "waiting";
   // Running it leaves the palette open (it changes the palette itself).
   keepOpen?: boolean;
   icon?: unknown;
@@ -84,25 +118,45 @@ export function fuzzyScore(query: string, text: string): number | null {
   return score;
 }
 
-// The commands a query finds, best first; all of them, in order, for none.
-export function matchCommands(
+export interface Scored {
+  c: PaletteCommand;
+  score: number;
+}
+
+// The commands a query finds, best first, with their scores. `boost` (0 to 1,
+// e.g. how much it's used) scales a match up by at most half: it can break a
+// close call, never rescue a non-match or outrank a far better match. With no
+// query the boost alone orders them, registry order breaking ties.
+export function scoreCommands(
   commands: PaletteCommand[],
-  query: string
-): PaletteCommand[] {
-  if (!query.trim()) return commands;
+  query: string,
+  boost: (c: PaletteCommand) => number = () => 0
+): Scored[] {
+  const empty = !query.trim();
   return commands
     .map((c, i) => {
-      const scores = [c.title, ...(c.keywords ?? []), c.group].map(
-        (text, j) => {
-          const s = fuzzyScore(query, text);
-          // A title match counts most.
-          return s === null ? null : j === 0 ? s * 1.5 : s;
-        }
-      );
-      const best = Math.max(...scores.map((s) => s ?? -Infinity));
-      return { c, i, best };
+      let base = 0;
+      if (!empty) {
+        const scores = [c.title, ...(c.keywords ?? []), c.group].map(
+          (text, j) => {
+            const s = fuzzyScore(query, text);
+            // A title match counts most.
+            return s === null ? null : j === 0 ? s * 1.5 : s;
+          }
+        );
+        base = Math.max(...scores.map((s) => s ?? -Infinity));
+      }
+      const b = boost(c);
+      return { c, i, base, score: empty ? b : base + Math.abs(base) * 0.5 * b };
     })
-    .filter((m) => m.best > -Infinity)
-    .sort((a, b) => b.best - a.best || a.i - b.i)
-    .map((m) => m.c);
+    .filter((m) => m.base > -Infinity)
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .map(({ c, score }) => ({ c, score }));
+}
+
+export function matchCommands(
+  commands: PaletteCommand[],
+  query: string
+): PaletteCommand[] {
+  return scoreCommands(commands, query).map((m) => m.c);
 }

package/lib/palette/sections.ts

@@ -0,0 +1,143 @@
+import {
+  PALETTE_TABS,
+  actsOnFocusedSession,
+  scoreCommands,
+  tabOf,
+  type PaletteCommand,
+  type PaletteTab,
+} from "./registry";
+import { recentIds, usageBoost, type Usage } from "./usage";
+
+export interface Section {
+  name: string;
+  items: PaletteCommand[];
+  // The tab that lists the whole section, when this is only part of it.
+  more?: { tab: PaletteTab; count: number };
+}
+
+export const PER_TAB = 5;
+export const RECENT = 5;
+const NEEDS_YOU = 5;
+const SUGGESTED = 6;
+
+const label = (tab: PaletteTab) =>
+  PALETTE_TABS.find((t) => t.id === tab)?.label ?? tab;
+
+export const boostFor = (usage: Usage, now: number) => (c: PaletteCommand) =>
+  usageBoost(usage[c.id], now);
+
+// What a query finds in All: each tab's best few under its heading, the
+// strongest group first, with how many more its tab holds. Conversations are
+// the caller's, to put last.
+export function allSections(
+  commands: PaletteCommand[],
+  query: string,
+  usage: Usage,
+  now: number
+): Section[] {
+  const scored = scoreCommands(commands, query, boostFor(usage, now));
+  const byTab = new Map<PaletteTab, typeof scored>();
+  for (const m of scored) {
+    const tab = tabOf(m.c);
+    if (tab === "conversations") continue;
+    byTab.set(tab, [...(byTab.get(tab) ?? []), m]);
+  }
+  return [...byTab.entries()]
+    .sort((a, b) => b[1][0].score - a[1][0].score)
+    .map(([tab, ms]) => ({
+      name: label(tab),
+      items: ms.slice(0, PER_TAB).map((m) => m.c),
+      ...(ms.length > PER_TAB
+        ? { more: { tab, count: ms.length } }
+        : undefined),
+    }));
+}
+
+// One tab's commands, for a query or (ordered by use) without one.
+export function tabItems(
+  commands: PaletteCommand[],
+  tab: PaletteTab,
+  query: string,
+  usage: Usage,
+  now: number
+): PaletteCommand[] {
+  return scoreCommands(
+    commands.filter((c) => tabOf(c) === tab),
+    query,
+    boostFor(usage, now)
+  ).map((m) => m.c);
+}
+
+// The short list All opens on: the last things run, sessions that need the
+// user or are working, and what the focused session can do.
+export function emptySections(
+  commands: PaletteCommand[],
+  usage: Usage
+): Section[] {
+  const seen = new Set<string>();
+  const take = (items: PaletteCommand[], limit: number) => {
+    const out: PaletteCommand[] = [];
+    for (const c of items) {
+      if (out.length >= limit) break;
+      if (seen.has(c.id)) continue;
+      seen.add(c.id);
+      out.push(c);
+    }
+    return out;
+  };
+  // A session that needs you is listed there, not also under Recent.
+  const rank = (c: PaletteCommand) => (c.status === "waiting" ? 0 : 1);
+  const busy = take(
+    commands.filter((c) => c.status).sort((a, b) => rank(a) - rank(b)),
+    NEEDS_YOU
+  );
+  const here = take(commands.filter(actsOnFocusedSession), 5);
+  const byId = new Map(commands.map((c) => [c.id, c]));
+  const recent = take(
+    recentIds(usage, commands.length)
+      .map((id) => byId.get(id))
+      .filter((c): c is PaletteCommand => !!c),
+    RECENT
+  );
+  const sections: Section[] = [
+    { name: "Recent", items: recent },
+    { name: "Needs you / running", items: busy },
+    { name: "This session", items: here },
+  ];
+  // A first run has no history: offer the commands that start things.
+  if (recent.length + busy.length + here.length < 4)
+    sections.push({
+      name: "Suggested",
+      items: take(
+        commands.filter((c) => tabOf(c) === "commands"),
+        SUGGESTED
+      ),
+    });
+  return sections.filter((s) => s.items.length);
+}
+
+// Each cut-short section ends with a row that opens its whole tab.
+export function withSeeAll(
+  sections: Section[],
+  open: (tab: PaletteTab) => void,
+  icon?: unknown
+): Section[] {
+  return sections.map((s) => {
+    const more = s.more;
+    if (!more) return s;
+    return {
+      ...s,
+      items: [
+        ...s.items,
+        {
+          id: `see-all:${more.tab}`,
+          title: `See all ${more.count} →`,
+          group: s.name,
+          icon,
+          keepOpen: true,
+          run: () => open(more.tab),
+        },
+      ],
+    };
+  });
+}

package/lib/palette/tabs.ts

@@ -0,0 +1,21 @@
+import { PALETTE_TABS, type PaletteTab } from "./registry";
+
+const PREFIXES: Record<string, PaletteTab> = {
+  ">": "commands",
+  "@": "sessions",
+};
+
+// A leading `>` or `@` on a fresh query picks a tab; null when there's none.
+export function parsePrefix(
+  text: string
+): { tab: PaletteTab; text: string } | null {
+  const tab = PREFIXES[text[0]];
+  return tab ? { tab, text: text.slice(1).trimStart() } : null;
+}
+
+// The next tab (or the one before), wrapping round.
+export function cycleTab(tab: PaletteTab, by: 1 | -1): PaletteTab {
+  const n = PALETTE_TABS.length;
+  const i = PALETTE_TABS.findIndex((t) => t.id === tab);
+  return PALETTE_TABS[(i + by + n) % n].id;
+}

package/lib/palette/usage.ts

@@ -0,0 +1,81 @@
+export interface UsageEntry {
+  count: number;
+  last: number;
+}
+export type Usage = Record<string, UsageEntry>;
+
+export const USAGE_KEY = "agentOS-palette-usage";
+export const MAX_USAGE = 200;
+const DAY = 86_400_000;
+const HALF_LIFE_DAYS = 14;
+// Uses at which the count part of the boost tops out.
+const SATURATES_AT = 20;
+
+// How strongly past use favours an item, 0 to 1: more uses count more (with
+// diminishing returns) and the whole fades by half every two weeks.
+export function usageBoost(entry: UsageEntry | undefined, now: number): number {
+  if (!entry) return 0;
+  const age = Math.max(0, now - entry.last) / DAY;
+  const weight = Math.min(
+    1,
+    Math.log2(1 + entry.count) / Math.log2(1 + SATURATES_AT)
+  );
+  return weight * Math.pow(0.5, age / HALF_LIFE_DAYS);
+}
+
+// The usage with one more run of `id`, keeping the MAX_USAGE items that
+// matter most right now.
+export function recordUse(usage: Usage, id: string, now: number): Usage {
+  const next: Usage = {
+    ...usage,
+    [id]: { count: (usage[id]?.count ?? 0) + 1, last: now },
+  };
+  const ids = Object.keys(next);
+  if (ids.length <= MAX_USAGE) return next;
+  const keep = ids
+    .sort((a, b) => usageBoost(next[b], now) - usageBoost(next[a], now))
+    .slice(0, MAX_USAGE);
+  return Object.fromEntries(keep.map((k) => [k, next[k]]));
+}
+
+// The ids last run most recently, newest first.
+export function recentIds(usage: Usage, limit: number): string[] {
+  return Object.entries(usage)
+    .sort((a, b) => b[1].last - a[1].last)
+    .slice(0, limit)
+    .map(([id]) => id);
+}
+
+function valid(e: unknown): e is UsageEntry {
+  const u = e as UsageEntry | null;
+  return (
+    !!u && Number.isFinite(u.count) && Number.isFinite(u.last) && u.count > 0
+  );
+}
+
+export function loadUsage(): Usage {
+  try {
+    const raw: unknown = JSON.parse(localStorage.getItem(USAGE_KEY) ?? "{}");
+    if (!raw || typeof raw !== "object") return {};
+    const usage: Usage = {};
+    for (const [id, e] of Object.entries(raw)) if (valid(e)) usage[id] = e;
+    return usage;
+  } catch {
+    return {};
+  }
+}
+
+export function saveUsage(usage: Usage): void {
+  try {
+    localStorage.setItem(USAGE_KEY, JSON.stringify(usage));
+  } catch {
+    // Private mode or a full disk: ranking just forgets.
+  }
+}
+
+// Records a run in storage and returns the new usage.
+export function noteUse(id: string, now = Date.now()): Usage {
+  const next = recordUse(loadUsage(), id, now);
+  saveUsage(next);
+  return next;
+}

package/lib/security/demo.ts

@@ -64,6 +64,7 @@ export const STATIC_SIBLINGS = [
   "browse",
   "check",
   "clone",
+  "compare",
   "connect",
   "detect",
   "done-idle",
@@ -84,6 +85,7 @@ export const STATIC_SIBLINGS = [
   "pdf",
   "preview",
   "queue",
+  "resolve",
   "status",
 ];
 // No leading "-": an id that reaches a command line can't read as an option.
@@ -101,6 +103,7 @@ const READS = [
   "sessions/[id]/pr",
   "sessions/[id]/artifacts",
   "sessions/[id]/artifacts/[id]",
+  "sessions/[id]/artifacts/[id]/compare",
   "sessions/[id]/setup",
   "sessions/[id]/preview",
   "projects",

package/lib/share/connect.ts

@@ -6,8 +6,10 @@ import {
   clean,
   listShares,
   replaceShare,
+  createLiveShare,
   revokeShare,
   uploadShare,
+  type LiveExpiry,
   type RemoteShare,
   type ShareExpiry,
 } from "@/lib/connect/control-api";
@@ -40,6 +42,16 @@ function explain(err: unknown): never {
         `Connect refused it as too big or over your quota: ${clean(err.message, 120)}`,
         413
       );
+    if (err.status === 402)
+      throw new ShareError(
+        clean(
+          typeof err.body.error === "string"
+            ? err.body.error
+            : "Your plan's live share limit is reached.",
+          160
+        ),
+        402
+      );
     if (err.status === 429)
       throw new ShareError(
         "Too many shares just now. Try again in a few minutes.",
@@ -95,3 +107,15 @@ export async function revokeRemote(id: string): Promise<void> {
     explain(err);
   }
 }
+
+export async function createLiveRemote(share: {
+  title: string;
+  expiresIn: LiveExpiry;
+}) {
+  const { config, machineKey } = files();
+  try {
+    return await createLiveShare(config, machineKey, share);
+  } catch (err) {
+    explain(err);
+  }
+}

package/lib/share/markdown.ts

@@ -12,6 +12,7 @@ import { toMarkdown } from "mdast-util-to-markdown";
 import type { Nodes as HastNodes } from "hast";
 import type { Nodes, Parents, RootContent } from "mdast";
 import type { Snapshot, SnapshotItem } from "./snapshot";
+import { EARLIER_NOT_SHARED, LATER_NOT_SHARED } from "./range";
 
 const DROP_TAGS = new Set([
   "script",
@@ -119,7 +120,9 @@ export function chatToMarkdown(
 ): string {
   const parts = [
     agentHeader(snap.title, opts.sharedAt),
+    ...(snap.cutBefore ? [`*${EARLIER_NOT_SHARED}.*`] : []),
     ...snap.items.map(itemToMarkdown),
+    ...(snap.cutAfter ? [`*${LATER_NOT_SHARED}.*`] : []),
   ];
   if (snap.toolsHidden) parts.push("*Tool calls and thinking were left out.*");
   return parts.join("\n\n") + "\n";