@saadnvd1/agent-os 0.3.558 → 0.3.561

package/README.md

@@ -20,6 +20,7 @@ and check on all of it from your phone.
 - **Built for your phone.** The whole app works on a phone; pair it with a QR code. [More](docs/guides/phone.md)
 - **Agents that talk to each other.** Sessions message each other with `aos`, and you see every conversation in Messages. [More](docs/guides/agent-network.md)
 - **Chat or terminal, same conversation.** Streaming replies, steps and diffs, plan mode, slash commands, `@file`, undo. [More](docs/guides/chat.md)
+- **Share a chat or a page.** A read-only snapshot link with secrets, home paths and machine names masked, and a preview before anything leaves your machine. [More](docs/guides/sharing.md)
 - **Project config.** `agentos.json` gives each session its own ports, environment, files and a private Postgres copy. [More](docs/reference/project-config.md)
 - **Schedules and recipes.** Start work on a timer, or save a job that comes up again. [More](docs/guides/schedules.md)
 - **Plans in pieces and stacks.** A plan splits into several PRs only for a real reason; a board can run as stacked PRs. [More](docs/guides/tasks.md#plans-in-pieces)

package/app/api/sessions/route.ts

@@ -10,9 +10,9 @@ import { isProjectRef } from "@/lib/tasks/project-ref";
 export async function GET() {
   try {
     const db = getDb();
-    // Merged and dropped tasks live in the Tasks panel (a moved one lives on
-    // the machine it moved to), archived sessions
-    // in the Archived view: neither is in the sidebar.
+    // Merged tasks are listed (the sidebar files them under Done). Dropped
+    // tasks live in the Tasks panel, a moved one on the machine it moved to,
+    // and archived sessions in the Archived view: none is in the sidebar.
     const sessions = queries.getSidebarSessions(db).all() as Session[];
     const groups = queries.getAllGroups(db).all() as Group[];
 

package/app/api/shares/[id]/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { NOT_LINKED, linked, revokeRemote } from "@/lib/share/connect";
+import { fail, refuseDemo, toResponse } from "@/lib/share/route";
+import { getSharedLink, markRevoked } from "@/lib/share/store";
+
+// DELETE /api/shares/[id] - revoke a link: Connect deletes the page at once.
+export async function DELETE(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const { id } = await params;
+  if (!getSharedLink(id)) return fail("No such shared link.", 404);
+  if (!linked()) return fail(NOT_LINKED, 409);
+  try {
+    await revokeRemote(id);
+    markRevoked(id);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    return toResponse(err);
+  }
+}

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

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { linked } from "@/lib/share/connect";
+import { readJson, refuseDemo, toResponse } from "@/lib/share/route";
+import { buildPage, parseRequest } from "@/lib/share/service";
+
+// POST /api/shares/preview - exactly what a share would upload, redacted.
+// Local work only: nothing goes to Connect until a share is created.
+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);
+    const page = await buildPage(req);
+    return NextResponse.json({
+      html: page.html,
+      title: page.title,
+      bytes: page.bytes,
+      hash: page.hash,
+      sharedAt: req.sharedAt,
+      items: page.items,
+      hits: page.hits,
+      tooBig: page.tooBig,
+      connectLinked: linked(),
+    });
+  } catch (err) {
+    return toResponse(err);
+  }
+}

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

