@saadnvd1/agent-os 0.3.532 → 0.3.534

package/data/features/index.ts

@@ -0,0 +1,40 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { FeatureView } from "@/lib/plans/view";
+import { usePollWhenOffline } from "../push/connection";
+
+export const featureKeys = {
+  all: ["features"] as const,
+  list: (workspaceId: string | null) =>
+    [...featureKeys.all, "list", workspaceId ?? "all"] as const,
+};
+
+export function useFeaturesQuery(workspaceId: string | null = null) {
+  return useQuery({
+    queryKey: featureKeys.list(workspaceId),
+    queryFn: async () => {
+      const res = await fetch(
+        `/api/features${workspaceId ? `?workspace=${workspaceId}` : ""}`
+      );
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Request failed");
+      return data.features as FeatureView[];
+    },
+    // Pushed when features or their pieces change.
+    refetchInterval: usePollWhenOffline(20000),
+  });
+}
+
+export function useReleasePiece() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id: number) => {
+      const res = await fetch(`/api/features/pieces/${id}/release`, {
+        method: "POST",
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || "Request failed");
+    },
+    onSettled: () =>
+      queryClient.invalidateQueries({ queryKey: featureKeys.all }),
+  });
+}

package/data/push/topics.ts

@@ -12,6 +12,8 @@ import { orchestratorKeys } from "../orchestrators";
 import { ruleKeys } from "../orchestrators/rules";
 import { workspaceKeys } from "../workspaces";
 import { scheduleKeys } from "../schedules";
+import { recipeKeys } from "../recipes";
+import { featureKeys } from "../features";
 import { archivedKeys } from "../done";
 import { awayKeys } from "../away";
 
@@ -54,6 +56,12 @@ function keysFor(topic: string): QueryKey[] {
     case "schedules":
     case "schedule_runs":
       return [scheduleKeys.all];
+    case "recipes":
+    case "recipe_runs":
+      return [recipeKeys.all];
+    case "features":
+    case "feature_pieces":
+      return [featureKeys.all, taskKeys.all, sessionKeys.all];
     case "orchestrator_asks":
     case "orchestrator_questions":
     case "needs_you_dismissed":

package/data/recipes/index.ts

@@ -0,0 +1,129 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { RecipeInput, RecipeRun, RecipeView } from "@/lib/recipes/types";
+import type { RecipeDraft } from "@/lib/recipes/draft";
+import type { TimerInput } from "@/lib/recipes/timer";
+import { sessionKeys } from "../sessions/keys";
+import { taskKeys } from "../tasks";
+import { usePollWhenOffline } from "../push/connection";
+
+export const recipeKeys = {
+  all: ["recipes"] as const,
+  list: (workspaceId: string | null) =>
+    [...recipeKeys.all, "list", workspaceId ?? "all"] as const,
+  detail: (id: string) => [...recipeKeys.all, "detail", id] as const,
+  preview: (id: string, note: string) =>
+    [...recipeKeys.all, "preview", id, note] as const,
+};
+
+async function call<T>(
+  url: string,
+  method = "GET",
+  body?: unknown
+): Promise<T> {
+  const res = await fetch(url, {
+    method,
+    headers:
+      body === undefined ? undefined : { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || "Request failed");
+  return data;
+}
+
+export function useRecipesQuery(workspaceId: string | null, enabled = true) {
+  return useQuery({
+    queryKey: recipeKeys.list(workspaceId),
+    queryFn: async () =>
+      (
+        await call<{ recipes: RecipeView[] }>(
+          `/api/recipes${workspaceId ? `?workspace=${workspaceId}` : ""}`
+        )
+      ).recipes,
+    enabled,
+    // Pushed when recipes or their runs change.
+    refetchInterval: usePollWhenOffline(15000),
+  });
+}
+
+export function useRecipeQuery(id: string | null) {
+  return useQuery({
+    queryKey: recipeKeys.detail(id ?? ""),
+    queryFn: () =>
+      call<{ recipe: RecipeView; runs: RecipeRun[] }>(`/api/recipes/${id}`),
+    enabled: !!id,
+    refetchInterval: usePollWhenOffline(10000),
+  });
+}
+
+// What a run started now would send, for the Run sheet.
+export function usePreviewQuery(id: string, note: string, enabled: boolean) {
+  return useQuery({
+    queryKey: recipeKeys.preview(id, note),
+    queryFn: () =>
+      call<{ prompt: string }>(
+        `/api/recipes/${id}/preview${note ? `?note=${encodeURIComponent(note)}` : ""}`
+      ),
+    enabled,
+  });
+}
+
+function useRecipeMutation<V, R>(fn: (v: V) => Promise<R>) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: fn,
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: recipeKeys.all });
+      queryClient.invalidateQueries({ queryKey: taskKeys.all });
+      queryClient.invalidateQueries({ queryKey: sessionKeys.all });
+    },
+  });
+}
+
+export type RecipeFormInput = RecipeInput & { timer?: TimerInput | null };
+
+export function useCreateRecipe() {
+  return useRecipeMutation((input: RecipeFormInput) =>
+    call<{ recipe: RecipeView }>("/api/recipes", "POST", input)
+  );
+}
+
+export function useUpdateRecipe() {
+  return useRecipeMutation(
+    ({
+      id,
+      ...patch
+    }: Partial<Omit<RecipeFormInput, "workspaceId">> & { id: string }) =>
+      call<{ recipe: RecipeView }>(`/api/recipes/${id}`, "PATCH", patch)
+  );
+}
+
+export function useArchiveRecipe() {
+  return useRecipeMutation((id: string) =>
+    call(`/api/recipes/${id}`, "DELETE")
+  );
+}
+
+export function useRunRecipe() {
+  return useRecipeMutation(
+    (input: { id: string; note?: string; requestId: string }) =>
+      call<{ run: RecipeRun; queued: boolean }>(
+        `/api/recipes/${input.id}/run`,
+        "POST",
+        { note: input.note, requestId: input.requestId }
+      )
+  );
+}
+
+export function useClearCarry() {
+  return useRecipeMutation((id: string) =>
+    call(`/api/recipes/${id}/carry/clear`, "POST", {})
+  );
+}
+
+export function useRecipeDraft() {
+  return useMutation({
+    mutationFn: (sessionId: string) =>
+      call<RecipeDraft>("/api/recipes/draft", "POST", { sessionId }),
+  });
+}

