@saadnvd1/agent-os 0.3.459 → 0.3.461

package/components/SessionList/SidebarHeader.tsx

@@ -35,6 +35,7 @@ import { settingsUiActions } from "@/stores/settingsUi";
 import { usageUiActions } from "@/stores/usageUi";
 import { WorkspaceSwitcher } from "./WorkspaceSwitcher";
 import { LoadGauge } from "./LoadGauge";
+import { AwayToggle } from "@/components/Away/AwayToggle";
 import { useSchedulesGlance } from "./useSchedulesGlance";
 import { cn } from "@/lib/utils";
 
@@ -67,6 +68,7 @@ export function SidebarHeader(props: SidebarHeaderProps) {
         <LoadGauge />
       </div>
       <div className="flex shrink-0 items-center gap-0.5">
+        <AwayToggle />
         <ADropdownMenu
           trigger={
             <Button

package/components/Workspaces/WorkspaceSettings.tsx

@@ -1,6 +1,7 @@
 "use client";
 
-import { useWorkspacesQuery } from "@/data/workspaces";
+import { SettingToggle } from "@/components/Settings/SettingToggle";
+import { useUpdateWorkspace, useWorkspacesQuery } from "@/data/workspaces";
 import { TaskLimitForm } from "./TaskLimitForm";
 import { RulesForm } from "./RulesForm";
 import { FreshStartForm } from "./FreshStartForm";
@@ -8,6 +9,7 @@ import { FreshStartForm } from "./FreshStartForm";
 // Settings > Workspaces: each workspace's own settings.
 export function WorkspaceSettings() {
   const { data: workspaces, isPending, isError, error } = useWorkspacesQuery();
+  const update = useUpdateWorkspace();
 
   if (isPending)
     return <div className="bg-muted/40 h-32 animate-pulse rounded-lg" />;
@@ -39,6 +41,12 @@ export function WorkspaceSettings() {
             workspace={w}
           />
           <RulesForm workspaceId={w.id} />
+          <SettingToggle
+            title="Wake tasks on CI failures and reviews"
+            detail="A task's agent is messaged once when a check fails on its PR's head, with the log's tail, and when someone reviews or comments on it."
+            checked={w.wake_tasks_on_pr}
+            onChange={(on) => update.mutate({ id: w.id, wakeTasksOnPR: on })}
+          />
         </section>
       ))}
       <FreshStartForm />

package/data/away/index.ts

@@ -0,0 +1,73 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { AwayView } from "@/lib/away/view";
+import { post } from "../orchestrators";
+import { usePollWhenOffline } from "../push/connection";
+
+export const awayKeys = {
+  all: ["away"] as const,
+};
+
+export function useAwayQuery() {
+  return useQuery({
+    queryKey: awayKeys.all,
+    queryFn: async () => {
+      const res = await fetch("/api/away");
+      if (!res.ok) throw new Error(`Request failed (${res.status})`);
+      return (await res.json()) as AwayView;
+    },
+    staleTime: 10_000,
+    // Pushed when it changes (away_periods); a minute catches it running
+    // out while the stream is down.
+    refetchInterval: usePollWhenOffline(60_000),
+  });
+}
+
+// expiresAt null: until he's back. `false` turns it off.
+export function useSetAway() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (on: false | { expiresAt: Date | null }) =>
+      post(
+        "/api/away",
+        on
+          ? { on: true, expiresAt: on.expiresAt?.toISOString() ?? null }
+          : { on: false }
+      ) as Promise<AwayView>,
+    onSuccess: (view) => queryClient.setQueryData(awayKeys.all, view),
+    onSettled: () => queryClient.invalidateQueries({ queryKey: awayKeys.all }),
+  });
+}
+
+export function useDismissAwayReport() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id: number) => post("/api/away/seen", { id }),
+    onMutate: () =>
+      queryClient.setQueryData<AwayView>(awayKeys.all, (prev) =>
+        prev ? { ...prev, report: null } : prev
+      ),
+    onSettled: () => queryClient.invalidateQueries({ queryKey: awayKeys.all }),
+  });
+}
+
+// The choices the toggle offers, as when each ends.
+export const AWAY_DURATIONS = [
+  { id: "1h", label: "For 1 hour" },
+  { id: "4h", label: "For 4 hours" },
+  { id: "morning", label: "Until morning" },
+  { id: "back", label: "Until I'm back" },
+] as const;
+
+export type AwayDuration = (typeof AWAY_DURATIONS)[number]["id"];
+
+// "Until morning" is 8 AM, local: today's if it's still before 5 AM,
+// else tomorrow's.
+export function awayEnds(d: AwayDuration, now = new Date()): Date | null {
+  if (d === "1h") return new Date(now.getTime() + 60 * 60 * 1000);
+  if (d === "4h") return new Date(now.getTime() + 4 * 60 * 60 * 1000);
+  if (d === "back") return null;
+  const morning = new Date(now);
+  morning.setHours(8, 0, 0, 0);
+  if (now.getHours() >= 5) morning.setDate(morning.getDate() + 1);
+  return morning;
+}

