@saadnvd1/agent-os 0.3.761 → 0.3.765

package/lib/artifacts/store.ts

@@ -6,7 +6,7 @@
 import { agentosHome } from "../agentos-home";
 import fs from "fs";
 import path from "path";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { db } from "../db";
 
 export interface Artifact {
@@ -15,8 +15,31 @@ export interface Artifact {
   title: string;
   path: string;
   created_at: string;
+  // The page this is a version of; every version of a page shares it.
+  page_id: string;
+  version: number;
+  // The agent's one line on what changed.
+  note: string | null;
+  bytes: number | null;
+  sha256: string | null;
 }
 
+export interface SaveOptions {
+  // Any version's id of a page in this session: add a version to it.
+  update?: string;
+  // With no update, the newest page in this session with the same title.
+  sameTitle?: boolean;
+  note?: string;
+}
+
+export interface Saved {
+  artifact: Artifact;
+  // False when the page was byte-for-byte its latest version already.
+  created: boolean;
+}
+
+export const MAX_NOTE_CHARS = 120;
+
 export const MAX_HTML_BYTES = 2 * 1024 * 1024;
 export const MAX_TITLE_CHARS = 120;
 
@@ -35,20 +58,92 @@ function sessionDir(sessionId: string): string {
 export function createArtifact(
   sessionId: string,
   title: string,
-  html: string
+  html: string,
+  opts: SaveOptions = {}
 ): Artifact {
-  if (Buffer.byteLength(html, "utf8") > MAX_HTML_BYTES)
+  return saveArtifact(sessionId, title, html, opts).artifact;
+}
+
+const oneLine = (s: string, max: number) =>
+  s.replace(/\s+/g, " ").trim().slice(0, max);
+
+// Saves a page, or a new version of one. Earlier versions are never touched.
+export function saveArtifact(
+  sessionId: string,
+  title: string,
+  html: string,
+  opts: SaveOptions = {}
+): Saved {
+  const bytes = Buffer.byteLength(html, "utf8");
+  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;
+  const sha256 = createHash("sha256").update(html).digest("hex");
   const id = randomUUID();
   const dir = sessionDir(sessionId);
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   const file = path.join(dir, `${id}.html`);
-  fs.writeFileSync(file, html, { mode: 0o600 });
-  const clean = title.replace(/\s+/g, " ").trim().slice(0, MAX_TITLE_CHARS);
-  db.prepare(
-    `INSERT INTO artifacts (id, session_id, title, path) VALUES (?, ?, ?, ?)`
-  ).run(id, sessionId, clean || "Untitled", file);
-  return getArtifact(id)!;
+  return db.transaction((): Saved => {
+    const pageId = resolvePage(sessionId, clean, opts);
+    const latest = pageId ? latestVersion(pageId) : undefined;
+    if (latest && latest.sha256 === sha256)
+      return { artifact: latest, created: false };
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, html, { mode: 0o600 });
+    db.prepare(
+      `INSERT INTO artifacts (id, session_id, title, path, page_id, version, note, bytes, sha256)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      sessionId,
+      clean,
+      file,
+      pageId ?? id,
+      latest ? latest.version + 1 : 1,
+      note,
+      bytes,
+      sha256
+    );
+    return { artifact: getArtifact(id)!, created: true };
+  })();
+}
+
+function resolvePage(
+  sessionId: string,
+  title: string,
+  opts: SaveOptions
+): string | undefined {
+  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;
+  }
+  if (!opts.sameTitle) return undefined;
+  const row = db
+    .prepare(
+      `SELECT page_id FROM artifacts WHERE session_id = ? AND lower(title) = lower(?)
+       ORDER BY created_at DESC, rowid DESC LIMIT 1`
+    )
+    .get(sessionId, title) as { page_id: string } | undefined;
+  return row?.page_id;
+}
+
+// Every version of a page, oldest first.
+export function listVersions(pageId: string): Artifact[] {
+  return db
+    .prepare(`SELECT * FROM artifacts WHERE page_id = ? ORDER BY version`)
+    .all(pageId) as Artifact[];
+}
+
+export function latestVersion(pageId: string): Artifact | undefined {
+  return db
+    .prepare(
+      `SELECT * FROM artifacts WHERE page_id = ? ORDER BY version DESC LIMIT 1`
+    )
+    .get(pageId) as Artifact | undefined;
 }
 
 export function getArtifact(id: string): Artifact | undefined {

package/lib/artifacts/tools.ts

@@ -13,11 +13,13 @@ import {
   type McpSdkServerConfigWithInstance,
 } from "@anthropic-ai/claude-agent-sdk";
 import {
-  createArtifact,
+  saveArtifact,
   MAX_HTML_BYTES,
+  MAX_NOTE_CHARS,
   MAX_TITLE_CHARS,
   type Artifact,
 } from "./store";
+import { followLatest } from "../share/follow";
 import { previewHtml } from "./preview";
 
 export const VISUALS_SERVER = "visuals";
@@ -84,20 +86,34 @@ export interface VisualsContext {
 // Saves the page and shows it in the conversation.
 export async function renderPage(
   ctx: VisualsContext,
-  args: { html?: string; path?: string; title: string; height?: number }
+  args: {
+    html?: string;
+    path?: string;
+    title: string;
+    height?: number;
+    update?: string;
+    note?: string;
+  }
 ): Promise<CallToolResult> {
   try {
-    const artifact = createArtifact(
+    const { artifact, created } = saveArtifact(
       ctx.sessionId,
       args.title,
-      readSource(args, ctx.cwd)
+      readSource(args, ctx.cwd),
+      { update: args.update, note: args.note, sameTitle: true }
     );
-    ctx.onRender(artifact, args.height);
+    if (created) {
+      ctx.onRender(artifact, args.height);
+      if (artifact.version > 1) followLatest(artifact.page_id);
+    }
+    const name = `"${artifact.title}"${artifact.version > 1 ? ` v${artifact.version}` : ""}`;
     return {
       content: [
         {
           type: "text",
-          text: `Shown in the chat as "${artifact.title}" (artifact ${artifact.id}).`,
+          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.`
+            : `Unchanged: the page is the same as ${name} (artifact ${artifact.id}), already in the chat.`,
         },
       ],
     };
@@ -171,6 +187,17 @@ export function visualsTools(
             .describe(
               "Cap on the frame's height in CSS pixels; longer pages scroll inside it. Defaults to fitting the page."
             ),
+          update: z
+            .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."
+            ),
+          note: z
+            .string()
+            .max(MAX_NOTE_CHARS)
+            .optional()
+            .describe("For a new version: one line on what changed."),
         },
         (args) => renderPage(ctx, args)
       ),

