@saadnvd1/agent-os 0.3.560 → 0.3.564

package/components/Shares/SharedLinksPanel.tsx

@@ -0,0 +1,147 @@
+"use client";
+
+import { toast } from "sonner";
+import { Copy, Link2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { writeClipboard } from "@/hooks/useCopyToClipboard";
+import {
+  useRevokeShare,
+  useSharesQuery,
+  type SharedLinkRow,
+} from "@/data/shares";
+import { cn } from "@/lib/utils";
+
+const when = (iso: string) =>
+  new Date(iso).toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+
+function Row({ share }: { share: SharedLinkRow }) {
+  const revoke = useRevokeShare();
+  const live = share.status === "active";
+
+  const copy = async () => {
+    try {
+      await writeClipboard(share.url);
+      toast.success("Link copied");
+    } catch {
+      toast.error("Could not copy to clipboard");
+    }
+  };
+  const onRevoke = () => {
+    if (
+      !window.confirm(
+        "Revoke this link? The page is deleted from Connect and the link stops working."
+      )
+    )
+      return;
+    revoke.mutate(share.id, {
+      onError: (err) => toast.error((err as Error).message),
+    });
+  };
+
+  const title =
+    share.kind === "chat" && share.sessionId ? (
+      <a
+        href={`/?session=${encodeURIComponent(share.sessionId)}`}
+        className="hover:underline"
+      >
+        {share.title}
+      </a>
+    ) : (
+      share.title
+    );
+
+  return (
+    <li className="bg-muted/40 flex flex-col gap-2 rounded-lg px-3 py-2.5 sm:flex-row sm:items-center">
+      <div className="min-w-0 flex-1">
+        <div className="truncate text-sm font-medium">{title}</div>
+        <div className="text-muted-foreground flex flex-wrap gap-x-3 text-xs">
+          <span>{share.kind === "chat" ? "Chat" : "Page"}</span>
+          <span>Created {when(share.createdAt)}</span>
+          <span>
+            {share.status === "revoked"
+              ? "Revoked"
+              : share.status === "expired"
+                ? "Expired"
+                : share.expiresAt
+                  ? `Expires ${when(share.expiresAt)}`
+                  : "Never expires"}
+          </span>
+          <span>
+            {share.views === null
+              ? "Views unavailable"
+              : `${share.views} ${share.views === 1 ? "view" : "views"}`}
+          </span>
+        </div>
+      </div>
+      <div className="flex shrink-0 gap-2">
+        <Button
+          variant="outline"
+          className={cn("min-h-11 sm:min-h-8", !live && "invisible")}
+          onClick={copy}
+          disabled={!live}
+        >
+          <Copy className="h-4 w-4" />
+          Copy link
+        </Button>
+        <Button
+          variant="outline"
+          className={cn(
+            "text-destructive min-h-11 sm:min-h-8",
+            !live && "invisible"
+          )}
+          onClick={onRevoke}
+          disabled={!live || revoke.isPending}
+        >
+          Revoke
+        </Button>
+      </div>
+    </li>
+  );
+}
+
+// Every snapshot link made from this machine, with views from Connect.
+export function SharedLinksPanel() {
+  const { data, isLoading, error } = useSharesQuery();
+  return (
+    <div className="space-y-3">
+      <p className="text-muted-foreground text-sm">
+        Read-only snapshots you shared from a chat or a page. Revoking one
+        deletes it from Connect straight away.
+      </p>
+      {data?.connect === "unavailable" && (
+        <p className="text-muted-foreground bg-muted/40 rounded-lg px-3 py-2 text-xs">
+          Can&apos;t reach Connect, so views are hidden and revoking is
+          unavailable until it is back.
+        </p>
+      )}
+      {data?.connect === "unlinked" && data.shares.length > 0 && (
+        <p className="text-muted-foreground bg-muted/40 rounded-lg px-3 py-2 text-xs">
+          This machine isn&apos;t linked to Connect, so views are hidden and
+          revoking is unavailable.
+        </p>
+      )}
+      {error && (
+        <p className="text-destructive text-sm">{(error as Error).message}</p>
+      )}
+      {isLoading ? (
+        <p className="text-muted-foreground text-sm">Loading…</p>
+      ) : data?.shares.length ? (
+        <ul className="space-y-2">
+          {data.shares.map((s) => (
+            <Row key={s.id} share={s} />
+          ))}
+        </ul>
+      ) : (
+        <div className="text-muted-foreground flex items-center gap-2 rounded-lg border border-dashed px-3 py-6 text-sm">
+          <Link2 className="h-4 w-4 shrink-0" />
+          Nothing shared yet. Use Share… in a chat&apos;s menu, or the share
+          button on a page.
+        </div>
+      )}
+    </div>
+  );
+}

package/data/shares/index.ts

@@ -0,0 +1,2 @@
+export * from "./keys";
+export * from "./queries";

package/data/shares/keys.ts

@@ -0,0 +1,4 @@
+export const shareKeys = {
+  all: ["shares"] as const,
+  list: () => [...shareKeys.all, "list"] as const,
+};

package/data/shares/queries.ts

@@ -0,0 +1,111 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { shareKeys } from "./keys";
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export type ShareExpiry = "1d" | "7d" | "30d" | "never";
+
+export interface ShareTarget {
+  kind: "chat" | "artifact";
+  sessionId?: string;
+  artifactId?: string;
+}
+
+export interface PreviewRequest extends ShareTarget {
+  includeTools: boolean;
+  /** Messages left out of the share. */
+  dropIds?: string[];
+}
+
+export interface PreviewItem {
+  id: string;
+  type: string;
+  tools: boolean;
+  excerpt: string;
+}
+
+export interface SharePreview {
+  html: string;
+  title: string;
+  bytes: number;
+  hash: string;
+  sharedAt: string;
+  items: PreviewItem[];
+  hits: Record<"secret" | "path" | "ip" | "host" | "email", number>;
+  tooBig: boolean;
+  connectLinked: boolean;
+}
+
+const post = (url: string, body: unknown) =>
+  fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+/** What would be uploaded, redacted. Local only. */
+export function useSharePreview() {
+  return useMutation({
+    mutationFn: async (req: PreviewRequest) =>
+      json<SharePreview>(await post("/api/shares/preview", req)),
+  });
+}
+
+export function useCreateShare() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (
+      req: PreviewRequest & {
+        sharedAt: string;
+        hash: string;
+        expiresIn: ShareExpiry;
+      }
+    ) =>
+      json<{ id: string; url: string; expiresAt: string | null }>(
+        await post("/api/shares", req)
+      ),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: shareKeys.all }),
+  });
+}
+
+export interface SharedLinkRow {
+  id: string;
+  url: string;
+  kind: "chat" | "artifact";
+  title: string;
+  sessionId: string | null;
+  artifactId: string | null;
+  createdAt: string;
+  expiresAt: string | null;
+  status: "active" | "expired" | "revoked";
+  views: number | null;
+  lastViewedAt: string | null;
+}
+
+export interface SharesResponse {
+  connect: "ok" | "unavailable" | "unlinked";
+  shares: SharedLinkRow[];
+}
+
+export function useSharesQuery(enabled = true) {
+  return useQuery({
+    queryKey: shareKeys.list(),
+    queryFn: async () => json<SharesResponse>(await fetch("/api/shares")),
+    enabled,
+  });
+}
+
+export function useRevokeShare() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id: string) =>
+      json<{ ok: true }>(
+        await fetch(`/api/shares/${id}`, { method: "DELETE" })
+      ),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: shareKeys.all }),
+  });
+}

