@saadnvd1/agent-os 0.3.585 → 0.3.587

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)
+- **Bookmarks.** Star any message, tool call or turn, then find it again from the chat or across every chat, with a search. [More](docs/guides/chat.md)
 - **Share a chat or a page.** A read-only snapshot link with secrets, home paths and machine names masked, a preview before anything leaves your machine, and a Markdown copy to hand to an agent. [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)

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

@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+import {
+  BookmarkError,
+  removeBookmark,
+  setBookmarkNote,
+} from "@/lib/bookmarks/store";
+import { readBookmarkBody } from "@/lib/bookmarks/body";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+const notFound = () =>
+  NextResponse.json({ error: "Bookmark not found" }, { status: 404 });
+
+// PATCH /api/bookmarks/:id { note } - set or clear (null) its note.
+export async function PATCH(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  const body = await readBookmarkBody(request);
+  if (body instanceof NextResponse) return body;
+  if (!("note" in body))
+    return NextResponse.json({ error: "note is required" }, { status: 400 });
+  try {
+    const bookmark = setBookmarkNote(id, body.note);
+    return bookmark ? NextResponse.json({ bookmark }) : notFound();
+  } catch (err) {
+    if (err instanceof BookmarkError)
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    throw err;
+  }
+}
+
+// DELETE /api/bookmarks/:id - unstar.
+export async function DELETE(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return removeBookmark(id) ? NextResponse.json({ ok: true }) : notFound();
+}

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

@@ -0,0 +1,103 @@
+import { randomUUID } from "crypto";
+import { describe, expect, it } from "vitest";
+import { getDb } from "@/lib/db";
+import type { ChatItem } from "@/lib/chat/events";
+import { saveItem } from "@/lib/chat/store";
+import { MAX_BOOKMARK_BODY_BYTES } from "@/lib/bookmarks/body";
+import * as sessionRoute from "../sessions/[id]/bookmarks/route";
+import * as oneRoute from "./[id]/route";
+import * as listRoute from "./route";
+
+function chat() {
+  const id = randomUUID();
+  getDb()
+    .prepare(
+      `INSERT INTO sessions (id, name, tmux_name, working_directory) VALUES (?, 'routes', ?, '/tmp')`
+    )
+    .run(id, `claude-${id}`);
+  const item = (i: object) => {
+    const full = { id: randomUUID(), createdAt: 1, ...i } as ChatItem;
+    saveItem(id, full);
+    return full.id;
+  };
+  return {
+    id,
+    user: item({ kind: "user", text: "find the albatross" }),
+    reasoning: item({ kind: "reasoning", text: "thinking" }),
+  };
+}
+
+const ctx = (id: string) => ({ params: Promise.resolve({ id }) });
+const req = (body?: unknown, raw?: string) =>
+  new Request("http://localhost/x", {
+    method: "POST",
+    body: raw ?? (body === undefined ? undefined : JSON.stringify(body)),
+  });
+const post = (id: string, body?: unknown, raw?: string) =>
+  sessionRoute.POST(req(body, raw), ctx(id));
+
+describe("bookmark routes", () => {
+  it("creates (201), returns the same one again (200), lists it", async () => {
+    const c = chat();
+    const made = await post(c.id, { itemId: c.user });
+    expect(made.status).toBe(201);
+    const { bookmark } = await made.json();
+    const again = await post(c.id, { itemId: c.user });
+    expect(again.status).toBe(200);
+    expect((await again.json()).bookmark.id).toBe(bookmark.id);
+    const list = await sessionRoute.GET(req(), ctx(c.id));
+    expect(
+      (await list.json()).bookmarks.map((b: { id: string }) => b.id)
+    ).toEqual([bookmark.id]);
+    const all = await listRoute.GET(
+      new Request("http://localhost/api/bookmarks?workspace=all&q=albatross")
+    );
+    expect((await all.json()).bookmarks[0].id).toBe(bookmark.id);
+  });
+
+  it("refuses a bad body (400) and what isn't there (404)", async () => {
+    const c = chat();
+    expect((await post(c.id, undefined, "not json")).status).toBe(400);
+    expect((await post(c.id, {})).status).toBe(400);
+    expect((await post(c.id, { itemId: c.reasoning })).status).toBe(400);
+    expect((await post(c.id, { itemId: c.user, scope: "x" })).status).toBe(400);
+    expect((await post(c.id, { itemId: "missing" })).status).toBe(404);
+    expect((await post(randomUUID(), { itemId: c.user })).status).toBe(404);
+  });
+
+  it("refuses a body past its cap (413) on POST and PATCH", async () => {
+    const c = chat();
+    const huge = { itemId: c.user, note: "x".repeat(MAX_BOOKMARK_BODY_BYTES) };
+    expect((await post(c.id, huge)).status).toBe(413);
+    const { bookmark } = await (await post(c.id, { itemId: c.user })).json();
+    const patched = await oneRoute.PATCH(
+      new Request("http://localhost/x", {
+        method: "PATCH",
+        body: JSON.stringify({ note: "x".repeat(MAX_BOOKMARK_BODY_BYTES) }),
+      }),
+      ctx(bookmark.id)
+    );
+    expect(patched.status).toBe(413);
+  });
+
+  it("sets a note, deletes once, and 404s a missing id", async () => {
+    const c = chat();
+    const { bookmark } = await (await post(c.id, { itemId: c.user })).json();
+    const patch = (id: string, body: unknown) =>
+      oneRoute.PATCH(
+        new Request("http://localhost/x", {
+          method: "PATCH",
+          body: JSON.stringify(body),
+        }),
+        ctx(id)
+      );
+    const noted = await patch(bookmark.id, { note: "seabird" });
+    expect((await noted.json()).bookmark.note).toBe("seabird");
+    expect((await patch(bookmark.id, {})).status).toBe(400);
+    expect((await patch(bookmark.id, { note: 3 })).status).toBe(400);
+    expect((await patch(randomUUID(), { note: "x" })).status).toBe(404);
+    const del = () => oneRoute.DELETE(req(), ctx(bookmark.id));
+    expect((await del()).status).toBe(200);
+    expect((await del()).status).toBe(404);
+  });
+});