@@ -0,0 +1,455 @@
+import crypto from "crypto";
+import fs from "fs";
+import http from "http";
+import os from "os";
+import path from "path";
+import type { AddressInfo } from "net";
+import { randomUUID } from "crypto";
+import { afterAll, beforeEach, describe, expect, it } from "vitest";
+
+// A fake Connect that verifies each signed request against the machine's key.
+const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agentos-share-route-"));
+const keys = crypto.generateKeyPairSync("ed25519");
+const publicPem = keys.publicKey
+  .export({ type: "spki", format: "pem" })
+  .toString();
+const privatePem = keys.privateKey
+  .export({ type: "pkcs8", format: "pem" })
+  .toString();
+const MACHINE = "abcd1234";
+const HOST = "m-0123456789abcdef.runagentos.com";
+
+interface Seen {
+  method: string;
+  url: string;
+  body: string;
+  signed: boolean;
+}
+let seen: Seen[] = [];
+let down = false;
+let remote: Record<string, unknown>[] = [];
+const server = http.createServer((req, res) => {
+  let body = "";
+  req.on("data", (c) => (body += c));
+  req.on("end", () => {
+    const h = (k: string) => String(req.headers[k] ?? "");
+    const message = [
+      "agentos-connect-api",
+      req.method,
+      req.url,
+      h("x-connect-timestamp"),
+      h("x-connect-nonce"),
+      crypto.createHash("sha256").update(body).digest("hex"),
+    ].join("\n");
+    const signed = crypto.verify(
+      null,
+      Buffer.from(message),
+      publicPem,
+      Buffer.from(h("x-connect-signature"), "base64url")
+    );
+    seen.push({ method: req.method!, url: req.url!, body, signed });
+    const send = (code: number, json: unknown) =>
+      res
+        .writeHead(code, { "Content-Type": "application/json" })
+        .end(JSON.stringify(json));
+    if (!signed) return send(401, { error: "bad signature" });
+    if (down) return send(503, { error: "down" });
+    const base = `/api/v1/machines/${MACHINE}/shares`;
+    if (req.method === "POST" && req.url === base) {
+      const b = JSON.parse(body);
+      const s = {
+        id: "abcdefghijkl",
+        kind: b.kind,
+        title: b.title,
+        status: "active",
+        byte_size: body.length,
+        view_count: 0,
+        last_viewed_at: null,
+        created_at: new Date().toISOString(),
+        expires_at:
+          b.expires_in === "never"
+            ? null
+            : new Date(Date.now() + 7 * 864e5).toISOString(),
+      };
+      remote = [{ ...s, view_count: 3 }];
+      return send(201, {
+        ...s,
+        url: `https://runagentos.com/s/${"T".repeat(32)}`,
+      });
+    }
+    if (req.method === "GET" && req.url === base)
+      return send(200, { shares: remote });
+    if (req.method === "DELETE" && req.url === `${base}/abcdefghijkl`) {
+      remote = remote.map((s) => ({ ...s, status: "revoked" }));
+      return send(200, remote[0]);
+    }
+    send(404, { error: "no such share" });
+  });
+});
+await new Promise<void>((r) => server.listen(0, "127.0.0.1", r));
+process.env.AGENTOS_CONNECT_DIR = dir;
+process.env.CONNECT_API_URL = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+process.env.AGENTOS_CONNECT_OPERATOR = "1";
+process.env.AGENTOS_ARTIFACTS_DIR = fs.mkdtempSync(
+  path.join(os.tmpdir(), "agentos-share-art-")
+);
+
+const link = () => {
+  fs.writeFileSync(
+    path.join(dir, "connect.json"),
+    JSON.stringify({
+      machineId: MACHINE,
+      hostname: HOST,
+      apiUrl: process.env.CONNECT_API_URL,
+      enabled: true,
+    }),
+    { mode: 0o600 }
+  );
+  fs.writeFileSync(path.join(dir, "machine.key"), privatePem, { mode: 0o600 });
+};
+const unlink = () => {
+  for (const f of ["connect.json", "machine.key"])
+    fs.rmSync(path.join(dir, f), { force: true });
+};
+
+const shares = await import("./route");
+const preview = await import("./preview/route");
+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 { getDb } = await import("@/lib/db");
+
+const secret = ["gh", "p_", "b".repeat(36)].join("");
+const home = os.homedir();
+const tailnet = ["box", "example-net", "ts", "net"].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() {
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp/p",
+  });
+  const id = seedSession({
+    projectId: project.id,
+    name: "Share me",
+    view: "chat",
+  });
+  let t = 0;
+  const add = (item: Record<string, unknown>) =>
+    saveItem(id, { createdAt: ++t, ...item } as never);
+  add({
+    id: "u1",
+    kind: "user",
+    text: `key ${secret} in ${home}/app on ${tailnet}`,
+  });
+  add({ id: "a1", kind: "assistant", text: "ok" });
+  return id;
+}
+
+beforeEach(() => {
+  seen = [];
+  down = false;
+  remote = [];
+  getDb().prepare(`DELETE FROM shared_links`).run();
+  link();
+});
+afterAll(() => {
+  server.close();
+  unlink();
+});
+
+describe("preview", () => {
+  it("shows the redacted page and never calls Connect", async () => {
+    const id = chat();
+    const res = await preview.POST(
+      post("/api/shares/preview", {
+        kind: "chat",
+        sessionId: id,
+        includeTools: false,
+      })
+    );
+    expect(res.status).toBe(200);
+    const p = await res.json();
+    expect(p.connectLinked).toBe(true);
+    expect(p.html).not.toContain(secret);
+    expect(p.html).not.toContain(home);
+    expect(p.html).not.toContain(tailnet);
+    expect(p.html).toContain("[secret]");
+    expect(p.hits).toMatchObject({ secret: 1, path: 1, host: 1 });
+    expect(p.items.map((i: { id: string }) => i.id)).toEqual(["u1", "a1"]);
+    expect(seen).toHaveLength(0);
+  });
+
+  it("refuses the demo, a bad body and an unknown chat", async () => {
+    process.env.AGENTOS_DEMO = "1";
+    expect((await preview.POST(post("/api/shares/preview", {}))).status).toBe(
+      403
+    );
+    delete process.env.AGENTOS_DEMO;
+    expect(
+      (await preview.POST(post("/api/shares/preview", { kind: "x" }))).status
+    ).toBe(400);
+    expect(
+      (
+        await preview.POST(
+          post("/api/shares/preview", { kind: "chat", sessionId: "nope" })
+        )
+      ).status
+    ).toBe(404);
+  });
+
+  it("rejects a body over the cap", async () => {
+    const res = await preview.POST(
+      post("/api/shares/preview", {
+        kind: "chat",
+        sessionId: "x".repeat(70_000),
+      })
+    );
+    expect(res.status).toBe(413);
+  });
+});
+
+describe("create", () => {
+  async function previewOf(id: string, extra = {}) {
+    const res = await preview.POST(
+      post("/api/shares/preview", {
+        kind: "chat",
+        sessionId: id,
+        includeTools: false,
+        ...extra,
+      })
+    );
+    return res.json();
+  }
+
+  it("uploads exactly what was previewed, redacted, signed, and keeps the link", async () => {
+    const id = chat();
+    const p = await previewOf(id);
+    const res = await shares.POST(
+      post("/api/shares", {
+        kind: "chat",
+        sessionId: id,
+        includeTools: false,
+        sharedAt: p.sharedAt,
+        hash: p.hash,
+        expiresIn: "7d",
+      })
+    );
+    expect(res.status).toBe(201);
+    const made = await res.json();
+    expect(made.url).toMatch(/^https:\/\/runagentos\.com\/s\/T{32}$/);
+    const upload = seen.find((s) => s.method === "POST")!;
+    expect(upload.signed).toBe(true);
+    const sent = JSON.parse(upload.body);
+    expect(sent).toMatchObject({
+      kind: "chat",
+      title: "Share me",
+      expires_in: "7d",
+      html: p.html,
+    });
+    for (const leak of [secret, home, tailnet])
+      expect(upload.body).not.toContain(leak);
+    const listed = await (await shares.GET()).json();
+    expect(listed.shares[0]).toMatchObject({
+      id: made.id,
+      url: made.url,
+      sessionId: id,
+      status: "active",
+      views: 3,
+    });
+  });
+
+  it("refuses when the page changed since the preview, uploading nothing", async () => {
+    const id = chat();
+    const p = await previewOf(id);
+    saveItem(id, {
+      id: "a2",
+      kind: "assistant",
+      text: "later",
+      createdAt: 99,
+    } as never);
+    const res = await shares.POST(
+      post("/api/shares", {
+        kind: "chat",
+        sessionId: id,
+        includeTools: false,
+        sharedAt: p.sharedAt,
+        hash: p.hash,
+        expiresIn: "7d",
+      })
+    );
+    expect(res.status).toBe(409);
+    expect(seen).toHaveLength(0);
+  });
+
+  it("respects the messages dropped in the preview", async () => {
+    const id = chat();
+    const p = await previewOf(id, { dropIds: ["u1"] });
+    expect(p.html).not.toContain("[secret]");
+    const res = await shares.POST(
+      post("/api/shares", {
+        kind: "chat",
+        sessionId: id,
+        includeTools: false,
+        dropIds: ["u1"],
+        sharedAt: p.sharedAt,
+        hash: p.hash,
+        expiresIn: "never",
+      })
+    );
+    expect(res.status).toBe(201);
+    expect(JSON.parse(seen[0].body).expires_in).toBe("never");
+  });
+
+  it("shares an artifact", async () => {
+    const id = chat();
+    const art = createArtifact(
+      id,
+      "Chart",
+      `<html><head></head><body>${secret}</body></html>`
+    );
+    const body = { kind: "artifact", artifactId: art.id };
+    const p = await (
+      await preview.POST(post("/api/shares/preview", body))
+    ).json();
+    const res = await shares.POST(
+      post("/api/shares", {
+        ...body,
+        sharedAt: p.sharedAt,
+        hash: p.hash,
+        expiresIn: "1d",
+      })
+    );
+    expect(res.status).toBe(201);
+    const html = JSON.parse(seen[0].body).html as string;
+    expect(html).not.toContain(secret);
+    expect(html).toContain("noindex");
+  });
+
+  it("says so when Connect isn't linked, and for a bad expiry or hash", async () => {
+    const id = chat();
+    const p = await previewOf(id);
+    const body = {
+      kind: "chat",
+      sessionId: id,
+      includeTools: false,
+      sharedAt: p.sharedAt,
+      hash: p.hash,
+    };
+    expect(
+      (
+        await shares.POST(
+          post("/api/shares", { ...body, expiresIn: "forever" })
+        )
+      ).status
+    ).toBe(400);
+    expect(
+      (await shares.POST(post("/api/shares", { ...body, hash: undefined })))
+        .status
+    ).toBe(400);
+    unlink();
+    const res = await shares.POST(
+      post("/api/shares", { ...body, expiresIn: "7d" })
+    );
+    expect(res.status).toBe(409);
+    expect((await res.json()).error).toMatch(/Connect/);
+    expect(seen).toHaveLength(0);
+  });
+
+  it("maps a Connect failure to a message, and refuses the demo", async () => {
+    const id = chat();
+    const p = await previewOf(id);
+    down = true;
+    const body = {
+      kind: "chat",
+      sessionId: id,
+      includeTools: false,
+      sharedAt: p.sharedAt,
+      hash: p.hash,
+      expiresIn: "7d",
+    };
+    expect((await shares.POST(post("/api/shares", body))).status).toBe(502);
+    process.env.AGENTOS_DEMO = "1";
+    expect((await shares.POST(post("/api/shares", body))).status).toBe(403);
+    delete process.env.AGENTOS_DEMO;
+  });
+});
+
+describe("list and revoke", () => {
+  async function made() {
+    const id = chat();
+    const p = await (
+      await preview.POST(
+        post("/api/shares/preview", { kind: "chat", sessionId: id })
+      )
+    ).json();
+    const res = await shares.POST(
+      post("/api/shares", {
+        kind: "chat",
+        sessionId: id,
+        sharedAt: p.sharedAt,
+        hash: p.hash,
+        expiresIn: "7d",
+      })
+    );
+    return (await res.json()).id as string;
+  }
+
+  it("falls back to the local rows when Connect is down", async () => {
+    await made();
+    down = true;
+    const listed = await (await shares.GET()).json();
+    expect(listed.connect).toBe("unavailable");
+    unlink();
+    expect((await (await shares.GET()).json()).connect).toBe("unlinked");
+    link();
+    expect(listed.shares[0]).toMatchObject({ views: null, status: "active" });
+  });
+
+  it("revokes on Connect and marks the row", async () => {
+    const id = await made();
+    const res = await one.DELETE(new Request("http://localhost"), {
+      params: Promise.resolve({ id }),
+    });
+    expect(res.status).toBe(200);
+    const del = seen.find((s) => s.method === "DELETE")!;
+    expect(del.signed).toBe(true);
+    const listed = await (await shares.GET()).json();
+    expect(listed.shares[0].status).toBe("revoked");
+    const row = getDb()
+      .prepare(`SELECT revoked_at FROM shared_links WHERE id = ?`)
+      .get(id) as { revoked_at: string };
+    expect(row.revoked_at).toBeTruthy();
+  });
+
+  it("404s an unknown link and keeps the row when Connect fails", async () => {
+    expect(
+      (
+        await one.DELETE(new Request("http://localhost"), {
+          params: Promise.resolve({ id: "zzzzzzzzzzzz" }),
+        })
+      ).status
+    ).toBe(404);
+    const id = await made();
+    down = true;
+    expect(
+      (
+        await one.DELETE(new Request("http://localhost"), {
+          params: Promise.resolve({ id }),
+        })
+      ).status
+    ).toBe(502);
+    const row = getDb()
+      .prepare(`SELECT revoked_at FROM shared_links WHERE id = ?`)
+      .get(id) as { revoked_at: string | null };
+    expect(row.revoked_at).toBeNull();
+  });
+});

