@saadnvd1/agent-os 0.3.595 → 0.3.596

package/lib/session-artifacts/peer.ts

@@ -0,0 +1,187 @@
+/**
+ * A linked machine's session: its chat and files are there, so its own
+ * AgentOS lists and serves them, with its own roots and secret filter. What
+ * comes back is checked field by field and re-served with this machine's
+ * headers, never passed through as it came.
+ */
+
+import { ARTIFACT_HEADERS } from "../artifacts/serve";
+import { IMAGE_TYPES } from "../artifacts/image-paths";
+import { IMAGE_CSP } from "../artifacts/serve";
+import { cleanRemoteText, hostApi, type HostLink } from "../hosts/remote-api";
+import type {
+  ArtifactKind,
+  ArtifactPreview,
+  ArtifactState,
+  SessionArtifact,
+} from "./types";
+import type { Content } from "./serve";
+
+const MAX_PEER_ARTIFACTS = 1000;
+export const MAX_PEER_BYTES = 20 * 1024 * 1024;
+
+const KINDS = new Set<ArtifactKind>([
+  "plan",
+  "file",
+  "page",
+  "image",
+  "log",
+  "pr",
+  "run",
+  "session-log",
+]);
+const STATES = new Set<ArtifactState>([
+  "live",
+  "kept",
+  "in-pr",
+  "gone",
+  "outside",
+]);
+const PREVIEWS = new Set<ArtifactPreview>([
+  "markdown",
+  "html",
+  "image",
+  "text",
+  "none",
+]);
+const ID = /^[0-9a-f]{16}$/;
+
+const num = (v: unknown) =>
+  typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : undefined;
+
+export function cleanPeerArtifact(raw: unknown): SessionArtifact | null {
+  const a = raw as Record<string, unknown> | null;
+  if (!a || typeof a !== "object") return null;
+  if (typeof a.id !== "string" || !ID.test(a.id)) return null;
+  if (!KINDS.has(a.kind as ArtifactKind)) return null;
+  if (!STATES.has(a.state as ArtifactState)) return null;
+  if (!PREVIEWS.has(a.preview as ArtifactPreview)) return null;
+  const url =
+    typeof a.url === "string" && /^https:\/\//.test(a.url)
+      ? cleanRemoteText(a.url)
+      : undefined;
+  return {
+    id: a.id,
+    kind: a.kind as ArtifactKind,
+    name: cleanRemoteText(a.name) || "Untitled",
+    ...(typeof a.path === "string" && { path: cleanRemoteText(a.path) }),
+    at: num(a.at) ?? 0,
+    ...(num(a.size) !== undefined && { size: num(a.size) }),
+    ...(num(a.edits) && { edits: num(a.edits) }),
+    state: a.state as ArtifactState,
+    preview: a.preview as ArtifactPreview,
+    ...((a.by === "you" || a.by === "shell") && { by: a.by }),
+    ...(typeof a.detail === "string" && { detail: cleanRemoteText(a.detail) }),
+    ...(typeof a.folder === "string" && { folder: cleanRemoteText(a.folder) }),
+    ...(url && { url }),
+  };
+}
+
+export async function peerArtifacts(
+  link: HostLink,
+  sessionId: string
+): Promise<SessionArtifact[]> {
+  const { artifacts } = await hostApi<{ artifacts?: unknown }>(
+    link,
+    `/api/sessions/${encodeURIComponent(sessionId)}/artifacts`
+  );
+  if (!Array.isArray(artifacts)) return [];
+  return artifacts
+    .slice(0, MAX_PEER_ARTIFACTS)
+    .map(cleanPeerArtifact)
+    .filter((a): a is SessionArtifact => !!a);
+}
+
+async function readBytes(
+  res: Response,
+  max: number
+): Promise<Uint8Array<ArrayBuffer>> {
+  if (Number(res.headers.get("content-length")) > max)
+    throw new Error("too large");
+  const reader = res.body?.getReader();
+  if (!reader) return new Uint8Array();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > max) {
+      await reader.cancel().catch(() => undefined);
+      throw new Error("too large");
+    }
+    chunks.push(value);
+  }
+  return new Uint8Array(Buffer.concat(chunks));
+}
+
+const IMAGE_MEDIA = new Set(Object.values(IMAGE_TYPES));
+const TEXT_HEADERS = (type: string) => ({
+  "Content-Type": `${type}; charset=utf-8`,
+  "Content-Security-Policy": "default-src 'none'; sandbox",
+  "X-Content-Type-Options": "nosniff",
+  "Cache-Control": "private, no-cache",
+});
+
+// Our own headers for what the peer says it is; anything else is refused.
+export function peerHeaders(
+  contentType: string
+): Record<string, string> | null {
+  const type = contentType.split(";")[0].trim().toLowerCase();
+  if (type === "text/html") return ARTIFACT_HEADERS;
+  if (type === "text/plain" || type === "text/markdown")
+    return TEXT_HEADERS(type);
+  if (IMAGE_MEDIA.has(type))
+    return {
+      "Content-Type": type,
+      "Content-Security-Policy": IMAGE_CSP,
+      "X-Content-Type-Options": "nosniff",
+      "Cache-Control": "private, no-cache",
+    };
+  return null;
+}
+
+export async function peerContent(
+  link: HostLink,
+  sessionId: string,
+  artifactId: string
+): Promise<Content> {
+  if (!ID.test(artifactId))
+    return { ok: false, status: 404, error: "Not found" };
+  let res: Response;
+  try {
+    res = await fetch(
+      `${link.url}/api/sessions/${encodeURIComponent(sessionId)}/artifacts/${artifactId}`,
+      {
+        headers: { Authorization: `Bearer ${link.token}` },
+        signal: AbortSignal.timeout(20_000),
+        redirect: "error",
+      }
+    );
+  } catch {
+    return {
+      ok: false,
+      status: 502,
+      error: `Can't reach AgentOS on ${link.hostName}`,
+    };
+  }
+  if (!res.ok) {
+    await res.body?.cancel().catch(() => undefined);
+    return {
+      ok: false,
+      status: res.status === 404 || res.status === 403 ? res.status : 502,
+      error: `${link.hostName}: HTTP ${res.status}`,
+    };
+  }
+  const headers = peerHeaders(res.headers.get("content-type") ?? "");
+  if (!headers) {
+    await res.body?.cancel().catch(() => undefined);
+    return { ok: false, status: 502, error: "Unexpected content" };
+  }
+  try {
+    const body = await readBytes(res, MAX_PEER_BYTES);
+    return { ok: true, body, headers };
+  } catch {
+    return { ok: false, status: 502, error: "Too large" };
+  }
+}

