@saadnvd1/agent-os 0.3.700 → 0.3.715

package/lib/__fixtures__/peer-rpc.ts

@@ -5,6 +5,7 @@
  */
 
 import http, { type IncomingMessage, type ServerResponse } from "http";
+import { NextRequest } from "next/server";
 import type { AddressInfo } from "net";
 import type { FakeMachine } from "@/lib/__fixtures__/peer-machine";
 import { tunnelListener } from "@/lib/connect/serve";
@@ -30,8 +31,11 @@ export interface Seen {
   body: string;
 }
 
-/** What Next would be: echoes how the gate saw the call. */
-function fakeNext(seen: Seen[]) {
+/** A real route handler, run behind the gate as Next would run it. */
+export type Route = (req: NextRequest) => Response | Promise<Response>;
+
+/** What Next would be: echoes how the gate saw the call, or runs `routes`. */
+function fakeNext(seen: Seen[], routes: Record<string, Route>) {
   return async (req: IncomingMessage, res: ServerResponse) => {
     let body = "";
     for await (const c of req) body += c;
@@ -41,6 +45,22 @@ function fakeNext(seen: Seen[]) {
       headers: { ...req.headers },
       body,
     });
+    const route = routes[(req.url ?? "").split("?")[0]];
+    if (route) {
+      const headers = new Headers();
+      for (const [k, v] of Object.entries(req.headers))
+        if (typeof v === "string") headers.set(k, v);
+      const out = await route(
+        new NextRequest(`http://127.0.0.1${req.url}`, {
+          method: req.method,
+          headers,
+          body: body || undefined,
+        })
+      );
+      res.statusCode = out.status;
+      res.setHeader("Content-Type", out.headers.get("content-type") ?? "");
+      return res.end(Buffer.from(await out.arrayBuffer()));
+    }
     res.setHeader("Content-Type", "application/json");
     res.setHeader("Set-Cookie", "aos_device=leak");
     if (req.url?.startsWith("/api/tasks/t-9/merge")) {
@@ -77,7 +97,8 @@ const listen = (s: http.Server) =>
 /** One machine's AgentOS: its loopback listener and its tunnel listener. */
 export async function machine(
   me: FakeMachine,
-  pinFor: (machineId: string) => PeerPin | null
+  pinFor: (machineId: string) => PeerPin | null,
+  o: { routes?: Record<string, Route>; unlinked?: RpcDeps["unlinked"] } = {}
 ): Promise<Machine> {
   const seen: Seen[] = [];
   const policy: AuthPolicy = {
@@ -85,12 +106,13 @@ export async function machine(
     lookup: (t) => (t === "aosd_phone" ? { id: "phone" } : null),
     peerSecret,
   };
-  const next = fakeNext(seen);
+  const next = fakeNext(seen, o.routes ?? {});
   let internalPort = 0;
   const deps: RpcDeps = {
     identity: () => me,
     boxKey: () => me.box,
     pinForMachine: pinFor,
+    unlinked: o.unlinked,
     anyActive: () => true,
     replay: createReplayGuard(),
     dispatch: (d: Parameters<ReturnType<typeof loopbackDispatch>>[0]) =>
@@ -135,36 +157,46 @@ export function edge(
     const m = machines.find((x) => x.hostname === url.hostname);
     if (url.protocol !== "https:" || !m) throw new Error("no such host");
     const body = init?.body ? Buffer.from(init.body as Uint8Array) : undefined;
-    const { status, buf } = await new Promise<{ status: number; buf: Buffer }>(
-      (resolve, reject) => {
-        const out = http.request(
-          {
-            host: "127.0.0.1",
-            port: m.tunnelPort,
-            method: init?.method ?? "GET",
-            path: url.pathname + url.search,
-            headers: {
-              ...(init?.headers as Record<string, string>),
-              host: url.hostname,
-              ...(body && { "content-length": String(body.length) }),
-            },
+    const { status, buf, headers } = await new Promise<{
+      status: number;
+      buf: Buffer;
+      headers: Record<string, string>;
+    }>((resolve, reject) => {
+      const out = http.request(
+        {
+          host: "127.0.0.1",
+          port: m.tunnelPort,
+          method: init?.method ?? "GET",
+          path: url.pathname + url.search,
+          headers: {
+            ...(init?.headers as Record<string, string>),
+            host: url.hostname,
+            ...(body && { "content-length": String(body.length) }),
           },
-          (res) => {
-            const chunks: Buffer[] = [];
-            res.on("data", (c) => chunks.push(c));
-            res.on("end", () =>
-              resolve({
-                status: res.statusCode ?? 0,
-                buf: Buffer.concat(chunks),
-              })
-            );
-          }
-        );
-        out.on("error", reject);
-        out.end(body);
-      }
-    );
-    return new Response(new Uint8Array(tamper ? tamper(buf) : buf), { status });
+        },
+        (res) => {
+          const chunks: Buffer[] = [];
+          res.on("data", (c) => chunks.push(c));
+          res.on("end", () =>
+            resolve({
+              status: res.statusCode ?? 0,
+              buf: Buffer.concat(chunks),
+              headers: Object.fromEntries(
+                Object.entries(res.headers).filter(
+                  (e): e is [string, string] => typeof e[1] === "string"
+                )
+              ),
+            })
+          );
+        }
+      );
+      out.on("error", reject);
+      out.end(body);
+    });
+    return new Response(new Uint8Array(tamper ? tamper(buf) : buf), {
+      status,
+      headers,
+    });
   }) as typeof fetch;
 }
 

package/lib/agents/spawn.ts

@@ -8,6 +8,7 @@ import { parseOverride, resolveRole, setSessionModel } from "../models/resolve";
 import { ANTHROPIC } from "../models/roles";
 import { launchClaude } from "./launch";
 import { nameFor } from "../session-titles";
+import { fileInGroup } from "../session-groups/assignSessions";
 
 // "dashboards" or a project id; case-insensitive on name.
 export function findProject(ref: string) {
@@ -37,6 +38,8 @@ export async function spawnSession(opts: {
   // model unless `model` is given.
   startedBy?: string | null;
   parentSessionId?: string | null;
+  // The user's group it starts in (lib/session-groups).
+  groupId?: string;
 }): Promise<Session> {
   const prompt = opts.prompt.trim();
   if (!prompt) throw new Error("Give the new session a prompt");
@@ -91,6 +94,7 @@ export async function spawnSession(opts: {
         ? "session"
         : "person",
   });
+  if (opts.groupId) fileInGroup(id, opts.groupId);
   if (routed) setSessionModel(id, routed);
   void naming.refine?.(id);
   await launchClaude({ sessionId: id, tmuxName, cwd, model, prompt });

package/lib/bus/index.ts

@@ -38,6 +38,7 @@ import {
   waitBadges,
 } from "./waits/store";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
+import { groupNames } from "../session-groups/store";
 
 export * from "./format";
 export {
@@ -64,6 +65,8 @@ export interface Peer {
   // Names of the sessions it waits on, and of those waiting on it.
   waitingOn: string[];
   waitedBy: string[];
+  // The user's group it sits in, when it is in one.
+  group?: string;
 }
 
 // A chat has no pane: its worker is the state, and it can always take a
@@ -99,6 +102,7 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
   const caller = sessionById(callerId);
   const orchestrator = heldOrchestrator(caller);
   const badges = waitBadges();
+  const groups = groupNames();
   const listed = await Promise.all(
     sessions.map(async (s, i) => {
       const info = await peerState(s);
@@ -114,6 +118,10 @@ export async function listPeers(callerId?: string): Promise<Peer[]> {
         orchestratorOf: orchestratorOf(s),
         waitingOn: badges.get(s.id)?.on.map((w) => w.name) ?? [],
         waitedBy: badges.get(s.id)?.by.map((w) => w.name) ?? [],
+        ...(s.session_group_id &&
+          groups.has(s.session_group_id) && {
+            group: groups.get(s.session_group_id),
+          }),
         ...(caller?.workspace_id &&
           s.role === "orchestrator" &&
           s.workspace_id === caller.workspace_id && { yours: true }),

package/lib/claims/collectLocal.ts

@@ -0,0 +1,121 @@
+// Turns this machine's live sessions into claims: the repo, branch and the
+// paths their diff touches so far. Only paths leave git, never content.
+
+import { getDb } from "../db";
+import { getCurrentBranch, getDefaultBranch } from "../git";
+import { git } from "../git-exec";
+import { repoKey } from "../git-remote";
+import { IN_FLIGHT } from "../tasks/queue-rows";
+import { expandHome } from "../tasks/session";
+import { MAX_FILES } from "./types";
+import {
+  localLiveSessionIds,
+  release,
+  upsertLocal,
+  type LocalClaim,
+} from "./store";
+
+interface SessionRow {
+  id: string;
+  name: string;
+  working_directory: string;
+  worktree_path: string | null;
+  branch_name: string | null;
+  base_branch: string | null;
+  pr_url: string | null;
+  pr_status: string | null;
+  task_status: string | null;
+}
+
+const OPTS = { timeout: 5000 };
+
+const paths = (out: string) => out.split("\0").filter(Boolean);
+
+export async function changedFiles(
+  dir: string,
+  base: string
+): Promise<string[]> {
+  const mergeBase = (
+    await git(dir, ["merge-base", "HEAD", `origin/${base}`], OPTS).catch(() =>
+      git(dir, ["merge-base", "HEAD", base], OPTS).catch(() => "")
+    )
+  ).trim();
+  const [committed, untracked] = await Promise.all([
+    mergeBase
+      ? git(dir, ["diff", "--name-only", "-z", mergeBase], OPTS)
+      : git(dir, ["diff", "--name-only", "-z", "HEAD"], OPTS).catch(() => ""),
+    git(dir, ["ls-files", "--others", "--exclude-standard", "-z"], OPTS),
+  ]);
+  return [...new Set([...paths(committed), ...paths(untracked)])];
+}
+
+// Sessions that can hold a claim: local, not a mirror of another machine's.
+function candidates(): SessionRow[] {
+  return getDb()
+    .prepare(
+      `SELECT id, name, working_directory, worktree_path, branch_name, base_branch,
+              pr_url, pr_status, task_status
+         FROM session_rows
+        WHERE archived_at IS NULL AND COALESCE(peer_mirror, 0) = 0
+          AND (host_id IS NULL OR host_id = 'local')`
+    )
+    .all() as SessionRow[];
+}
+
+const last = new Map<string, LocalClaim>();
+
+// Writes this machine's claims and releases the ones whose session is gone,
+// finished, or whose PR closed. A git failure keeps the last good paths.
+export async function collectLocal(origin: {
+  id: string;
+  name: string;
+}): Promise<void> {
+  const alive = new Set<string>();
+  for (const s of candidates()) {
+    try {
+      const done = s.pr_status === "merged" || s.pr_status === "closed";
+      const idleTask =
+        s.task_status &&
+        !IN_FLIGHT.includes(s.task_status) &&
+        s.pr_status !== "open";
+      if (done || idleTask) {
+        if (done) release(s.id, s.pr_status === "merged" ? "merged" : "done");
+        continue;
+      }
+      const dir = expandHome(s.worktree_path || s.working_directory);
+      const repo = await repoKey(dir);
+      if (!repo) continue;
+      const branch = s.branch_name || (await getCurrentBranch(dir));
+      const base = s.base_branch || (await getDefaultBranch(dir));
+      let files: string[];
+      try {
+        files = await changedFiles(dir, base);
+      } catch {
+        files = last.get(s.id)?.files ?? [];
+      }
+      // A shell sitting on the default branch with no changes claims nothing.
+      if ((branch === base || branch === "HEAD") && !files.length) continue;
+      const claim: LocalClaim = {
+        sessionId: s.id,
+        sessionName: s.name,
+        repo,
+        branch,
+        base,
+        goal: s.name,
+        files: files.slice(0, MAX_FILES),
+        filesMore: Math.max(0, files.length - MAX_FILES),
+        prUrl: s.pr_url,
+      };
+      last.set(s.id, claim);
+      upsertLocal(origin, claim);
+      alive.add(s.id);
+    } catch {
+      // This session claims nothing this round.
+    }
+  }
+  for (const id of localLiveSessionIds())
+    if (!alive.has(id)) {
+      release(id, "abandoned");
+      last.delete(id);
+    }
+}

package/lib/claims/describe.ts

@@ -0,0 +1,41 @@
+// The claims as text for the orchestrator and `aos claims`. A goal and a
+// session name are another machine's words: fenced as data.
+
+import { untrusted } from "../orchestrator/untrusted";
+import { machineId } from "./machine";
+import { findOverlaps } from "./overlap";
+import type { Claim } from "./types";
+
+const ago = (ms: number) => {
+  const m = Math.max(0, Math.round(ms / 60_000));
+  return m < 1 ? "just now" : m < 60 ? `${m}m` : `${Math.round(m / 60)}h`;
+};
+
+export function describeClaims(
+  claims: Claim[],
+  opts: { onlyOthers?: boolean; now?: number } = {}
+): string {
+  const now = opts.now ?? Date.now();
+  const self = machineId();
+  const shown = opts.onlyOthers
+    ? claims.filter((c) => c.origin !== self)
+    : claims;
+  if (!shown.length) return "";
+  const lines = shown.map((c) => {
+    const where = c.origin === self ? "here" : `on ${c.originName}`;
+    const files = c.files.length + c.filesMore;
+    return `- ${untrusted("claim", c.goal)} ${where}, ${c.branch ?? "no branch"}, ${files} file${files === 1 ? "" : "s"}, started ${ago(now - c.startedAt)} ago${c.prUrl ? `, ${c.prUrl}` : ""}`;
+  });
+  const overlaps = findOverlaps(claims).filter(
+    (o) => !opts.onlyOthers || o.a.origin !== self || o.b.origin !== self
+  );
+  const tail = overlaps.map(
+    (o) =>
+      `! ${o.strength} overlap (${o.kinds.join("+")}): ${untrusted("claim", o.a.goal)} (${o.a.originName}) and ${untrusted("claim", o.b.goal)} (${o.b.originName})${o.shared.length ? `, shared ${o.shared.slice(0, 5).join(", ")}` : ""}`
+  );
+  return [
+    "Claimed work (live sessions on linked machines):",
+    ...lines,
+    ...tail,
+  ].join("\n");
+}

package/lib/claims/exchange.ts

@@ -0,0 +1,91 @@
+// The claims exchange between linked machines: one request carries our claims
+// and brings back theirs. The side that holds the link does the calling, so
+// it works when only one machine can reach the other.
+
+import { hostApi, HostApiError, type HostLink } from "../hosts/remote-api";
+import { claimsShared, machineId, machineName } from "./machine";
+import { exchangeTargets, peerMachineOf, rememberPeer } from "./peers";
+import { upsertRemote, wireFor } from "./store";
+import { exchangeBody, type ExchangeBody } from "./types";
+
+const OLD_PEER_MS = 60 * 60_000;
+const skipUntil = new Map<string, number>();
+const failing = new Set<string>();
+
+export const selfMachine = () => ({ id: machineId(), name: machineName() });
+
+// Takes what a peer sent; returns how many claims were new or newer.
+// viaHost is the link it arrived through, when we know it.
+export function acceptExchange(
+  body: ExchangeBody,
+  viaHost: string | null = null,
+  now = Date.now()
+): number {
+  if (!claimsShared()) return 0;
+  const self = machineId();
+  if (body.machine.id === self) return 0;
+  let n = 0;
+  for (const c of body.claims)
+    if (upsertRemote(self, body.machine.id, c, now, viaHost)) n++;
+  return n;
+}
+
+// What we answer a peer that called: our claims, not echoed back to it.
+export function answerExchange(body: ExchangeBody): ExchangeBody {
+  const self = selfMachine();
+  return {
+    machine: self,
+    claims: claimsShared()
+      ? wireFor(self.id, { machineId: body.machine.id })
+      : [],
+  };
+}
+
+async function exchangeOver(
+  link: HostLink,
+  self: { id: string; name: string },
+  log: (line: string) => void
+): Promise<boolean> {
+  const hostId = link.hostId;
+  if ((skipUntil.get(hostId) ?? 0) > Date.now()) return false;
+  try {
+    const raw = await hostApi<unknown>(link, "/api/claims/exchange", {
+      body: {
+        machine: self,
+        claims: wireFor(self.id, { machineId: peerMachineOf(hostId) }),
+      },
+      timeout: 8000,
+    });
+    const parsed = exchangeBody.safeParse(raw);
+    if (!parsed.success) throw new Error("its answer wasn't claims");
+    rememberPeer(hostId, parsed.data.machine.id);
+    acceptExchange(parsed.data, hostId);
+    failing.delete(hostId);
+    return true;
+  } catch (err) {
+    if (err instanceof HostApiError && err.status === 404) {
+      skipUntil.set(hostId, Date.now() + OLD_PEER_MS);
+      return false;
+    }
+    if (!failing.has(hostId)) {
+      failing.add(hostId);
+      log(
+        `claims: ${link.hostName} didn't answer: ${(err as Error)?.message ?? err}`
+      );
+    }
+    return false;
+  }
+}
+
+// Each machine once per tick, over its best working link.
+export async function syncPeers(
+  log: (line: string) => void = () => {}
+): Promise<void> {
+  if (!claimsShared()) return;
+  const self = selfMachine();
+  await Promise.all(
+    exchangeTargets().map(async (links) => {
+      for (const link of links) if (await exchangeOver(link, self, log)) return;
+    })
+  );
+}

package/lib/claims/goal.ts

@@ -0,0 +1,45 @@
+// How alike two one-line goals read: the share of content words they have
+// in common. Words every task title has (add, fix, update) carry nothing.
+
+const STOP = new Set(
+  "a an and the to of for in on at with from by or as is are be it its this that into via add adds added fix fixes fixed update updates make makes use using new support improve implement allow when not no all use".split(
+    " "
+  )
+);
+
+const stem = (w: string) =>
+  w.length > 5 && w.endsWith("ing")
+    ? w.slice(0, -3)
+    : w.length > 3 && w.endsWith("s") && !w.endsWith("ss")
+      ? w.slice(0, -1)
+      : w;
+
+export function goalWords(goal: string): Set<string> {
+  return new Set(
+    goal
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter((w) => w.length > 1 && !STOP.has(w))
+      .map(stem)
+  );
+}
+
+export function goalSimilarity(
+  a: string,
+  b: string
+): {
+  score: number;
+  shared: number;
+} {
+  const x = goalWords(a);
+  const y = goalWords(b);
+  let shared = 0;
+  for (const w of x) if (y.has(w)) shared++;
+  const union = x.size + y.size - shared;
+  return { score: union ? shared / union : 0, shared };
+}
+
+export const goalsAlike = (a: string, b: string) => {
+  const { score, shared } = goalSimilarity(a, b);
+  return score >= 0.5 && shared >= 2;
+};

package/lib/claims/index.ts

@@ -0,0 +1,10 @@
+export { startClaimsLoop, claimsTick } from "./loop";
+export { acceptExchange, answerExchange, selfMachine } from "./exchange";
+export { liveClaim, liveClaims } from "./store";
+export { findOverlaps, overlapBetween } from "./overlap";
+export { describeClaims } from "./describe";
+export { claimsShared, machineId, machineName } from "./machine";
+export type { Claim, Overlap, ClaimWire } from "./types";
+export { endOutside, registerOutside } from "./outside";
+export { claimsSnapshot, refreshOverlapCache } from "./overlapCache";
+export { claimsView } from "./view";

package/lib/claims/loop.ts

@@ -0,0 +1,51 @@
+import { collectLocal } from "./collectLocal";
+import { selfMachine, syncPeers } from "./exchange";
+import { claimsShared } from "./machine";
+import { dropViaInactive } from "./peers";
+import { notifyOverlaps } from "./notifyOverlaps";
+import { handleMerged } from "./onMerged";
+import { refreshOverlapCache } from "./overlapCache";
+import { purgeExpired } from "./store";
+import { CLAIMS_SYNC_MS } from "./types";
+
+export async function claimsTick(
+  log: (line: string) => void = () => {}
+): Promise<void> {
+  if (!claimsShared()) return;
+  try {
+    await collectLocal(selfMachine());
+    await syncPeers(log);
+    await notifyOverlaps();
+    await handleMerged();
+    dropViaInactive();
+    purgeExpired();
+    refreshOverlapCache();
+  } catch (err) {
+    log(`claims: ${(err as Error)?.message ?? err}`);
+  }
+}
+
+// One tick a minute. Nothing here may throw into the server.
+export function startClaimsLoop(
+  log: (line: string) => void = (l) => console.log(l)
+): { stop: () => void } {
+  let stopped = false;
+  let timer: NodeJS.Timeout | null = null;
+  const next = () => {
+    if (stopped) return;
+    timer = setTimeout(run, CLAIMS_SYNC_MS);
+    timer.unref?.();
+  };
+  const run = async () => {
+    await claimsTick(log);
+    next();
+  };
+  timer = setTimeout(run, 5000);
+  timer.unref?.();
+  return {
+    stop: () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    },
+  };
+}

package/lib/claims/machine.ts

@@ -0,0 +1,21 @@
+import { randomUUID } from "crypto";
+import os from "os";
+import { getSetting, putSetting } from "../settings-store";
+
+const ID_KEY = "claims.machine_id";
+
+export function machineId(): string {
+  const have = getSetting(ID_KEY);
+  if (have) return have;
+  const id = randomUUID();
+  putSetting(ID_KEY, id);
+  return id;
+}
+
+export function machineName(): string {
+  const set = getSetting("claims.machine_name")?.trim();
+  return (set || os.hostname().split(".")[0] || "machine").slice(0, 60);
+}
+
+// Off: this machine neither sends nor takes claims.
+export const claimsShared = () => getSetting("claims.share") !== "off";

package/lib/claims/mine.ts

@@ -0,0 +1,43 @@
+// The strong overlaps that touch a session on this machine, each seen from
+// that session's side. Pure over the claims it is given.
+
+import { findOverlaps } from "./overlap";
+import { pairKey, whoYields } from "./yield";
+import type { Claim } from "./types";
+
+export interface SessionOverlap {
+  sessionId: string;
+  pairKey: string;
+  mine: Claim;
+  other: Claim;
+  shared: string[];
+  kinds: ("branch" | "files" | "goal")[];
+  // This session is the one asked to give way.
+  yields: boolean;
+}
+
+export function sessionOverlaps(
+  self: string,
+  claims: Claim[]
+): SessionOverlap[] {
+  const out: SessionOverlap[] = [];
+  for (const o of findOverlaps(claims)) {
+    if (o.strength !== "strong") continue;
+    const yielder = whoYields(o.a, o.b);
+    for (const [mine, other] of [
+      [o.a, o.b],
+      [o.b, o.a],
+    ] as const)
+      if (mine.origin === self && mine.sessionId)
+        out.push({
+          sessionId: mine.sessionId,
+          pairKey: pairKey(o.a, o.b),
+          mine,
+          other,
+          shared: o.shared,
+          kinds: o.kinds,
+          yields: yielder === mine,
+        });
+  }
+  return out;
+}