package/app/api/bookmarks/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { listBookmarks } from "@/lib/bookmarks/store";
+
+// GET /api/bookmarks?workspace=<id|all|none>&q=&before=&limit= - bookmarks
+// across chats, newest first, a page at a time (`next` is the next `before`).
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+  const ws = url.searchParams.get("workspace") ?? "all";
+  const limit = Number(url.searchParams.get("limit") ?? 50);
+  return NextResponse.json(
+    listBookmarks({
+      workspace: ws === "none" ? null : ws,
+      q: url.searchParams.get("q") ?? undefined,
+      before: url.searchParams.get("before"),
+      limit: Number.isFinite(limit) ? limit : 50,
+    })
+  );
+}

package/app/api/sessions/[id]/bookmarks/route.ts

@@ -0,0 +1,38 @@
+import { NextResponse } from "next/server";
+import {
+  BookmarkError,
+  createBookmark,
+  listSessionBookmarks,
+} from "@/lib/bookmarks/store";
+import { readBookmarkBody } from "@/lib/bookmarks/body";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+// GET /api/sessions/:id/bookmarks - this chat's bookmarks, in chat order.
+// A deleted chat's still list: they outlive it.
+export async function GET(_request: Request, { params }: Ctx) {
+  const { id } = await params;
+  return NextResponse.json({ bookmarks: listSessionBookmarks(id) });
+}
+
+// POST /api/sessions/:id/bookmarks { itemId, scope?, note? } - bookmark one
+// item, or (scope 'turn') the turn its user message starts. 201 when made,
+// 200 with the one already there.
+export async function POST(request: Request, { params }: Ctx) {
+  const { id } = await params;
+  const body = await readBookmarkBody(request);
+  if (body instanceof NextResponse) return body;
+  try {
+    const { bookmark, created } = createBookmark({
+      sessionId: id,
+      itemId: body.itemId,
+      scope: body.scope,
+      note: body.note,
+    });
+    return NextResponse.json({ bookmark }, { status: created ? 201 : 200 });
+  } catch (err) {
+    if (err instanceof BookmarkError)
+      return NextResponse.json({ error: err.message }, { status: err.status });
+    throw err;
+  }
+}

package/app/api/tasks/[id]/merge/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { signOffTask } from "@/lib/tasks";
 import { callingDevice } from "@/lib/security/device-me";