package/lib/session-artifacts/serve.ts

@@ -0,0 +1,265 @@
+/**
+ * What opening an artifact returns. Every file is checked again here (real
+ * path, roots, secrets, size), whatever the list said; HTML is served as
+ * agent output in the same sandbox as a rendered page.
+ */
+
+import fs from "fs";
+import os from "os";
+import { db, type Session } from "../db";
+import { getItem } from "../chat/store";
+import { findOutputFile } from "../chat/task-output";
+import {
+  getArtifact,
+  readArtifactHtml,
+  MAX_HTML_BYTES,
+} from "../artifacts/store";
+import { MAX_IMAGE_BYTES } from "../artifacts/images";
+import { IMAGE_TYPES } from "../artifacts/image-paths";
+import {
+  ARTIFACT_HEADERS,
+  IMAGE_CSP,
+  prepareArtifact,
+} from "../artifacts/serve";
+import { demoMode } from "../security/demo";
+import { run } from "../tasks/gh";
+import { repoOfPR } from "../tasks/pr-activity";
+import { resolveAllowed } from "./access";
+import { previewFor, type Entry } from "./derive";
+import { rootsOf } from "./collect";
+
+export const MAX_TEXT_BYTES = 256 * 1024;
+export const LOG_TAIL_BYTES = 64 * 1024;
+
+export type Content =
+  | {
+      ok: true;
+      body: Uint8Array<ArrayBuffer> | string;
+      headers: Record<string, string>;
+    }
+  | { ok: false; status: number; error: string };
+
+const TEXT_CSP = "default-src 'none'; sandbox";
+
+const textHeaders = (type: string, truncated = false) => ({
+  "Content-Type": `${type}; charset=utf-8`,
+  "Content-Security-Policy": TEXT_CSP,
+  "X-Content-Type-Options": "nosniff",
+  "Cache-Control": "private, no-cache",
+  ...(truncated && { "X-Artifact-Truncated": "1" }),
+});
+
+const imageHeaders = (type: string) => ({
+  "Content-Type": type,
+  "Content-Security-Policy": IMAGE_CSP,
+  "X-Content-Type-Options": "nosniff",
+  "Cache-Control": "private, no-cache",
+});
+
+const IMAGE_MEDIA = new Set(Object.values(IMAGE_TYPES));
+const fail = (status: number, error: string): Content => ({
+  ok: false,
+  status,
+  error,
+});
+const markdown = (text: string): Content => ({
+  ok: true,
+  body: text,
+  headers: textHeaders("text/markdown"),
+});
+
+// Bytes from a file: its head, or its tail for a log.
+function readSlice(file: string, size: number, max: number, tail: boolean) {
+  const len = Math.min(size, max);
+  const buf = Buffer.alloc(len);
+  const fd = fs.openSync(file, "r");
+  try {
+    fs.readSync(fd, buf, 0, len, tail ? size - len : 0);
+  } finally {
+    fs.closeSync(fd);
+  }
+  return buf;
+}
+
+const binary = (buf: Buffer) => buf.subarray(0, 8000).includes(0);
+
+function serveFile(file: string, roots: string[], asLog = false): Content {
+  const hit = resolveAllowed(file, roots);
+  if (!hit.ok)
+    return fail(hit.status, hit.status === 403 ? "Not served" : "Not found");
+  const kind = asLog ? "text" : previewFor(hit.real);
+  if (kind === "image") {
+    const ext = hit.real.split(".").pop()!.toLowerCase();
+    if (hit.size > MAX_IMAGE_BYTES) return fail(413, "Too large");
+    return {
+      ok: true,
+      body: new Uint8Array(fs.readFileSync(hit.real)),
+      headers: imageHeaders(IMAGE_TYPES[ext]),
+    };
+  }
+  if (kind === "html") {
+    if (hit.size > MAX_HTML_BYTES) return fail(413, "Too large");
+    return {
+      ok: true,
+      body: prepareArtifact(fs.readFileSync(hit.real, "utf8")),
+      headers: ARTIFACT_HEADERS,
+    };
+  }
+  const max = asLog ? LOG_TAIL_BYTES : MAX_TEXT_BYTES;
+  const buf = readSlice(hit.real, hit.size, max, asLog);
+  if (binary(buf)) return fail(415, "Not a text file");
+  let text = buf.toString("utf8");
+  // A tail starts mid-line; drop the partial one.
+  if (asLog && hit.size > max) text = text.slice(text.indexOf("\n") + 1);
+  return {
+    ok: true,
+    body: text,
+    headers: textHeaders(
+      kind === "markdown" ? "text/markdown" : "text/plain",
+      hit.size > max
+    ),
+  };
+}
+
+interface Commit {
+  oid?: string;
+  messageHeadline?: string;
+}
+
+async function prMarkdown(session: Session): Promise<string> {
+  const lines = [
+    `# ${session.pr_number ? `PR #${session.pr_number}` : "Pull request"}`,
+    "",
+    `Status: **${session.pr_status ?? "open"}**`,
+  ];
+  if (session.pr_url) lines.push("", session.pr_url);
+  const repo = session.pr_url ? repoOfPR(session.pr_url) : null;
+  if (!repo || !session.pr_number || demoMode()) return lines.join("\n");
+  try {
+    const out = await run(
+      "gh",
+      [
+        "pr",
+        "view",
+        String(session.pr_number),
+        "--repo",
+        `${repo.owner}/${repo.name}`,
+        "--json",
+        "commits",
+      ],
+      os.tmpdir(),
+      15_000
+    );
+    const commits = (JSON.parse(out).commits ?? []) as Commit[];
+    lines.push("", `## Commits (${commits.length})`, "");
+    for (const c of commits)
+      lines.push(
+        `- \`${String(c.oid ?? "").slice(0, 7)}\` ${String(c.messageHeadline ?? "").replace(/\n/g, " ")}`
+      );
+  } catch {
+    lines.push("", "_Couldn't load its commits from GitHub._");
+  }
+  return lines.join("\n");
+}
+
+function runMarkdown(runId: number, sessionId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT r.status, r.summary, r.outputs, r.error, r.duration_ms, r.pr_url,
+              x.name AS recipe_name
+         FROM recipe_runs r LEFT JOIN recipes x ON x.id = r.recipe_id
+        WHERE r.id = ? AND r.session_id = ?`
+    )
+    .get(runId, sessionId) as
+    | {
+        status: string;
+        summary: string | null;
+        outputs: string | null;
+        error: string | null;
+        duration_ms: number | null;
+        pr_url: string | null;
+        recipe_name: string | null;
+      }
+    | undefined;
+  if (!row) return null;
+  const lines = [
+    `# ${row.recipe_name ? `Recipe run: ${row.recipe_name}` : "Recipe run"}`,
+    "",
+    `Status: **${row.status}**${row.duration_ms ? ` · ${Math.round(row.duration_ms / 1000)}s` : ""}`,
+  ];
+  if (row.pr_url) lines.push("", row.pr_url);
+  if (row.summary) lines.push("", "## Summary", "", row.summary);
+  if (row.outputs) {
+    let pretty = row.outputs;
+    try {
+      pretty = JSON.stringify(JSON.parse(row.outputs), null, 2);
+    } catch {
+      // Shown as stored.
+    }
+    lines.push("", "## Outputs", "", "```json", pretty, "```");
+  }
+  if (row.error) lines.push("", "## Error", "", row.error);
+  return lines.join("\n");
+}
+
+export async function artifactContent(
+  session: Session,
+  entry: Entry
+): Promise<Content> {
+  const roots = rootsOf(session);
+  const { source } = entry;
+  const state = entry.artifact.state;
+  if (state === "outside") return fail(403, "Outside what AgentOS serves");
+  switch (source.type) {
+    case "page": {
+      const page = getArtifact(source.artifactId);
+      if (!page || page.session_id !== session.id)
+        return fail(404, "Not found");
+      const html = await readArtifactHtml(page);
+      if (html === null) return fail(404, "Not found");
+      return {
+        ok: true,
+        body: prepareArtifact(html),
+        headers: ARTIFACT_HEADERS,
+      };
+    }
+    case "file":
+      return entry.read ? serveFile(entry.read, roots) : fail(404, "Gone");
+    case "plan": {
+      if (entry.read) return serveFile(entry.read, roots);
+      const item = source.chatItemId
+        ? getItem(session.id, source.chatItemId)
+        : undefined;
+      return item?.kind === "plan" ? markdown(item.plan) : fail(404, "Gone");
+    }
+    case "log": {
+      const file = entry.read ?? findOutputFile(source.taskId);
+      return file ? serveFile(file, roots, true) : fail(404, "No output yet");
+    }
+    case "attached": {
+      const item = getItem(session.id, source.itemId);
+      const image = item?.kind === "user" ? item.images?.[source.index] : null;
+      if (!image || !IMAGE_MEDIA.has(image.mediaType))
+        return fail(404, "Not found");
+      const data = Buffer.from(image.data, "base64");
+      if (data.length > MAX_IMAGE_BYTES) return fail(413, "Too large");
+      return {
+        ok: true,
+        body: new Uint8Array(data),
+        headers: imageHeaders(image.mediaType),
+      };
+    }
+    case "pr":
+      return markdown(await prMarkdown(session));
+    case "run": {
+      const text = runMarkdown(source.runId, session.id);
+      return text === null ? fail(404, "Not found") : markdown(text);
+    }
+    case "session-log": {
+      const row = db
+        .prepare(`SELECT markdown FROM session_logs WHERE session_id = ?`)
+        .get(session.id) as { markdown: string } | undefined;
+      return row ? markdown(row.markdown) : fail(404, "Not found");
+    }
+  }
+}

