@saadnvd1/agent-os 0.3.654 → 0.3.657

package/lib/health/env/types.ts

@@ -0,0 +1,73 @@
+// What the environment-failure detector knows and shows. Plain data, no I/O.
+
+export interface EnvClass {
+  id: string;
+  label: string;
+  // shell: only shell tools' output; guard: any tool's refused call.
+  scope: "shell" | "guard";
+  // Any of these, tested per line.
+  match: RegExp[];
+  // Also has to hold, tested on the whole output.
+  requires?: RegExp;
+  // Vetoes: a command or output that shows it isn't this machine's fault.
+  except?: { command?: RegExp; output?: RegExp };
+  // Sent once to a session that hit it; null means record and escalate only.
+  fix: string | null;
+}
+
+export interface EnvHit {
+  class: string;
+  line: string;
+  command: string;
+}
+
+export interface EnvFailureRow {
+  id: number;
+  session_id: string;
+  class: string;
+  project_id: string | null;
+  workspace_id: string | null;
+  command: string | null;
+  line: string | null;
+  last_item_id: string | null;
+  hits: number;
+  first_at: number;
+  last_at: number;
+  nudged_at: number | null;
+  nudge_skipped: string | null;
+  alerted: string | null;
+  alerted_at: number | null;
+}
+
+export interface EnvClassView {
+  id: string;
+  label: string;
+  fix: string | null;
+  fixOverridden: boolean;
+  sessions7: number;
+  sessions30: number;
+  projects: {
+    id: string | null;
+    name: string;
+    sessions7: number;
+    sessions30: number;
+  }[];
+}
+
+export interface EnvSummary {
+  now: number;
+  classes: EnvClassView[];
+}
+
+export interface EnvSessionView {
+  sessionId: string;
+  name: string;
+  project: string | null;
+  command: string | null;
+  line: string | null;
+  hits: number;
+  firstAt: number;
+  lastAt: number;
+  // "sent", or why not.
+  fix: string;
+}

package/lib/health/tick.ts

@@ -10,6 +10,7 @@ import { leaveHeartbeat } from "./boots";
 import { healthConfig, type HealthConfig } from "./config";
 import { runDetectors } from "./detectors";
 import { gatherFacts, liveBackgroundJobs } from "./facts";
+import { envTick, realEnv, type EnvDeps } from "./env/envTick";
 import { addNote } from "./notes";
 import { closeResolvedPieces } from "./pieces";
 import { deliver, deliverClosed, type RouteDeps, realRoute } from "./route";
@@ -52,6 +53,7 @@ export interface TickDeps {
   facts: (now: number, c: HealthConfig) => HealthFacts;
   watch: WatchDeps;
   route: RouteDeps;
+  env: EnvDeps;
   wake: typeof wake;
 }
 
@@ -60,6 +62,7 @@ export const realTick: TickDeps = {
   facts: gatherFacts,
   watch: { run: runClaude, usagePct: currentUsagePct },
   route: realRoute,
+  env: realEnv,
   wake,
 };
 
