@saadnvd1/agent-os 0.3.762 → 0.3.765

package/app/api/shares/route.test.ts

@@ -117,7 +117,7 @@ const one = await import("./[id]/route");
 const { saveItem } = await import("@/lib/chat/store");
 const { seedSession } = await import("@/lib/orchestrator/testing");
 const { createProject } = await import("@/lib/projects");
-const { createArtifact } = await import("@/lib/artifacts/store");
+const { createArtifact, saveArtifact } = await import("@/lib/artifacts/store");
 const { getDb } = await import("@/lib/db");
 
 const secret = ["gh", "p_", "b".repeat(36)].join("");
@@ -341,6 +341,71 @@ describe("create", () => {
     expect(html).toContain("noindex");
   });
 
+  describe("follow latest", () => {
+    const page = (html: string) =>
+      `<html><head></head><body>${html}</body></html>`;
+    async function create(artifactId: string, extra: object = {}) {
+      const body = { kind: "artifact", artifactId, ...extra };
+      const p = await (
+        await preview.POST(post("/api/shares/preview", body))
+      ).json();
+      return shares.POST(
+        post("/api/shares", {
+          ...body,
+          sharedAt: p.sharedAt,
+          hash: p.hash,
+          expiresIn: "7d",
+        })
+      );
+    }
+    const stored = () =>
+      getDb().prepare(`SELECT follow_latest, version FROM shared_links`).get();
+
+    it("pins the shown version by default", async () => {
+      const sid = chat();
+      saveArtifact(sid, "Doc", page("one"), { sameTitle: true });
+      const v2 = saveArtifact(sid, "Doc", page("two"), {
+        sameTitle: true,
+      }).artifact;
+      expect((await create(v2.id)).status).toBe(201);
+      expect(stored()).toEqual({ follow_latest: 0, version: 2 });
+      const listed = await (await shares.GET()).json();
+      expect(listed.shares[0]).toMatchObject({ follow: false, version: 2 });
+    });
+
+    it("keeps follow: latest on the link and lists it", async () => {
+      const sid = chat();
+      const v1 = saveArtifact(sid, "Doc", page("one"), {
+        sameTitle: true,
+      }).artifact;
+      expect((await create(v1.id, { follow: "latest" })).status).toBe(201);
+      expect(stored()).toEqual({ follow_latest: 1, version: 1 });
+      const listed = await (await shares.GET()).json();
+      expect(listed.shares[0]).toMatchObject({ follow: true, version: 1 });
+    });
+
+    it("refuses to follow from an older version, and for a chat", async () => {
+      const sid = chat();
+      const v1 = saveArtifact(sid, "Doc", page("one"), {
+        sameTitle: true,
+      }).artifact;
+      saveArtifact(sid, "Doc", page("two"), { sameTitle: true });
+      const old = await create(v1.id, { follow: "latest" });
+      expect(old.status).toBe(409);
+      expect((await old.json()).error).toMatch(/share v2/);
+      const res = await shares.POST(
+        post("/api/shares", {
+          kind: "chat",
+          sessionId: sid,
+          follow: "latest",
+          hash: "x",
+        })
+      );
+      expect(res.status).toBe(400);
+      expect(seen).toHaveLength(0);
+    });
+  });
+
   it("says so when Connect isn't linked, and for a bad expiry or hash", async () => {
     const id = chat();
     const p = await previewOf(id);

package/app/api/shares/route.ts

@@ -12,6 +12,7 @@ import {
   buildPage,
   parseRequest,
 } from "@/lib/share/service";
+import { getArtifact, latestVersion } from "@/lib/artifacts/store";
 import { insertSharedLink, listSharedLinks } from "@/lib/share/store";
 import type { ShareExpiry } from "@/lib/connect/control-api";
 
@@ -31,6 +32,16 @@ export async function POST(request: Request) {
     if (typeof body?.hash !== "string") return fail("hash is required.", 400);
     if (!linked()) return fail(NOT_LINKED, 409);
 
+    const artifact = req.artifactId ? getArtifact(req.artifactId) : undefined;
+    if (req.follow && artifact) {
+      const latest = latestVersion(artifact.page_id);
+      if (latest && latest.id !== artifact.id)
+        return fail(
+          `v${artifact.version} isn't the latest; share v${latest.version} to follow the page.`,
+          409
+        );
+    }
+
     const page = await buildPage(req);
     if (page.tooBig) return fail(TOO_BIG, 413);
     if (page.hash !== body.hash)
@@ -53,6 +64,8 @@ export async function POST(request: Request) {
       expires_at: share.expires_at,
       created_at: share.created_at,
       revoked_at: null,
+      follow_latest: req.follow ? 1 : 0,
+      version: artifact?.version ?? null,
     });
     return NextResponse.json(
       { id: share.id, url: share.url, expiresAt: share.expires_at },
@@ -96,6 +109,8 @@ export async function GET() {
         status,
         views: r ? r.view_count : null,
         lastViewedAt: r?.last_viewed_at ?? null,
+        follow: l.follow_latest === 1,
+        version: l.version,
       };
     }),
   });