package/data/tasks/index.ts

@@ -97,6 +97,20 @@ export function useApprovePlan() {
   );
 }
 
+// Which waiting pieces of a plan to fold into the one before, or leave out.
+export function usePlanEdits() {
+  return useTaskMutation(
+    async (input: { id: string; merge: number[]; drop: number[] }) =>
+      json(
+        await fetch(`/api/tasks/${input.id}/plan-edits`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ merge: input.merge, drop: input.drop }),
+        })
+      )
+  );
+}
+
 export function useResumeTask() {
   return useTaskMutation(async (input: { id: string; force?: boolean }) =>
     json(

package/lib/away/run.ts

@@ -286,7 +286,10 @@ async function rerunReview(
 
 const SHA = /^[0-9a-f]{40}$/;
 
-async function mergeCommit(repo: string, pr: number): Promise<string | null> {
+export async function mergeCommit(
+  repo: string,
+  pr: number
+): Promise<string | null> {
   const out = await run(
     "gh",
     [

package/lib/connect/cli.ts

@@ -21,13 +21,8 @@ import {
   serverPort,
   setConnectEnabled,
 } from "./config";
-import { enrol } from "./enrol";
-import {
-  checkApiUrl,
-  DEFAULT_API,
-  registerWithCode,
-  requestTunnel,
-} from "./control-api";
+import { linkWithCode } from "./link";
+import { checkApiUrl, requestTunnel } from "./control-api";
 
 const arg = (flag: string) => {
   const i = process.argv.indexOf(flag);
@@ -83,23 +78,16 @@ async function main() {
     config = { ...config, hostname };
     saveConnect(config, dir);
   } else {
-    const apiUrl = checkApiUrl(
-      process.env.CONNECT_API_URL || DEFAULT_API,
-      operator
-    );
     const code = await linkCode();
     if (!code)
       throw new Error(
         "get a code from runagentos.com (Connect a machine), then run agent-os connect and paste it"
       );
-    config = await enrol({
+    config = await linkWithCode({
       dir,
-      register: registerWithCode(
-        apiUrl,
-        code,
-        arg("--name") || os.hostname(),
-        port
-      ),
+      code,
+      name: arg("--name") || os.hostname(),
+      port,
     });
   }
   console.log(`\n  Machine ${config.machineId}`);

package/lib/connect/link.ts

@@ -0,0 +1,35 @@
+/**
+ * Linking this machine to the Connect service with a code from
+ * runagentos.com. Shared by `agent-os connect` and the setup's link form.
+ */
+
+import { type ConnectConfig } from "./config";
+import { DEFAULT_API, checkApiUrl, registerWithCode } from "./control-api";
+import { enrol } from "./enrol";
+
+/** The code as typed, or null when it can't be one. */
+export function cleanLinkCode(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  const code = raw.trim();
+  if (!code || code.length > 128 || /[\s\u0000-\u001f\u007f-\u009f]/.test(code))
+    return null;
+  return code;
+}
+
+export async function linkWithCode(opts: {
+  code: string;
+  name: string;
+  port: number;
+  dir?: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<ConnectConfig> {
+  const env = opts.env ?? process.env;
+  const apiUrl = checkApiUrl(
+    env.CONNECT_API_URL || DEFAULT_API,
+    env.AGENTOS_CONNECT_OPERATOR === "1"
+  );
+  return enrol({
+    dir: opts.dir,
+    register: registerWithCode(apiUrl, opts.code, opts.name, opts.port),
+  });
+}

package/lib/connect/serve.ts

@@ -195,7 +195,18 @@ export function startConnect(
       ? "AGENTOS_CONNECT_PORT isn't a usable port"
       : decision.reason;
     if (readConnect(dir).ok) log(`connect: not starting: ${reason}`);
-    base = { state: "refused", reason };
+    // Still says whether the machine is linked, read when asked.
+    g.__agentosConnect = () => {
+      const r = readConnect(dir);
+      return {
+        state: "refused",
+        reason,
+        ...(r.ok && {
+          enrolled: true,
+          hostname: r.files.config.hostname || undefined,
+        }),
+      };
+    };
     return { hostname: () => null as string | null, close: () => {} };
   }
 

package/lib/connect/view.ts

@@ -0,0 +1,28 @@
+import type { ConnectStatus } from "./serve";
+
+export const CONNECT_SITE = "https://runagentos.com";
+
+export const CONNECT_STATE: Record<ConnectStatus["state"], string> = {
+  up: "Connected",
+  connecting: "Connecting…",
+  denied: "Refused by Connect",
+  off: "Off",
+  refused: "Not running here",
+  error: "Problem",
+};
+
+/** What the UI needs to know about Connect on this machine. */
+export function connectView(s: ConnectStatus) {
+  const linked = !!s.enrolled || !!s.hostname;
+  const on =
+    s.state === "up" ||
+    s.state === "connecting" ||
+    s.state === "denied" ||
+    (s.state === "error" && !!s.enrolled);
+  return {
+    linked,
+    on,
+    canToggle: linked && s.state !== "refused",
+    hostname: s.hostname,
+  };
+}

package/lib/db/changes.ts

@@ -34,6 +34,13 @@ export const TABLES_WATCHED_78 = [
   "needs_you_dismissed",
 ] as const;
 
+export const TABLES_WATCHED_80 = [
+  "recipes",
+  "recipe_runs",
+  "features",
+  "feature_pieces",
+] as const;
+
 // Every table any migration watches, for the browser's topic map to cover.
 export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_45,
@@ -41,6 +48,7 @@ export const WATCHED_TABLES: readonly string[] = [
   ...TABLES_WATCHED_56,
   ...TABLES_WATCHED_58,
   ...TABLES_WATCHED_78,
+  ...TABLES_WATCHED_80,
 ];
 
 export function installChangeTriggers(

package/lib/db/migrations.ts

@@ -5,6 +5,7 @@ import {
   TABLES_WATCHED_56,
   TABLES_WATCHED_58,
   TABLES_WATCHED_78,
+  TABLES_WATCHED_80,
 } from "./changes";
 import type Database from "better-sqlite3";
 
@@ -1830,6 +1831,132 @@ const migrations: Migration[] = [
       if (!has) db.exec(`ALTER TABLE task_queue ADD COLUMN agent_type TEXT`);
     },
   },
+  {
+    id: 80,
+    name: "recipes",
+    up: (db) => {
+      // Recipes: a saved brief that starts a fresh task or session each run
+      // (lib/recipes), and the features a plan splits into pieces
+      // (lib/plans). All additive. A run or piece finds its session by
+      // session_id, so sessions gains no column.
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS recipes (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL,
+          project_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          kind TEXT NOT NULL,
+          brief TEXT NOT NULL,
+          model TEXT,
+          view TEXT NOT NULL DEFAULT 'chat',
+          auto_done INTEGER NOT NULL DEFAULT 1,
+          max_minutes INTEGER,
+          carry_cleared_at INTEGER,
+          source_session_id TEXT,
+          created_by_session_id TEXT,
+          updated_by_session_id TEXT,
+          archived_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipes_name
+          ON recipes(workspace_id, name COLLATE NOCASE) WHERE archived_at IS NULL;
+
+        CREATE TABLE IF NOT EXISTS recipe_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          recipe_id TEXT NOT NULL,
+          seq INTEGER NOT NULL,
+          trigger TEXT NOT NULL,
+          triggered_by_session_id TEXT,
+          schedule_run_id INTEGER,
+          request_id TEXT,
+          note TEXT,
+          prompt TEXT NOT NULL,
+          revision_id INTEGER,
+          status TEXT NOT NULL,
+          session_id TEXT,
+          pr_number INTEGER,
+          pr_url TEXT,
+          summary TEXT,
+          outputs TEXT,
+          summary_source TEXT,
+          error TEXT,
+          cost_usd REAL,
+          duration_ms INTEGER,
+          started_at TEXT,
+          ended_at TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now')),
+          UNIQUE (recipe_id, seq)
+        );
+        CREATE INDEX IF NOT EXISTS idx_recipe_runs_recipe
+          ON recipe_runs(recipe_id, id DESC);
+        CREATE INDEX IF NOT EXISTS idx_recipe_runs_session
+          ON recipe_runs(session_id);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipe_runs_one_live
+          ON recipe_runs(recipe_id)
+          WHERE status IN ('queued','starting','running');
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_recipe_runs_request
+          ON recipe_runs(request_id) WHERE request_id IS NOT NULL;
+
+        CREATE TABLE IF NOT EXISTS recipe_revisions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          recipe_id TEXT NOT NULL,
+          brief TEXT NOT NULL,
+          settings TEXT NOT NULL,
+          edited_by_session_id TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS features (
+          id TEXT PRIMARY KEY,
+          workspace_id TEXT NOT NULL,
+          name TEXT NOT NULL,
+          plan_session_id TEXT NOT NULL,
+          plan_text TEXT NOT NULL,
+          status TEXT NOT NULL,
+          done_at TEXT,
+          cost_usd REAL,
+          duration_ms INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+        CREATE INDEX IF NOT EXISTS idx_features_plan
+          ON features(plan_session_id);
+
+        CREATE TABLE IF NOT EXISTS feature_pieces (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          feature_id TEXT NOT NULL,
+          position INTEGER NOT NULL,
+          name TEXT NOT NULL,
+          slice TEXT NOT NULL,
+          project_id TEXT NOT NULL,
+          after_position INTEGER,
+          after_kind TEXT,
+          reasons TEXT,
+          owns TEXT,
+          status TEXT NOT NULL,
+          session_id TEXT,
+          note TEXT,
+          UNIQUE (feature_id, position)
+        );
+        CREATE INDEX IF NOT EXISTS idx_feature_pieces_session
+          ON feature_pieces(session_id);
+      `);
+      const cols = (
+        db.prepare(`PRAGMA table_info(schedules)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      if (!cols.includes("recipe_id"))
+        db.exec(`ALTER TABLE schedules ADD COLUMN recipe_id TEXT`);
+      if (!cols.includes("migrated_from_kind"))
+        db.exec(`ALTER TABLE schedules ADD COLUMN migrated_from_kind TEXT`);
+      const plan = (
+        db.prepare(`PRAGMA table_info(sessions)`).all() as { name: string }[]
+      ).map((c) => c.name);
+      // Edits Saad made to a plan's pieces before approving it (merge, drop).
+      if (!plan.includes("plan_edits"))
+        db.exec(`ALTER TABLE sessions ADD COLUMN plan_edits TEXT`);
+      installChangeTriggers(db, TABLES_WATCHED_80);
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/db/queries.ts

@@ -32,7 +32,10 @@ export function sessionListColumns(db: Database.Database, alias = ""): string {
     .split(",")
     .map((c) => `${prefix}${c}`)
     .join(", ");
-  return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief`;
+  // The recipe run or feature piece a session is, as JSON, for its row's chip.
+  const recipe = `(SELECT json_object('id', r.id, 'name', r.name, 'seq', rr.seq) FROM recipe_runs rr JOIN recipes r ON r.id = rr.recipe_id WHERE rr.session_id = ${alias || "sessions"}.id)`;
+  const piece = `(SELECT json_object('feature', f.id, 'name', f.name, 'position', fp.position, 'total', (SELECT COUNT(*) FROM feature_pieces WHERE feature_id = f.id AND status != 'dropped')) FROM feature_pieces fp JOIN features f ON f.id = fp.feature_id WHERE fp.session_id = ${alias || "sessions"}.id)`;
+  return `${list}, (${prefix}task_brief IS NOT NULL AND ${prefix}task_brief != '') AS has_brief, ${recipe} AS recipe_run, ${piece} AS feature_piece`;
 }
 
 export const queries = {

package/lib/db/types.ts

@@ -26,6 +26,8 @@ export interface Session {
   started_by?: string | null;
   // 1 planned, 0 no plan, null not stated; why, in the starter's words.
   plan_decided?: number | null;
+  // JSON: the pieces Saad merged or dropped before approving the plan.
+  plan_edits?: string | null;
   plan_reason?: string | null;
   system_prompt: string | null;
   group_path: string; // Deprecated - use project_id
@@ -55,6 +57,10 @@ export interface Session {
   task_brief?: string | null;
   // Lists carry this instead of the brief itself (0/1).
   has_brief?: number;
+  // JSON, in lists: the recipe run this session is ({id, name, seq}), and the
+  // feature piece it builds ({feature, name, position, total}).
+  recipe_run?: string | null;
+  feature_piece?: string | null;
   // How the session is shown: a chat conversation or a terminal.
   view: "chat" | "terminal";
   chat_access: ChatAccess;