package/lib/artifacts/versions.ts

@@ -0,0 +1,73 @@
+// A page's versions for the version switcher: each with its note, size and
+// the message that asked for it.
+
+import { db } from "../db";
+import { getArtifact, listVersions, type Artifact } from "./store";
+import {
+  pageActions,
+  type ArtifactVersion,
+  type PageVersions,
+} from "./actions";
+
+const PROMPT_CHARS = 80;
+
+const sqliteMs = (t: string) =>
+  Date.parse(t.includes("T") ? t : `${t.replace(" ", "T")}Z`) || 0;
+
+// The user message before the chat item that showed this version.
+function turnOf(a: Artifact): ArtifactVersion["turn"] {
+  const row = db
+    .prepare(
+      `SELECT u.item_id AS itemId,
+              json_extract(u.data, '$.text') AS text,
+              (SELECT COUNT(*) FROM chat_items c
+                WHERE c.session_id = u.session_id AND c.kind = 'user'
+                  AND c.seq <= u.seq) AS idx
+         FROM chat_items u
+        WHERE u.session_id = ? AND u.kind = 'user'
+          AND u.seq < (SELECT seq FROM chat_items
+                        WHERE session_id = ? AND item_id = ?)
+        ORDER BY u.seq DESC LIMIT 1`
+    )
+    .get(a.session_id, a.session_id, `artifact-${a.id}`) as
+    { itemId: string; text: string | null; idx: number } | undefined;
+  if (!row) return undefined;
+  const prompt = (row.text ?? "").replace(/\s+/g, " ").trim();
+  return {
+    itemId: row.itemId,
+    index: row.idx,
+    prompt:
+      prompt.length > PROMPT_CHARS
+        ? `${prompt.slice(0, PROMPT_CHARS - 1)}…`
+        : prompt,
+  };
+}
+
+export function toVersion(a: Artifact): ArtifactVersion {
+  const turn = turnOf(a);
+  return {
+    id: a.id,
+    version: a.version,
+    title: a.title,
+    ...(a.note && { note: a.note }),
+    createdAt: sqliteMs(a.created_at),
+    ...(a.bytes != null && { bytes: a.bytes }),
+    ...(turn && { turn }),
+  };
+}
+
+// Every version of the page that artifactId is a version of.
+export function pageVersions(
+  artifactId: string,
+  ctx: { pdf: boolean }
+): PageVersions | undefined {
+  const a = getArtifact(artifactId);
+  if (!a) return undefined;
+  const versions = listVersions(a.page_id).map(toVersion);
+  return {
+    pageId: a.page_id,
+    latestId: versions[versions.length - 1]?.id ?? a.id,
+    versions,
+    actions: pageActions(ctx),
+  };
+}

