@saadnvd1/agent-os 0.3.533 → 0.3.535

package/lib/recipes/store.ts

@@ -0,0 +1,378 @@
+import { randomUUID } from "crypto";
+import { db } from "../db";
+import { getProject } from "../projects";
+import { getWorkspace } from "../workspaces";
+import { parseOverride, type ModelOverride } from "../models/resolve";
+import {
+  MAX_BRIEF,
+  MAX_NAME,
+  RECIPE_KINDS,
+  isLive,
+  type Recipe,
+  type RecipeInput,
+  type RecipeRun,
+  type RecipeTotals,
+  type RunStatus,
+} from "./types";
+
+type RecipeRow = Omit<Recipe, "auto_done"> & { auto_done: number };
+const toRecipe = (r: RecipeRow): Recipe => ({ ...r, auto_done: !!r.auto_done });
+
+type RunRow = Omit<RecipeRun, "outputs"> & { outputs: string | null };
+export const toRun = (r: RunRow): RecipeRun => ({
+  ...r,
+  outputs: r.outputs ? (JSON.parse(r.outputs) as Record<string, string>) : null,
+});
+
+export function getRecipe(id: string): Recipe | null {
+  const row = db.prepare(`SELECT * FROM recipes WHERE id = ?`).get(id) as
+    | RecipeRow
+    | undefined;
+  return row ? toRecipe(row) : null;
+}
+
+export function listRecipes(workspaceId?: string | null): Recipe[] {
+  const rows = (
+    workspaceId
+      ? db
+          .prepare(
+            `SELECT * FROM recipes WHERE archived_at IS NULL AND workspace_id = ? ORDER BY name COLLATE NOCASE`
+          )
+          .all(workspaceId)
+      : db
+          .prepare(
+            `SELECT * FROM recipes WHERE archived_at IS NULL ORDER BY name COLLATE NOCASE`
+          )
+          .all()
+  ) as RecipeRow[];
+  return rows.map(toRecipe);
+}
+
+// By id, id prefix or name (case-insensitive) among a workspace's live
+// recipes. Never reaches another workspace's.
+export function findRecipe(workspaceId: string, ref: string): Recipe {
+  const r = ref.trim();
+  const live = listRecipes(workspaceId);
+  const byId = live.filter(
+    (x) => x.id === r || (r.length >= 6 && x.id.startsWith(r))
+  );
+  const matches = byId.length
+    ? byId
+    : live.filter((x) => x.name.toLowerCase() === r.toLowerCase());
+  if (matches.length === 1) return matches[0];
+  if (matches.length)
+    throw new Error(`"${ref}" matches several recipes; use its id`);
+  const names = live.map((x) => x.name).join(", ") || "none";
+  throw new Error(`No recipe "${ref}" in this workspace (recipes: ${names})`);
+}
+
+export const modelOf = (r: Pick<Recipe, "model">): ModelOverride | null =>
+  !r.model
+    ? null
+    : r.model.startsWith("{")
+      ? (JSON.parse(r.model) as ModelOverride)
+      : r.model;
+
+function validate(
+  input: RecipeInput,
+  selfId?: string
+): Required<Omit<RecipeInput, "sourceSessionId">> {
+  const name = input.name?.trim();
+  if (!name) throw new Error("Give the recipe a name");
+  if (name.length > MAX_NAME)
+    throw new Error(`Keep the name under ${MAX_NAME} characters`);
+  // It's quoted inside the run's first message.
+  if (/["[\]\n]/.test(name))
+    throw new Error("A recipe name can't use quotes or [ ]");
+  const brief = input.brief?.trim();
+  if (!brief) throw new Error("Write the brief it runs");
+  if (brief.length > MAX_BRIEF)
+    throw new Error(
+      `Keep the brief under ${MAX_BRIEF} characters: put the steps in a script in the repo and have the brief run it`
+    );
+  if (!RECIPE_KINDS.includes(input.kind))
+    throw new Error("Pick task or session");
+  if (!getWorkspace(input.workspaceId)) throw new Error("Pick a workspace");
+  const project = input.projectId ? getProject(input.projectId) : null;
+  if (!project || project.is_uncategorized) throw new Error("Pick a project");
+  if (project.workspace_id !== input.workspaceId)
+    throw new Error(`${project.name} isn't in this workspace`);
+  if (project.host_id && project.host_id !== "local")
+    throw new Error("Recipes run on this machine's projects only");
+  const view = input.view ?? "chat";
+  if (view !== "chat" && view !== "terminal")
+    throw new Error("view: chat or terminal");
+  let model: string | null = null;
+  const parsed = parseOverride(input.model);
+  if (parsed) {
+    if (input.kind === "session" && typeof parsed !== "string")
+      throw new Error(`model: a session takes one "provider/model"`);
+    model = typeof parsed === "string" ? parsed : JSON.stringify(parsed);
+  }
+  const maxMinutes = input.maxMinutes ?? null;
+  if (
+    maxMinutes !== null &&
+    (!Number.isInteger(maxMinutes) || maxMinutes < 1 || maxMinutes > 1440)
+  )
+    throw new Error("Time limit: 1 to 1440 minutes");
+  const clash = db
+    .prepare(
+      `SELECT name FROM recipes WHERE workspace_id = ? AND archived_at IS NULL
+         AND name = ? COLLATE NOCASE AND id != ?`
+    )
+    .get(input.workspaceId, name, selfId ?? "") as { name: string } | undefined;
+  if (clash) throw new Error(`There's already a recipe called "${clash.name}"`);
+  return {
+    workspaceId: input.workspaceId,
+    projectId: project.id,
+    name,
+    kind: input.kind,
+    brief,
+    model,
+    view,
+    autoDone: input.autoDone ?? true,
+    maxMinutes,
+  };
+}
+
+function settingsOf(v: {
+  kind: string;
+  model: string | null;
+  view: string;
+  autoDone: boolean;
+  maxMinutes: number | null;
+}) {
+  return JSON.stringify({
+    kind: v.kind,
+    model: v.model,
+    view: v.view,
+    auto_done: v.autoDone,
+    max_minutes: v.maxMinutes,
+  });
+}
+
+function addRevision(
+  recipeId: string,
+  brief: string,
+  settings: string,
+  by: string | null
+): number {
+  return Number(
+    db
+      .prepare(
+        `INSERT INTO recipe_revisions (recipe_id, brief, settings, edited_by_session_id) VALUES (?, ?, ?, ?)`
+      )
+      .run(recipeId, brief, settings, by).lastInsertRowid
+  );
+}
+
+// `by`: the agent session that wrote it, or null for Saad.
+export function createRecipe(
+  input: RecipeInput,
+  by: string | null = null
+): Recipe {
+  const v = validate(input);
+  const id = randomUUID();
+  const make = db.transaction(() => {
+    db.prepare(
+      `INSERT INTO recipes (id, workspace_id, project_id, name, kind, brief, model, view, auto_done, max_minutes,
+         source_session_id, created_by_session_id, updated_by_session_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      v.workspaceId,
+      v.projectId,
+      v.name,
+      v.kind,
+      v.brief,
+      v.model,
+      v.view,
+      v.autoDone ? 1 : 0,
+      v.maxMinutes,
+      input.sourceSessionId ?? null,
+      by,
+      by
+    );
+    addRevision(id, v.brief, settingsOf(v), by);
+  });
+  make();
+  return getRecipe(id)!;
+}
+
+export function updateRecipe(
+  id: string,
+  patch: Partial<Omit<RecipeInput, "workspaceId" | "sourceSessionId">>,
+  by: string | null = null
+): Recipe {
+  const current = getRecipe(id);
+  if (!current || current.archived_at) throw new Error("Recipe not found");
+  const v = validate(
+    {
+      workspaceId: current.workspace_id,
+      projectId: patch.projectId ?? current.project_id,
+      name: patch.name ?? current.name,
+      kind: patch.kind ?? current.kind,
+      brief: patch.brief ?? current.brief,
+      model: patch.model === undefined ? current.model : patch.model,
+      view: patch.view ?? current.view,
+      autoDone: patch.autoDone ?? current.auto_done,
+      maxMinutes:
+        patch.maxMinutes === undefined ? current.max_minutes : patch.maxMinutes,
+    },
+    id
+  );
+  const settings = settingsOf(v);
+  const before = settingsOf({
+    kind: current.kind,
+    model: current.model,
+    view: current.view,
+    autoDone: current.auto_done,
+    maxMinutes: current.max_minutes,
+  });
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE recipes SET project_id = ?, name = ?, kind = ?, brief = ?, model = ?, view = ?, auto_done = ?,
+         max_minutes = ?, updated_by_session_id = ?, updated_at = datetime('now') WHERE id = ?`
+    ).run(
+      v.projectId,
+      v.name,
+      v.kind,
+      v.brief,
+      v.model,
+      v.view,
+      v.autoDone ? 1 : 0,
+      v.maxMinutes,
+      by,
+      id
+    );
+    if (v.brief !== current.brief || settings !== before)
+      addRevision(id, v.brief, settings, by);
+    db.prepare(
+      `UPDATE schedules SET name = ?, project_id = ?, updated_at = datetime('now') WHERE recipe_id = ?`
+    ).run(v.name, v.projectId, id);
+  })();
+  return getRecipe(id)!;
+}
+
+// History stays: the recipe leaves the list and its timer turns off.
+export function archiveRecipe(id: string): void {
+  db.transaction(() => {
+    db.prepare(
+      `UPDATE recipes SET archived_at = datetime('now') WHERE id = ? AND archived_at IS NULL`
+    ).run(id);
+    db.prepare(
+      `UPDATE schedules SET enabled = 0, archived_at = datetime('now') WHERE recipe_id = ? AND archived_at IS NULL`
+    ).run(id);
+  })();
+}
+
+// "Clear" on the last-run card: the next run starts without a carry block.
+export function clearCarry(id: string, now = Date.now()): void {
+  db.prepare(`UPDATE recipes SET carry_cleared_at = ? WHERE id = ?`).run(
+    now,
+    id
+  );
+}
+
+export function lastRevisionId(recipeId: string): number | null {
+  const row = db
+    .prepare(
+      `SELECT id FROM recipe_revisions WHERE recipe_id = ? ORDER BY id DESC LIMIT 1`
+    )
+    .get(recipeId) as { id: number } | undefined;
+  return row?.id ?? null;
+}
+
+export function getRun(id: number): RecipeRun | null {
+  const row = db.prepare(`SELECT * FROM recipe_runs WHERE id = ?`).get(id) as
+    | RunRow
+    | undefined;
+  return row ? toRun(row) : null;
+}
+
+export function runForSession(sessionId: string): RecipeRun | null {
+  const row = db
+    .prepare(`SELECT * FROM recipe_runs WHERE session_id = ?`)
+    .get(sessionId) as RunRow | undefined;
+  return row ? toRun(row) : null;
+}
+
+export function listRuns(
+  recipeId: string,
+  opts: { before?: number; limit?: number } = {}
+): RecipeRun[] {
+  const limit = Math.min(Math.max(opts.limit ?? 20, 1), 100);
+  const rows = db
+    .prepare(
+      `SELECT * FROM recipe_runs WHERE recipe_id = ? AND id < ? ORDER BY id DESC LIMIT ?`
+    )
+    .all(recipeId, opts.before ?? Number.MAX_SAFE_INTEGER, limit) as RunRow[];
+  return rows.map(toRun);
+}
+
+export function liveRun(recipeId: string): RecipeRun | null {
+  const row = db
+    .prepare(
+      `SELECT * FROM recipe_runs WHERE recipe_id = ? AND status IN ('queued','starting','running')`
+    )
+    .get(recipeId) as RunRow | undefined;
+  return row ? toRun(row) : null;
+}
+
+export function lastRun(recipeId: string): RecipeRun | null {
+  return listRuns(recipeId, { limit: 1 })[0] ?? null;
+}
+
+// The newest settled run with this status, after the carry was last cleared.
+export function lastSettled(
+  recipeId: string,
+  clearedAt: number | null,
+  status?: RunStatus
+): RecipeRun | null {
+  const row = db
+    .prepare(
+      `SELECT * FROM recipe_runs WHERE recipe_id = ?
+         AND status NOT IN ('queued','starting','running','skipped','cancelled')
+         ${status ? "AND status = ?" : ""}
+         ${clearedAt ? "AND strftime('%s', COALESCE(ended_at, created_at)) * 1000 > ?" : ""}
+       ORDER BY id DESC LIMIT 1`
+    )
+    .get(
+      ...[
+        recipeId,
+        ...(status ? [status] : []),
+        ...(clearedAt ? [clearedAt] : []),
+      ]
+    ) as RunRow | undefined;
+  return row ? toRun(row) : null;
+}
+
+export function totals(recipeId: string): RecipeTotals {
+  const row = db
+    .prepare(
+      `SELECT COUNT(*) AS runs,
+         SUM(status = 'succeeded') AS succeeded,
+         SUM(status IN ('failed','blocked','timed_out')) AS failed,
+         COALESCE(SUM(cost_usd), 0) AS cost,
+         AVG(duration_ms) AS avg_ms
+       FROM recipe_runs WHERE recipe_id = ? AND status NOT IN ('skipped','cancelled')`
+    )
+    .get(recipeId) as {
+    runs: number;
+    succeeded: number | null;
+    failed: number | null;
+    cost: number;
+    avg_ms: number | null;
+  };
+  return {
+    runs: row.runs,
+    succeeded: row.succeeded ?? 0,
+    failed: row.failed ?? 0,
+    costUsd: row.cost,
+    avgMs: row.avg_ms === null ? null : Math.round(row.avg_ms),
+  };
+}
+
+export { isLive };
+
+export const hasLiveRun = (recipeId: string): boolean => !!liveRun(recipeId);

package/lib/recipes/test-fixtures.ts

@@ -0,0 +1,49 @@
+// Shared setup for the recipes tests: a workspace and project, a recipe in
+// them, and a session standing in for a run's.
+
+import { randomUUID } from "crypto";
+import { db } from "../db";
+import { createProject } from "../projects";
+import { createWorkspace, setProjectWorkspace } from "../workspaces";
+import { createRecipe } from "./store";
+import type { Recipe, RecipeInput } from "./types";
+
+export function workspaceWithProject() {
+  const ws = createWorkspace(`ws-${randomUUID().slice(0, 6)}`);
+  const project = createProject({
+    name: `p-${randomUUID().slice(0, 6)}`,
+    workingDirectory: "/tmp",
+  });
+  setProjectWorkspace(project.id, ws.id);
+  return { ws, project };
+}
+
+export function makeRecipe(
+  fields: Partial<RecipeInput> = {},
+  by: string | null = null
+): Recipe {
+  const { ws, project } = workspaceWithProject();
+  return createRecipe(
+    {
+      workspaceId: ws.id,
+      projectId: project.id,
+      name: "TestFlight build",
+      kind: "session",
+      brief: "Run scripts/testflight and judge the result.",
+      ...fields,
+    },
+    by
+  );
+}
+
+export function makeSession(
+  fields: Record<string, string | number | null> = {}
+) {
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO sessions (id, name, tmux_name, working_directory, view) VALUES (?, 's', ?, '/tmp', 'chat')`
+  ).run(id, `claude-${id}`);
+  for (const [k, v] of Object.entries(fields))
+    db.prepare(`UPDATE sessions SET ${k} = ? WHERE id = ?`).run(v, id);
+  return id;
+}

package/lib/recipes/timer.ts

@@ -0,0 +1,107 @@
+// A recipe's timer is a `schedules` row of kind "recipe": the Schedules
+// engine (ticker, lease, slot claiming, catch-up, brake retry) runs it.
+
+import { randomUUID } from "crypto";
+import { db } from "../db";
+import {
+  cronError,
+  DEFAULT_TIMEZONE,
+  describeCron,
+  isTimezone,
+  MIN_GAP_MINUTES,
+  minGapMinutes,
+} from "../schedules/cron";
+import { nextRunAt } from "../schedules/scheduler";
+import { getSchedule } from "../schedules/store";
+import type { Recipe, RecipeTimer } from "./types";
+
+export interface TimerInput {
+  cron: string;
+  timezone?: string;
+  enabled?: boolean;
+}
+
+function timerRowId(recipeId: string): string | null {
+  const row = db
+    .prepare(
+      `SELECT id FROM schedules WHERE recipe_id = ? AND archived_at IS NULL`
+    )
+    .get(recipeId) as { id: string } | undefined;
+  return row?.id ?? null;
+}
+
+export function getTimer(
+  recipeId: string,
+  now = Date.now()
+): RecipeTimer | null {
+  const id = timerRowId(recipeId);
+  const s = id ? getSchedule(id) : null;
+  if (!s) return null;
+  return {
+    scheduleId: s.id,
+    cron: s.cron,
+    timezone: s.timezone,
+    enabled: s.enabled,
+    description: describeCron(s.cron),
+    nextRunAt: nextRunAt(s, now),
+  };
+}
+
+// Only Saad sets a recurring trigger: the orchestrator's tools have no way
+// in here.
+export function setTimer(
+  recipe: Recipe,
+  input: TimerInput | null,
+  now = Date.now()
+): RecipeTimer | null {
+  const existing = timerRowId(recipe.id);
+  if (input === null) {
+    if (existing)
+      db.prepare(
+        `UPDATE schedules SET enabled = 0, archived_at = datetime('now') WHERE id = ?`
+      ).run(existing);
+    return null;
+  }
+  const cron = input.cron.trim().replace(/\s+/g, " ");
+  const timezone = input.timezone?.trim() || DEFAULT_TIMEZONE;
+  if (!isTimezone(timezone)) throw new Error(`Unknown time zone "${timezone}"`);
+  const bad = cronError(cron);
+  if (bad) throw new Error(bad);
+  if (minGapMinutes(cron, timezone) < MIN_GAP_MINUTES)
+    throw new Error("A recipe runs at most once an hour");
+  const enabled = input.enabled ?? true;
+  if (!existing) {
+    db.prepare(
+      `INSERT INTO schedules (id, workspace_id, project_id, name, cron, timezone, prompt, kind, recipe_id, enabled, armed_at)
+       VALUES (?, ?, ?, ?, ?, ?, '', 'recipe', ?, ?, ?)`
+    ).run(
+      randomUUID(),
+      recipe.workspace_id,
+      recipe.project_id,
+      recipe.name,
+      cron,
+      timezone,
+      recipe.id,
+      enabled ? 1 : 0,
+      now
+    );
+  } else {
+    const current = getSchedule(existing)!;
+    // A new time or a fresh enable counts from now: no earlier slot is
+    // "missed".
+    const rearm =
+      cron !== current.cron ||
+      timezone !== current.timezone ||
+      (enabled && !current.enabled);
+    db.prepare(
+      `UPDATE schedules SET cron = ?, timezone = ?, enabled = ?, armed_at = ?, updated_at = datetime('now') WHERE id = ?`
+    ).run(
+      cron,
+      timezone,
+      enabled ? 1 : 0,
+      rearm ? now : current.armed_at,
+      existing
+    );
+  }
+  return getTimer(recipe.id, now);
+}

package/lib/recipes/types.ts

@@ -0,0 +1,116 @@
+// Recipes: a saved brief that starts a fresh task or session each run.
+
+export const RECIPE_KINDS = ["task", "session"] as const;
+export type RecipeKind = (typeof RECIPE_KINDS)[number];
+
+export const MAX_BRIEF = 4000;
+export const MAX_NOTE = 1000;
+export const MAX_NAME = 80;
+
+export interface Recipe {
+  id: string;
+  workspace_id: string;
+  project_id: string;
+  name: string;
+  kind: RecipeKind;
+  brief: string;
+  // "provider/model", or a JSON role map (see lib/models); null: the defaults.
+  model: string | null;
+  view: "chat" | "terminal";
+  auto_done: boolean;
+  max_minutes: number | null;
+  carry_cleared_at: number | null;
+  source_session_id: string | null;
+  created_by_session_id: string | null;
+  updated_by_session_id: string | null;
+  archived_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export const RUN_TRIGGERS = [
+  "manual",
+  "tool",
+  "cli",
+  "timer",
+  "catch-up",
+] as const;
+export type RunTriggerKind = (typeof RUN_TRIGGERS)[number];
+
+export type RunStatus =
+  | "queued"
+  | "starting"
+  | "running"
+  | "succeeded"
+  | "failed"
+  | "blocked"
+  | "timed_out"
+  | "cancelled"
+  | "skipped";
+
+export const LIVE_STATUSES: RunStatus[] = ["queued", "starting", "running"];
+export const isLive = (s: RunStatus) => LIVE_STATUSES.includes(s);
+
+export interface RecipeRun {
+  id: number;
+  recipe_id: string;
+  seq: number;
+  trigger: RunTriggerKind;
+  triggered_by_session_id: string | null;
+  schedule_run_id: number | null;
+  request_id: string | null;
+  note: string | null;
+  prompt: string;
+  revision_id: number | null;
+  status: RunStatus;
+  session_id: string | null;
+  pr_number: number | null;
+  pr_url: string | null;
+  summary: string | null;
+  outputs: Record<string, string> | null;
+  summary_source: "line" | "model" | "state" | null;
+  error: string | null;
+  cost_usd: number | null;
+  duration_ms: number | null;
+  started_at: string | null;
+  ended_at: string | null;
+  created_at: string;
+}
+
+export interface RecipeInput {
+  workspaceId: string;
+  projectId: string;
+  name: string;
+  kind: RecipeKind;
+  brief: string;
+  model?: string | null;
+  view?: "chat" | "terminal";
+  autoDone?: boolean;
+  maxMinutes?: number | null;
+  sourceSessionId?: string | null;
+}
+
+export interface RecipeTimer {
+  scheduleId: string;
+  cron: string;
+  timezone: string;
+  enabled: boolean;
+  description: string;
+  nextRunAt: number | null;
+}
+
+export interface RecipeTotals {
+  runs: number;
+  succeeded: number;
+  failed: number;
+  costUsd: number;
+  avgMs: number | null;
+}
+
+export interface RecipeView extends Recipe {
+  projectName: string | null;
+  lastRun: RecipeRun | null;
+  liveRun: RecipeRun | null;
+  timer: RecipeTimer | null;
+  totals: RecipeTotals;
+}

package/lib/schedules/index.ts

@@ -78,7 +78,10 @@ export function scheduleView(s: Schedule, now = Date.now()): ScheduleView {
 }
 
 export function listScheduleViews(workspaceId?: string | null): ScheduleView[] {
-  return listSchedules(workspaceId).map((s) => scheduleView(s));
+  // A recipe's timer shows on the recipe, not in this list.
+  return listSchedules(workspaceId)
+    .filter((s) => s.kind !== "recipe")
+    .map((s) => scheduleView(s));
 }
 
 // `aos schedule add --session <ref> --every 30m "<prompt>"`: the session by