@saadnvd1/agent-os 0.3.558 → 0.3.561

package/components/Shares/SharedLinksPanel.tsx

@@ -0,0 +1,147 @@
+"use client";
+
+import { toast } from "sonner";
+import { Copy, Link2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { writeClipboard } from "@/hooks/useCopyToClipboard";
+import {
+  useRevokeShare,
+  useSharesQuery,
+  type SharedLinkRow,
+} from "@/data/shares";
+import { cn } from "@/lib/utils";
+
+const when = (iso: string) =>
+  new Date(iso).toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+  });
+
+function Row({ share }: { share: SharedLinkRow }) {
+  const revoke = useRevokeShare();
+  const live = share.status === "active";
+
+  const copy = async () => {
+    try {
+      await writeClipboard(share.url);
+      toast.success("Link copied");
+    } catch {
+      toast.error("Could not copy to clipboard");
+    }
+  };
+  const onRevoke = () => {
+    if (
+      !window.confirm(
+        "Revoke this link? The page is deleted from Connect and the link stops working."
+      )
+    )
+      return;
+    revoke.mutate(share.id, {
+      onError: (err) => toast.error((err as Error).message),
+    });
+  };
+
+  const title =
+    share.kind === "chat" && share.sessionId ? (
+      <a
+        href={`/?session=${encodeURIComponent(share.sessionId)}`}
+        className="hover:underline"
+      >
+        {share.title}
+      </a>
+    ) : (
+      share.title
+    );
+
+  return (
+    <li className="bg-muted/40 flex flex-col gap-2 rounded-lg px-3 py-2.5 sm:flex-row sm:items-center">
+      <div className="min-w-0 flex-1">
+        <div className="truncate text-sm font-medium">{title}</div>
+        <div className="text-muted-foreground flex flex-wrap gap-x-3 text-xs">
+          <span>{share.kind === "chat" ? "Chat" : "Page"}</span>
+          <span>Created {when(share.createdAt)}</span>
+          <span>
+            {share.status === "revoked"
+              ? "Revoked"
+              : share.status === "expired"
+                ? "Expired"
+                : share.expiresAt
+                  ? `Expires ${when(share.expiresAt)}`
+                  : "Never expires"}
+          </span>
+          <span>
+            {share.views === null
+              ? "Views unavailable"
+              : `${share.views} ${share.views === 1 ? "view" : "views"}`}
+          </span>
+        </div>
+      </div>
+      <div className="flex shrink-0 gap-2">
+        <Button
+          variant="outline"
+          className={cn("min-h-11 sm:min-h-8", !live && "invisible")}
+          onClick={copy}
+          disabled={!live}
+        >
+          <Copy className="h-4 w-4" />
+          Copy link
+        </Button>
+        <Button
+          variant="outline"
+          className={cn(
+            "text-destructive min-h-11 sm:min-h-8",
+            !live && "invisible"
+          )}
+          onClick={onRevoke}
+          disabled={!live || revoke.isPending}
+        >
+          Revoke
+        </Button>
+      </div>
+    </li>
+  );
+}
+
+// Every snapshot link made from this machine, with views from Connect.
+export function SharedLinksPanel() {
+  const { data, isLoading, error } = useSharesQuery();
+  return (
+    <div className="space-y-3">
+      <p className="text-muted-foreground text-sm">
+        Read-only snapshots you shared from a chat or a page. Revoking one
+        deletes it from Connect straight away.
+      </p>
+      {data?.connect === "unavailable" && (
+        <p className="text-muted-foreground bg-muted/40 rounded-lg px-3 py-2 text-xs">
+          Can&apos;t reach Connect, so views are hidden and revoking is
+          unavailable until it is back.
+        </p>
+      )}
+      {data?.connect === "unlinked" && data.shares.length > 0 && (
+        <p className="text-muted-foreground bg-muted/40 rounded-lg px-3 py-2 text-xs">
+          This machine isn&apos;t linked to Connect, so views are hidden and
+          revoking is unavailable.
+        </p>
+      )}
+      {error && (
+        <p className="text-destructive text-sm">{(error as Error).message}</p>
+      )}
+      {isLoading ? (
+        <p className="text-muted-foreground text-sm">Loading…</p>
+      ) : data?.shares.length ? (
+        <ul className="space-y-2">
+          {data.shares.map((s) => (
+            <Row key={s.id} share={s} />
+          ))}
+        </ul>
+      ) : (
+        <div className="text-muted-foreground flex items-center gap-2 rounded-lg border border-dashed px-3 py-6 text-sm">
+          <Link2 className="h-4 w-4 shrink-0" />
+          Nothing shared yet. Use Share… in a chat&apos;s menu, or the share
+          button on a page.
+        </div>
+      )}
+    </div>
+  );
+}

