@saadnvd1/agent-os 0.3.700 → 0.3.715

package/lib/security/demo.ts

@@ -49,23 +49,30 @@ export function assertDemoSandbox(env: Env = process.env, home = os.homedir()) {
 // "projects/[id]"): Next serves the folder, so an id must never match them.
 // The test walks app/api and fails when one is missing here.
 export const STATIC_SIBLINGS = [
+  "account",
   "archived",
   "arrived",
   "availability",
   "browse",
+  "check",
   "clone",
   "connect",
   "detect",
   "done-idle",
   "draft",
   "ended",
+  "exchange",
   "held-replies",
   "import",
   "init",
+  "group",
   "init-script",
   "me",
   "items",
+  "link",
   "network",
+  "order",
+  "pending",
   "pdf",
   "preview",
   "queue",

package/lib/session-groups/assignSessions.ts

@@ -0,0 +1,81 @@
+import { getDb } from "@/lib/db";
+import { liveGroup } from "./store";
+import { sessionWorkspaceId } from "./workspace";
+import { GroupError, type SessionGroup } from "./types";
+
+// The one place that checks the invariant: a session joins only a group of
+// its own workspace. Membership is a view choice, so it leaves updated_at
+// alone, like pinning.
+export function checkMember(sessionId: string, group: SessionGroup): void {
+  const workspaceId = sessionWorkspaceId(sessionId);
+  if (workspaceId === undefined)
+    throw new GroupError("not-found", "Session not found");
+  if ((workspaceId ?? null) !== (group.workspace_id ?? null))
+    throw new GroupError(
+      "workspace",
+      `"${group.name}" is a group of another workspace`
+    );
+}
+
+// Files sessions into a group, or out of any (groupId null). All or none.
+export function assignSessions(
+  sessionIds: readonly string[],
+  groupId: string | null
+): { moved: number } {
+  const ids = [...new Set(sessionIds)];
+  const group = groupId === null ? null : liveGroup(groupId);
+  const db = getDb();
+  return db.transaction(() => {
+    let moved = 0;
+    for (const id of ids) {
+      if (group) checkMember(id, group);
+      else if (sessionWorkspaceId(id) === undefined)
+        throw new GroupError("not-found", "Session not found");
+      moved += db
+        .prepare(
+          `UPDATE sessions SET session_group_id = ?
+           WHERE id = ? AND session_group_id IS NOT ?`
+        )
+        .run(group?.id ?? null, id, group?.id ?? null).changes;
+    }
+    return { moved };
+  })();
+}
+
+// For a session that is starting: its group may have been deleted, or its
+// workspace changed, since it was asked for. Starting must not fail over a
+// view choice, so it just starts ungrouped.
+export function fileInGroup(sessionId: string, groupId: string): void {
+  try {
+    assignSessions([sessionId], groupId);
+  } catch (err) {
+    if (!(err instanceof GroupError)) throw err;
+  }
+}
+
+// A new session starts in the group of the one it came from (a worker from its
+// conductor, a fork or a fresh start from its source), when that group is
+// still live and in the new session's workspace.
+export function inheritGroup(fromSessionId: string, toSessionId: string): void {
+  const row = getDb()
+    .prepare(`SELECT session_group_id AS id FROM sessions WHERE id = ?`)
+    .get(fromSessionId) as { id: string | null } | undefined;
+  if (row?.id) fileInGroup(toSessionId, row.id);
+}
+
+// Leaving a workspace leaves its groups (a project move into another one).
+export function clearForeignGroup(sessionId: string): string | null {
+  const row = getDb()
+    .prepare(
+      `SELECT g.id AS id, g.name AS name, g.workspace_id AS ws
+       FROM sessions s JOIN session_groups g ON g.id = s.session_group_id
+       WHERE s.id = ?`
+    )
+    .get(sessionId) as
+    { id: string; name: string; ws: string | null } | undefined;
+  if (!row || (sessionWorkspaceId(sessionId) ?? null) === row.ws) return null;
+  getDb()
+    .prepare(`UPDATE sessions SET session_group_id = NULL WHERE id = ?`)
+    .run(sessionId);
+  return row.name;
+}

package/lib/session-groups/cli.ts

@@ -0,0 +1,61 @@
+import { getDb } from "@/lib/db";
+import { resolveReadable, readerScope } from "@/lib/bus/read-scope";
+import { assignSessions } from "./assignSessions";
+import { createGroup } from "./createGroup";
+import { listGroups } from "./store";
+import { updateGroup } from "./updateGroup";
+import { resolveGroup } from "./resolveGroup";
+import { GroupError } from "./types";
+
+export type GroupCommand =
+  | { action: "list" }
+  | { action: "new"; name: string }
+  | { action: "rename"; group: string; name: string }
+  | { action: "add"; group: string; sessions: string[] }
+  | { action: "rm"; sessions: string[] };
+
+// `aos group ...`: the caller's own workspace's groups, resolved the way
+// `aos read` resolves sessions, so it reaches nothing outside that scope.
+export function groupCommand(callerId: string, cmd: GroupCommand): string {
+  const scope = readerScope(callerId);
+  const ws = scope.workspaceId;
+  if (cmd.action === "list") return describe(ws, scope.label);
+  if (cmd.action === "new") {
+    const g = createGroup(ws, cmd.name);
+    return `created group "${g.name}" in your ${scope.label}`;
+  }
+  if (cmd.action === "rename") {
+    const from = resolveGroup(ws, cmd.group);
+    return `renamed "${from.name}" to "${updateGroup(from.id, { name: cmd.name }).name}"`;
+  }
+  if (!cmd.sessions.length)
+    throw new GroupError("invalid", "Name at least one session");
+  const target = cmd.action === "add" ? resolveGroup(ws, cmd.group) : null;
+  const ids = cmd.sessions.map((ref) => {
+    if (ref === "me") return callerId;
+    const found = resolveReadable(callerId, ref);
+    if (!found.ok) throw new GroupError("not-found", found.error);
+    return found.session.id;
+  });
+  assignSessions(ids, target?.id ?? null);
+  return target
+    ? `put ${ids.length} session${ids.length === 1 ? "" : "s"} in "${target.name}"`
+    : `took ${ids.length} session${ids.length === 1 ? "" : "s"} out of their group`;
+}
+
+function describe(workspaceId: string | null, label: string): string {
+  const groups = listGroups(workspaceId);
+  if (!groups.length) return `no groups in your ${label}`;
+  const counts = new Map(
+    (
+      getDb()
+        .prepare(
+          `SELECT session_group_id AS id, COUNT(*) AS n FROM sessions
+           WHERE session_group_id IS NOT NULL AND archived_at IS NULL
+           GROUP BY session_group_id`
+        )
+        .all() as { id: string; n: number }[]
+    ).map((r) => [r.id, r.n])
+  );
+  return groups.map((g) => `${g.name}  ·  ${counts.get(g.id) ?? 0}`).join("\n");
+}

package/lib/session-groups/createGroup.ts

@@ -0,0 +1,28 @@
+import { randomUUID } from "crypto";
+import { getDb } from "@/lib/db";
+import { cleanName, findGroup, groupByName } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// A new group goes to the bottom of its workspace's order. The name is
+// unique within the workspace, ignoring case.
+export function createGroup(
+  workspaceId: string | null,
+  name: unknown
+): SessionGroup {
+  const clean = cleanName(name);
+  const db = getDb();
+  if (
+    workspaceId &&
+    !db.prepare(`SELECT 1 FROM workspaces WHERE id = ?`).get(workspaceId)
+  )
+    throw new GroupError("not-found", "Workspace not found");
+  if (groupByName(workspaceId, clean))
+    throw new GroupError("duplicate", `There is already a group "${clean}"`);
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO session_groups (id, workspace_id, name, sort_order)
+     VALUES (?, ?, ?, (SELECT COALESCE(MAX(sort_order) + 1, 0)
+       FROM session_groups WHERE COALESCE(workspace_id, '') = COALESCE(?, '')))`
+  ).run(id, workspaceId, clean, workspaceId);
+  return findGroup(id)!;
+}

package/lib/session-groups/index.ts

@@ -0,0 +1,21 @@
+export * from "./types";
+export {
+  groupNames,
+  listGroups,
+  findGroup,
+  groupByName,
+  liveGroup,
+} from "./store";
+export { createGroup } from "./createGroup";
+export { updateGroup } from "./updateGroup";
+export { reorderGroups } from "./reorderGroups";
+export { deleteGroup, restoreGroup } from "./removeGroup";
+export {
+  assignSessions,
+  checkMember,
+  clearForeignGroup,
+  fileInGroup,
+  inheritGroup,
+} from "./assignSessions";
+export { resolveGroup } from "./resolveGroup";
+export { sessionWorkspaceId } from "./workspace";

package/lib/session-groups/removeGroup.ts

@@ -0,0 +1,36 @@
+import { getDb } from "@/lib/db";
+import { findGroup, groupByName, liveGroup } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// Soft delete: members keep their session_group_id and the sidebar ignores a
+// deleted group, so they fall back to the status shelves and Undo (restore)
+// puts them back. Nothing is hard-deleted.
+export function deleteGroup(id: string): SessionGroup {
+  const group = liveGroup(id);
+  getDb()
+    .prepare(
+      `UPDATE session_groups SET deleted_at = datetime('now'),
+         updated_at = datetime('now') WHERE id = ?`
+    )
+    .run(id);
+  return group;
+}
+
+export function restoreGroup(id: string): SessionGroup {
+  const group = findGroup(id);
+  if (!group) throw new GroupError("not-found", "Group not found");
+  if (!group.deleted) return group;
+  // A new group took the name meanwhile.
+  if (groupByName(group.workspace_id, group.name))
+    throw new GroupError(
+      "duplicate",
+      `There is already a group "${group.name}"`
+    );
+  getDb()
+    .prepare(
+      `UPDATE session_groups SET deleted_at = NULL,
+         updated_at = datetime('now') WHERE id = ?`
+    )
+    .run(id);
+  return liveGroup(id);
+}

package/lib/session-groups/reorderGroups.ts

@@ -0,0 +1,31 @@
+import { getDb } from "@/lib/db";
+import { listGroups } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// Sets a workspace's group order. `ids` may name only some of them (a move
+// up or down sends the whole list; a stale list from another device leaves
+// newer groups at the end), but never one from another workspace.
+export function reorderGroups(
+  workspaceId: string | null,
+  ids: unknown
+): SessionGroup[] {
+  if (!Array.isArray(ids) || ids.some((i) => typeof i !== "string"))
+    throw new GroupError("invalid", "ids is a list of group ids");
+  const current = listGroups(workspaceId);
+  const known = new Set(current.map((g) => g.id));
+  const wanted = [...new Set(ids as string[])];
+  const stranger = wanted.find((i) => !known.has(i));
+  if (stranger)
+    throw new GroupError("workspace", "A group is not in this workspace");
+  const order = [
+    ...wanted,
+    ...current.map((g) => g.id).filter((i) => !wanted.includes(i)),
+  ];
+  const db = getDb();
+  const set = db.prepare(
+    `UPDATE session_groups SET sort_order = ?, updated_at = datetime('now')
+     WHERE id = ? AND sort_order != ?`
+  );
+  db.transaction(() => order.forEach((id, i) => set.run(i, id, i)))();
+  return listGroups(workspaceId);
+}

package/lib/session-groups/resolveGroup.ts

@@ -0,0 +1,19 @@
+import { groupByName, listGroups } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// A group named by a caller (`aos --group`, an orchestrator tool): it must
+// exist in that workspace, and the error lists the ones that do.
+export function resolveGroup(
+  workspaceId: string | null,
+  name: string
+): SessionGroup {
+  const found = groupByName(workspaceId, name);
+  if (found) return found;
+  const names = listGroups(workspaceId).map((g) => `"${g.name}"`);
+  throw new GroupError(
+    "not-found",
+    names.length
+      ? `No group "${name.trim()}" in this workspace. Groups: ${names.join(", ")}`
+      : `No group "${name.trim()}": this workspace has no groups`
+  );
+}

package/lib/session-groups/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import type { z } from "zod";
+import { GROUP_STATUS, GroupError } from "./types";
+
+// Runs a group action for a route: a body that fails its schema is a 400, a
+// GroupError becomes its status code.
+export async function groupRoute<S extends z.ZodType>(
+  request: Request,
+  schema: S,
+  act: (body: z.infer<S>) => unknown
+): Promise<NextResponse> {
+  const parsed = schema.safeParse(await request.json().catch(() => null));
+  if (!parsed.success)
+    return NextResponse.json(
+      { error: parsed.error.issues[0]?.message ?? "Bad request" },
+      { status: 400 }
+    );
+  return run(() => act(parsed.data));
+}
+
+export function run(act: () => unknown): NextResponse {
+  try {
+    return NextResponse.json(act());
+  } catch (err) {
+    if (err instanceof GroupError)
+      return NextResponse.json(
+        { error: err.message, code: err.code },
+        { status: GROUP_STATUS[err.code] }
+      );
+    throw err;
+  }
+}

package/lib/session-groups/store.ts

@@ -0,0 +1,85 @@
+import { getDb } from "@/lib/db";
+import { GroupError, NAME_MAX, type SessionGroup } from "./types";
+
+interface GroupRow extends Omit<SessionGroup, "collapsed"> {
+  collapsed: number;
+  deleted_at: string | null;
+}
+
+const COLUMNS = `id, workspace_id, name, sort_order, collapsed, created_at,
+  updated_at, deleted_at`;
+
+const toGroup = ({ deleted_at: _, ...row }: GroupRow): SessionGroup => ({
+  ...row,
+  collapsed: !!row.collapsed,
+});
+
+export function cleanName(name: unknown): string {
+  const trimmed =
+    typeof name === "string" ? name.trim().replace(/\s+/g, " ") : "";
+  if (!trimmed) throw new GroupError("invalid", "A group needs a name");
+  if (trimmed.length > NAME_MAX)
+    throw new GroupError(
+      "invalid",
+      `A group name is at most ${NAME_MAX} characters`
+    );
+  return trimmed;
+}
+
+// Live groups (not deleted), in the order to show them within a workspace.
+export function listGroups(workspaceId?: string | null): SessionGroup[] {
+  const rows = (
+    workspaceId === undefined
+      ? getDb()
+          .prepare(
+            `SELECT ${COLUMNS} FROM session_groups WHERE deleted_at IS NULL
+             ORDER BY sort_order, created_at`
+          )
+          .all()
+      : getDb()
+          .prepare(
+            `SELECT ${COLUMNS} FROM session_groups WHERE deleted_at IS NULL
+               AND COALESCE(workspace_id, '') = COALESCE(?, '')
+             ORDER BY sort_order, created_at`
+          )
+          .all(workspaceId)
+  ) as GroupRow[];
+  return rows.map(toGroup);
+}
+
+// Live groups' names by id, for labelling.
+export function groupNames(): Map<string, string> {
+  return new Map(listGroups().map((g) => [g.id, g.name]));
+}
+
+// Any group by id, deleted or not, with whether it is deleted.
+export function findGroup(
+  id: string
+): (SessionGroup & { deleted: boolean }) | null {
+  const row = getDb()
+    .prepare(`SELECT ${COLUMNS} FROM session_groups WHERE id = ?`)
+    .get(id) as GroupRow | undefined;
+  return row ? { ...toGroup(row), deleted: !!row.deleted_at } : null;
+}
+
+// A live group by id, or the error a caller should surface.
+export function liveGroup(id: unknown): SessionGroup {
+  const group = typeof id === "string" ? findGroup(id) : null;
+  if (!group) throw new GroupError("not-found", "Group not found");
+  if (group.deleted) throw new GroupError("deleted", "That group was deleted");
+  return group;
+}
+
+export function groupByName(
+  workspaceId: string | null,
+  name: string
+): SessionGroup | null {
+  const row = getDb()
+    .prepare(
+      `SELECT ${COLUMNS} FROM session_groups
+       WHERE deleted_at IS NULL AND lower(name) = lower(?)
+         AND COALESCE(workspace_id, '') = COALESCE(?, '')`
+    )
+    .get(name.trim(), workspaceId) as GroupRow | undefined;
+  return row ? toGroup(row) : null;
+}

package/lib/session-groups/types.ts

@@ -0,0 +1,25 @@
+export type { SessionGroup } from "@/lib/sidebar/shelves";
+
+export type GroupErrorCode =
+  "not-found" | "duplicate" | "workspace" | "invalid" | "deleted";
+
+// Thrown for anything the caller got wrong; routes map the code to a status.
+export class GroupError extends Error {
+  constructor(
+    readonly code: GroupErrorCode,
+    message: string
+  ) {
+    super(message);
+    this.name = "GroupError";
+  }
+}
+
+export const GROUP_STATUS: Record<GroupErrorCode, number> = {
+  "not-found": 404,
+  duplicate: 409,
+  workspace: 409,
+  invalid: 400,
+  deleted: 409,
+};
+
+export const NAME_MAX = 60;

package/lib/session-groups/updateGroup.ts

@@ -0,0 +1,35 @@
+import { getDb } from "@/lib/db";
+import { cleanName, groupByName, liveGroup } from "./store";
+import { GroupError, type SessionGroup } from "./types";
+
+// Rename and fold. Folding is stored here so every device agrees.
+export function updateGroup(
+  id: string,
+  patch: { name?: unknown; collapsed?: unknown }
+): SessionGroup {
+  const group = liveGroup(id);
+  const sets: string[] = [];
+  const args: (string | number)[] = [];
+  if (patch.name !== undefined) {
+    const clean = cleanName(patch.name);
+    const clash = groupByName(group.workspace_id, clean);
+    if (clash && clash.id !== id)
+      throw new GroupError("duplicate", `There is already a group "${clean}"`);
+    sets.push("name = ?");
+    args.push(clean);
+  }
+  if (patch.collapsed !== undefined) {
+    if (typeof patch.collapsed !== "boolean")
+      throw new GroupError("invalid", "collapsed must be a boolean");
+    sets.push("collapsed = ?");
+    args.push(patch.collapsed ? 1 : 0);
+  }
+  if (sets.length)
+    getDb()
+      .prepare(
+        `UPDATE session_groups SET ${sets.join(", ")},
+           updated_at = datetime('now') WHERE id = ?`
+      )
+      .run(...args, id);
+  return liveGroup(id);
+}

package/lib/session-groups/workspace.ts

@@ -0,0 +1,21 @@
+import { getDb } from "@/lib/db";
+
+// The workspace a session belongs to: its project's, else the one kept on the
+// session (an orchestrator, or a scratch session in no project). Same rule as
+// inWorkspace in lib/sidebar/shelves, read from the database.
+export function sessionWorkspaceId(
+  sessionId: string
+): string | null | undefined {
+  const row = getDb()
+    .prepare(
+      `SELECT s.role AS role, s.workspace_id AS own, p.workspace_id AS byProject
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       WHERE s.id = ?`
+    )
+    .get(sessionId) as
+    | { role: string | null; own: string | null; byProject: string | null }
+    | undefined;
+  if (!row) return undefined;
+  if (row.role === "orchestrator") return row.own;
+  return row.byProject ?? row.own;
+}

package/lib/sessions/launch.ts

@@ -3,6 +3,7 @@
  * then (for a worktree) the setup in the background, then the first message.
  */
 
+import { fileInGroup } from "../session-groups/assignSessions";
 import { agentosHome } from "../agentos-home";
 import type { StartVia } from "../tasks/starter";
 import fs from "fs";
@@ -82,8 +83,9 @@ export interface LaunchInput {
   // The workspace selected when it was started. A session in a project
   // follows the project; one in none keeps this (see inWorkspace).
   workspaceId?: string | null;
-  groupPath?: string;
   systemPrompt?: string | null;
+  // The user's group it starts in (lib/session-groups).
+  groupId?: string;
 }
 
 export interface Launched {
@@ -317,7 +319,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
       input.parentSessionId ?? null,
       model,
       input.systemPrompt ?? null,
-      input.groupPath ?? "sessions",
+      "sessions",
       agentType,
       input.autoApprove || input.access === "full" ? 1 : 0,
       project?.id ?? "uncategorized",
@@ -335,6 +337,7 @@ async function launch(input: LaunchInput, id: string): Promise<Launched> {
     id
   );
   setHome(id, home);
+  if (input.groupId) fileInGroup(id, input.groupId);
   if (interactive) setSessionModel(id, interactive);
   if (input.access)
     db.prepare(`UPDATE sessions SET chat_access = ? WHERE id = ?`).run(

package/lib/sidebar/rollup.ts

@@ -28,6 +28,7 @@ export function rollups(
   const rows = flatten([
     ...shelves.orchestrators,
     ...shelves.pinned,
+    ...shelves.groups.flatMap((g) => g.rows),
     ...shelves.needsYou,
     ...shelves.working,
     ...shelves.inReview,

package/lib/sidebar/row-menu.ts

@@ -21,6 +21,7 @@ export type RowMenuItem =
   | "new-conversation"
   | "move-machine"
   | "move-project"
+  | "move-group"
   | "check-ins"
   | "save-recipe"
   | "run-again"
@@ -133,6 +134,7 @@ export function rowMenu(input: RowMenuInput): RowMenuPlan {
     ...group("move", [
       input.machineTargets > 0 && "move-machine",
       agentRow && input.otherProjects > 0 && live && "move-project",
+      agentRow && "move-group",
     ]),
     ...group("automate", [
       input.hasWorkspace &&