@saadnvd1/agent-os 0.3.824 → 0.3.825

package/lib/fork/worktree.ts

@@ -0,0 +1,115 @@
+/**
+ * A throwaway checkout for a fork child that has to edit code to find its
+ * answer (`aos fork --worktree`): detached at the parent's HEAD, with the
+ * parent's uncommitted changes applied on top, so it sees what the parent
+ * sees. No branch is made and nothing from it is merged; it is removed when
+ * the child settles.
+ */
+
+import fs from "fs";
+import path from "path";
+import { git } from "../git-exec";
+import { setupWorktree } from "../env-setup";
+import { forkHome, worktreeOf } from "./scratch";
+
+const MAX_UNTRACKED = 200;
+const MAX_UNTRACKED_BYTES = 5_000_000;
+// A change to these means the parent's installed packages may not match.
+const DEPENDENCY_FILES =
+  /(^|\/)(package\.json|package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?)$/;
+
+export interface ForkWorktree {
+  // Where the child runs: the parent's folder, in the checkout.
+  cwd: string;
+  // The checkout's root.
+  root: string;
+  // The parent's packages are linked in instead of installed.
+  linked: boolean;
+  // The commit it started from, for the child's return.
+  head: string;
+}
+
+export async function createForkWorktree(opts: {
+  childId: string;
+  parentCwd: string;
+}): Promise<ForkWorktree> {
+  const cwd = opts.parentCwd;
+  const top = (await git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+  const head = (await git(top, ["rev-parse", "HEAD"])).trim();
+  const wt = worktreeOf(opts.childId);
+  await fs.promises.mkdir(forkHome(opts.childId), { recursive: true });
+  try {
+    await git(top, ["worktree", "add", "--detach", "--", wt, head], {
+      timeout: 5 * 60_000,
+    });
+    const diff = await git(top, ["diff", "HEAD", "--binary"], {
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    if (diff.trim())
+      await git(wt, ["apply", "--whitespace=nowarn", "--binary", "-"], {
+        input: diff,
+      });
+    await copyUntracked(top, wt);
+    const changed = (await git(top, ["diff", "HEAD", "--name-only"]))
+      .split("\n")
+      .filter(Boolean);
+    const hasPackages = await exists(path.join(top, "node_modules"));
+    const linked =
+      hasPackages && !changed.some((f) => DEPENDENCY_FILES.test(f));
+    if (linked)
+      await fs.promises.symlink(
+        path.join(top, "node_modules"),
+        path.join(wt, "node_modules")
+      );
+    const setup = await setupWorktree({
+      worktreePath: wt,
+      sourcePath: top,
+      skipInstall: linked,
+    });
+    if (!setup.success)
+      throw new Error(
+        setup.steps.find((s) => !s.success)?.error ?? "worktree setup failed"
+      );
+    return {
+      cwd: path.join(wt, path.relative(top, cwd)),
+      root: wt,
+      linked,
+      head,
+    };
+  } catch (error) {
+    const { removeFork } = await import("./scratch");
+    await removeFork(opts.childId);
+    throw error;
+  }
+}
+
+const exists = (p: string) =>
+  fs.promises.access(p).then(
+    () => true,
+    () => false
+  );
+
+// Files the parent made and hasn't added yet, which a diff doesn't carry.
+async function copyUntracked(top: string, wt: string): Promise<void> {
+  const out = await git(top, [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+  ]);
+  const files = out.split("\0").filter(Boolean);
+  if (files.length > MAX_UNTRACKED)
+    throw new Error(
+      `the parent has ${files.length} new files; commit or stage them first`
+    );
+  for (const rel of files) {
+    const from = path.join(top, rel);
+    const stat = await fs.promises.lstat(from);
+    if (stat.isSymbolicLink() || !stat.isFile()) continue;
+    if (stat.size > MAX_UNTRACKED_BYTES)
+      throw new Error(`${rel} is too large to carry into a checkout`);
+    const to = path.join(wt, rel);
+    await fs.promises.mkdir(path.dirname(to), { recursive: true });
+    await fs.promises.copyFile(from, to);
+  }
+}

package/lib/orchestrator/shell-guard.ts

@@ -37,7 +37,7 @@ export interface ShellContext {
   protectedPids: () => Promise<Set<number>>;
 }
 
-interface Invocation {
+export interface Invocation {
   name: string;
   args: string[];
   cmd: SimpleCommand;
@@ -87,7 +87,10 @@ const SHELLS = /^(ba|z|da|k|fi|c|tc)?sh$/;
 
 // What a simple command runs once its wrappers are taken off: one
 // invocation, or several (`bash -c '…'`, `find -exec`).
-function invocations(cmd: SimpleCommand, depth = 0): Invocation[] | string {
+export function invocations(
+  cmd: SimpleCommand,
+  depth = 0
+): Invocation[] | string {
   let words = cmd.words;
   for (;;) {
     while (
@@ -183,7 +186,7 @@ function findInvocations(
 }
 
 // Words that aren't options; `--` ends options. `values` take the next word.
-function positionals(args: string[], values: string[] = []): string[] {
+export function positionals(args: string[], values: string[] = []): string[] {
   const out: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const a = args[i];

package/lib/orchestrator/write-guard.ts

@@ -130,7 +130,7 @@ const FOLDS_CASE =
 const key = (p: string) =>
   FOLDS_CASE ? p.normalize("NFC").toLowerCase() : p.normalize("NFC");
 
-const within = (p: string, root: string) => {
+export const within = (p: string, root: string) => {
   const [a, b] = [key(p), key(root)];
   return a === b || a.startsWith(b === "/" ? b : b + "/");
 };

package/lib/security/demo.ts

@@ -120,10 +120,9 @@ const READS = [
   "schedules",
   "schedules/[id]",
   "orchestrators",
-  "orchestrate/workers",
-  "orchestrate/workers/[id]",
   "bus/messages",
   "bus/peers",
+  "fork/children",
   "usage",
   "vendor/mermaid",
   "artifacts/[id]",

package/lib/sessions/end.ts

@@ -5,6 +5,8 @@ import { endTmuxSession } from "../tmux/end";
 import { releaseOnEnd, shutTaskSimulators } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 import { kickWaits } from "../bus/waits/kick";
+import { openChildren } from "../fork/ledger";
+import { cancelChildren } from "../fork/settle";
 
 type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
   Partial<Pick<Session, "worktree_path" | "branch_name">>;
@@ -14,6 +16,9 @@ type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
 // finish share.
 export async function endSessionAgent(s: Agent): Promise<void> {
   forgetPlanWait(s.id);
+  // Its forks have no one to report to.
+  if (openChildren(s.id).length)
+    void cancelChildren(s.id).catch(() => undefined);
   stopChat(s.id);
   // The task's simulator goes with it; no row, no work.
   releaseOnEnd(s.id, { remove: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.824",
+  "version": "0.3.825",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/server.ts

@@ -17,6 +17,7 @@ import { stackStartGate } from "./lib/orchestrator/brakes";
 import { buildId } from "./lib/build";
 import { startOrchestratorWatcher } from "./lib/orchestrator/watcher";
 import { startWaitWatcher } from "./lib/bus/waits/tick";
+import { startForkWatcher } from "./lib/fork/tick";
 import { installErrorCounter } from "./lib/health/errors";
 import { recordBoot } from "./lib/health/boots";
 import { realDeps, schedulesEnabled, startScheduler } from "./lib/schedules";
@@ -498,6 +499,7 @@ app.prepare().then(async () => {
   if (process.env.AGENTOS_ORCHESTRATOR !== "off") startOrchestratorWatcher();
   // Sessions waiting on each other (aos send --await, aos wait).
   startWaitWatcher();
+  startForkWatcher();
   // Schedules tick here, once a minute, and nowhere else.
   if (schedulesEnabled(process.env)) startScheduler(realDeps);
   // Looking for a newer version, and running an update when one is asked

package/app/api/orchestrate/spawn/route.ts

@@ -1,54 +0,0 @@
-import { NextResponse } from "next/server";
-import { resolveModelForAgent } from "@/lib/model-catalog";
-import { isValidAgentType, type AgentType } from "@/lib/providers";
-import { spawnWorker } from "@/lib/orchestration";
-
-export async function POST(request: Request) {
-  try {
-    const body = await request.json();
-    const {
-      conductorSessionId,
-      task,
-      workingDirectory,
-      branchName,
-      useWorktree = true,
-      model,
-      agentType: rawAgentType = "claude",
-    } = body;
-    const agentType: AgentType = isValidAgentType(rawAgentType)
-      ? rawAgentType
-      : "claude";
-    const resolvedModel = resolveModelForAgent(
-      agentType,
-      typeof model === "string" ? model.trim() : model
-    );
-
-    if (!conductorSessionId || !task || !workingDirectory) {
-      return NextResponse.json(
-        {
-          error:
-            "Missing required fields: conductorSessionId, task, workingDirectory",
-        },
-        { status: 400 }
-      );
-    }
-
-    const session = await spawnWorker({
-      conductorSessionId,
-      task,
-      workingDirectory,
-      branchName,
-      useWorktree,
-      model: resolvedModel,
-      agentType,
-    });
-
-    return NextResponse.json({ session });
-  } catch (error) {
-    console.error("Failed to spawn worker:", error);
-    return NextResponse.json(
-      { error: "Failed to spawn worker" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/orchestrate/workers/[id]/route.ts

@@ -1,89 +0,0 @@
-import { NextResponse } from "next/server";
-import {
-  getWorkerOutput,
-  sendToWorker,
-  completeWorker,
-  failWorker,
-  killWorker,
-} from "@/lib/orchestration";
-
-interface RouteParams {
-  params: Promise<{ id: string }>;
-}
-
-// GET /api/orchestrate/workers/[id] - Get worker output
-export async function GET(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const { searchParams } = new URL(request.url);
-    const lines = parseInt(searchParams.get("lines") || "50", 10);
-
-    const output = await getWorkerOutput(id, lines);
-    return NextResponse.json({ output });
-  } catch (error) {
-    console.error("Failed to get worker output:", error);
-    return NextResponse.json(
-      { error: "Failed to get worker output" },
-      { status: 500 }
-    );
-  }
-}
-
-// POST /api/orchestrate/workers/[id] - Send message or update status
-export async function POST(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const body = await request.json();
-    const { action, message } = body;
-
-    switch (action) {
-      case "send":
-        if (!message) {
-          return NextResponse.json(
-            { error: "Missing message" },
-            { status: 400 }
-          );
-        }
-        const sent = await sendToWorker(id, message);
-        return NextResponse.json({ success: sent });
-
-      case "complete":
-        completeWorker(id);
-        return NextResponse.json({ success: true });
-
-      case "fail":
-        failWorker(id);
-        return NextResponse.json({ success: true });
-
-      default:
-        return NextResponse.json(
-          { error: "Invalid action. Use: send, complete, or fail" },
-          { status: 400 }
-        );
-    }
-  } catch (error) {
-    console.error("Failed to perform worker action:", error);
-    return NextResponse.json(
-      { error: "Failed to perform worker action" },
-      { status: 500 }
-    );
-  }
-}
-
-// DELETE /api/orchestrate/workers/[id] - Kill worker
-export async function DELETE(request: Request, { params }: RouteParams) {
-  try {
-    const { id } = await params;
-    const { searchParams } = new URL(request.url);
-    const cleanupWorktree = searchParams.get("cleanup") === "true";
-
-    await killWorker(id, cleanupWorktree);
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("Failed to kill worker:", error);
-    return NextResponse.json(
-      { error: "Failed to kill worker" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/orchestrate/workers/route.ts

@@ -1,31 +0,0 @@
-import { NextResponse } from "next/server";
-import { getWorkers, getWorkersSummary } from "@/lib/orchestration";
-
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const conductorId = searchParams.get("conductorId");
-    const summaryOnly = searchParams.get("summary") === "true";
-
-    if (!conductorId) {
-      return NextResponse.json(
-        { error: "Missing conductorId parameter" },
-        { status: 400 }
-      );
-    }
-
-    if (summaryOnly) {
-      const summary = await getWorkersSummary(conductorId);
-      return NextResponse.json({ summary });
-    }
-
-    const workers = await getWorkers(conductorId);
-    return NextResponse.json({ workers });
-  } catch (error) {
-    console.error("Failed to get workers:", error);
-    return NextResponse.json(
-      { error: "Failed to get workers" },
-      { status: 500 }
-    );
-  }
-}

package/app/api/sessions/[id]/mcp-config/route.ts

@@ -1,34 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { db, queries, type Session } from "@/lib/db";
-import { ensureMcpConfig } from "@/lib/mcp-config";
-
-// POST /api/sessions/[id]/mcp-config - Ensure MCP config exists for this session
-export async function POST(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  try {
-    const { id } = await params;
-    const session = queries.getSession(db).get(id) as Session | undefined;
-
-    if (!session) {
-      return NextResponse.json({ error: "Session not found" }, { status: 404 });
-    }
-
-    // Expand ~ to home directory
-    const workingDirectory = session.working_directory.replace(
-      /^~/,
-      process.env.HOME || ""
-    );
-
-    ensureMcpConfig(workingDirectory, id);
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.error("Failed to write MCP config:", error);
-    return NextResponse.json(
-      { error: "Failed to write MCP config" },
-      { status: 500 }
-    );
-  }
-}

package/components/ConductorPanel.tsx

@@ -1,258 +0,0 @@
-"use client";
-
-import { useState, useEffect, useCallback } from "react";
-import { WorkerCard, type WorkerInfo } from "./WorkerCard";
-import { Button } from "./ui/button";
-import {
-  RefreshCw,
-  Users,
-  CheckCircle,
-  Loader2,
-  AlertCircle,
-  XCircle,
-} from "lucide-react";
-import { cn } from "@/lib/utils";
-
-interface WorkersSummary {
-  total: number;
-  pending: number;
-  running: number;
-  waiting: number;
-  completed: number;
-  failed: number;
-}
-
-interface ConductorPanelProps {
-  conductorSessionId: string;
-  onAttachToWorker?: (workerId: string) => void;
-}
-
-export function ConductorPanel({
-  conductorSessionId,
-  onAttachToWorker,
-}: ConductorPanelProps) {
-  const [workers, setWorkers] = useState<WorkerInfo[]>([]);
-  const [summary, setSummary] = useState<WorkersSummary | null>(null);
-  const [expandedWorkers, setExpandedWorkers] = useState<Set<string>>(
-    new Set()
-  );
-  const [workerOutputs, setWorkerOutputs] = useState<Record<string, string>>(
-    {}
-  );
-  const [loading, setLoading] = useState(true);
-  const [refreshing, setRefreshing] = useState(false);
-
-  const fetchWorkers = useCallback(async () => {
-    try {
-      const res = await fetch(
-        `/api/orchestrate/workers?conductorId=${conductorSessionId}`
-      );
-      const data = await res.json();
-      if (data.workers) {
-        setWorkers(data.workers);
-      }
-    } catch (error) {
-      console.error("Failed to fetch workers:", error);
-    }
-  }, [conductorSessionId]);
-
-  const fetchSummary = useCallback(async () => {
-    try {
-      const res = await fetch(
-        `/api/orchestrate/workers?conductorId=${conductorSessionId}&summary=true`
-      );
-      const data = await res.json();
-      if (data.summary) {
-        setSummary(data.summary);
-      }
-    } catch (error) {
-      console.error("Failed to fetch summary:", error);
-    }
-  }, [conductorSessionId]);
-
-  const fetchWorkerOutput = useCallback(async (workerId: string) => {
-    try {
-      const res = await fetch(`/api/orchestrate/workers/${workerId}?lines=30`);
-      const data = await res.json();
-      if (data.output) {
-        setWorkerOutputs((prev) => ({ ...prev, [workerId]: data.output }));
-      }
-    } catch (error) {
-      console.error("Failed to fetch worker output:", error);
-    }
-  }, []);
-
-  const refresh = useCallback(async () => {
-    setRefreshing(true);
-    await Promise.all([fetchWorkers(), fetchSummary()]);
-    setRefreshing(false);
-  }, [fetchWorkers, fetchSummary]);
-
-  // Initial load
-  useEffect(() => {
-    const load = async () => {
-      setLoading(true);
-      await Promise.all([fetchWorkers(), fetchSummary()]);
-      setLoading(false);
-    };
-    load();
-  }, [fetchWorkers, fetchSummary]);
-
-  // Poll for updates every 5 seconds
-  useEffect(() => {
-    const interval = setInterval(refresh, 5000);
-    return () => clearInterval(interval);
-  }, [refresh]);
-
-  // Fetch output for expanded workers
-  useEffect(() => {
-    expandedWorkers.forEach((workerId) => {
-      if (!workerOutputs[workerId]) {
-        fetchWorkerOutput(workerId);
-      }
-    });
-  }, [expandedWorkers, workerOutputs, fetchWorkerOutput]);
-
-  const toggleExpand = (workerId: string) => {
-    setExpandedWorkers((prev) => {
-      const next = new Set(prev);
-      if (next.has(workerId)) {
-        next.delete(workerId);
-      } else {
-        next.add(workerId);
-        // Fetch output when expanding
-        fetchWorkerOutput(workerId);
-      }
-      return next;
-    });
-  };
-
-  const handleSendMessage = async (workerId: string, message: string) => {
-    try {
-      await fetch(`/api/orchestrate/workers/${workerId}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ action: "send", message }),
-      });
-      // Refresh output after sending
-      setTimeout(() => fetchWorkerOutput(workerId), 1000);
-    } catch (error) {
-      console.error("Failed to send message:", error);
-    }
-  };
-
-  const handleKillWorker = async (workerId: string) => {
-    if (!confirm("Kill this worker?")) return;
-    try {
-      await fetch(`/api/orchestrate/workers/${workerId}`, {
-        method: "DELETE",
-      });
-      await refresh();
-    } catch (error) {
-      console.error("Failed to kill worker:", error);
-    }
-  };
-
-  if (loading) {
-    return (
-      <div className="flex h-full items-center justify-center">
-        <Loader2 className="text-muted-foreground h-6 w-6 animate-spin" />
-      </div>
-    );
-  }
-
-  if (workers.length === 0) {
-    return (
-      <div className="text-muted-foreground flex h-full flex-col items-center justify-center">
-        <Users className="mb-4 h-12 w-12 opacity-50" />
-        <p className="text-lg font-medium">No workers yet</p>
-        <p className="text-sm">
-          This conductor hasn&apos;t spawned any workers.
-        </p>
-        <p className="mt-4 max-w-md text-center text-xs">
-          Use the MCP tools or API to spawn workers. The conductor can delegate
-          tasks to parallel worker sessions.
-        </p>
-      </div>
-    );
-  }
-
-  return (
-    <div className="flex h-full flex-col">
-      {/* Header with summary */}
-      <div className="flex items-center justify-between border-b p-4">
-        <div className="flex items-center gap-4">
-          <div className="flex items-center gap-2">
-            <Users className="text-primary h-5 w-5" />
-            <span className="font-semibold">Workers</span>
-            <span className="text-muted-foreground">
-              ({summary?.total || workers.length})
-            </span>
-          </div>
-
-          {summary && (
-            <div className="flex items-center gap-3 text-sm">
-              {summary.running > 0 && (
-                <div className="flex items-center gap-1 text-green-500">
-                  <Loader2 className="h-3 w-3 animate-spin" />
-                  <span>{summary.running} running</span>
-                </div>
-              )}
-              {summary.waiting > 0 && (
-                <div className="flex items-center gap-1 text-yellow-500">
-                  <AlertCircle className="h-3 w-3" />
-                  <span>{summary.waiting} waiting</span>
-                </div>
-              )}
-              {summary.completed > 0 && (
-                <div className="flex items-center gap-1 text-green-500">
-                  <CheckCircle className="h-3 w-3" />
-                  <span>{summary.completed} done</span>
-                </div>
-              )}
-              {summary.failed > 0 && (
-                <div className="flex items-center gap-1 text-red-500">
-                  <XCircle className="h-3 w-3" />
-                  <span>{summary.failed} failed</span>
-                </div>
-              )}
-            </div>
-          )}
-        </div>
-
-        <Button
-          variant="ghost"
-          size="icon-sm"
-          onClick={refresh}
-          disabled={refreshing}
-        >
-          <RefreshCw className={cn("h-4 w-4", refreshing && "animate-spin")} />
-        </Button>
-      </div>
-
-      {/* Workers grid */}
-      <div className="flex-1 overflow-auto p-4">
-        <div className="grid grid-cols-1 gap-3 lg:grid-cols-2">
-          {workers.map((worker) => (
-            <WorkerCard
-              key={worker.id}
-              worker={worker}
-              isExpanded={expandedWorkers.has(worker.id)}
-              output={workerOutputs[worker.id]}
-              onToggleExpand={() => toggleExpand(worker.id)}
-              onViewOutput={() => {
-                toggleExpand(worker.id);
-                fetchWorkerOutput(worker.id);
-              }}
-              onSendMessage={(msg) => handleSendMessage(worker.id, msg)}
-              onKill={() => handleKillWorker(worker.id)}
-              onAttach={
-                onAttachToWorker ? () => onAttachToWorker(worker.id) : undefined
-              }
-            />
-          ))}
-        </div>
-      </div>
-    </div>
-  );
-}