package/data/push/topics.ts

@@ -12,6 +12,7 @@ import { ruleKeys } from "../orchestrators/rules";
 import { workspaceKeys } from "../workspaces";
 import { scheduleKeys } from "../schedules";
 import { archivedKeys } from "../done";
+import { awayKeys } from "../away";
 
 // What each pushed topic (a table that changed, lib/db/changes.ts, or a
 // pushed view) means the browser should refetch. Only queries on screen
@@ -56,6 +57,8 @@ function keysFor(topic: string): QueryKey[] {
       return [orchestratorKeys.all];
     case "orchestrator_rules":
       return [ruleKeys.all];
+    case "away_periods":
+      return [awayKeys.all];
     case "dev_servers":
       return [devServerKeys.all];
     default:
@@ -96,6 +99,7 @@ export const ALL_TOPICS = [
   "schedules",
   "orchestrator_asks",
   "orchestrator_rules",
+  "away_periods",
   "dev_servers",
 ];
 

package/data/workspaces/index.ts

@@ -53,6 +53,8 @@ export function useUpdateWorkspace() {
       collapsed?: boolean;
       // Running tasks at once; null for no limit.
       maxRunningTasks?: number | null;
+      // Message tasks about failing checks and reviews on their PRs.
+      wakeTasksOnPR?: boolean;
     }) =>
       json(
         await fetch(`/api/workspaces/${id}`, {
@@ -61,7 +63,7 @@ export function useUpdateWorkspace() {
           body: JSON.stringify(updates),
         })
       ),
-    onMutate: async ({ id, maxRunningTasks, ...updates }) => {
+    onMutate: async ({ id, maxRunningTasks, wakeTasksOnPR, ...updates }) => {
       await queryClient.cancelQueries({ queryKey: workspaceKeys.list() });
       queryClient.setQueryData<Workspace[]>(workspaceKeys.list(), (prev) =>
         prev?.map((w) =>
@@ -72,6 +74,9 @@ export function useUpdateWorkspace() {
                 ...(maxRunningTasks !== undefined && {
                   max_running_tasks: maxRunningTasks,
                 }),
+                ...(wakeTasksOnPR !== undefined && {
+                  wake_tasks_on_pr: wakeTasksOnPR,
+                }),
               }
             : w
         )

package/lib/away/brief.ts

@@ -0,0 +1,23 @@
+/**
+ * What an orchestrator is told while Saad is away: the event that turns
+ * Away on, and the line leading its brief's digest on a fresh start.
+ */
+
+import {
+  activeAway,
+  clockTime,
+  fromSql,
+  untilText,
+  type AwayRow,
+} from "./state";
+import { SWEEP_EVERY_MS } from "./sweep";
+
+export function awayOnLine(row: AwayRow, now = Date.now()): string {
+  return `Saad is away (Away mode, since ${clockTime(fromSql(row.started_at), now)}, ${untilText(row, now)}). Follow work through rather than only reacting to events: keep each task moving to merged and deployed, sign off what passes its gates, and pick up what stalled. Every ${SWEEP_EVERY_MS / 60000} minutes AgentOS sweeps: it nudges stalled tasks, asks idle ones with uncommitted work to commit and open a PR, runs lost reviews again and checks the deploy after each merge; what needs you comes as events, and each step is in your log. Interactive sessions (not tasks) are Saad's: in Away mode only ask them to wrap up, never drive them further. Hard lines still go to ask_saad; while he's away his asks reach his phone in one batch per sweep, so raise them as usual. \`aos notify\` is held for that batch too, so don't send one per item.`;
+}
+
+// For the digest: the same line while Away is on, else nothing.
+export function awayDigestLine(now = Date.now()): string | null {
+  const row = activeAway();
+  return row ? awayOnLine(row, now) : null;
+}

package/lib/away/deploy.ts

@@ -0,0 +1,173 @@
+/**
+ * After a merge, did the deploy land and the server come back healthy? Read
+ * from the project's `deploy` config (agentos.json): the file its deploy
+ * writes the deployed commit to (scripts/autodeploy's `deployed`), the file
+ * it writes a commit whose deploy failed to (`alerted`), and a health URL.
+ * A project without one isn't checked; a missing `deployed` file means no
+ * deploy runs on this machine, which isn't a failure either.
+ */
+
+import fs from "fs";
+import type { ProjectConfig } from "../project-config";
+import { run } from "../tasks/gh";
+import { expandHome } from "../tasks/session";
+import { selfUrl } from "../agents/self-env";
+import { commitTime } from "../orchestrator/repo";
+
+export type DeployConfig = NonNullable<ProjectConfig["deploy"]>;
+
+export type DeployVerdict =
+  | { state: "ok"; detail: string }
+  | { state: "failed"; detail: string }
+  | { state: "pending" }
+  | { state: "unchecked"; detail: string };
+
+export const DEPLOY_WITHIN_MIN = 30;
+// After the deploy lands, the server gets this long to answer healthy.
+export const HEALTH_GRACE_MS = 3 * 60 * 1000;
+
+export interface DeployDeps {
+  // The commit a state file names, or null when there's no such file.
+  readSha: (file: string) => { sha: string; at: number } | null;
+  // Whether `sha` is in the history of `tip` (fetching it if need be);
+  // throws when that can't be told.
+  contains: (repo: string, tip: string, sha: string) => Promise<boolean>;
+  // startedAt, when the server says when it started (AgentOS's
+  // /api/health does), so a deploy that never restarted it is caught.
+  health: (
+    url: string
+  ) => Promise<{ ok: boolean; why?: string; startedAt?: number }>;
+  // When GitHub made the merge commit, in ms (0 when unknown): the time a
+  // restart has to come after. Not when AgentOS noticed the merge, which
+  // can be after a restart that already took it.
+  committedAt: (repo: string, sha: string) => Promise<number>;
+}
+
+const SHA = /^[0-9a-f]{40}$/;
+
+function readSha(file: string): { sha: string; at: number } | null {
+  try {
+    const full = expandHome(file);
+    const sha = fs.readFileSync(full, "utf-8").slice(0, 80).trim();
+    return SHA.test(sha) ? { sha, at: fs.statSync(full).mtimeMs } : null;
+  } catch {
+    return null;
+  }
+}
+
+async function contains(
+  repo: string,
+  tip: string,
+  sha: string
+): Promise<boolean> {
+  if (tip === sha) return true;
+  const ancestor = () =>
+    run("git", ["merge-base", "--is-ancestor", sha, tip], repo).then(
+      () => true,
+      () => false
+    );
+  if (await ancestor()) return true;
+  // The deployed commit may be newer than this checkout knows. A fetch that
+  // fails throws, so stale refs never read as "not deployed".
+  await run("git", ["fetch", "--quiet", "origin"], repo);
+  return ancestor();
+}
+
+async function health(
+  url: string
+): Promise<{ ok: boolean; why?: string; startedAt?: number }> {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+    if (!res.ok) return { ok: false, why: `HTTP ${res.status}` };
+    const body = (await res.json().catch(() => null)) as {
+      startedAt?: unknown;
+    } | null;
+    const startedAt =
+      typeof body?.startedAt === "string" ? Date.parse(body.startedAt) : NaN;
+    return Number.isFinite(startedAt) ? { ok: true, startedAt } : { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      why: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export const DEFAULT_DEPS: DeployDeps = {
+  readSha,
+  contains,
+  health,
+  committedAt: async (repo, sha) =>
+    (await commitTime(repo, sha).catch(() => 0)) * 1000,
+};
+
+// A path alone is this AgentOS server's own.
+export const healthUrl = (health: string) =>
+  health.startsWith("/") ? `${selfUrl()}${health}` : health;
+
+// Pending when it can't be told yet (git couldn't fetch): the next sweep
+// asks again, rather than a blip reading as a failed deploy.
+export async function checkDeploy(
+  input: Parameters<typeof judge>[0],
+  deps: DeployDeps = DEFAULT_DEPS
+): Promise<DeployVerdict> {
+  try {
+    return await judge(input, deps);
+  } catch {
+    return { state: "pending" };
+  }
+}
+
+async function judge(
+  input: {
+    repo: string;
+    config: DeployConfig | undefined;
+    mergeSha: string | null;
+    mergedAt: number;
+    now: number;
+  },
+  deps: DeployDeps = DEFAULT_DEPS
+): Promise<DeployVerdict> {
+  const { config, mergeSha } = input;
+  if (!config)
+    return { state: "unchecked", detail: "no deploy check configured" };
+  if (!mergeSha) return { state: "pending" };
+  const short = mergeSha.slice(0, 7);
+  const deployed = deps.readSha(config.deployed);
+  if (!deployed)
+    return { state: "unchecked", detail: "no deploy runs on this machine" };
+
+  if (await deps.contains(input.repo, deployed.sha, mergeSha)) {
+    if (!config.health) return { state: "ok", detail: `${short} deployed` };
+    const url = healthUrl(config.health);
+    const answer = await deps.health(url);
+    const merged =
+      answer.ok && answer.startedAt !== undefined
+        ? await deps.committedAt(input.repo, mergeSha)
+        : 0;
+    const stale = !!merged && answer.startedAt! < merged;
+    if (answer.ok && !stale)
+      return { state: "ok", detail: `${short} deployed, server healthy` };
+    if (input.now - deployed.at < HEALTH_GRACE_MS) return { state: "pending" };
+    return {
+      state: "failed",
+      detail: stale
+        ? `${short} deployed, but the server answering ${config.health} hasn't restarted since the merge`
+        : `${short} deployed, but ${config.health} didn't answer healthy: ${answer.why ?? "no answer"}`,
+    };
+  }
+
+  const failed = config.failed ? deps.readSha(config.failed) : null;
+  if (failed && (await deps.contains(input.repo, failed.sha, mergeSha)))
+    return {
+      state: "failed",
+      detail: `the deploy of ${failed.sha.slice(0, 7)} (which has ${short}) failed; see the deploy's log`,
+    };
+  const within = (config.within_minutes ?? DEPLOY_WITHIN_MIN) * 60 * 1000;
+  if (input.now - input.mergedAt >= within)
+    return {
+      state: "failed",
+      detail: `${short} not deployed ${Math.round(within / 60000)} minutes after the merge`,
+    };
+  return { state: "pending" };
+}