package/lib/session-artifacts/types.ts

@@ -0,0 +1,43 @@
+// What a session produced, as the Artifacts view lists it. Client-safe.
+
+export type ArtifactKind =
+  | "plan"
+  | "file"
+  | "page"
+  | "image"
+  | "log"
+  | "pr"
+  | "run"
+  | "session-log";
+
+// live: there to open. kept: its worktree went, a copy was kept. in-pr:
+// committed, so the PR has it. gone: nothing left to open. outside: there,
+// but outside what the app serves.
+export type ArtifactState = "live" | "kept" | "in-pr" | "gone" | "outside";
+
+export type ArtifactPreview = "markdown" | "html" | "image" | "text" | "none";
+
+export interface SessionArtifact {
+  id: string;
+  kind: ArtifactKind;
+  name: string;
+  // Where it is, ~ for home; files, images, logs and plan files only.
+  path?: string;
+  // When it last changed in the chat (ms).
+  at: number;
+  size?: number;
+  edits?: number;
+  state: ArtifactState;
+  preview: ArtifactPreview;
+  // You attached it, or a shell command (not an edit tool) made it.
+  by?: "you" | "shell";
+  // A short line under the name: a PR's status, a job's state.
+  detail?: string;
+  // Its folder inside the worktree, "" at the top.
+  folder?: string;
+  // A link out (the PR on GitHub).
+  url?: string;
+}
+
+export const openable = (a: Pick<SessionArtifact, "state" | "preview">) =>
+  (a.state === "live" || a.state === "kept") && a.preview !== "none";

package/lib/tasks/finish.ts

@@ -36,6 +36,7 @@ import { dropSessionDatabase } from "../project-config/database";
 import { captureMergedTask } from "../session-logs";
 import { sessionEnded } from "../experiments/hooks";
 import { snapshotWorktree } from "../resurrect/snapshot";
+import { keepSessionFiles } from "../session-artifacts/collect";
 
 // Never deleted, whatever a setting says.
 export const PROTECTED_BRANCHES = new Set(["main", "master", "HEAD"]);
@@ -60,6 +61,7 @@ async function cleanup(
     if (fate?.action === "kept")
       console.log(`[tasks] kept ${fate.path} after merge: ${fate.why}`);
   } else if (session.worktree_path) {
+    await keepSessionFiles(session.id);
     await deleteWorktree(session.worktree_path, repo, true).catch(() => {});
   }
   // A stacked child's PR targets this branch: deleting it on origin would

package/package.json

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