package/lib/chat/events.ts

@@ -254,6 +254,10 @@ export type ChatItem =
       kind: "artifact";
       artifactId: string;
       title: string;
+      // The page it's a version of, and which; absent before versions (v1 of
+      // its own page).
+      pageId?: string;
+      version?: number;
       // A cap on the frame's height; it fits the page otherwise.
       height?: number;
     })

package/lib/chat/worker/host.ts

@@ -215,6 +215,8 @@ export class ChatHost {
                 kind: "artifact",
                 artifactId: artifact.id,
                 title: artifact.title,
+                pageId: artifact.page_id,
+                version: artifact.version,
                 height,
                 createdAt: Date.now(),
               }),

package/lib/connect/control-api.ts

@@ -428,6 +428,21 @@ export async function uploadShare(
   return { ...shareFrom(r), url };
 }
 
+/** Replaces a live share's content under the same link. */
+export async function replaceShare(
+  config: ConnectConfig,
+  privateKey: string,
+  id: string,
+  share: { title: string; html: string; markdown: string }
+): Promise<void> {
+  if (!/^[a-z0-9]{12}$/.test(id)) throw new Error("not a share id");
+  await signed(config, privateKey)(
+    "PUT",
+    `/api/v1/machines/${config.machineId}/shares/${id}`,
+    { title: share.title, html: share.html, markdown: share.markdown }
+  );
+}
+
 export async function listShares(
   config: ConnectConfig,
   privateKey: string

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

@@ -0,0 +1,28 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261029T1200_artifact_versions",
+  up: (db) => {
+    // Each artifacts row is one version of a page; rows sharing page_id are
+    // that page's history. Versions are only ever added, never rewritten.
+    const cols = new Set(
+      (
+        db.prepare(`PRAGMA table_info(artifacts)`).all() as { name: string }[]
+      ).map((c) => c.name)
+    );
+    const add = (name: string, type: string) => {
+      if (!cols.has(name))
+        db.exec(`ALTER TABLE artifacts ADD COLUMN ${name} ${type}`);
+    };
+    add("page_id", "TEXT");
+    add("version", "INTEGER NOT NULL DEFAULT 1");
+    // The agent's one line on what changed.
+    add("note", "TEXT");
+    add("bytes", "INTEGER");
+    add("sha256", "TEXT");
+    db.exec(`UPDATE artifacts SET page_id = id WHERE page_id IS NULL`);
+    db.exec(
+      `CREATE UNIQUE INDEX IF NOT EXISTS idx_artifacts_page_version ON artifacts(page_id, version)`
+    );
+  },
+} satisfies Migration;

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

