@saadnvd1/agent-os 0.3.758 → 0.3.762

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,8 +13,9 @@ 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";
@@ -84,20 +85,31 @@ 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);
+    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 +183,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/commands.ts

@@ -11,6 +11,15 @@ export function slashQuery(
   return { query: m[2].toLowerCase(), start: m.index + m[1].length };
 }
 
+// The SDK ends a description with where the command comes from, "(user)",
+// "(project)" or "(plugin-name)"; the menu's group header says that already.
+export function stripSourceSuffix(description: string): string {
+  return description.replace(
+    /\s*\((?:user|project|builtin|plugin|[\w.-]+@[\w.-]+)\)\s*$/i,
+    ""
+  );
+}
+
 function isSubsequence(q: string, s: string): boolean {
   let i = 0;
   for (const ch of s) if (ch === q[i]) i++;

package/lib/chat/drivers/claude-mapper.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "crypto";
 import type { ChatCommand, ChatItem, DriverEvent } from "../events";
 import { clipOutput, toolDiff, toolTitle } from "../tools";
-import { leadingCommand } from "../commands";
+import { leadingCommand, stripSourceSuffix } from "../commands";
 import { usageTotals } from "../context";
 
 // Loose views of the SDK's message shapes: only what the mapper reads.
@@ -93,7 +93,7 @@ export type SdkCommand = {
 export function toCommand(c: SdkCommand): ChatCommand {
   return {
     name: c.name,
-    description: c.description ?? "",
+    description: stripSourceSuffix(c.description ?? ""),
     argumentHint: c.argumentHint || undefined,
     builtin: c.builtin,
   };

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/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/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/next.config.ts

@@ -7,6 +7,12 @@ const nextConfig: NextConfig = {
   // so the live server never serves a half-written build.
   distDir: process.env.AGENTOS_DIST_DIR || ".next",
   devIndicators: false,
+  // Next 16.4 stops `next dev` once under an agent to print an upgrade
+  // nudge, which kills every task's dev server. Upgrades go through
+  // Dependabot and tasks instead.
+  experimental: {
+    agentUpgrade: false,
+  },
   turbopack: {
     root: resolve(import.meta.dirname),
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.758",
+  "version": "0.3.762",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -136,7 +136,7 @@
     "mermaid": "^12.2.0",
     "micromark-extension-gfm": "^3.0.0",
     "monaco-editor": "^0.57.0",
-    "next": "^16.3.8",
+    "next": "^16.4.2",
     "next-themes": "^0.4.6",
     "node-pty": "^1.2.0-beta.6",
     "playwright": "^1.63.0",
@@ -167,7 +167,7 @@
     "@types/react-dom": "^19.2.3",
     "@types/ws": "^8.18.1",
     "eslint": "^9.39.5",
-    "eslint-config-next": "^16.3.8",
+    "eslint-config-next": "^16.4.2",
     "husky": "^9.1.7",
     "jsdom": "^30.1.2",
     "prettier": "^3.7.4",

package/stores/shareUi.ts

@@ -3,12 +3,16 @@ import type { ShareTarget } from "@/data/shares";
 
 // What the share dialog is open on: a chat or an artifact, started from a
 // menu, the pane or the artifact card.
+// A page's version, when it has more than one, is named in the title; the
+// share is of that exact version.
+export type ShareUiTarget = ShareTarget & { title: string; version?: number };
+
 export const shareUi = proxy<{
-  target: (ShareTarget & { title: string }) | null;
+  target: ShareUiTarget | null;
 }>({ target: null });
 
 export const shareUiActions = {
-  open: (target: ShareTarget & { title: string }) => {
+  open: (target: ShareUiTarget) => {
     shareUi.target = target;
   },
   close: () => {