@saadnvd1/agent-os 0.3.654 → 0.3.658

package/app/api/health/env-failures/route.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { NextRequest } from "next/server";
+import { recordHit } from "@/lib/health/env/recordHit";
+import { resetEnv, seedSession } from "@/lib/health/env/helpers.test-util";
+import { GET, PATCH } from "./route";
+
+const get = (qs = "") =>
+  GET(new NextRequest(`http://localhost/api/health/env-failures${qs}`));
+const patch = (body: unknown) =>
+  PATCH(
+    new NextRequest("http://localhost/api/health/env-failures", {
+      method: "PATCH",
+      body: JSON.stringify(body),
+    })
+  );
+
+beforeEach(resetEnv);
+
+describe("/api/health/env-failures", () => {
+  it("counts sessions per class and lists a class's sessions", async () => {
+    seedSession("env-a");
+    recordHit(
+      "env-a",
+      "i",
+      { class: "python-not-found", line: "l", command: "python x" },
+      Date.now()
+    );
+    const summary = await (await get()).json();
+    const c = summary.classes.find(
+      (k: { id: string }) => k.id === "python-not-found"
+    );
+    expect([c.sessions7, c.sessions30]).toEqual([1, 1]);
+    const list = await (await get("?class=python-not-found")).json();
+    expect(
+      list.sessions.map((s: { sessionId: string }) => s.sessionId)
+    ).toEqual(["env-a"]);
+  });
+
+  it("refuses an unknown class or days", async () => {
+    expect((await get("?class=nope")).status).toBe(400);
+    expect((await get("?days=0")).status).toBe(400);
+  });
+
+  it("sets and clears this machine's fix text", async () => {
+    expect(
+      (await patch({ class: "python-not-found", fix: "Use uv." })).status
+    ).toBe(200);
+    let s = await (await get()).json();
+    let c = s.classes.find((k: { id: string }) => k.id === "python-not-found");
+    expect([c.fix, c.fixOverridden]).toEqual(["Use uv.", true]);
+    await patch({ class: "python-not-found", fix: null });
+    s = await (await get()).json();
+    c = s.classes.find((k: { id: string }) => k.id === "python-not-found");
+    expect(c.fixOverridden).toBe(false);
+    expect((await patch({ class: "nope", fix: "x" })).status).toBe(404);
+    expect(
+      (await patch({ class: "python-not-found", fix: "x".repeat(501) })).status
+    ).toBe(400);
+  });
+});

package/app/api/health/env-failures/route.ts