package/components/Share/ShareDialog.tsx

@@ -19,6 +19,7 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { DownloadMenu } from "./DownloadMenu";
+import { cn } from "@/lib/utils";
 import { Switch } from "@/components/ui/switch";
 import { writeClipboard } from "@/hooks/useCopyToClipboard";
 import {
@@ -76,6 +77,7 @@ function ShareBody({
   const [preview, setPreview] = useState<SharePreview | null>(null);
   const [error, setError] = useState<string | null>(null);
   const [created, setCreated] = useState<string | null>(null);
+  const [follow, setFollow] = useState(false);
   const [copied, setCopied] = useState(false);
   const [tab, setTab] = useState<"page" | "markdown">("page");
   const previewReq = useSharePreview();
@@ -121,6 +123,7 @@ function ShareBody({
         sharedAt: preview.sharedAt,
         hash: preview.hash,
         expiresIn,
+        follow: follow ? "latest" : undefined,
       });
       setCreated(res.url);
       try {
@@ -235,6 +238,48 @@ function ShareBody({
             </>
           )}
 
+          {linked && kind === "artifact" && (
+            <fieldset className="space-y-2">
+              <legend className="text-muted-foreground mb-1 text-xs font-medium">
+                What the link shows
+              </legend>
+              {[
+                {
+                  value: false,
+                  title: `This version${target.version ? ` (v${target.version})` : ""}`,
+                  hint: "Never changes. You review it above before it goes out.",
+                },
+                {
+                  value: true,
+                  title: "Always the latest",
+                  hint: "Updates when the agent makes a new version. New versions are redacted the same way but publish without a fresh preview.",
+                },
+              ].map((o) => (
+                <label
+                  key={o.title}
+                  className={cn(
+                    "flex min-h-11 cursor-pointer items-start gap-3 rounded-lg border px-3 py-2 text-sm",
+                    follow === o.value && "border-primary bg-primary/5"
+                  )}
+                >
+                  <input
+                    type="radio"
+                    name="share-follow"
+                    className="mt-1 h-4 w-4 shrink-0"
+                    checked={follow === o.value}
+                    onChange={() => setFollow(o.value)}
+                  />
+                  <span className="min-w-0">
+                    <span className="block font-medium">{o.title}</span>
+                    <span className="text-muted-foreground block text-xs">
+                      {o.hint}
+                    </span>
+                  </span>
+                </label>
+              ))}
+            </fieldset>
+          )}
+
           {linked && (
             <label className="flex min-h-11 items-center justify-between gap-3 text-sm">
               <span>Link expires after</span>

package/components/Shares/SharedLinksPanel.tsx

@@ -60,6 +60,13 @@ function Row({ share }: { share: SharedLinkRow }) {
         <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>
+          {share.kind === "artifact" && (
+            <span>
+              {share.follow
+                ? `Follows latest${share.version ? ` · now v${share.version}` : ""}`
+                : `pinned${share.version ? ` v${share.version}` : ""}`}
+            </span>
+          )}
           <span>Created {when(share.createdAt)}</span>
           <span>
             {share.status === "revoked"

package/lib/artifacts/tools.ts

@@ -19,6 +19,7 @@ import {
   MAX_TITLE_CHARS,
   type Artifact,
 } from "./store";
+import { followLatest } from "../share/follow";
 import { previewHtml } from "./preview";
 
 export const VISUALS_SERVER = "visuals";
@@ -101,7 +102,10 @@ export async function renderPage(
       readSource(args, ctx.cwd),
       { update: args.update, note: args.note, sameTitle: true }
     );
-    if (created) 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: [

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/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/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);
+}

package/lib/share/view.ts

@@ -7,6 +7,8 @@ export interface ShareTarget {
   kind: "chat" | "artifact";
   sessionId?: string;
   artifactId?: string;
+  /** A page link that is re-uploaded when the page gets a new version. */
+  follow?: "latest";
 }
 
 export interface PreviewRequest extends ShareTarget {
@@ -52,6 +54,10 @@ export interface SharedLinkRow {
   status: "active" | "expired" | "revoked";
   views: number | null;
   lastViewedAt: string | null;
+  /** True when the link follows the page's latest version. */
+  follow: boolean;
+  /** The page version the link shows now. */
+  version: number | null;
 }
 
 export interface SharesResponse {

package/package.json

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