+import { isBranchName } from "@/lib/git";
 import { heldRefusal } from "@/lib/tasks/held";
 
 // head: merge only if the PR is still at this commit; the answer names the
@@ -12,15 +13,18 @@ export async function POST(
   const id = (await params).id;
   const held = heldRefusal(id, callingDevice(request));
   if (held) return NextResponse.json({ error: held }, { status: 403 });
-  const { head } = await request.json().catch(() => ({}));
+  const { head, base } = await request.json().catch(() => ({}));
   if (
     head !== undefined &&
     !(typeof head === "string" && /^[0-9a-f]{40}$/.test(head))
   )
     return NextResponse.json({ error: "Bad head commit" }, { status: 400 });
+  if (base !== undefined && !(typeof base === "string" && isBranchName(base)))
+    return NextResponse.json({ error: "Bad base branch" }, { status: 400 });
   try {
     const method = await signOffTask(id, {
       head,
+      base,
       device: callingDevice(request),
     });
     return NextResponse.json({ success: true, head: head ?? null, method });

package/app/globals.css

@@ -10,6 +10,7 @@
 @theme inline {
   --color-background: hsl(var(--background));
   --color-foreground: hsl(var(--foreground));
+  --color-bookmark: hsl(var(--bookmark));
   --font-sans: var(--font-geist-sans);
   --font-mono: var(--font-geist-mono);
 

package/app/page.tsx

@@ -91,6 +91,20 @@ const MessagesDialog = dynamic(
   () => import("@/components/Bus/MessagesDialog").then((m) => m.MessagesDialog),
   { ssr: false }
 );
+const BookmarksDialog = dynamic(
+  () =>
+    import("@/components/Bookmarks/BookmarksDialog").then(
+      (m) => m.BookmarksDialog
+    ),
+  { ssr: false }
+);
+const ChatBookmarksDialog = dynamic(
+  () =>
+    import("@/components/Bookmarks/ChatBookmarks").then(
+      (m) => m.ChatBookmarksDialog
+    ),
+  { ssr: false }
+);
 const ArchivedDialog = dynamic(
   () =>
     import("@/components/Archived/ArchivedDialog").then(
@@ -143,6 +157,8 @@ const AppDialogs = memo(function AppDialogs({
       <AddProjectDialog />
       <MessagesDialog />
       <ArchivedDialog />
+      <BookmarksDialog />
+      <ChatBookmarksDialog />
       <CleanupDialog />
       <LumifyHubDialogs />
       <UsageDialog />

package/components/Bookmarks/BookmarkButton.tsx

@@ -0,0 +1,149 @@
+"use client";
+
+import type { ReactNode } from "react";
+import { Star } from "lucide-react";
+import { cn } from "@/lib/utils";
+import type { BookmarkScope } from "@/lib/bookmarks/types";
+import { useBookmarkChat, useTurnStart } from "./context";
+import { useBookmarkToggle } from "./useBookmarkToggle";
+import { useLongPress } from "@/components/Chat/useLongPress";
+
+// Holding a message on a phone stars it. Outside a chat panel (a share, a
+// test) it's just its children.
+export function BookmarkPress({
+  itemId,
+  children,
+}: {
+  itemId: string;
+  children: ReactNode;
+}) {
+  const chat = useBookmarkChat();
+  if (!chat) return children;
+  return (
+    <Press sessionId={chat.sessionId} itemId={itemId}>
+      {children}
+    </Press>
+  );
+}
+
+function Press({
+  sessionId,
+  itemId,
+  children,
+}: {
+  sessionId: string;
+  itemId: string;
+  children: ReactNode;
+}) {
+  const { toggle } = useBookmarkToggle(sessionId, itemId, "item");
+  const press = useLongPress(toggle);
+  return (
+    <div className="contents" {...press}>
+      {children}
+    </div>
+  );
+}
+
+export const STAR_ON = "fill-bookmark text-bookmark";
+
+// The star in a message's action row. Unset, it shows as its row does (on
+// hover on a desktop, dimmed on a phone); set, it always shows, so a
+// bookmarked message is seen while scrolling.
+export function BookmarkButton({
+  itemId,
+  scope = "item",
+  className,
+}: {
+  itemId: string;
+  scope?: BookmarkScope;
+  className?: string;
+}) {
+  const chat = useBookmarkChat();
+  if (!chat) return null;
+  return (
+    <StarToggle
+      sessionId={chat.sessionId}
+      itemId={itemId}
+      scope={scope}
+      className={className}
+    />
+  );
+}
+
+function StarToggle({
+  sessionId,
+  itemId,
+  scope,
+  className,
+}: {
+  sessionId: string;
+  itemId: string;
+  scope: BookmarkScope;
+  className?: string;
+}) {
+  const { on, toggle } = useBookmarkToggle(sessionId, itemId, scope);
+  return (
+    <button
+      type="button"
+      aria-label={on ? "Remove bookmark" : "Bookmark"}
+      aria-pressed={on}
+      title={on ? "Remove bookmark" : "Bookmark"}
+      data-bookmarked={on || undefined}
+      onClick={(e) => {
+        e.stopPropagation();
+        toggle();
+      }}
+      className={cn(
+        "text-muted-foreground hover:text-foreground hover:bg-foreground/[0.06] flex h-11 w-11 shrink-0 items-center justify-center rounded-md md:h-7 md:w-7",
+        on
+          ? "opacity-100"
+          : "opacity-40 group-hover:opacity-100 focus-visible:opacity-100 md:opacity-0",
+        className
+      )}
+    >
+      <Star className={cn("h-3.5 w-3.5", on && STAR_ON)} />
+    </button>
+  );
+}
+
+// "Bookmark turn" on a turn's end line: marks the turn by its first message.
+export function TurnBookmark({ turnEndId }: { turnEndId: string }) {
+  const chat = useBookmarkChat();
+  const start = useTurnStart(turnEndId);
+  if (!chat || !start) return null;
+  return <TurnStar sessionId={chat.sessionId} itemId={start} />;
+}
+
+function TurnStar({
+  sessionId,
+  itemId,
+}: {
+  sessionId: string;
+  itemId: string;
+}) {
+  const { on, toggle } = useBookmarkToggle(sessionId, itemId, "turn");
+  return (
+    <button
+      type="button"
+      aria-pressed={on}
+      onClick={toggle}
+      className={cn(
+        "hover:text-foreground hover:bg-foreground/[0.06] -my-2 flex min-h-11 shrink-0 items-center gap-1 rounded-md px-2 md:-my-1 md:min-h-7",
+        on
+          ? "text-bookmark"
+          : "opacity-60 group-hover:opacity-100 focus-visible:opacity-100"
+      )}
+      aria-label={on ? "Turn bookmarked" : "Bookmark turn"}
+    >
+      <Star className={cn("h-3 w-3", on && STAR_ON)} />
+      {/* On desktop an unstarred turn shows only its star until hovered. */}
+      <span
+        className={cn(
+          !on && "md:hidden md:group-focus-within:inline md:group-hover:inline"
+        )}
+      >
+        {on ? "Turn bookmarked" : "Bookmark turn"}
+      </span>
+    </button>
+  );
+}

package/components/Bookmarks/BookmarkRow.tsx

@@ -0,0 +1,161 @@
+"use client";
+
+import { useRef, useState } from "react";
+import {
+  AlignLeft,
+  MessageSquare,
+  Pencil,
+  Star,
+  Terminal,
+  User,
+} from "lucide-react";
+import { toast } from "sonner";
+import { cn } from "@/lib/utils";
+import type { Bookmark } from "@/lib/bookmarks/types";
+import { useRemoveBookmark, useSetBookmarkNote } from "@/data/bookmarks";
+import { bookmarksUiActions } from "@/stores/bookmarksUi";
+import { STAR_ON } from "./BookmarkButton";
+import { KIND_LABEL, STATE_BADGE, canOpen, excerpt, timeOf } from "./helpers";
+
+const KIND_ICON = {
+  user: User,
+  assistant: MessageSquare,
+  tool: Terminal,
+  turn: AlignLeft,
+} as const;
+
+// One bookmark in a list: tap to open it, edit its note, or unstar it.
+export function BookmarkRow({
+  bookmark: b,
+  editing,
+  showSession,
+  onOpen,
+}: {
+  bookmark: Bookmark;
+  editing: boolean;
+  showSession?: boolean;
+  onOpen: (b: Bookmark) => void;
+}) {
+  const Icon = KIND_ICON[b.kind];
+  const badge = STATE_BADGE[b.state];
+  const remove = useRemoveBookmark();
+  const openable = canOpen(b);
+  return (
+    <div className="hover:bg-accent/60 flex flex-wrap items-start gap-2 rounded-lg px-2 py-1.5">
+      <button
+        type="button"
+        disabled={!openable}
+        onClick={() => onOpen(b)}
+        className="flex min-h-11 min-w-0 flex-1 items-start gap-2.5 py-1 text-left disabled:cursor-default"
+      >
+        <span className="bg-muted text-muted-foreground mt-0.5 flex h-6 w-6 shrink-0 items-center justify-center rounded-md">
+          <Icon className="h-3.5 w-3.5" />
+        </span>
+        <span className="min-w-0 flex-1">
+          <span className="text-muted-foreground flex flex-wrap items-center gap-x-1.5 text-xs">
+            {showSession && (
+              <span className="text-foreground truncate font-medium">
+                {b.sessionName}
+              </span>
+            )}
+            <span>{KIND_LABEL[b.kind]}</span>
+            <span aria-hidden>·</span>
+            <span>{timeOf(b)}</span>
+            {badge && (
+              <span className="rounded border px-1.5 text-[10.5px] leading-4">
+                {badge}
+              </span>
+            )}
+          </span>
+          <span
+            className={cn(
+              "line-clamp-2 text-sm break-words",
+              b.kind === "tool" && "font-mono text-xs"
+            )}
+          >
+            {excerpt(b.text) || "(empty)"}
+          </span>
+          {b.note && !editing && (
+            <span className="text-muted-foreground block truncate text-xs">
+              “{b.note}”
+            </span>
+          )}
+        </span>
+      </button>
+      <div className="flex shrink-0 items-center">
+        <button
+          type="button"
+          aria-label={b.note ? "Edit note" : "Add note"}
+          title={b.note ? "Edit note" : "Add note"}
+          onClick={() => bookmarksUiActions.edit(editing ? null : b.id)}
+          className="text-muted-foreground hover:text-foreground hover:bg-foreground/[0.06] flex h-11 w-11 items-center justify-center rounded-md md:h-8 md:w-8"
+        >
+          <Pencil className="h-3.5 w-3.5" />
+        </button>
+        <button
+          type="button"
+          aria-label="Remove bookmark"
+          title="Remove bookmark"
+          onClick={() =>
+            remove.mutate(b.id, {
+              onError: (err) => toast.error(err.message),
+            })
+          }
+          className="hover:bg-foreground/[0.06] flex h-11 w-11 items-center justify-center rounded-md md:h-8 md:w-8"
+        >
+          <Star className={cn("h-3.5 w-3.5", STAR_ON)} />
+        </button>
+      </div>
+      {editing && <NoteEditor bookmark={b} />}
+    </div>
+  );
+}
+
+function NoteEditor({ bookmark: b }: { bookmark: Bookmark }) {
+  const [note, setNote] = useState(b.note ?? "");
+  const save = useSetBookmarkNote();
+  // Escape, or a save already sent: the blur that follows does nothing.
+  const done = useRef(false);
+  const commit = () => {
+    if (done.current) return;
+    done.current = true;
+    if ((b.note ?? "") === note.trim()) return bookmarksUiActions.edit(null);
+    save.mutate(
+      { id: b.id, note: note.trim() || null },
+      {
+        onSuccess: () => bookmarksUiActions.edit(null),
+        onError: (err) => {
+          done.current = false;
+          toast.error(err.message);
+        },
+      }
+    );
+  };
+  return (
+    <form
+      className="basis-full pb-1 pl-9"
+      onSubmit={(e) => {
+        e.preventDefault();
+        commit();
+      }}
+    >
+      <input
+        autoFocus
+        value={note}
+        maxLength={500}
+        onChange={(e) => setNote(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Escape") {
+            e.stopPropagation();
+            done.current = true;
+            bookmarksUiActions.edit(null);
+          }
+        }}
+        onBlur={commit}
+        placeholder="A note to find it by"
+        aria-label="Bookmark note"
+        className="border-input bg-background focus-visible:ring-ring h-11 w-full rounded-md border px-3 text-base outline-none focus-visible:ring-1 md:h-8 md:text-sm"
+      />
+    </form>
+  );
+}