@saadnvd1/agent-os 0.3.508 → 0.3.510

package/README.md

@@ -485,6 +485,17 @@ and the same actions in each row's menu; a row becomes the task's own row
 when it starts. Why it works
 this way: [docs/decisions/2026-10-10-queued-tasks.md](docs/decisions/2026-10-10-queued-tasks.md).
 
+A paired device's token can run the building loop through read-only routes:
+`GET /api/start-options?projectId=` (agents and models, the models a task can
+run on, machines, branches, whether a task plans first, in one request),
+`GET /api/tasks/<id>/diff` (the task's whole change, base to head: a file list,
+then `?file=<path>` for one file's patch; capped, with `truncated` when a cap
+is hit; read from the worktree, else the PR), and `GET /api/tasks/<id>/checks`
+(the PR head's checks, the tail of a failing job's log, and the review gate's
+verdict). A task's `plan` in `GET /api/tasks` carries `status` (`writing`,
+`ready` or `approved`), a title and capped text. Their shapes are in
+`lib/tasks/loop-types.ts`, which has no server imports so a client can share it.
+
 ## Model routing
 
 Each kind of work AgentOS launches an agent for runs on its own model, set in

package/app/api/git/check/route.ts

@@ -1,10 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import {
-  isGitRepo,
-  getBranches,
-  getDefaultBranch,
-  getCurrentBranch,
-} from "@/lib/git";
+import { gitCheck } from "@/lib/git";
 
 /**
  * POST /api/git/check
@@ -19,31 +14,7 @@ export async function POST(request: NextRequest) {
       return NextResponse.json({ error: "Path is required" }, { status: 400 });
     }
 
-    // Check if it's a git repo
-    const isRepo = await isGitRepo(dirPath);
-
-    if (!isRepo) {
-      return NextResponse.json({
-        isGitRepo: false,
-        branches: [],
-        defaultBranch: null,
-        currentBranch: null,
-      });
-    }
-
-    // Get branch info
-    const [branches, defaultBranch, currentBranch] = await Promise.all([
-      getBranches(dirPath),
-      getDefaultBranch(dirPath),
-      getCurrentBranch(dirPath),
-    ]);
-
-    return NextResponse.json({
-      isGitRepo: true,
-      branches,
-      defaultBranch,
-      currentBranch,
-    });
+    return NextResponse.json(await gitCheck(dirPath));
   } catch (error) {
     console.error("Error checking git repo:", error);
     return NextResponse.json(

package/app/api/projects/[id]/machines/route.ts

@@ -1,8 +1,6 @@
 import { NextResponse } from "next/server";
 import { getProject } from "@/lib/projects";
-import { projectRef } from "@/lib/tasks/project-ref";
-import { projectOnPeers } from "@/lib/hosts/peer-actions";
-import { linkedHostIds } from "@/lib/hosts/remote-api";
+import { projectMachines } from "@/lib/hosts/project-machines";
 
 // Which linked machines can take a session for this project, and why not
 // where one can't: { machines: { [hostId]: reason | null } }.
@@ -13,19 +11,5 @@ export async function GET(
   const project = getProject((await params).id);
   if (!project || project.is_uncategorized)
     return NextResponse.json({ error: "Project not found" }, { status: 404 });
-  if ((project.host_id || "local") !== "local")
-    return NextResponse.json({ machines: {} });
-  try {
-    return NextResponse.json({
-      machines: await projectOnPeers(await projectRef(project)),
-    });
-  } catch {
-    // A project outside the home folder has no place on another machine.
-    const reason = "Its folder is outside your home folder";
-    return NextResponse.json({
-      machines: Object.fromEntries(
-        [...linkedHostIds()].map((id) => [id, reason])
-      ),
-    });
-  }
+  return NextResponse.json({ machines: await projectMachines(project) });
 }

package/app/api/start-options/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { startOptions, UnknownProjectError } from "@/lib/start-options";
+
+// GET /api/start-options?projectId= - everything the start form needs in
+// one request: agents and their models, the models a task can run on, the
+// machines, the project's branches and whether a task plans first. Without
+// a project, the options for a scratch chat.
+export async function GET(request: NextRequest) {
+  try {
+    return NextResponse.json(
+      await startOptions(request.nextUrl.searchParams.get("projectId") || null)
+    );
+  } catch (error) {
+    if (error instanceof UnknownProjectError)
+      return NextResponse.json({ error: error.message }, { status: 404 });
+    console.error("Reading start options:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the start options" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, queries, type Session } from "@/lib/db";
+import { taskChecks } from "@/lib/tasks/checks-view";
+import { LoopError, localTask } from "@/lib/tasks/loop-error";
+import { isMirror } from "@/lib/tasks/remote";
+
+// GET /api/tasks/:id/checks - the PR head's checks, the tail of a failing
+// job's log, and the review gate's verdict on the head. ?log=0 leaves the
+// logs out. Log and verdict text is untrusted: show it, never run it.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const session = localTask(
+      queries.getSession(db).get(id) as Session | undefined,
+      isMirror
+    );
+    return NextResponse.json(
+      await taskChecks(session, {
+        logs: request.nextUrl.searchParams.get("log") !== "0",
+      })
+    );
+  } catch (error) {
+    if (error instanceof LoopError)
+      return NextResponse.json(
+        { error: error.message },
+        { status: error.status }
+      );
+    console.error("Reading a task's checks:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the task's checks" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, queries, type Session } from "@/lib/db";
+import { taskDiff } from "@/lib/tasks/diff";
+import { LoopError, localTask } from "@/lib/tasks/loop-error";
+import { isMirror } from "@/lib/tasks/remote";
+
+// GET /api/tasks/:id/diff - the task's whole change, base to head: a file
+// list with status and line counts; with ?file=<path>, that file's patch.
+// Sizes are capped and say "truncated" when a cap was hit.
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const session = localTask(
+      queries.getSession(db).get(id) as Session | undefined,
+      isMirror
+    );
+    return NextResponse.json(
+      await taskDiff(session, request.nextUrl.searchParams.get("file"))
+    );
+  } catch (error) {
+    if (error instanceof LoopError)
+      return NextResponse.json(
+        { error: error.message },
+        { status: error.status }
+      );
+    console.error("Reading a task's diff:", error);
+    return NextResponse.json(
+      { error: "Couldn't read the task's change" },
+      { status: 500 }
+    );
+  }
+}

package/data/models/index.ts

@@ -112,14 +112,4 @@ export function useCompareQuery(days: number, enabled = true) {
 }
 
 // Every model a role can be set to: each usable provider's, as references.
-export function modelChoices(effective: EffectiveModels | undefined) {
-  return (effective?.providers ?? [])
-    .filter((p) => p.enabled)
-    .flatMap((p) =>
-      p.models.map((m) => ({
-        ref: `${p.id}/${m}`,
-        label: m,
-        provider: p.label,
-      }))
-    );
-}
+export { modelChoices } from "@/lib/models/choices";

package/lib/connect/heartbeat.ts

@@ -0,0 +1,88 @@
+/**
+ * Tells the Connect service this machine is alive: one signed beat when
+ * Connect starts, then one a minute. The answer can switch the machine off
+ * (the account disabled it) or say it is gone (removed from the account).
+ * Nothing here may throw: a rejection would take AgentOS down.
+ */
+
+import fs from "fs";
+import path from "path";
+import { ApiError, clean } from "./control-api";
+
+export const HEARTBEAT_MS = 60_000;
+
+export interface HeartbeatOptions {
+  beat: () => Promise<{ enabled: boolean }>;
+  /** The account disabled this machine: stop the tunnel. */
+  onDisabled: () => void;
+  /** The service no longer knows this machine. */
+  onGone: () => void;
+  log?: (line: string) => void;
+  intervalMs?: number;
+}
+
+export function startHeartbeat(opts: HeartbeatOptions) {
+  const log = opts.log ?? (() => {});
+  const every = opts.intervalMs ?? HEARTBEAT_MS;
+  let stopped = false;
+  let failing = false;
+  let timer: NodeJS.Timeout | null = null;
+
+  const stop = () => {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+
+  const next = () => {
+    if (stopped) return;
+    timer = setTimeout(tick, every);
+    timer.unref?.();
+  };
+
+  const tick = async () => {
+    timer = null;
+    try {
+      const { enabled } = await opts.beat();
+      if (stopped) return;
+      failing = false;
+      if (enabled === false) {
+        stop();
+        log("connect: this machine was disabled in your account; tunnel off");
+        opts.onDisabled();
+        return;
+      }
+    } catch (err) {
+      if (stopped) return;
+      const status = err instanceof ApiError ? err.status : 0;
+      if (status === 401 || status === 404) {
+        stop();
+        log("connect: machine no longer linked, run agent-os connect");
+        opts.onGone();
+        return;
+      }
+      if (!failing) {
+        failing = true;
+        log(
+          `connect: heartbeat failed: ${clean((err as Error)?.message ?? String(err))}; retrying`
+        );
+      }
+    }
+    next();
+  };
+
+  void tick();
+  return { stop };
+}
+
+/** The running AgentOS version, from package.json. */
+export function appVersion(cwd = process.cwd()): string {
+  try {
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(cwd, "package.json"), "utf8")
+    ) as { version?: string };
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}