@@ -0,0 +1,28 @@
+import type { Migration } from "../migration-types";
+
+export default {
+  key: "20261029T1300_shared_links_follow",
+  up: (db) => {
+    // follow_latest: the link is re-uploaded whenever its page gets a new
+    // version. version: the page version the link shows now (pinned or not).
+    const cols = new Set(
+      (
+        db.prepare(`PRAGMA table_info(shared_links)`).all() as {
+          name: string;
+        }[]
+      ).map((c) => c.name)
+    );
+    if (!cols.has("follow_latest"))
+      db.exec(
+        `ALTER TABLE shared_links ADD COLUMN follow_latest INTEGER NOT NULL DEFAULT 0`
+      );
+    if (!cols.has("version"))
+      db.exec(`ALTER TABLE shared_links ADD COLUMN version INTEGER`);
+    // Links made before this show the version their artifact row is.
+    db.exec(
+      `UPDATE shared_links SET version = (
+         SELECT a.version FROM artifacts a WHERE a.id = shared_links.artifact_id
+       ) WHERE version IS NULL AND artifact_id IS NOT NULL`
+    );
+  },
+} satisfies Migration;

package/lib/security/demo.ts

@@ -124,6 +124,7 @@ const READS = [
   "usage",
   "vendor/mermaid",
   "artifacts/[id]",
+  "artifacts/[id]/versions",
   "git/status",
   "git/file-content",
   "git/history",

package/lib/session-artifacts/collect.ts

@@ -12,7 +12,7 @@ import { db, queries, type Session } from "../db";
 import { flushItems } from "../chat/store";
 import { git } from "../git-exec";
 import { PLAN_FILE } from "../models/plan-step";
-import { listArtifacts } from "../artifacts/store";
+import { listArtifacts, type Artifact } from "../artifacts/store";
 import { allowedRoots, within } from "./access";
 import { SCREENSHOT_DIR } from "../tasks/ui-brief";
 import {
@@ -51,6 +51,7 @@ const ITEMS_SQL = `
          json_extract(data, '$.input.filePath') AS file_path_camel,
          json_extract(data, '$.input.changes') AS changes,
          json_extract(data, '$.artifactId') AS artifact_id,
+         json_extract(data, '$.pageId') AS page_id,
          json_extract(data, '$.title') AS title,
          json_extract(data, '$.taskId') AS task_id,
          json_extract(data, '$.outputFile') AS output_file,
@@ -202,16 +203,37 @@ async function build(session: Session): Promise<Entry[]> {
   const keptBase = sessionKeptDir(session.id);
   const tracked = new Set(manifest?.tracked);
   const kept = new Set(manifest?.kept);
-  const pages = new Map(listArtifacts(session.id).map((a) => [a.id, a.path]));
+  const saved = listArtifacts(session.id);
+  const byId = new Map(saved.map((a) => [a.id, a]));
+  // Each page's newest version and how many it has.
+  const newest = new Map<string, Artifact>();
+  const count = new Map<string, number>();
+  for (const a of saved) {
+    count.set(a.page_id, (count.get(a.page_id) ?? 0) + 1);
+    if ((newest.get(a.page_id)?.version ?? 0) < a.version)
+      newest.set(a.page_id, a);
+  }
   const entries = await Promise.all(
     candidates.map(async (c): Promise<Entry> => {
       if (c.source.type === "page") {
-        const page = pages.get(c.source.artifactId);
-        const size = page ? await sizeOf(page) : undefined;
-        return toArtifact(
-          c,
+        const seen = byId.get(c.source.artifactId);
+        const page = seen && (newest.get(seen.page_id) ?? seen);
+        const size = page ? await sizeOf(page.path) : undefined;
+        const c2 = page
+          ? { ...c, source: { type: "page" as const, artifactId: page.id } }
+          : c;
+        const entry = toArtifact(
+          c2,
           size === undefined ? { state: "gone" } : { state: "live", size }
         );
+        if (page)
+          Object.assign(entry.artifact, {
+            name: page.title,
+            artifactId: page.id,
+            version: page.version,
+            versionCount: count.get(page.page_id) ?? 1,
+          });
+        return entry;
       }
       const file = filePathOf(c);
       if (!file) return toArtifact(c, null);

package/lib/session-artifacts/derive.ts

@@ -29,6 +29,7 @@ export interface ItemRow {
   file_path_camel?: string | null;
   changes?: string | null;
   artifact_id?: string | null;
+  page_id?: string | null;
   title?: string | null;
   task_id?: string | null;
   output_file?: string | null;
@@ -177,7 +178,8 @@ export function fromItems(
           });
       }
     } else if (row.kind === "artifact" && row.artifact_id) {
-      const key = `page:${row.artifact_id}`;
+      // One row per page: a later version replaces an earlier one.
+      const key = `page:${row.page_id || row.artifact_id}`;
       out.set(key, {
         key,
         kind: "page",

package/lib/session-artifacts/types.ts

@@ -1,5 +1,7 @@
 // What a session produced, as the Artifacts view lists it. Client-safe.
 
+import type { ArtifactAction } from "../artifacts/actions";
+
 export type ArtifactKind =
   "plan" | "file" | "page" | "image" | "log" | "pr" | "run" | "session-log";
 
@@ -30,6 +32,13 @@ export interface SessionArtifact {
   folder?: string;
   // A link out (the PR on GitHub).
   url?: string;
+  // A page: its latest version's artifact id, which version that is, and
+  // how many there are.
+  artifactId?: string;
+  version?: number;
+  versionCount?: number;
+  // What the viewer can do with it; set by the server.
+  actions?: ArtifactAction[];
 }
 
 export const openable = (a: Pick<SessionArtifact, "state" | "preview">) =>

package/lib/share/connect.ts

@@ -5,6 +5,7 @@ import {
   ApiError,
   clean,
   listShares,
+  replaceShare,
   revokeShare,
   uploadShare,
   type RemoteShare,
@@ -70,6 +71,15 @@ export async function createRemote(share: {
   }
 }
 
+/** Puts new content under a live link. Throws the raw ApiError, so the caller can tell a dead link from a failed try. */
+export async function replaceRemote(
+  id: string,
+  content: { title: string; html: string; markdown: string }
+): Promise<void> {
+  const { config, machineKey } = files();
+  await replaceShare(config, machineKey, id, content);
+}
+
 export async function listRemote(): Promise<RemoteShare[]> {
   const { config, machineKey } = files();
   return listShares(config, machineKey);

package/lib/share/follow.ts

@@ -0,0 +1,76 @@
+/**
+ * Follow-latest share links: when a page gets a new version, every live link
+ * that follows it is re-uploaded through Connect's PUT, built the same way as
+ * a normal share (same snapshot, same redaction). Nothing here throws into
+ * the caller: a failed try is logged and the next version tries again, and
+ * the content already on the link stays live meanwhile.
+ */
+
+import { ApiError } from "@/lib/connect/control-api";
+import { latestVersion } from "@/lib/artifacts/store";
+import { linked, replaceRemote } from "./connect";
+import { BadShare, buildPage } from "./service";
+import { listFollowing, setLinkVersion, stopFollowing } from "./store";
+
+// One run per page at a time, so two quick versions can't land out of order.
+const running = new Map<string, Promise<void>>();
+
+export function followLatest(pageId: string): Promise<void> {
+  const next = (running.get(pageId) ?? Promise.resolve())
+    .then(() => run(pageId))
+    .catch((err) => console.error("[share-follow]", pageId, err))
+    .finally(() => {
+      if (running.get(pageId) === next) running.delete(pageId);
+    });
+  running.set(pageId, next);
+  return next;
+}
+
+async function run(pageId: string): Promise<void> {
+  const latest = latestVersion(pageId);
+  if (!latest) return;
+  // A link that missed an earlier version is behind too, so this is also the retry.
+  const behind = listFollowing(pageId).filter(
+    (l) => (l.version ?? 0) < latest.version
+  );
+  if (!behind.length || !linked()) return;
+  let page;
+  try {
+    page = await buildPage({
+      kind: "artifact",
+      artifactId: latest.id,
+      includeTools: false,
+      sharedAt: new Date().toISOString(),
+    });
+  } catch (err) {
+    console.error(
+      "[share-follow] could not build",
+      latest.id,
+      err instanceof BadShare ? err.message : err
+    );
+    return;
+  }
+  if (page.tooBig) {
+    console.error("[share-follow] v%d is too big to share", latest.version);
+    return;
+  }
+  for (const link of behind) {
+    try {
+      await replaceRemote(link.id, {
+        title: page.title,
+        html: page.html,
+        markdown: page.markdown,
+      });
+      setLinkVersion(link.id, latest.version, page.title);
+    } catch (err) {
+      if (err instanceof ApiError && (err.status === 404 || err.status === 410))
+        stopFollowing(link.id);
+      console.error(
+        "[share-follow] %s stays on v%s:",
+        link.id,
+        link.version,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+}

package/lib/share/service.ts

@@ -25,6 +25,7 @@ export interface ShareRequest {
   includeTools: boolean;
   /** Messages the reader left out in the preview. */
   dropIds?: string[];
+  follow?: "latest";
   sharedAt: string;
 }
 
@@ -86,6 +87,10 @@ export function parseRequest(raw: unknown, sharedAt?: unknown): ShareRequest {
       throw new BadShare("dropIds must be a list of ids", 400);
     dropIds = b.dropIds as string[];
   }
+  if (b.follow !== undefined && b.follow !== "latest")
+    throw new BadShare("follow must be latest", 400);
+  if (b.follow && kind !== "artifact")
+    throw new BadShare("Only a page can follow its latest version", 400);
   const at = typeof sharedAt === "string" ? sharedAt : new Date().toISOString();
   if (Number.isNaN(Date.parse(at)))
     throw new BadShare("sharedAt is not a date", 400);
@@ -95,6 +100,7 @@ export function parseRequest(raw: unknown, sharedAt?: unknown): ShareRequest {
     artifactId,
     includeTools: b.includeTools === true,
     dropIds,
+    follow: b.follow === "latest" ? "latest" : undefined,
     sharedAt: at,
   };
 }

package/lib/share/store.ts

@@ -10,13 +10,16 @@ export interface SharedLink {
   expires_at: string | null;
   created_at: string;
   revoked_at: string | null;
+  follow_latest: number;
+  // The page version the link shows now.
+  version: number | null;
 }
 
 export function insertSharedLink(link: SharedLink): void {
   db.prepare(
     `INSERT INTO shared_links
-       (id, url, kind, title, session_id, artifact_id, expires_at, created_at, revoked_at)
-     VALUES (@id, @url, @kind, @title, @session_id, @artifact_id, @expires_at, @created_at, @revoked_at)`
+       (id, url, kind, title, session_id, artifact_id, expires_at, created_at, revoked_at, follow_latest, version)
+     VALUES (@id, @url, @kind, @title, @session_id, @artifact_id, @expires_at, @created_at, @revoked_at, @follow_latest, @version)`
   ).run(link);
 }
 
@@ -36,3 +39,32 @@ export function markRevoked(id: string): void {
     `UPDATE shared_links SET revoked_at = COALESCE(revoked_at, ?) WHERE id = ?`
   ).run(new Date().toISOString(), id);
 }
+
+/** Live follow-latest links to any version of a page. */
+export function listFollowing(pageId: string): SharedLink[] {
+  return db
+    .prepare(
+      `SELECT l.* FROM shared_links l JOIN artifacts a ON a.id = l.artifact_id
+       WHERE a.page_id = ? AND l.follow_latest = 1 AND l.revoked_at IS NULL
+         AND (l.expires_at IS NULL OR l.expires_at > ?)
+       ORDER BY l.created_at, l.rowid`
+    )
+    .all(pageId, new Date().toISOString()) as SharedLink[];
+}
+
+export function setLinkVersion(
+  id: string,
+  version: number,
+  title: string
+): void {
+  db.prepare(`UPDATE shared_links SET version = ?, title = ? WHERE id = ?`).run(
+    version,
+    title,
+    id
+  );
+}
+
+/** Connect no longer has it: stop trying. */
+export function stopFollowing(id: string): void {
+  db.prepare(`UPDATE shared_links SET follow_latest = 0 WHERE id = ?`).run(id);
+}