package/lib/chat/drivers/claude.ts

@@ -19,7 +19,11 @@ import { toChatContext, usageTotals } from "../context";
 import { cacheTtlMs } from "../stale";
 import { ClaudeMapper, toCommand, type ClaudeMessage } from "./claude-mapper";
 import { SuggestionTrace } from "./suggestion-trace";
-import { redact } from "../../orchestrator/untrusted";
+import {
+  redact,
+  SECRET_PARAM,
+  URL_USERINFO,
+} from "../../orchestrator/untrusted";
 import { NO_ATTRIBUTION } from "../../agents/attribution";
 import { callFromAssistant } from "../../usage/calls";
 
@@ -52,9 +56,6 @@ const firstLine = (text?: string) => {
 
 // A server's error text can quote its URL, and with it a key: shown and
 // stored redacted, on one line, and short.
-const URL_USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi;
-const SECRET_PARAM =
-  /([?&][\w.-]*(?:key|token|secret|password|auth|sig|code)[\w.-]*=)[^&\s#]+/gi;
 function cleanError(text?: string): string | undefined {
   if (!text) return undefined;
   const line = redact(

package/lib/connect/control-api.ts

@@ -264,3 +264,87 @@ export async function pushRelay(
     throw new Error("the Connect service sent no push results");
   return r.results;
 }
+
+export type ShareStatus = "active" | "expired" | "revoked";
+
+/** A snapshot link as Connect reports it. The link itself is never in a list. */
+export interface RemoteShare {
+  id: string;
+  kind: string;
+  title: string;
+  status: ShareStatus;
+  byte_size: number;
+  view_count: number;
+  last_viewed_at: string | null;
+  created_at: string;
+  expires_at: string | null;
+}
+
+export type ShareExpiry = "1d" | "7d" | "30d" | "never";
+
+const shareFrom = (r: unknown): RemoteShare => {
+  const s = (r ?? {}) as Record<string, unknown>;
+  if (typeof s.id !== "string" || typeof s.status !== "string")
+    throw new Error("the Connect service sent an unusable share");
+  return s as unknown as RemoteShare;
+};
+
+/** Uploads a rendered snapshot; the answer carries the public link, once. */
+export async function uploadShare(
+  config: ConnectConfig,
+  privateKey: string,
+  share: {
+    kind: "chat" | "artifact";
+    title: string;
+    html: string;
+    expiresIn: ShareExpiry;
+  }
+): Promise<RemoteShare & { url: string }> {
+  const res = await signed(config, privateKey)(
+    "POST",
+    `/api/v1/machines/${config.machineId}/shares`,
+    {
+      kind: share.kind,
+      title: share.title,
+      html: share.html,
+      expires_in: share.expiresIn,
+    }
+  );
+  const r = (await res.json().catch(() => null)) as Record<
+    string,
+    unknown
+  > | null;
+  const url = r?.url;
+  if (typeof url !== "string" || !/^https?:\/\//.test(url))
+    throw new Error("the Connect service sent no link");
+  return { ...shareFrom(r), url };
+}
+
+export async function listShares(
+  config: ConnectConfig,
+  privateKey: string
+): Promise<RemoteShare[]> {
+  const res = await signed(config, privateKey)(
+    "GET",
+    `/api/v1/machines/${config.machineId}/shares`
+  );
+  const r = (await res.json().catch(() => null)) as {
+    shares?: unknown[];
+  } | null;
+  if (!Array.isArray(r?.shares))
+    throw new Error("the Connect service sent no share list");
+  return r.shares.map(shareFrom);
+}
+
+export async function revokeShare(
+  config: ConnectConfig,
+  privateKey: string,
+  id: string
+): Promise<RemoteShare> {
+  if (!/^[a-z0-9]{12}$/.test(id)) throw new Error("not a share id");
+  const res = await signed(config, privateKey)(
+    "DELETE",
+    `/api/v1/machines/${config.machineId}/shares/${id}`
+  );
+  return shareFrom(await res.json().catch(() => null));
+}

package/lib/db/migrations-legacy-checksums.json

@@ -0,0 +1,90 @@
+{
+  "1": "f6d5756a104c16ec",
+  "2": "3699f5f3cd215455",
+  "3": "dc4efbc29c2976ef",
+  "4": "d3db3af92f123a13",
+  "5": "d5937aba3b590fed",
+  "6": "0c4668cf9a58cecd",
+  "7": "7f535265ae1ad37f",
+  "8": "5c24f600f5f73145",
+  "9": "99496923fc7ff333",
+  "10": "22162670e68726c0",
+  "11": "21cd323c1654f9a9",
+  "12": "d66b982154dc3ee2",
+  "13": "ba1c8c4e2486a74d",
+  "14": "2f9575eed78d3284",
+  "15": "4c2293b3766c0d84",
+  "16": "8e798e52aed97875",
+  "17": "a743501f00312926",
+  "18": "cb84130b195bfa63",
+  "19": "b0ba5d304ca64aba",
+  "20": "ef3e125d28bfa506",
+  "21": "542664a9bef5f215",
+  "22": "195a6a7a87776269",
+  "23": "e4b50e60ac0821fa",
+  "24": "afb9644f31cc7602",
+  "25": "52bb47e1eed4e8d4",
+  "26": "9b5247315a01bdbe",
+  "27": "9c34c46d26c93cc4",
+  "28": "83d816f925aa0aba",
+  "29": "5ce556a828f7510b",
+  "30": "3d1bc245c30dcf49",
+  "31": "250433b280fd8df1",
+  "32": "95ec3c8125969681",
+  "33": "711226e6a027f6cd",
+  "34": "d8c917aa6f3e00b6",
+  "35": "7db35660583c2a50",
+  "36": "7ff8363149a3952c",
+  "37": "b7e72a18d3398da6",
+  "38": "cea02e00d1262601",
+  "39": "61c77d0f357d71d6",
+  "40": "6cedcf70268ddd25",
+  "41": "3d9af0548ae91946",
+  "42": "410ef4562a046ce6",
+  "43": "b0fca4e05ff6499e",
+  "44": "06b7f4dc636c9675",
+  "45": "73948f256c522959",
+  "46": "202f8fd102ef2581",
+  "47": "510435d6afa487cd",
+  "48": "10727869e8c8dea1",
+  "49": "0384a86395f6650a",
+  "50": "cc05c3663ca18b2b",
+  "51": "b381268fe096fb02",
+  "52": "281ad10453d9177a",
+  "53": "a7a53074ed49a566",
+  "54": "2358b106da3e7b68",
+  "55": "478ece72deb01953",
+  "56": "d04bafcaa2eda941",
+  "57": "0f9bc09a7a31f64d",
+  "58": "ccbf7eebccadfa3f",
+  "59": "1859ac87155d546b",
+  "60": "035e204a4b6c457e",
+  "61": "85d9bb65b051409a",
+  "62": "723d9c60994dec97",
+  "63": "77dd17570476ee17",
+  "64": "de5f368a88af93de",
+  "65": "081cc6eaf666581b",
+  "66": "08eedfefd3d3f3f9",
+  "67": "e37ead69c14e2d01",
+  "68": "9ab2551e258f1588",
+  "69": "55edb197ed55afe1",
+  "70": "d8a4faf39318bd1d",
+  "71": "45b9b9ff57d2083d",
+  "72": "51b77e2e1c5c8ae6",
+  "73": "2878b9f0762ab53d",
+  "74": "c94cd8f644a8518f",
+  "75": "e082428a046f9e6b",
+  "76": "17f3160630d658dc",
+  "77": "cd54bfd73fbcd168",
+  "78": "8ad44a982b1eb58d",
+  "79": "0b09d57d6ea8ce0a",
+  "80": "941d85f2ef8bd012",
+  "81": "ecd85de2bdf45ff1",
+  "82": "07f11cdac5f8444a",
+  "83": "eabf72b6a8616eac",
+  "84": "1ed4fb30b7435f28",
+  "85": "a85ac25c0e34f2fb",
+  "86": "50b5725a67286dee",
+  "87": "6024c62bcdbb186e",
+  "88": "bb58ec622ae398e5"
+}

package/lib/db/migrations.ts

@@ -10,14 +10,43 @@ import {
 import type Database from "better-sqlite3";
 import { moveSchedulesToRecipes } from "./schedules-move";
 
-interface Migration {
+// HOW TO ADD A MIGRATION: append an object with a timestamp `key`, never an
+// integer `id`: `key: "YYYYMMDDTHHMM_snake_name"` (UTC, e.g.
+// "20261014T0130_share_links"). Hand-picked numbers collide when two tasks run
+// in parallel and the loser is silently skipped on databases that already
+// applied the winner. Ids 1..88 are legacy: they run first, by number, and
+// never change. Timestamp keys run after them, in lexical order. Never edit a
+// migration that has shipped; add a new one. lib/db/migrations.test.ts
+// enforces all of this.
+interface LegacyMigration {
   id: number;
+  key?: undefined;
   name: string;
   up: (db: Database.Database) => void;
 }
+interface KeyedMigration {
+  key: string;
+  id?: undefined;
+  name?: undefined;
+  up: (db: Database.Database) => void;
+}
+export type Migration = LegacyMigration | KeyedMigration;
+
+export const migrationKey = (m: Migration): string => m.key ?? String(m.id);
+const migrationName = (m: Migration): string =>
+  m.name ?? (m.key as string).replace(/^\d{8}T\d{4}_/, "");
+
+// Legacy ids sort before every timestamp key.
+function compareToUpTo(m: Migration, upTo: number | string): number {
+  if (typeof upTo === "number") {
+    return m.id === undefined ? 1 : m.id - upTo;
+  }
+  if (m.id !== undefined) return -1;
+  return m.key < upTo ? -1 : m.key > upTo ? 1 : 0;
+}
 
 // All migrations in order - never modify existing ones, only add new
-const migrations: Migration[] = [
+export const migrations: Migration[] = [
   {
     id: 1,
     name: "add_group_path_to_sessions",
@@ -2114,12 +2143,57 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 88,
+    name: "shared_links",
+    up: (db) => {
+      // Snapshot links made through Connect. Connect keeps only a digest of
+      // the token, so this is the one place the link can be copied again.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS shared_links (
+          id TEXT PRIMARY KEY,
+          url TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          title TEXT NOT NULL,
+          session_id TEXT,
+          artifact_id TEXT,
+          expires_at TEXT,
+          created_at TEXT NOT NULL,
+          revoked_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_shared_links_created
+          ON shared_links(created_at DESC);
+      `);
+    },
+  },
+  {
+    id: 89,
+    name: "passkeys_device_keys",
+    up: (db) => {
+      // A paired device's own approval key (Secure Enclave, Face ID) sits in
+      // the passkeys table beside the browser passkeys: type 'device', bound
+      // to the device that made it. Additive; existing rows read as webauthn.
+      const columns = db.prepare(`PRAGMA table_info(passkeys)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === "type"))
+        db.exec(
+          `ALTER TABLE passkeys ADD COLUMN type TEXT NOT NULL DEFAULT 'webauthn'`
+        );
+      if (!columns.some((c) => c.name === "device_id"))
+        db.exec(`ALTER TABLE passkeys ADD COLUMN device_id TEXT`);
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_passkeys_device ON passkeys(device_id)`
+      );
+    },
+  },
 ];
 
-// `upTo`: stop after this id (tests that start from an older database).
+// `upTo`: stop after this legacy id or timestamp key, inclusive (tests that
+// start from an older database).
 export function runMigrations(
   db: Database.Database,
-  upTo = Number.POSITIVE_INFINITY
+  upTo?: number | string
 ): void {
   // Create migrations tracking table
   db.exec(`
@@ -2129,31 +2203,59 @@ export function runMigrations(
       applied_at TEXT NOT NULL DEFAULT (datetime('now'))
     )
   `);
+  // Timestamp-keyed rows get an auto id and carry their key here; legacy rows
+  // (key NULL) keep meaning "applied" by their integer id.
+  const cols = db.prepare(`PRAGMA table_info(_migrations)`).all() as {
+    name: string;
+  }[];
+  if (!cols.some((c) => c.name === "key")) {
+    try {
+      db.exec(`ALTER TABLE _migrations ADD COLUMN key TEXT`);
+    } catch (error) {
+      if (!String(error).includes("duplicate column")) throw error;
+    }
+  }
+  db.exec(
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_migrations_key ON _migrations(key)`
+  );
 
-  // Get already applied migrations
   const applied = new Set(
-    (db.prepare(`SELECT id FROM _migrations`).all() as { id: number }[]).map(
-      (r) => r.id
-    )
+    (
+      db.prepare(`SELECT id, key FROM _migrations`).all() as {
+        id: number;
+        key: string | null;
+      }[]
+    ).map((r) => r.key ?? String(r.id))
   );
 
   // Use INSERT OR IGNORE to handle concurrent workers
-  const insertMigration = db.prepare(
+  const insertLegacy = db.prepare(
     `INSERT OR IGNORE INTO _migrations (id, name) VALUES (?, ?)`
   );
+  const insertKeyed = db.prepare(
+    `INSERT OR IGNORE INTO _migrations (key, name) VALUES (?, ?)`
+  );
+  const record = (m: Migration) =>
+    m.key === undefined
+      ? insertLegacy.run(m.id, m.name)
+      : insertKeyed.run(m.key, migrationName(m));
 
   for (const migration of migrations) {
-    if (applied.has(migration.id) || migration.id > upTo) continue;
+    const key = migrationKey(migration);
+    const name = migrationName(migration);
+    if (
+      applied.has(key) ||
+      (upTo !== undefined && compareToUpTo(migration, upTo) > 0)
+    )
+      continue;
 
     try {
       migration.up(db);
-      const result = insertMigration.run(migration.id, migration.name);
+      const result = record(migration);
       if (result.changes > 0) {
-        console.log(`Migration ${migration.id}: ${migration.name} applied`);
+        console.log(`Migration ${key}: ${name} applied`);
       } else {
-        console.log(
-          `Migration ${migration.id}: ${migration.name} skipped (concurrent apply)`
-        );
+        console.log(`Migration ${key}: ${name} skipped (concurrent apply)`);
       }
     } catch (error) {
       // Some migrations may fail if columns already exist (from old system or concurrent worker)
@@ -2163,15 +2265,10 @@ export function runMigrations(
         errorMsg.includes("duplicate column") ||
         errorMsg.includes("already exists")
       ) {
-        insertMigration.run(migration.id, migration.name);
-        console.log(
-          `Migration ${migration.id}: ${migration.name} skipped (already applied)`
-        );
+        record(migration);
+        console.log(`Migration ${key}: ${name} skipped (already applied)`);
       } else {
-        console.error(
-          `Migration ${migration.id}: ${migration.name} failed:`,
-          error
-        );
+        console.error(`Migration ${key}: ${name} failed:`, error);
         throw error;
       }
     }

package/lib/orchestrator/passkey-asks.ts

@@ -3,8 +3,11 @@
 // Declining a new passkey's ask revokes it.
 
 import type { PasskeyRow } from "../security/passkeys";
+import { revokeDeviceKeys } from "../security/device-keys";
+import { revokeDevice } from "../security/devices";
 import {
   AskRefused,
+  resolvePasskeyAsks,
   passkeySubject,
   raiseAsk,
   revokedPasskeySubject,
@@ -54,3 +57,14 @@ export function raisePasskeyAsks(
   }
   return n;
 }
+
+// Signing a device out takes its approval key with it, and the revoke goes
+// on the asks list like any other.
+export function revokeDeviceAndKeys(deviceId: string, place: string): boolean {
+  const changed = revokeDevice(deviceId);
+  for (const key of revokeDeviceKeys(deviceId)) {
+    resolvePasskeyAsks(key.id, "revoked");
+    raisePasskeyAsks(key, place, "revoked");
+  }
+  return changed;
+}