package/lib/connect/serve.ts

@@ -28,7 +28,13 @@ import {
   type ConnectConfig,
 } from "./config";
 import { shouldStartConnect, takeConnectLock } from "./guard";
-import { checkApiUrl, requestTunnel, type Tunnel } from "./control-api";
+import {
+  checkApiUrl,
+  heartbeat as sendHeartbeat,
+  requestTunnel,
+  type Tunnel,
+} from "./control-api";
+import { appVersion, startHeartbeat } from "./heartbeat";
 import { ensureCloudflared } from "./cloudflared";
 import { superviseTunnel, type Spawn, type TunnelState } from "./supervise";
 
@@ -93,12 +99,15 @@ export interface ConnectDeps {
   ) => Promise<Tunnel>;
   spawn?: Spawn;
   delays?: Parameters<typeof superviseTunnel>[0]["delays"];
+  heartbeat?: typeof sendHeartbeat;
+  heartbeatMs?: number;
 }
 
 interface Running {
   server: http.Server;
   sockets: Set<Socket>;
   supervisor: ReturnType<typeof superviseTunnel>;
+  heartbeat: ReturnType<typeof startHeartbeat>;
   release: () => void;
 }
 
@@ -115,6 +124,9 @@ export function startConnect(
   let base: ConnectStatus = { state: "off" };
   let hostname = "";
   let running: Running | null = null;
+  // Set when the service disabled or dropped this machine; sync() leaves it
+  // off until connect.json is turned off or relinked.
+  let halted: string | null = null;
   // Set while the tunnel listener can't bind; it keeps trying.
   let bindError: string | undefined;
   g.__agentosConnect = () => {
@@ -140,6 +152,7 @@ export function startConnect(
   const down = (why: string) => {
     if (!running) return;
     bindError = undefined;
+    running.heartbeat.stop();
     running.supervisor.stop();
     running.sockets.forEach((s) => s.destroy());
     running.server.close();
@@ -162,6 +175,14 @@ export function startConnect(
     hostname = config.hostname;
     base = { state: "off", enrolled: true, hostname: hostname || undefined };
     if (!read.enabled) return;
+    if (halted) {
+      base = {
+        ...base,
+        state: "off",
+        reason: "stopped by the Connect service",
+      };
+      return;
+    }
     try {
       checkApiUrl(config.apiUrl, env.AGENTOS_CONNECT_OPERATOR === "1");
     } catch (err) {
@@ -225,7 +246,22 @@ export function startConnect(
         return { bin, token: tunnel.token };
       },
     });
-    running = { server, sockets, supervisor, release: lock.release };
+    const beat = deps.heartbeat ?? sendHeartbeat;
+    const version = appVersion();
+    const heartbeat = startHeartbeat({
+      beat: () => beat(config, machineKey, version),
+      log,
+      intervalMs: deps.heartbeatMs,
+      onDisabled: () => {
+        halted = config.machineId;
+        down("disabled in your account");
+      },
+      onGone: () => {
+        halted = config.machineId;
+        down("machine no longer linked");
+      },
+    });
+    running = { server, sockets, supervisor, heartbeat, release: lock.release };
     server.listen(tunnelPort, "127.0.0.1");
   };
 
@@ -233,7 +269,12 @@ export function startConnect(
   const sync = () => {
     try {
       const read = readConnect(dir);
-      const want = read.ok && read.enabled;
+      if (
+        halted &&
+        (!read.ok || !read.enabled || read.files.config.machineId !== halted)
+      )
+        halted = null;
+      const want = read.ok && read.enabled && !halted;
       if (running && !want) down(read.ok ? "turned off" : read.reason);
       else if (!running && want) up();
       else if (!running) up(); // refreshes what the status shows

package/lib/git.ts

@@ -148,3 +148,27 @@ export async function renameBranch(
     { timeout: 10000 }
   );
 }
+
+export interface GitCheck {
+  isGitRepo: boolean;
+  branches: string[];
+  defaultBranch: string | null;
+  currentBranch: string | null;
+}
+
+/** Whether a path is a repository, and its branches. */
+export async function gitCheck(dirPath: string): Promise<GitCheck> {
+  if (!(await isGitRepo(dirPath)))
+    return {
+      isGitRepo: false,
+      branches: [],
+      defaultBranch: null,
+      currentBranch: null,
+    };
+  const [branches, defaultBranch, currentBranch] = await Promise.all([
+    getBranches(dirPath),
+    getDefaultBranch(dirPath),
+    getCurrentBranch(dirPath),
+  ]);
+  return { isGitRepo: true, branches, defaultBranch, currentBranch };
+}

package/lib/hosts/project-machines.ts

@@ -0,0 +1,19 @@
+import type { Project } from "../db";
+import { projectRef } from "../tasks/project-ref";
+import { projectOnPeers } from "./peer-actions";
+import { linkedHostIds } from "./remote-api";
+
+// Which linked machines can take a session for this project, and why not
+// where one can't: { [hostId]: reason | null }.
+export async function projectMachines(
+  project: Project
+): Promise<Record<string, string | null>> {
+  if ((project.host_id || "local") !== "local") return {};
+  try {
+    return await projectOnPeers(await projectRef(project));
+  } catch {
+    // A project outside the home folder has no place on another machine.
+    const reason = "Its folder is outside your home folder";
+    return Object.fromEntries([...linkedHostIds()].map((id) => [id, reason]));
+  }
+}

package/lib/models/choices.ts

@@ -0,0 +1,17 @@
+import type { EffectiveModels } from "./config";
+
+// The "provider/model" refs a task can run on: every model of each enabled
+// provider.
+export function modelChoices(
+  effective: Pick<EffectiveModels, "providers"> | undefined
+) {
+  return (effective?.providers ?? [])
+    .filter((p) => p.enabled)
+    .flatMap((p) =>
+      p.models.map((m) => ({
+        ref: `${p.id}/${m}`,
+        label: m,
+        provider: p.label,
+      }))
+    );
+}

package/lib/orchestrator/repo.ts

@@ -88,7 +88,7 @@ async function fetchBranches(
 }
 
 // origin/<branch> when it's there, else a local <branch>.
-async function existingRef(
+export async function existingRef(
   repo: string,
   branch: string
 ): Promise<string | null> {

package/lib/orchestrator/signoff.ts

@@ -43,7 +43,7 @@ const short = (sha: string) => sha.slice(0, 7);
 
 // The heads AgentOS's own restack, or its automatic rebase onto the base,
 // moved the task's branch between.
-function restackedOf(task: Session) {
+export function restackedOf(task: Session) {
   const item = stackQueries.itemForSession(db, task.id);
   if (item) return { from: item.restacked_from, to: item.restacked_to };
   return task.rebased_to

package/lib/start-options.ts

@@ -0,0 +1,93 @@
+/**
+ * What the start form needs in one request: the agents and their models, the
+ * models a task can run on, the machines, the default branch and whether a
+ * task plans first. Built from the helpers the web form already uses; never
+ * a provider's address or key reference, nor a machine's ssh target.
+ */
+
+import { AGENT_OPTIONS } from "./agent-options";
+import { probeAgents } from "./agents/probe";
+import { gitCheck } from "./git";
+import { listHosts } from "./hosts";
+import { projectMachines } from "./hosts/project-machines";
+import { getModelOptions, getDefaultModelForAgent } from "./model-catalog";
+import { effectiveModels } from "./models/config";
+import { modelChoices } from "./models/choices";
+import { resolveRole } from "./models/resolve";
+import { getProject } from "./projects";
+import { expandHome } from "./tasks/session";
+import { taskRouting } from "./tasks";
+import type { StartOptions } from "./tasks/loop-types";
+
+const BRANCHES_MAX = 50;
+
+export class UnknownProjectError extends Error {}
+
+export async function startOptions(
+  projectId: string | null
+): Promise<StartOptions> {
+  const project = projectId ? getProject(projectId) : undefined;
+  if (projectId && (!project || project.is_uncategorized))
+    throw new UnknownProjectError("Project not found");
+  const here = !project || (project.host_id || "local") === "local";
+  const models = effectiveModels();
+
+  let planDefault = false;
+  let planError: string | null = null;
+  const roles = { plan: "", implement: "" };
+  try {
+    const opts = { workspaceId: project?.workspace_id ?? null };
+    roles.plan = resolveRole("plan", opts, models).ref;
+    roles.implement = resolveRole("implement", opts, models).ref;
+    planDefault = taskRouting(opts.workspaceId, "chat", undefined).plan;
+  } catch (error) {
+    planError = error instanceof Error ? error.message : String(error);
+  }
+
+  const [probes, git, machines] = await Promise.all([
+    here ? probeAgents() : Promise.resolve(null),
+    project && here
+      ? gitCheck(expandHome(project.working_directory))
+      : Promise.resolve(null),
+    project
+      ? projectMachines(project)
+      : Promise.resolve<Record<string, string | null>>({}),
+  ]);
+
+  return {
+    project: project
+      ? {
+          id: project.id,
+          name: project.name,
+          agentType: project.agent_type,
+          defaultModel: project.default_model,
+          hostId: project.host_id || "local",
+        }
+      : null,
+    agents: AGENT_OPTIONS.map((a) => ({
+      value: a.value,
+      label: a.label,
+      installed: probes?.[a.value]?.installed ?? null,
+      auth: probes?.[a.value]?.auth ?? null,
+      hint: probes?.[a.value]?.hint ?? null,
+      models: getModelOptions(a.value),
+      defaultModel: getDefaultModelForAgent(a.value),
+    })),
+    taskModels: modelChoices(models),
+    roles,
+    planDefault,
+    planError,
+    hosts: listHosts().map((h) => ({
+      id: h.id,
+      name: h.name,
+      linked: h.id === "local" || Boolean(h.linked),
+      unavailable: machines[h.id] ?? null,
+    })),
+    git: git && {
+      isGitRepo: git.isGitRepo,
+      defaultBranch: git.defaultBranch,
+      currentBranch: git.currentBranch,
+      branches: git.branches.slice(0, BRANCHES_MAX),
+    },
+  };
+}