package/app/api/shares/route.ts

@@ -0,0 +1,101 @@
+import { NextResponse } from "next/server";
+import {
+  listRemote,
+  linked,
+  createRemote,
+  NOT_LINKED,
+} from "@/lib/share/connect";
+import { fail, readJson, refuseDemo, toResponse } from "@/lib/share/route";
+import {
+  EXPIRIES,
+  TOO_BIG,
+  buildPage,
+  parseRequest,
+} from "@/lib/share/service";
+import { insertSharedLink, listSharedLinks } from "@/lib/share/store";
+import type { ShareExpiry } from "@/lib/connect/control-api";
+
+// POST /api/shares - upload a snapshot to Connect and keep its link.
+// The page is rendered again here from the same inputs as the preview and
+// must hash the same: markup from the client is never uploaded.
+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;
+  const body = read.body as Record<string, unknown>;
+  try {
+    const req = parseRequest(body, body?.sharedAt);
+    const expiresIn = (body?.expiresIn ?? "7d") as ShareExpiry;
+    if (!EXPIRIES.includes(expiresIn)) return fail("Unknown expiry.", 400);
+    if (typeof body?.hash !== "string") return fail("hash is required.", 400);
+    if (!linked()) return fail(NOT_LINKED, 409);
+
+    const page = await buildPage(req);
+    if (page.tooBig) return fail(TOO_BIG, 413);
+    if (page.hash !== body.hash)
+      return fail("Changed since the preview; review it again.", 409);
+
+    const share = await createRemote({
+      kind: req.kind,
+      title: page.title,
+      html: page.html,
+      expiresIn,
+    });
+    insertSharedLink({
+      id: share.id,
+      url: share.url,
+      kind: req.kind,
+      title: page.title,
+      session_id: req.sessionId ?? null,
+      artifact_id: req.artifactId ?? null,
+      expires_at: share.expires_at,
+      created_at: share.created_at,
+      revoked_at: null,
+    });
+    return NextResponse.json(
+      { id: share.id, url: share.url, expiresAt: share.expires_at },
+      { status: 201 }
+    );
+  } catch (err) {
+    return toResponse(err);
+  }
+}
+
+// GET /api/shares - the links made here, with views and status from Connect
+// when it can be reached.
+export async function GET() {
+  const refused = refuseDemo();
+  if (refused) return refused;
+  const local = listSharedLinks();
+  let remote: Awaited<ReturnType<typeof listRemote>> | null = null;
+  if (linked()) remote = await listRemote().catch(() => null);
+  const byId = new Map(remote?.map((s) => [s.id, s]));
+  const now = Date.now();
+  return NextResponse.json({
+    connect: !linked() ? "unlinked" : remote ? "ok" : "unavailable",
+    shares: local.map((l) => {
+      const r = byId.get(l.id);
+      const status =
+        r?.status ??
+        (l.revoked_at
+          ? "revoked"
+          : l.expires_at && Date.parse(l.expires_at) <= now
+            ? "expired"
+            : "active");
+      return {
+        id: l.id,
+        url: l.url,
+        kind: l.kind,
+        title: l.title,
+        sessionId: l.session_id,
+        artifactId: l.artifact_id,
+        createdAt: l.created_at,
+        expiresAt: l.expires_at,
+        status,
+        views: r ? r.view_count : null,
+        lastViewedAt: r?.last_viewed_at ?? null,
+      };
+    }),
+  });
+}