@@ -0,0 +1,51 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { ENV_CLASSES } from "@/lib/health/env/classes";
+import { setFix, MAX_FIX } from "@/lib/health/env/fixText";
+import { envSessions, envSummary } from "@/lib/health/env/summarize";
+
+const query = z.object({
+  class: z
+    .string()
+    .refine((c) => ENV_CLASSES.some((k) => k.id === c))
+    .optional(),
+  days: z.coerce.number().int().min(1).max(90).default(30),
+});
+
+// GET /api/health/env-failures - sessions per class and project over the
+// last 7 and 30 days. ?class=<id>[&days=30] lists that class's sessions.
+export function GET(request: NextRequest) {
+  const parsed = query.safeParse(
+    Object.fromEntries(request.nextUrl.searchParams)
+  );
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: "Unknown class or days" },
+      { status: 400 }
+    );
+  const { class: cls, days } = parsed.data;
+  return NextResponse.json(
+    cls ? { sessions: envSessions(cls, days) } : envSummary()
+  );
+}
+
+const patch = z.object({
+  class: z.string(),
+  fix: z.string().max(MAX_FIX).nullable(),
+});
+
+// PATCH /api/health/env-failures { class, fix } - this machine's own fix text
+// for a class; null puts the default back.
+export async function PATCH(request: NextRequest) {
+  const body = patch.safeParse(await request.json().catch(() => null));
+  if (!body.success)
+    return NextResponse.json(
+      {
+        error: `Send { class, fix: text up to ${MAX_FIX} characters, or null }`,
+      },
+      { status: 400 }
+    );
+  if (!setFix(body.data.class, body.data.fix))
+    return NextResponse.json({ error: "No such class" }, { status: 404 });
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,122 @@
+import { randomUUID } from "crypto";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+let available = true;
+const printed: string[] = [];
+vi.mock("@/lib/share/pdf", () => ({
+  pdfAvailable: async () => available,
+  renderPdf: async (html: string) => {
+    printed.push(html);
+    return Buffer.from("%PDF-1.4 fake");
+  },
+}));
+
+const pdf = await import("./route");
+const preview = await import("../preview/route");
+const { saveItem } = await import("@/lib/chat/store");
+const { seedSession } = await import("@/lib/orchestrator/testing");
+const { createProject } = await import("@/lib/projects");
+const { MAX_SHARE_BYTES } = await import("@/lib/share/render");
+
+const secret = ["gh", "p_", "b".repeat(36)].join("");
+
+const post = (url: string, body: unknown) =>
+  new Request(`http://localhost${url}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+function chat(extra = "") {
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp/p",
+  });
+  const id = seedSession({
+    projectId: project.id,
+    name: "Share me",
+    view: "chat",
+  });
+  saveItem(id, {
+    id: "u1",
+    kind: "user",
+    text: `key ${secret} keepme`,
+    createdAt: 1,
+  } as never);
+  saveItem(id, {
+    id: "a1",
+    kind: "assistant",
+    text: "```js\nconsole.log(1)\n```" + extra,
+    createdAt: 2,
+  } as never);
+  return id;
+}
+
+beforeEach(() => {
+  available = true;
+  printed.length = 0;
+});
+
+describe("POST /api/shares/pdf", () => {
+  it("returns a named PDF of the redacted page", async () => {
+    const id = chat();
+    const res = await pdf.POST(
+      post("/api/shares/pdf", { kind: "chat", sessionId: id })
+    );
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toBe("application/pdf");
+    expect(res.headers.get("content-disposition")).toBe(
+      'attachment; filename="share-me.pdf"'
+    );
+    expect(Buffer.from(await res.arrayBuffer()).toString()).toMatch(/^%PDF/);
+    expect(printed[0]).toContain("[secret]");
+    expect(printed[0]).not.toContain(secret);
+  });
+
+  it("prints the same page the preview shows, honouring leave-outs", async () => {
+    const id = chat();
+    const body = { kind: "chat", sessionId: id, dropIds: ["u1"] };
+    const p = await (
+      await preview.POST(post("/api/shares/preview", body))
+    ).json();
+    await pdf.POST(post("/api/shares/pdf", body));
+    expect(printed[0]).toBe(p.html);
+    expect(printed[0]).not.toContain("keepme");
+  });
+
+  it("refuses too-big input, bad bodies and an empty selection", async () => {
+    const big = await pdf.POST(
+      post("/api/shares/pdf", {
+        kind: "chat",
+        sessionId: chat("word ".repeat(MAX_SHARE_BYTES / 4)),
+      })
+    );
+    expect(big.status).toBe(413);
+    expect((await pdf.POST(post("/api/shares/pdf", {}))).status).toBe(400);
+    const id = chat();
+    const none = await pdf.POST(
+      post("/api/shares/pdf", {
+        kind: "chat",
+        sessionId: id,
+        dropIds: ["u1", "a1"],
+      })
+    );
+    expect(none.status).toBe(400);
+    expect(printed).toHaveLength(0);
+  });
+
+  it("says 501 with no browser, and preview then omits pdf", async () => {
+    const id = chat();
+    const body = { kind: "chat", sessionId: id };
+    const withBrowser = await (
+      await preview.POST(post("/api/shares/preview", body))
+    ).json();
+    expect(withBrowser.formats).toEqual(["pdf", "html", "md"]);
+    available = false;
+    expect((await pdf.POST(post("/api/shares/pdf", body))).status).toBe(501);
+    const without = await (
+      await preview.POST(post("/api/shares/preview", body))
+    ).json();
+    expect(without.formats).toEqual(["html", "md"]);
+  });
+});

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

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { renderPdf, pdfAvailable } from "@/lib/share/pdf";
+import { readJson, refuseDemo, fail, toResponse } from "@/lib/share/route";
+import { TOO_BIG, buildPage, parseRequest } from "@/lib/share/service";
+import { fileName } from "@/lib/share/view";
+
+// POST /api/shares/pdf - the preview's page as a PDF. Same body as preview.
+// Local work only; the response is application/pdf, named after the title.
+export async function POST(request: Request) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const read = await readJson(request);
+  if ("refused" in read) return read.refused;
+  try {
+    const req = parseRequest(read.body);
+    if (!(await pdfAvailable()))
+      return fail("PDF isn't available on this machine.", 501);
+    const page = await buildPage(req);
+    if (page.tooBig) return fail(TOO_BIG, 413);
+    const pdf = await renderPdf(page.html);
+    return new NextResponse(new Uint8Array(pdf), {
+      headers: {
+        "Content-Type": "application/pdf",
+        "Content-Disposition": `attachment; filename="${fileName(page.title, "pdf")}"`,
+        "Cache-Control": "no-store",
+      },
+    });
+  } catch (err) {
+    return toResponse(err);
+  }
+}

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

@@ -1,6 +1,8 @@
 import { NextResponse } from "next/server";
+import { pdfAvailable } from "@/lib/share/pdf";
 import { linked } from "@/lib/share/connect";
 import { readJson, refuseDemo, toResponse } from "@/lib/share/route";
+import type { ShareFormat } from "@/lib/share/view";
 import { buildPage, parseRequest } from "@/lib/share/service";
 
 // POST /api/shares/preview - exactly what a share would upload, redacted.
@@ -13,6 +15,8 @@ export async function POST(request: Request) {
   try {
     const req = parseRequest(read.body);
     const page = await buildPage(req);
+    const formats: ShareFormat[] = ["html", "md"];
+    if (await pdfAvailable()) formats.unshift("pdf");
     return NextResponse.json({
       html: page.html,
       markdown: page.markdown,
@@ -24,6 +28,7 @@ export async function POST(request: Request) {
       hits: page.hits,
       tooBig: page.tooBig,
       connectLinked: linked(),
+      formats,
     });
   } catch (err) {
     return toResponse(err);

package/components/Health/EnvFailures/ClassRow.tsx

@@ -0,0 +1,104 @@
+"use client";
+
+import { useState } from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
+import { useEnvSessions, useSetEnvFix } from "@/data/health";
+import type { EnvClassView } from "@/lib/health/env/types";
+import { SessionList } from "./SessionList";
+
+function Fix({ view }: { view: EnvClassView }) {
+  const save = useSetEnvFix();
+  const [draft, setDraft] = useState<string | null>(null);
+  if (draft === null)
+    return (
+      <div className="space-y-1">
+        <p className="text-sm font-medium">
+          Fix it sends {view.fixOverridden && "(this machine's text)"}
+        </p>
+        <p className="text-muted-foreground text-sm">
+          {view.fix ?? "None: recorded and escalated only."}
+        </p>
+        <Button
+          variant="outline"
+          className="min-h-11 md:min-h-8"
+          onClick={() => setDraft(view.fix ?? "")}
+        >
+          Edit
+        </Button>
+      </div>
+    );
+  const done = () => setDraft(null);
+  return (
+    <div className="space-y-2">
+      <Textarea
+        aria-label={`Fix text for ${view.label}`}
+        value={draft}
+        maxLength={500}
+        onChange={(e) => setDraft(e.target.value)}
+      />
+      <div className="flex gap-2">
+        <Button
+          className="min-h-11 md:min-h-8"
+          disabled={save.isPending}
+          onClick={() =>
+            save.mutate({ class: view.id, fix: draft }, { onSuccess: done })
+          }
+        >
+          Save
+        </Button>
+        {view.fixOverridden && (
+          <Button
+            variant="outline"
+            className="min-h-11 md:min-h-8"
+            disabled={save.isPending}
+            onClick={() =>
+              save.mutate({ class: view.id, fix: null }, { onSuccess: done })
+            }
+          >
+            Use default
+          </Button>
+        )}
+        <Button variant="ghost" className="min-h-11 md:min-h-8" onClick={done}>
+          Cancel
+        </Button>
+      </div>
+      {save.error && (
+        <p role="alert" className="text-destructive text-sm">
+          {save.error.message}
+        </p>
+      )}
+    </div>
+  );
+}
+
+export function ClassRow({ view }: { view: EnvClassView }) {
+  const [open, setOpen] = useState(false);
+  const sessions = useEnvSessions(view.id, open);
+  return (
+    <li className="border-border/60 border-b px-3 py-1 last:border-b-0">
+      <details onToggle={(e) => setOpen(e.currentTarget.open)}>
+        <summary className="flex min-h-11 cursor-pointer flex-wrap items-center gap-x-3 gap-y-1 text-sm">
+          <span className="font-medium">{view.label}</span>
+          <Badge variant="warning">{view.sessions7} in 7d</Badge>
+          <Badge variant="secondary">{view.sessions30} in 30d</Badge>
+          <span className="text-muted-foreground min-w-0 basis-full text-xs">
+            {view.projects
+              .slice(0, 4)
+              .map((p) => `${p.name} ${p.sessions7}/${p.sessions30}`)
+              .join(" · ")}
+          </span>
+        </summary>
+        <div className="space-y-3 pb-3">
+          <Fix view={view} />
+          <SessionList
+            pending={sessions.isPending}
+            error={sessions.error?.message}
+            sessions={sessions.data?.sessions ?? []}
+          />
+        </div>
+      </details>
+    </li>
+  );
+}

package/components/Health/EnvFailures/SessionList.tsx

@@ -0,0 +1,49 @@
+"use client";
+
+import { openSessionLink } from "@/components/Chat/session-link";
+import { compactTimeAgo } from "@/lib/session-meta";
+import { hrefWithSession } from "@/lib/session-url";
+import type { EnvSessionView } from "@/lib/health/env/types";
+
+export function SessionList({
+  sessions,
+  pending,
+  error,
+}: {
+  sessions: EnvSessionView[];
+  pending: boolean;
+  error?: string;
+}) {
+  if (pending)
+    return <div className="bg-muted/40 h-16 animate-pulse rounded-lg" />;
+  if (error)
+    return (
+      <p role="alert" className="text-destructive text-sm">
+        {error}
+      </p>
+    );
+  return (
+    <ul className="space-y-1">
+      {sessions.map((s) => (
+        <li key={s.sessionId} className="min-h-11 text-sm">
+          <a
+            href={hrefWithSession("/", s.sessionId)}
+            onClick={(e) => openSessionLink(e, s.sessionId)}
+            className="font-medium underline-offset-2 hover:underline"
+          >
+            {s.name}
+          </a>
+          <span className="text-muted-foreground">
+            {s.project ? ` · ${s.project}` : ""} ·{" "}
+            {compactTimeAgo(new Date(s.lastAt))} · fix {s.fix}
+          </span>
+          {s.command && (
+            <code className="text-muted-foreground block truncate text-xs">
+              {s.command}
+            </code>
+          )}
+        </li>
+      ))}
+    </ul>
+  );
+}

package/components/Health/EnvFailures/index.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { useEnvFailures } from "@/data/health";
+import { ClassRow } from "./ClassRow";
+
+// Environment failures sessions hit (wrong Python, refused writes, lost
+// permissions): how many sessions per class and project, and who.
+export function EnvFailures() {
+  const { data, isPending, error } = useEnvFailures();
+  const hit = data?.classes.filter((c) => c.sessions30 > 0) ?? [];
+  const quiet = data?.classes.filter((c) => c.sessions30 === 0) ?? [];
+  return (
+    <div className="space-y-3">
+      <p className="text-muted-foreground text-sm">
+        Sessions that hit a known environment failure, once per session and
+        class. Each gets the fix once; the orchestrator hears when a class
+        spikes or comes back.
+      </p>
+      {error && (
+        <p role="alert" className="text-destructive text-sm">
+          {error.message}
+        </p>
+      )}
+      {isPending && (
+        <div className="bg-muted/40 h-24 animate-pulse rounded-xl" />
+      )}
+      {data && hit.length === 0 && (
+        <p className="text-muted-foreground text-sm">
+          No environment failures in the last 30 days.
+        </p>
+      )}
+      {hit.length > 0 && (
+        <ul className="border-border/60 overflow-hidden rounded-xl border">
+          {hit.map((c) => (
+            <ClassRow key={c.id} view={c} />
+          ))}
+        </ul>
+      )}
+      {quiet.length > 0 && (
+        <p className="text-muted-foreground text-xs">
+          Watching, no hits: {quiet.map((c) => c.label).join(", ")}.
+        </p>
+      )}
+    </div>
+  );
+}

package/components/Health/HealthPanel.tsx

@@ -19,13 +19,22 @@ import {
   type CheckSummary,
 } from "@/lib/health/view";
 import { cn } from "@/lib/utils";
+import { EnvFailures } from "./EnvFailures";
 import { SweepRuns } from "./SweepRuns";
 
-const TABS = ["open", "history", "notes", "thresholds", "cleanup"] as const;
+const TABS = [
+  "open",
+  "history",
+  "env",
+  "notes",
+  "thresholds",
+  "cleanup",
+] as const;
 type Tab = (typeof TABS)[number];
 const TAB_LABEL: Record<Tab, string> = {
   open: "Open",
   history: "History",
+  env: "Environment",
   notes: "Notes",
   thresholds: "Thresholds",
   cleanup: "Clean-up",
@@ -407,6 +416,7 @@ export function HealthPanel() {
           empty="Nothing has closed in the last 7 days."
         />
       )}
+      {tab === "env" && <EnvFailures />}
       {tab === "notes" && <Notes />}
       {tab === "thresholds" && <Thresholds />}
       {tab === "cleanup" && <SweepRuns />}

package/components/Share/DownloadMenu.tsx

@@ -0,0 +1,112 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import {
+  ChevronDown,
+  Download,
+  FileCode,
+  FileText,
+  Loader2,
+  type LucideIcon,
+} from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import {
+  useSharePdf,
+  type PreviewRequest,
+  type SharePreview,
+} from "@/data/shares";
+import { fileName, type ShareFormat } from "@/lib/share/view";
+
+const FORMAT: Record<ShareFormat, { label: string; Icon: LucideIcon }> = {
+  pdf: { label: "PDF", Icon: FileText },
+  html: { label: "HTML page", Icon: FileCode },
+  md: { label: "Markdown", Icon: FileText },
+};
+
+function save(blob: Blob, name: string) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = name;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+// One Download button for every format the server says it can make. PDF is
+// printed server-side, so it shows a spinner; HTML and Markdown are in hand.
+export function DownloadMenu({
+  preview,
+  request,
+  title,
+  disabled,
+}: {
+  preview: SharePreview | null;
+  request: PreviewRequest;
+  title: string;
+  disabled: boolean;
+}) {
+  const pdf = useSharePdf();
+  const [open, setOpen] = useState(false);
+  const formats = preview?.formats ?? [];
+
+  const choose = async (format: ShareFormat) => {
+    if (!preview) return;
+    if (format === "pdf") {
+      try {
+        save(await pdf.mutateAsync(request), fileName(title, "pdf"));
+      } catch (err) {
+        toast.error((err as Error).message || "Couldn't make the PDF");
+      }
+      return;
+    }
+    const md = format === "md";
+    save(
+      new Blob([md ? preview.markdown : preview.html], {
+        type: md ? "text/markdown" : "text/html",
+      }),
+      fileName(title, format)
+    );
+  };
+
+  return (
+    <DropdownMenu open={open} onOpenChange={setOpen}>
+      <DropdownMenuTrigger asChild>
+        <Button
+          variant="outline"
+          className="min-h-11 flex-1 sm:flex-none"
+          disabled={disabled || !formats.length || pdf.isPending}
+        >
+          {pdf.isPending ? (
+            <Loader2 className="h-4 w-4 animate-spin" />
+          ) : (
+            <Download className="h-4 w-4" />
+          )}
+          {pdf.isPending ? "Making PDF…" : "Download"}
+          <ChevronDown className="h-4 w-4 opacity-60" />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="min-w-44">
+        {formats.map((f) => {
+          const { label, Icon } = FORMAT[f];
+          return (
+            <DropdownMenuItem
+              key={f}
+              className="min-h-11 gap-2"
+              onSelect={() => void choose(f)}
+            >
+              <Icon className="h-4 w-4" />
+              {label}
+            </DropdownMenuItem>
+          );
+        })}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}