@saadnvd1/agent-os 0.3.631 → 0.3.639

package/lib/session-audit/sources.ts

@@ -81,7 +81,7 @@ export function loadSessions(
       `SELECT s.id, s.name, s.created_at, s.role, s.view, s.task_prompt,
               length(s.task_brief) AS task_brief_chars, s.working_directory,
               s.worktree_path, s.claude_session_id, s.workspace_id, p.name AS project
-         FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+         FROM session_rows s LEFT JOIN projects p ON p.id = s.project_id
         WHERE coalesce(s.host_id, 'local') = 'local'`
     )
     .all() as SessionRow[];
@@ -297,8 +297,8 @@ export function loadSignals(
   }>(
     `SELECT m.from_id, m.to_id, m.body, f.role AS from_role, (t.task_prompt IS NOT NULL) AS to_task
        FROM bus_messages m
-       LEFT JOIN sessions f ON f.id = m.from_id
-       LEFT JOIN sessions t ON t.id = m.to_id
+       LEFT JOIN session_rows f ON f.id = m.from_id
+       LEFT JOIN session_rows t ON t.id = m.to_id
       WHERE m.created_at >= ? AND m.created_at < ?`,
     a,
     b

package/lib/session-logs/index.ts

@@ -120,7 +120,7 @@ export async function writeLog(
   id: string,
   opts: CaptureOpts & { plan?: string | null } = {}
 ): Promise<boolean> {
-  const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  const row = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
   const existing = getLog(id);

package/lib/session-titles.ts

@@ -283,7 +283,7 @@ export function titleChatFromMessage(
 ): Promise<void> | void {
   const s = db
     .prepare(
-      `SELECT name, name_source, working_directory, task_prompt FROM sessions WHERE id = ?`
+      `SELECT name, name_source, working_directory, task_prompt FROM session_rows WHERE id = ?`
     )
     .get(sessionId) as
     | {

package/lib/sessions/setup-progress.ts

@@ -110,7 +110,7 @@ export function getSetup(sessionId: string): SetupView | null {
 function savedSetup(sessionId: string): string | null {
   const row = db
     .prepare(
-      `SELECT setup_status FROM sessions WHERE id = ? AND task_status IS NULL`
+      `SELECT setup_status FROM session_rows WHERE id = ? AND task_status IS NULL`
     )
     .get(sessionId) as { setup_status: string | null } | undefined;
   return row?.setup_status ?? null;

package/lib/sessions/stop.ts

@@ -2,7 +2,7 @@ import { endTmuxSession } from "../tmux/end";
 import { hostLink } from "../hosts/remote-api";
 import { stopChatTurn } from "../chat/stop";
 import type { Session } from "../db";
-import { isHeldRemote, stopHeldTask } from "../tasks/held-remote";
+import { isHeldRemote, stopHeldTask } from "../tasks/contract/held-calls";
 import { releaseOnEnd } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 

package/lib/sessions/worktree-setup.ts

@@ -175,7 +175,8 @@ export function failInterruptedSetups(): number {
            THEN COALESCE((SELECT working_directory FROM projects WHERE id = sessions.project_id), working_directory)
            ELSE working_directory END,
          setup_error = 'AgentOS restarted before setup finished. Your message is still queued: send it when you are ready.'
-       WHERE setup_status = 'running' AND task_status IS NULL`
+       WHERE setup_status = 'running'
+         AND id IN (SELECT id FROM session_rows WHERE task_status IS NULL)`
     )
     .run().changes;
 }

package/lib/simulator/index.ts

@@ -70,7 +70,7 @@ export { simulatorAvailable };
 export { shutTaskSimulators, shutFinishedTaskSimulators } from "./task-devices";
 
 const session = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 

package/lib/simulator/task-devices.ts

@@ -148,7 +148,7 @@ export async function shutFinishedTaskSimulators(): Promise<number> {
       db
         .prepare(
           `SELECT id, branch_name, worktree_path, task_status, host_id
-           FROM sessions WHERE task_status IS NOT NULL`
+           FROM session_rows WHERE task_status IS NOT NULL`
         )
         .all() as (TaskRef & { host_id: string })[]
     ).filter((t) => !isRemoteHost(t.host_id));

package/lib/stacks/board.ts

@@ -44,7 +44,7 @@ export function toPlanCards(
 function runningTasks(boardId: string): Map<string, string> {
   const rows = db
     .prepare(
-      `SELECT id, lh_card_id FROM sessions
+      `SELECT id, lh_card_id FROM session_rows
        WHERE lh_board_id = ? AND lh_card_id IS NOT NULL AND task_status = 'running'`
     )
     .all(boardId) as Array<{ id: string; lh_card_id: string }>;

package/lib/stacks/land.ts

@@ -67,7 +67,7 @@ export const LAND_DEFAULTS: LandDeps = {
 
 const sessionOf = (id: string | null) =>
   (id
-    ? db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id)
+    ? db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id)
     : undefined) as Session | undefined;
 
 class Stop extends Error {}

package/lib/stacks/restack.ts

@@ -109,7 +109,7 @@ const defaults: RestackDeps = {
 
 const sessionOf = (id: string | null) =>
   id
-    ? ((db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+    ? ((db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
         | Session
         | undefined) ?? null)
     : null;

package/lib/stacks/start.ts

@@ -25,7 +25,7 @@ async function stackedBase(
   item: StackItemRow
 ) {
   const session = db
-    .prepare(`SELECT * FROM sessions WHERE id = ?`)
+    .prepare(`SELECT * FROM session_rows WHERE id = ?`)
     .get(parent.session_id) as Session | undefined;
   const branch = session?.branch_name;
   if (!branch) throw new Error(`${itemName(parent)} has no branch to stack on`);
@@ -52,7 +52,7 @@ async function stackedBase(
 export function existingTask(cardId: string): string | null {
   const row = db
     .prepare(
-      `SELECT id FROM sessions WHERE lh_card_id = ? AND task_status = 'running'
+      `SELECT id FROM session_rows WHERE lh_card_id = ? AND task_status = 'running'
        ORDER BY created_at DESC LIMIT 1`
     )
     .get(cardId) as { id: string } | undefined;

package/lib/stacks/tick.ts

@@ -39,7 +39,7 @@ export function setStartGate(gate: StartGate | null): void {
 const LIVE = new Set(["running", "pr"]);
 
 const sessionOf = (id: string) =>
-  db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as
+  db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
     | Session
     | undefined;
 

package/lib/stacks/view.ts

@@ -51,7 +51,7 @@ const prUrlOf = (sessionId: string | null) =>
   sessionId
     ? ((
         db
-          .prepare(`SELECT pr_url FROM sessions WHERE id = ?`)
+          .prepare(`SELECT pr_url FROM session_rows WHERE id = ?`)
           .get(sessionId) as { pr_url: string | null } | undefined
       )?.pr_url ?? null)
     : null;

package/lib/status/incremental.ts

@@ -60,7 +60,7 @@ export function resetStatusCaches(): void {
 function loadRows(dirty: Set<string>): void {
   const rows = getDb()
     .prepare(
-      `SELECT s.*, p.workspace_id AS project_workspace_id FROM sessions s
+      `SELECT s.*, p.workspace_id AS project_workspace_id FROM session_rows s
          LEFT JOIN projects p ON p.id = s.project_id
         WHERE s.archived_at IS NULL`
     )

package/lib/tasks/contract/actions.ts

@@ -0,0 +1,35 @@
+import type { Session } from "../../db";
+import { requireHostLink } from "../../hosts/remote-api";
+import type { MergeMethod } from "../merge-methods";
+import * as client from "./client";
+import { setMirrorStatus } from "./start";
+
+/**
+ * Sign off on the machine that runs it. It returns the method that machine
+ * merged with; null when it doesn't say (an older AgentOS).
+ */
+export async function mergeThere(
+  session: Session,
+  head?: string,
+  base?: string | null
+): Promise<MergeMethod | null> {
+  const link = requireHostLink(session.host_id);
+  const res = await client.merge(
+    link,
+    session.id,
+    head ? { head, base } : undefined,
+    session.name
+  );
+  setMirrorStatus(session.id, "merged");
+  if (head && res.head !== head)
+    throw new Error(
+      `${link.hostName} merged without confirming it was ${head.slice(0, 7)}`
+    );
+  return res.method;
+}
+
+/** Drop on the machine that runs it. */
+export async function dropThere(session: Session): Promise<void> {
+  await client.drop(requireHostLink(session.host_id), session.id);
+  setMirrorStatus(session.id, "dropped");
+}

package/lib/tasks/contract/authorize.ts

@@ -0,0 +1,82 @@
+/**
+ * Who may call a task route on the machine that runs the task. One rule per
+ * route, applied the same way everywhere:
+ *
+ *  - holder: a task an orchestrator on another machine holds (held.ts); only
+ *    the device that holds it, and a task nobody holds is "No such held task".
+ *  - open: the holder, when there is one; any caller otherwise. A mirror row
+ *    or a task started here is never held, so this machine's own web UI
+ *    (which sends no device) is never refused on them.
+ *  - plan: open, and a plan another machine placed here is read and approved
+ *    by that machine only.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { db, type Session } from "../../db";
+import { callingDevice } from "../../security/device-me";
+import { heldRefusal, holderRefusal, planWaitRefusal } from "../held";
+
+export type Rule = "holder" | "open" | "plan";
+
+type Ctx = { params: Promise<{ id: string }> };
+
+export interface Refusal {
+  status: 403 | 404;
+  error: string;
+}
+
+export function callerRefusal(
+  id: string,
+  device: string | null | undefined,
+  rule: Rule
+): Refusal | null {
+  if (rule === "holder") {
+    const task = db
+      .prepare(
+        `SELECT held_by_device, held_from FROM session_rows WHERE id = ?`
+      )
+      .get(id) as Pick<Session, "held_by_device" | "held_from"> | undefined;
+    if (!task?.held_by_device)
+      return { status: 404, error: "No such held task" };
+    const error = holderRefusal(task, device);
+    return error ? { status: 403, error } : null;
+  }
+  const error =
+    heldRefusal(id, device) ??
+    (rule === "plan" ? planWaitRefusal(id, device) : null);
+  return error ? { status: 403, error } : null;
+}
+
+/** The refusal as a response, or null when the caller may go on. */
+export function refuse(
+  request: NextRequest,
+  id: string,
+  rule: Rule
+): NextResponse | null {
+  const refusal = callerRefusal(id, callingDevice(request), rule);
+  return refusal
+    ? NextResponse.json({ error: refusal.error }, { status: refusal.status })
+    : null;
+}
+
+export async function taskRoute(
+  request: NextRequest,
+  { params }: Ctx,
+  rule: Rule,
+  run: (task: Session) => Promise<object>
+): Promise<NextResponse> {
+  const id = (await params).id;
+  const refused = refuse(request, id, rule);
+  if (refused) return refused;
+  const task = db.prepare(`SELECT * FROM session_rows WHERE id = ?`).get(id) as
+    | Session
+    | undefined;
+  if (!task)
+    return NextResponse.json({ error: "No such task" }, { status: 404 });
+  try {
+    return NextResponse.json(await run(task));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return NextResponse.json({ error: message }, { status: 409 });
+  }
+}

package/lib/tasks/contract/client.ts

@@ -0,0 +1,296 @@
+/**
+ * The one client for a task running on a linked machine: every call the Mac
+ * makes to that machine's task API, with its path, body, timeout and retry in
+ * one place. Callers hold a HostLink and say what they want; none of them
+ * builds a task URL.
+ */
+
+import { MERGE_METHODS, type MergeMethod } from "../merge-methods";
+import type { Session } from "../../db";
+import {
+  HostApiError,
+  cleanRemoteBlock,
+  cleanRemoteText,
+  hostApi,
+  type HostLink,
+} from "../../hosts/remote-api";
+import type { OrchestratedBundle } from "../move-bundle";
+import type { TaskBundle } from "../move-bundle";
+import {
+  HELD_REPLIES,
+  IMPORT,
+  LIST,
+  TIMEOUT,
+  arrivedPath,
+  taskPath,
+} from "./routes";
+import type { ChatFacts, HostTasks } from "./types";
+
+export const unknownOutcome = (err: unknown) =>
+  err instanceof HostApiError && !err.refused;
+
+/** POST a call that's safe to repeat; once more if we can't tell it landed. */
+export async function postIdempotent<T>(
+  link: HostLink,
+  path: string,
+  body: unknown,
+  timeout: number
+): Promise<T> {
+  try {
+    return await hostApi<T>(link, path, { body, timeout });
+  } catch (err) {
+    if (!unknownOutcome(err)) throw err;
+    return hostApi<T>(link, path, { body, timeout });
+  }
+}
+
+/** POST, repeated when the outcome is unknown (the calls are idempotent). */
+export async function tell(
+  link: HostLink,
+  path: string,
+  body: object = {}
+): Promise<void> {
+  for (let i = 0; ; i++) {
+    try {
+      await hostApi(link, path, { body });
+      return;
+    } catch (err) {
+      if (!unknownOutcome(err) || i === 2) throw err;
+    }
+  }
+}
+
+const cache = new Map<string, { at: number; list: Promise<HostTasks> }>();
+
+/** The machine's task list; the last answer within 3 s unless `fresh`. */
+export function list(link: HostLink, fresh = false): Promise<HostTasks> {
+  const hit = cache.get(link.hostId);
+  if (!fresh && hit && Date.now() - hit.at < 3000) return hit.list;
+  const next = hostApi<HostTasks>(link, LIST, { timeout: TIMEOUT.list });
+  cache.set(link.hostId, { at: Date.now(), list: next });
+  next.catch(() => cache.delete(link.hostId));
+  return next;
+}
+
+export const forget = (hostId: string) => cache.delete(hostId);
+
+export async function view(
+  link: HostLink,
+  id: string,
+  fresh = false
+): Promise<HostTasks["tasks"][number] | undefined> {
+  const { tasks } = await list(link, fresh);
+  return (Array.isArray(tasks) ? tasks : []).find((t) => t?.id === id);
+}
+
+/**
+ * A machine on an older AgentOS would take a chat task as a terminal one,
+ * or an orchestrator's task as a plain one that anyone there could merge, or
+ * refuse to hand one over.
+ */
+export async function requireCapability(
+  link: HostLink,
+  capability: string,
+  what: string,
+  verb = "move"
+): Promise<void> {
+  const { capabilities = [] } = await list(link, true).catch((err) => {
+    throw new Error(
+      `Can't ask ${link.hostName} whether it takes ${what}: ${(err as Error).message}`
+    );
+  });
+  if (!capabilities.includes(capability))
+    throw new Error(
+      `${link.hostName}'s AgentOS can't ${verb} ${what} yet; update it first`
+    );
+}
+
+export const start = (link: HostLink, body: object) =>
+  postIdempotent<{ session: Session }>(link, LIST, body, TIMEOUT.start);
+
+export async function plan(link: HostLink, id: string): Promise<string | null> {
+  const { text } = await hostApi<{ text: string | null }>(
+    link,
+    taskPath(id, "plan"),
+    { timeout: TIMEOUT.plan }
+  );
+  return text;
+}
+
+export const approvePlan = (link: HostLink, id: string, message?: string) =>
+  hostApi<{ model?: string }>(link, taskPath(id, "approve-plan"), {
+    body: message ? { message } : {},
+    timeout: TIMEOUT.approvePlan,
+  });
+
+export async function hold(
+  link: HostLink,
+  id: string,
+  orchestrated: OrchestratedBundle
+): Promise<void> {
+  await hostApi(link, taskPath(id, "hold"), {
+    body: { orchestrated },
+    timeout: TIMEOUT.hold,
+  });
+}
+
+export async function message(
+  link: HostLink,
+  id: string,
+  body: { id?: string; line: string; from: string }
+): Promise<"queued" | "delivered"> {
+  const { state } = await hostApi<{ state?: unknown }>(
+    link,
+    taskPath(id, "message"),
+    { body, timeout: TIMEOUT.message }
+  );
+  return state === "queued" ? "queued" : "delivered";
+}
+
+export async function chatTail(
+  link: HostLink,
+  id: string,
+  lines: number
+): Promise<string | null> {
+  const { text } = await hostApi<{ text?: unknown }>(
+    link,
+    `${taskPath(id, "chat-tail")}?lines=${lines}`,
+    { timeout: TIMEOUT.chat }
+  );
+  // Whole lines, as a local read has them (read.ts caps and trims them).
+  return typeof text === "string" ? cleanRemoteBlock(text, 16000) : null;
+}
+
+export async function chatFacts(
+  link: HostLink,
+  id: string
+): Promise<ChatFacts | null> {
+  const res = await hostApi<{ blocked?: unknown; turn?: unknown }>(
+    link,
+    taskPath(id, "chat-facts"),
+    { timeout: TIMEOUT.chat }
+  );
+  if (res.blocked !== null && typeof res.blocked !== "string") return null;
+  if (res.turn !== null && typeof res.turn !== "string") return null;
+  return {
+    blocked: res.blocked ? cleanRemoteBlock(res.blocked, 2000) : null,
+    turn: res.turn,
+  };
+}
+
+export async function stop(link: HostLink, id: string): Promise<string> {
+  const { text } = await hostApi<{ text?: unknown }>(
+    link,
+    taskPath(id, "stop"),
+    {
+      body: {},
+      timeout: TIMEOUT.stop,
+    }
+  );
+  return cleanRemoteText(text);
+}
+
+export async function done(link: HostLink, id: string): Promise<void> {
+  await hostApi(link, taskPath(id, "done"), {
+    body: {},
+    timeout: TIMEOUT.done,
+  });
+}
+
+/** A merge returns the method that machine merged with; null when it doesn't say. */
+export async function merge(
+  link: HostLink,
+  id: string,
+  pin?: { head: string; base?: string | null },
+  label = "it"
+): Promise<{ head: string | null; method: MergeMethod | null }> {
+  // An AgentOS that predates pinned merges would ignore the head and merge
+  // whatever the PR is at: refuse before asking it.
+  if (pin)
+    await requireCapability(link, "pinned-merge", "a merge to a commit", "pin");
+  const res = await hostApi<{ head?: string | null; method?: unknown }>(
+    link,
+    taskPath(id, "merge"),
+    {
+      // base: what the gates here were judged against; the machine that
+      // merges compares the PR with it, not with a base only it recorded.
+      body: {
+        ...(pin && { head: pin.head }),
+        ...(pin?.base && { base: pin.base }),
+      },
+      timeout: TIMEOUT.merge,
+    }
+  ).catch(async (err) => {
+    if (!unknownOutcome(err)) throw err;
+    // A proxy or a dropped connection after the merge ran answers 502 with
+    // nothing from AgentOS: ask what state the task is in before failing.
+    const merged = await view(link, id, true)
+      .then((t) => t?.state === "merged")
+      .catch(() => false);
+    if (!merged)
+      throw new Error(
+        `${(err as Error).message}: couldn't confirm whether ${link.hostName} merged ${label}; check its PR before signing off again`
+      );
+    return { head: pin?.head ?? null, method: undefined };
+  });
+  forget(link.hostId);
+  return {
+    head: res.head ?? null,
+    method: MERGE_METHODS.find((m) => m === res.method) ?? null,
+  };
+}
+
+export async function drop(link: HostLink, id: string): Promise<void> {
+  await hostApi(link, taskPath(id, "drop"), {
+    body: {},
+    timeout: TIMEOUT.merge,
+  });
+  forget(link.hostId);
+}
+
+export const resume = (link: HostLink, id: string, body: object = {}) =>
+  tell(link, taskPath(id, "resume"), body);
+
+export const confirmMoved = (link: HostLink, id: string, to: string) =>
+  tell(link, taskPath(id, "moved"), { to });
+
+export async function exportOut(
+  link: HostLink,
+  id: string,
+  to: string
+): Promise<TaskBundle> {
+  const { bundle } = await postIdempotent<{ bundle: TaskBundle }>(
+    link,
+    taskPath(id, "export"),
+    { to },
+    TIMEOUT.exportOut
+  );
+  return bundle;
+}
+
+export const importBundle = (link: HostLink, bundle: TaskBundle) =>
+  postIdempotent<{ session: Session }>(
+    link,
+    IMPORT,
+    bundle,
+    TIMEOUT.importBundle
+  );
+
+export async function arrived(
+  link: HostLink,
+  from: string
+): Promise<Session | null> {
+  const { session } = await hostApi<{ session: Session | null }>(
+    link,
+    arrivedPath(from)
+  );
+  return session;
+}
+
+export const replies = (link: HostLink) =>
+  hostApi<{ messages?: unknown }>(link, HELD_REPLIES, {
+    timeout: TIMEOUT.replies,
+  });
+
+export const ackReplies = (link: HostLink, ids: number[]) =>
+  hostApi(link, HELD_REPLIES, { body: { ids }, timeout: TIMEOUT.replies });