package/app/page.tsx

@@ -118,6 +118,10 @@ const MoveDialog = dynamic(
   () => import("@/components/Tasks/MoveDialog").then((m) => m.MoveDialog),
   { ssr: false }
 );
+const ShareDialog = dynamic(
+  () => import("@/components/Share/ShareDialog").then((m) => m.ShareDialog),
+  { ssr: false }
+);
 const CommandPalette = dynamic(
   () =>
     import("@/components/CommandPalette/CommandPalette").then(
@@ -143,6 +147,7 @@ const AppDialogs = memo(function AppDialogs({
       <LumifyHubDialogs />
       <UsageDialog />
       <MoveDialog />
+      <ShareDialog />
       <AwayReport />
       <CommandPalette />
     </>

package/components/Chat/Artifact.tsx

@@ -1,9 +1,10 @@
 "use client";
 
 import { useState } from "react";
-import { ExternalLink, Maximize2, X } from "lucide-react";
+import { ExternalLink, Maximize2, Share2, X } from "lucide-react";
 import type { ChatItem } from "@/lib/chat/events";
 import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
+import { shareUiActions } from "@/stores/shareUi";
 import { ArtifactFrame, artifactUrl } from "./ArtifactFrame";
 
 type ArtifactItem = Extract<ChatItem, { kind: "artifact" }>;
@@ -31,6 +32,21 @@ function Actions({
           <Maximize2 className="h-4 w-4" />
         </button>
       )}
+      <button
+        type="button"
+        onClick={() =>
+          shareUiActions.open({
+            kind: "artifact",
+            artifactId: item.artifactId,
+            title: item.title,
+          })
+        }
+        className={ICON_BUTTON}
+        aria-label="Share"
+        title="Share"
+      >
+        <Share2 className="h-4 w-4" />
+      </button>
       <a
         href={artifactUrl(item.artifactId)}
         target="_blank"