package/data/shares/index.ts

@@ -0,0 +1,2 @@
+export * from "./keys";
+export * from "./queries";

package/data/shares/keys.ts

@@ -0,0 +1,4 @@
+export const shareKeys = {
+  all: ["shares"] as const,
+  list: () => [...shareKeys.all, "list"] as const,
+};

package/data/shares/queries.ts

@@ -0,0 +1,111 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { shareKeys } from "./keys";
+
+async function json<T>(res: Response): Promise<T> {
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export type ShareExpiry = "1d" | "7d" | "30d" | "never";
+
+export interface ShareTarget {
+  kind: "chat" | "artifact";
+  sessionId?: string;
+  artifactId?: string;
+}
+
+export interface PreviewRequest extends ShareTarget {
+  includeTools: boolean;
+  /** Messages left out of the share. */
+  dropIds?: string[];
+}
+
+export interface PreviewItem {
+  id: string;
+  type: string;
+  tools: boolean;
+  excerpt: string;
+}
+
+export interface SharePreview {
+  html: string;
+  title: string;
+  bytes: number;
+  hash: string;
+  sharedAt: string;
+  items: PreviewItem[];
+  hits: Record<"secret" | "path" | "ip" | "host" | "email", number>;
+  tooBig: boolean;
+  connectLinked: boolean;
+}
+
+const post = (url: string, body: unknown) =>
+  fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+
+/** What would be uploaded, redacted. Local only. */
+export function useSharePreview() {
+  return useMutation({
+    mutationFn: async (req: PreviewRequest) =>
+      json<SharePreview>(await post("/api/shares/preview", req)),
+  });
+}
+
+export function useCreateShare() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (
+      req: PreviewRequest & {
+        sharedAt: string;
+        hash: string;
+        expiresIn: ShareExpiry;
+      }
+    ) =>
+      json<{ id: string; url: string; expiresAt: string | null }>(
+        await post("/api/shares", req)
+      ),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: shareKeys.all }),
+  });
+}
+
+export interface SharedLinkRow {
+  id: string;
+  url: string;
+  kind: "chat" | "artifact";
+  title: string;
+  sessionId: string | null;
+  artifactId: string | null;
+  createdAt: string;
+  expiresAt: string | null;
+  status: "active" | "expired" | "revoked";
+  views: number | null;
+  lastViewedAt: string | null;
+}
+
+export interface SharesResponse {
+  connect: "ok" | "unavailable" | "unlinked";
+  shares: SharedLinkRow[];
+}
+
+export function useSharesQuery(enabled = true) {
+  return useQuery({
+    queryKey: shareKeys.list(),
+    queryFn: async () => json<SharesResponse>(await fetch("/api/shares")),
+    enabled,
+  });
+}
+
+export function useRevokeShare() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id: string) =>
+      json<{ ok: true }>(
+        await fetch(`/api/shares/${id}`, { method: "DELETE" })
+      ),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: shareKeys.all }),
+  });
+}

package/lib/chat/drivers/claude.ts