@@ -137,6 +140,9 @@ export function healthTick(
   closeResolvedPieces(now);
   leaveHeartbeat(now, liveBackgroundJobs());
   giveUpStale(now, deps);
+  void envTick(now, c, deps.env).catch((error) =>
+    console.error("[health] environment failures:", error)
+  );
 
   const running: Promise<void>[] = [];
   for (const row of openAnomalies()) {

package/lib/security/demo.ts

@@ -66,6 +66,7 @@ export const STATIC_SIBLINGS = [
   "me",
   "items",
   "network",
+  "pdf",
   "preview",
   "queue",
   "status",

package/lib/share/pdf.ts

@@ -0,0 +1,116 @@
+/**
+ * The share page as a PDF, printed by headless Chromium from the exact HTML
+ * the preview shows. One browser is launched lazily, reused, and closed after
+ * a quiet spell. Nothing on the page can reach the network: only the inlined
+ * markup is rendered.
+ */
+
+import fs from "fs";
+import type { Browser, LaunchOptions } from "playwright";
+
+const IDLE_MS = 60_000;
+const RENDER_MS = 30_000;
+
+const CHROME_PATHS = [
+  "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+  "/usr/bin/google-chrome",
+  "/usr/bin/google-chrome-stable",
+  "/usr/bin/chromium",
+  "/usr/bin/chromium-browser",
+];
+
+/** Print-only rules, added here so the HTML download stays as it was. */
+const PRINT_CSS = `
+@page{margin:16mm 14mm}
+html,body{background:#fff!important}
+.wrap{max-width:none;padding:0}
+*{-webkit-print-color-adjust:exact;print-color-adjust:exact}
+pre code,pre,details.tool pre{white-space:pre-wrap!important;word-break:break-word!important;overflow-wrap:anywhere;overflow:visible;max-height:none}
+table{display:table;width:100%;table-layout:auto;overflow-wrap:anywhere}
+pre,table,tr,.plan,.error,details.tool{break-inside:avoid-page}
+h1,h2,h3,h4{break-after:avoid}
+img{max-width:100%;break-inside:avoid}
+`;
+
+let found: LaunchOptions | null | undefined;
+
+/** How to launch a browser on this machine, or null when there is none. */
+export async function findBrowser(): Promise<LaunchOptions | null> {
+  if (found !== undefined) return found;
+  const { chromium } = await import("playwright");
+  const candidates = [chromium.executablePath(), ...CHROME_PATHS];
+  const path = candidates.find((p) => p && fs.existsSync(p));
+  found = path ? { executablePath: path, headless: true } : null;
+  return found;
+}
+
+export const pdfAvailable = async () => (await findBrowser()) !== null;
+
+/** Test hook: forget the cached lookup and any open browser. */
+export async function resetPdfBrowser() {
+  found = undefined;
+  await closeBrowser();
+}
+
+let browser: Promise<Browser> | null = null;
+let idle: NodeJS.Timeout | null = null;
+
+async function closeBrowser() {
+  if (idle) clearTimeout(idle);
+  idle = null;
+  const b = browser;
+  browser = null;
+  if (b) await (await b).close().catch(() => {});
+}
+
+async function getBrowser(): Promise<Browser> {
+  const opts = await findBrowser();
+  if (!opts) throw new Error("No browser to print with on this machine.");
+  if (!browser) {
+    const { chromium } = await import("playwright");
+    const launched = chromium.launch(opts);
+    browser = launched;
+    launched.then(
+      (b) =>
+        b.on("disconnected", () => browser === launched && (browser = null)),
+      () => {
+        if (browser === launched) browser = null;
+      }
+    );
+  }
+  return browser;
+}
+
+const withPrint = (html: string) =>
+  html.includes("</head>")
+    ? html.replace("</head>", () => `<style>${PRINT_CSS}</style></head>`)
+    : `<style>${PRINT_CSS}</style>${html}`;
+
+/** The page printed to an A4 PDF. */
+export async function renderPdf(html: string): Promise<Buffer> {
+  const b = await getBrowser();
+  if (idle) clearTimeout(idle);
+  const ctx = await b.newContext({
+    javaScriptEnabled: false,
+    colorScheme: "light",
+  });
+  try {
+    await ctx.setOffline(true);
+    const page = await ctx.newPage();
+    page.setDefaultTimeout(RENDER_MS);
+    await page.emulateMedia({ media: "print", colorScheme: "light" });
+    // "load" waits for images and fonts; scripts are off, so nothing runs after.
+    await page.setContent(withPrint(html), { waitUntil: "load" });
+    return Buffer.from(
+      await page.pdf({
+        format: "A4",
+        printBackground: true,
+        preferCSSPageSize: true,
+      })
+    );
+  } finally {
+    await ctx.close().catch(() => {});
+    idle = setTimeout(() => void closeBrowser(), IDLE_MS);
+    idle.unref();
+  }
+}

package/lib/share/view.ts

@@ -22,6 +22,9 @@ export interface PreviewItem {
   excerpt: string;
 }
 
+/** Download formats a server can make; the client lists what it is told. */
+export type ShareFormat = "pdf" | "html" | "md";
+
 export interface SharePreview {
   html: string;
   markdown: string;
@@ -33,6 +36,8 @@ export interface SharePreview {
   hits: Record<"secret" | "path" | "ip" | "host" | "email", number>;
   tooBig: boolean;
   connectLinked: boolean;
+  /** Best first. pdf only when this machine has a browser to print with. */
+  formats: ShareFormat[];
 }
 
 export interface SharedLinkRow {
@@ -103,7 +108,10 @@ export function formatBytes(n: number): string {
 }
 
 /** A file name for a download: the title, plain, with .html (or `ext`). */
-export function fileName(title: string, ext: "html" | "md" = "html"): string {
+export function fileName(
+  title: string,
+  ext: "html" | "md" | "pdf" = "html"
+): string {
   const slug = title
     .toLowerCase()
     .replace(/[^a-z0-9]+/g, "-")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.654",
+  "version": "0.3.657",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"
@@ -31,10 +31,12 @@
   "scripts": {
     "predev": "node scripts/ensure-native.mjs && node scripts/gen-migrations-index.mjs",
     "dev": "AGENTOS_DEV=1 tsx server.ts",
+    "dev:task": "tsx scripts/dev-task.ts",
+    "dev:stop": "tsx scripts/dev-stop.ts",
     "prebuild": "node scripts/gen-migrations-index.mjs",
     "build": "next build",
     "prestart": "node scripts/ensure-native.mjs && node scripts/gen-migrations-index.mjs",
-    "start": "NODE_ENV=production tsx server.ts",
+    "start": "NODE_ENV=production AGENTOS_SERVER=live node --import tsx server.ts",
     "pretypecheck": "node scripts/gen-migrations-index.mjs",
     "typecheck": "tsc --noEmit",
     "setup": "bash scripts/setup.sh",
@@ -141,6 +143,7 @@
     "next": "^16.3.8",
     "next-themes": "^0.4.6",
     "node-pty": "^1.2.0-beta.6",
+    "playwright": "^1.63.0",
     "qrcode": "^1.5.4",
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
@@ -171,7 +174,6 @@
     "eslint-config-next": "^16.3.8",
     "husky": "^9.1.7",
     "jsdom": "^30.1.2",
-    "playwright": "^1.63.0",
     "prettier": "^3.7.4",
     "prettier-plugin-tailwindcss": "^0.7.2",
     "sharp": "^0.35.5",

package/scripts/dev-stop.ts

@@ -0,0 +1,7 @@
+import fs from "fs";
+import { stopDevServer } from "@/lib/dev-instance";
+
+stopDevServer(fs.realpathSync(process.cwd())).then((r) => {
+  console.log(r.message);
+  process.exit(r.ok ? 0 : 1);
+});

package/scripts/dev-task.ts

@@ -0,0 +1,16 @@
+import fs from "fs";
+import { startDevServer } from "@/lib/dev-instance";
+
+const i = process.argv.indexOf("--port");
+const requested = i === -1 ? undefined : Number(process.argv[i + 1]);
+
+startDevServer({ worktree: fs.realpathSync(process.cwd()), requested })
+  .then((r) =>
+    console.log(
+      `Dev server ${r.reused ? "already running" : "started"}: pid ${r.pid} on http://localhost:${r.port} (log ${r.log}). Stop it with npm run dev:stop.`
+    )
+  )
+  .catch((e: Error) => {
+    console.error(e.message);
+    process.exit(1);
+  });

package/scripts/screenshots/demo.ts

@@ -11,7 +11,7 @@
  */
 import fs from "fs";
 import path from "path";
-import { execFileSync, spawn } from "child_process";
+import { spawnServer } from "@/lib/dev-instance";
 import { PORT, REPO, demoEnv } from "./config";
 import { seed, teardownTmux } from "./seed";
 import { startPeer } from "./peer";
@@ -35,13 +35,9 @@ async function main() {
       process.env[k] ? [[k, process.env[k]!]] : []
     )
   );
-  // server.ts imports the generated migrations index.
-  execFileSync(process.execPath, ["scripts/gen-migrations-index.mjs"], {
-    cwd: REPO,
-  });
-  const tsx = path.join(REPO, "node_modules", "tsx", "dist", "cli.mjs");
-  const server = spawn(process.execPath, [tsx, "server.ts"], {
-    cwd: REPO,
+  const server = spawnServer({
+    repo: REPO,
+    port: PORT,
     env: demoEnv({
       AGENTOS_BIND: "127.0.0.1",
       ...passed,

package/scripts/screenshots/run.ts

@@ -8,7 +8,8 @@
  */
 import fs from "fs";
 import path from "path";
-import { execFileSync, spawn, type ChildProcess } from "child_process";
+import { type ChildProcess } from "child_process";
+import { spawnServer } from "@/lib/dev-instance";
 import { BASE_URL, PORT, REPO, ROOT, demoEnv } from "./config";
 import { seed, teardownTmux } from "./seed";
 import { shoot } from "./shoot";
@@ -38,14 +39,10 @@ async function waitForServer(server: ChildProcess): Promise<void> {
 
 function startServer(): ChildProcess {
   const log = fs.openSync(path.join(ROOT, "server.log"), "w");
-  // server.ts imports the generated migrations index.
-  execFileSync(process.execPath, ["scripts/gen-migrations-index.mjs"], {
-    cwd: REPO,
-  });
-  const tsx = path.join(REPO, "node_modules", "tsx", "dist", "cli.mjs");
   // Loopback only: the demo never listens on another network.
-  return spawn(process.execPath, [tsx, "server.ts"], {
-    cwd: REPO,
+  return spawnServer({
+    repo: REPO,
+    port: PORT,
     // No watchers: the seeded orchestrator and tasks must sit still, never
     // start an agent.
     env: demoEnv({

package/server.ts

@@ -78,6 +78,11 @@ import { failInterruptedSetups } from "./lib/sessions/worktree-setup";
 import { sweepOrphanTmux } from "./lib/tmux/orphans";
 import { releaseInterruptedClaims } from "./lib/orchestrator/ask-approvals";
 import { resumeReviews } from "./lib/orchestrator/review";
+import {
+  isLiveServer,
+  readLiveRecord,
+  writeLiveRecord,
+} from "./lib/dev-instance";
 import { claimAgentosEnv } from "./lib/agents/self-env";
 import { wslNotes, wslVersion } from "./lib/wsl";
 import { getAllProjects } from "./lib/projects";
@@ -89,6 +94,19 @@ const hostname = "127.0.0.1";
 
 // Support: npm run dev -- -p 3012
 const port = serverPort();
+const live = isLiveServer();
+// A distinct title keeps `pkill -f server.ts` and `pkill tsx` off the
+// production server; an AgentOS in a worktree can't take its port.
+process.title = live ? "agentos-server" : "agentos-dev";
+if (!live) {
+  const rec = readLiveRecord();
+  if (rec && rec.port === port && rec.pid !== process.pid) {
+    console.error(
+      `Refusing to start: port ${port} is the live AgentOS server (pid ${rec.pid}). Use npm run dev:task.`
+    );
+    process.exit(1);
+  }
+}
 claimAgentosEnv(port);
 // Demo mode: seeded data, nothing that runs code (lib/security/demo).
 const demo = demoMode();
@@ -302,6 +320,13 @@ app.prepare().then(async () => {
     });
     server.listen(port, address, () => {
       console.log(`> Agent-OS ready on http://${address}:${port}`);
+      if (live)
+        writeLiveRecord({
+          pid: process.pid,
+          port,
+          cwd: process.cwd(),
+          startedAt: Date.now(),
+        });
     });
   };
   const stopListening = (address: string) => {