@@ -19,7 +19,11 @@ import { toChatContext, usageTotals } from "../context";
 import { cacheTtlMs } from "../stale";
 import { ClaudeMapper, toCommand, type ClaudeMessage } from "./claude-mapper";
 import { SuggestionTrace } from "./suggestion-trace";
-import { redact } from "../../orchestrator/untrusted";
+import {
+  redact,
+  SECRET_PARAM,
+  URL_USERINFO,
+} from "../../orchestrator/untrusted";
 import { NO_ATTRIBUTION } from "../../agents/attribution";
 import { callFromAssistant } from "../../usage/calls";
 
@@ -52,9 +56,6 @@ const firstLine = (text?: string) => {
 
 // A server's error text can quote its URL, and with it a key: shown and
 // stored redacted, on one line, and short.
-const URL_USERINFO = /\b([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi;
-const SECRET_PARAM =
-  /([?&][\w.-]*(?:key|token|secret|password|auth|sig|code)[\w.-]*=)[^&\s#]+/gi;
 function cleanError(text?: string): string | undefined {
   if (!text) return undefined;
   const line = redact(

package/lib/connect/control-api.ts

@@ -264,3 +264,87 @@ export async function pushRelay(
     throw new Error("the Connect service sent no push results");
   return r.results;
 }
+
+export type ShareStatus = "active" | "expired" | "revoked";
+
+/** A snapshot link as Connect reports it. The link itself is never in a list. */
+export interface RemoteShare {
+  id: string;
+  kind: string;
+  title: string;
+  status: ShareStatus;
+  byte_size: number;
+  view_count: number;
+  last_viewed_at: string | null;
+  created_at: string;
+  expires_at: string | null;
+}
+
+export type ShareExpiry = "1d" | "7d" | "30d" | "never";
+
+const shareFrom = (r: unknown): RemoteShare => {
+  const s = (r ?? {}) as Record<string, unknown>;
+  if (typeof s.id !== "string" || typeof s.status !== "string")
+    throw new Error("the Connect service sent an unusable share");
+  return s as unknown as RemoteShare;
+};
+
+/** Uploads a rendered snapshot; the answer carries the public link, once. */
+export async function uploadShare(
+  config: ConnectConfig,
+  privateKey: string,
+  share: {
+    kind: "chat" | "artifact";
+    title: string;
+    html: string;
+    expiresIn: ShareExpiry;
+  }
+): Promise<RemoteShare & { url: string }> {
+  const res = await signed(config, privateKey)(
+    "POST",
+    `/api/v1/machines/${config.machineId}/shares`,
+    {
+      kind: share.kind,
+      title: share.title,
+      html: share.html,
+      expires_in: share.expiresIn,
+    }
+  );
+  const r = (await res.json().catch(() => null)) as Record<
+    string,
+    unknown
+  > | null;
+  const url = r?.url;
+  if (typeof url !== "string" || !/^https?:\/\//.test(url))
+    throw new Error("the Connect service sent no link");
+  return { ...shareFrom(r), url };
+}
+
+export async function listShares(
+  config: ConnectConfig,
+  privateKey: string
+): Promise<RemoteShare[]> {
+  const res = await signed(config, privateKey)(
+    "GET",
+    `/api/v1/machines/${config.machineId}/shares`
+  );
+  const r = (await res.json().catch(() => null)) as {
+    shares?: unknown[];
+  } | null;
+  if (!Array.isArray(r?.shares))
+    throw new Error("the Connect service sent no share list");
+  return r.shares.map(shareFrom);
+}
+
+export async function revokeShare(
+  config: ConnectConfig,
+  privateKey: string,
+  id: string
+): Promise<RemoteShare> {
+  if (!/^[a-z0-9]{12}$/.test(id)) throw new Error("not a share id");
+  const res = await signed(config, privateKey)(
+    "DELETE",
+    `/api/v1/machines/${config.machineId}/shares/${id}`
+  );
+  return shareFrom(await res.json().catch(() => null));
+}

package/lib/db/migrations.ts

@@ -2087,6 +2087,56 @@ const migrations: Migration[] = [
       `);
     },
   },
+  {
+    id: 87,
+    name: "plan_pieces_reconcile",
+    up: (db) => {
+      // How many pieces a plan listed and what the checker folded, so a plan
+      // that builds as fewer than it listed is never silent; the PRs agents
+      // opened (from their `gh pr create` output) so one outside its task's
+      // repo is noticed.
+      const columns = db.prepare(`PRAGMA table_info(features)`).all() as {
+        name: string;
+      }[];
+      if (!columns.some((c) => c.name === "listed"))
+        db.exec(`ALTER TABLE features ADD COLUMN listed INTEGER`);
+      if (!columns.some((c) => c.name === "folded"))
+        db.exec(`ALTER TABLE features ADD COLUMN folded TEXT`);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS agent_prs (
+          url TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          repo TEXT NOT NULL,
+          number INTEGER NOT NULL,
+          seen_at TEXT NOT NULL DEFAULT (datetime('now')),
+          told_at TEXT
+        );
+      `);
+    },
+  },
+  {
+    id: 88,
+    name: "shared_links",
+    up: (db) => {
+      // Snapshot links made through Connect. Connect keeps only a digest of
+      // the token, so this is the one place the link can be copied again.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS shared_links (
+          id TEXT PRIMARY KEY,
+          url TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          title TEXT NOT NULL,
+          session_id TEXT,
+          artifact_id TEXT,
+          expires_at TEXT,
+          created_at TEXT NOT NULL,
+          revoked_at TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_shared_links_created
+          ON shared_links(created_at DESC);
+      `);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/queries.ts

@@ -56,15 +56,16 @@ export const queries = {
       `SELECT ${sessionListColumns(db)} FROM sessions ORDER BY updated_at DESC`
     ),
 
-  // The sidebar's sessions: not archived, and not a task that is over or
-  // lives on another machine.
+  // The sidebar's sessions: not archived, and not a dropped task (a
+  // rejection, not finished work) or one that lives on another machine.
+  // Merged tasks stay: they are the Done shelf.
   getSidebarSessions: (db: Database.Database) =>
     getStmt(
       db,
       `SELECT ${sessionListColumns(db)} FROM sessions
          WHERE archived_at IS NULL
            AND (task_status IS NULL
-                OR task_status NOT IN ('merged', 'dropped', 'moved'))
+                OR task_status NOT IN ('dropped', 'moved'))
          ORDER BY updated_at DESC`
     ),
 

package/lib/models/plan-step.ts

@@ -22,8 +22,14 @@ import { queueEvent } from "../orchestrator/events";
 import { noApprovalsOn, recordAutoApproval } from "../approvals/no-approvals";
 import { addNote } from "../orchestrator/notes";
 import { amendBrief, amendmentsOf } from "../orchestrator/amendments";
-import { PIECES_PROMPT, pieceBrief } from "../plans/pieces";
-import { createFeature, planFor, planPathOf, splitOf } from "../plans/features";
+import { PIECES_PROMPT, foldedBrief, pieceBrief } from "../plans/pieces";
+import {
+  createFeature,
+  ownPieceOf,
+  planFor,
+  planPathOf,
+  splitOf,
+} from "../plans/features";
 
 export const PLAN_FILE = ".agentos/plan.md";
 
@@ -52,10 +58,11 @@ export function implementPrompt(
   amendment?: string,
   piece?: string
 ): string {
+  const where = ` Work only in this task's repository; if part of the work belongs in another repository, say so in your final message instead of doing it there.`;
   const base = piece
-    ? `The plan is in \`${PLAN_FILE}\`. ${piece}\nFinish it as the task's instructions above say. Where the plan turns out wrong, do what's right and say so.`
+    ? `The plan is in \`${PLAN_FILE}\`. ${piece}\nFinish it as the task's instructions above say. Where the plan turns out wrong, do what's right and say so.${where}`
     : planned
-      ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.`
+      ? `The plan is in \`${PLAN_FILE}\`. Implement it now, finishing the task as its instructions above say. Where the plan turns out wrong, do what's right and say so.${where}`
       : `No plan was written to \`${PLAN_FILE}\`. Plan briefly, then implement the task, finishing it as its instructions above say.`;
   return amendment
     ? `${base}\n\nThe plan was approved with this change, which is now part of the task's scope:\n${amendment}`
@@ -104,7 +111,7 @@ function piecesLine(r: NonNullable<ReturnType<typeof planFor>>): string {
       ? ` after ${p.afterPosition} is ${p.afterKind}`
       : "";
     const why = p.reasons.length ? ` (${p.reasons.join("+")})` : "";
-    return `${p.position} ${p.name}${after}${why}`;
+    return `${p.position} ${p.name} [${p.project.name}]${after}${why}`;
   });
   const folded = r.folded.length ? `, ${r.folded.length} folded` : "";
   return `${r.pieces.length} pieces${folded}: ${parts.join("; ")}`;
@@ -130,6 +137,8 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
     if (summary.length) head += `\n${summary.map((l) => `- ${l}`).join("\n")}`;
     const pieces = planFor(s, fs.readFileSync(file, "utf8"));
     if (pieces && pieces.pieces.length > 1) head += `\n${piecesLine(pieces)}`;
+    if (pieces?.folded.length)
+      head += `\nPlan listed ${pieces.listed} pieces, building ${pieces.pieces.length}: ${pieces.folded.map((f) => `${f.name} folded (${f.why})`).join("; ")}`;
   } catch {
     // No plan file: the line says so.
   }
@@ -143,6 +152,46 @@ function announcePlan(s: Session, ref: string | null, retried = false): void {
   queueEvent(workspaceId!, `plan-done:${s.id}`, s.id, head);
 }
 
+// Plans that build as other than one piece in this repository say so, once.
+function sayHowItSplit(
+  s: Session,
+  workspaceId: string,
+  split: NonNullable<ReturnType<typeof splitOf>>,
+  nothingOwn: boolean
+): void {
+  if (nothingOwn)
+    queueEvent(
+      workspaceId,
+      `plan-routed:${s.id}`,
+      s.id,
+      `Task "${s.name}" split its plan into ${split.pieces.length} ${split.pieces.length === 1 ? "piece" : "pieces"} and none is first in its own repository, so it builds nothing itself and ends; each piece starts as its own task: ${split.pieces.map((p) => `${p.position} ${p.name} [${p.project.name}]`).join("; ")}.`
+    );
+  else if (split.folded.length)
+    queueEvent(
+      workspaceId,
+      `plan-folded:${s.id}`,
+      s.id,
+      `Plan of "${s.name}" listed ${split.listed} pieces, building ${split.pieces.length}: ${split.folded.map((f) => `${f.name} folded into ${f.into} (${f.why})`).join("; ")}. The task was told to build the folded work too.`
+    );
+}
+
+// A planning task with no piece of its own is finished: its pieces are
+// started as tasks in their projects, now rather than on the next sweep.
+async function handOffToPieces(s: Session): Promise<void> {
+  try {
+    const { doneSession } = await import("../done");
+    await doneSession(s.id, { by: "direct", noMerge: true });
+  } catch (e) {
+    console.error(`Ending planning task ${s.id} failed:`, e);
+  }
+  try {
+    const { releasePieces } = await import("../plans/release");
+    await releasePieces();
+  } catch (e) {
+    console.error("Starting the pieces failed:", e);
+  }
+}
+
 function readPlan(s: Session): string | null {
   try {
     return fs.readFileSync(path.join(s.worktree_path!, PLAN_FILE), "utf8");
@@ -180,8 +229,14 @@ async function startImplementing(
   });
   const id = implementMessageId(sessionId);
   const planText = readPlan(s);
-  const split = planText ? splitOf(s, planText) : null;
+  let split = planText ? splitOf(s, planText) : null;
   const workspaceId = sessionWorkspace(s);
+  // Approved despite pieces that couldn't be registered: built as one piece,
+  // and told so, rather than guessing which repository each belongs to.
+  const unreadable = split?.errors.length ? split.errors : null;
+  if (unreadable) split = null;
+  let nothingOwn = false;
+  let featureId: string | null = null;
   const claimed = db.transaction(() => {
     const changed = db
       .prepare(
@@ -193,18 +248,38 @@ async function startImplementing(
     setSessionModel(sessionId, routed);
     let piece: string | undefined;
     let note = amendment;
+    if (unreadable)
+      note = [
+        amendment,
+        `The plan's pieces couldn't be registered (${unreadable.join("; ")}); build the whole plan as one piece in this repository.`,
+      ]
+        .filter(Boolean)
+        .join("\n");
     if (split?.notBuilding.length)
       note = [amendment, `Not building: ${split.notBuilding.join("; ")}`]
         .filter(Boolean)
         .join("\n");
-    if (split && split.pieces.length > 1 && planText && workspaceId) {
-      const feature = createFeature(s, planText, split.pieces, workspaceId);
-      piece = pieceBrief(
-        split.pieces.length,
-        split.pieces[0],
-        planPathOf(feature.id)
-      );
+    if (split?.feature && planText && workspaceId) {
+      const feature = createFeature(s, planText, split.pieces, workspaceId, {
+        listed: split.listed,
+        folded: split.folded,
+      });
+      featureId = feature.id;
+      const own = ownPieceOf(split.pieces, s.project_id);
+      if (!own) nothingOwn = true;
+      else if (split.pieces.length === 1 && split.folded.length)
+        piece = foldedBrief(split);
+      else
+        piece = pieceBrief(
+          split.pieces.length,
+          own,
+          planPathOf(feature.id),
+          [],
+          own.project.name
+        );
     }
+    // Every piece is another task's: nothing for this one to implement.
+    if (nothingOwn) return true;
     enqueue(sessionId, {
       id,
       text: implementPrompt(
@@ -224,6 +299,12 @@ async function startImplementing(
       console.error("plan-done event failed:", e);
     }
   }
+  if (split?.feature && featureId && workspaceId)
+    sayHowItSplit(s, workspaceId, split, nothingOwn);
+  if (nothingOwn) {
+    await handOffToPieces(s);
+    return routed.ref;
+  }
   await applySessionModel(sessionId, s.model_provider ?? ANTHROPIC, routed);
   await send(sessionId, id);
   return routed.ref;
@@ -342,9 +423,12 @@ export async function handoffAfterPlan(
   deleteQueued(sessionId, planRetryMessageId(sessionId));
   const retried = waiting.get(sessionId)?.retried ?? false;
   forget(sessionId);
-  // No approvals mode doesn't stop at the plan to wait for one.
+  // No approvals mode doesn't stop at the plan to wait for one. Pieces that
+  // couldn't be registered always do: building on a guess is the bug.
   const auto = !!s.plan_only && noApprovalsOn();
-  if (!s.plan_only || auto) {
+  const planText = readPlan(s);
+  const pieceErrors = (planText ? splitOf(s, planText)?.errors : null) ?? [];
+  if ((!s.plan_only || auto) && !pieceErrors.length) {
     const ref = await startImplementing(
       s,
       "planning",
@@ -374,6 +458,14 @@ export async function handoffAfterPlan(
   } catch (e) {
     console.error("plan-done event failed:", e);
   }
+  const workspaceId = sessionWorkspace(s);
+  if (pieceErrors.length && workspaceId)
+    queueEvent(
+      workspaceId,
+      `plan-pieces:${s.id}`,
+      s.id,
+      `Plan of "${s.name}": couldn't register its pieces: ${pieceErrors.join("; ")}. It is held, not building. Message the task to fix the plan, or approve_plan to build it as one piece.`
+    );
   try {
     const text = readPlan(s);
     const planned = text ? planFor(s, text) : null;