@saadnvd1/agent-os 0.3.570 → 0.3.572

package/components/SessionList/QueuedRow.tsx

@@ -1,12 +1,13 @@
 "use client";
 
 import { Fragment } from "react";
-import { ArrowDown, ArrowUp, Play, Trash2 } from "lucide-react";
+import { ArrowDown, ArrowUp, Flag, Play, Trash2 } from "lucide-react";
 import { toast } from "sonner";
 import * as DM from "@/components/ui/dropdown-menu";
 import * as CM from "@/components/ui/context-menu";
-import { useQueueAction, type QueueAction } from "@/data/tasks";
+import { useQueueAction, useSetPriority, type QueueAction } from "@/data/tasks";
 import {
+  priorityMenu,
   queueMenu,
   queuedSubtitle,
   type QueuedRow as Row,
@@ -22,6 +23,18 @@ const SEPARATOR = {
   context: CM.ContextMenuSeparator,
 };
 const icon = "mr-2 h-3.5 w-3.5";
+const SUB = {
+  dropdown: {
+    Sub: DM.DropdownMenuSub,
+    Trigger: DM.DropdownMenuSubTrigger,
+    Content: DM.DropdownMenuSubContent,
+  },
+  context: {
+    Sub: CM.ContextMenuSub,
+    Trigger: CM.ContextMenuSubTrigger,
+    Content: CM.ContextMenuSubContent,
+  },
+};
 const ICONS = { start: Play, up: ArrowUp, down: ArrowDown, remove: Trash2 };
 
 const DONE: Record<QueueAction, string> = {
@@ -55,16 +68,47 @@ export function QueuedRow({ row }: { row: Row }) {
     );
   const failed = item.status === "failed";
   const busy = action.isPending;
+  const setPriority = useSetPriority();
+  const priorities = priorityMenu(item);
 
   const items = queueMenu(row);
   const menu = items.length
     ? (kind: RowMenuKind) => {
         const Item = ITEM[kind];
         const Separator = SEPARATOR[kind];
+        const { Sub, Trigger, Content } = SUB[kind];
         return items.map(({ action: a, label, disabled }) => {
           const Icon = ICONS[a];
           return (
             <Fragment key={a}>
+              {a === "remove" && priorities.length > 0 && (
+                <Sub>
+                  <Trigger>
+                    <Flag className={icon} />
+                    Priority
+                  </Trigger>
+                  <Content>
+                    {priorities.map((p) => (
+                      <Item
+                        key={p.priority}
+                        onClick={() =>
+                          setPriority.mutate(
+                            { id: item.id, priority: p.priority },
+                            { onError: (e) => toast.error(e.message) }
+                          )
+                        }
+                      >
+                        {p.label}
+                        {p.current && (
+                          <span className="text-muted-foreground ml-3 text-xs">
+                            current
+                          </span>
+                        )}
+                      </Item>
+                    ))}
+                  </Content>
+                </Sub>
+              )}
               {a === "remove" && items.length > 1 && <Separator />}
               <Item
                 disabled={disabled || busy}

package/components/SessionList/RowSubtitle.tsx

@@ -9,6 +9,7 @@ import { headerParts } from "@/lib/orchestrator/header-line";
 import { cn } from "@/lib/utils";
 import { usageLabel, useSessionUsage } from "@/data/load";
 import { useRowContext } from "./RowContext";
+import { pauseSubtitle } from "@/lib/sidebar/paused";
 
 const ATTENTION = (part: string) => part === "paused" || /\basks?$/.test(part);
 
@@ -56,9 +57,21 @@ export function RowSubtitle({
   }
   const project = ctx.projectNames.get(session.project_id ?? "");
   const group = rowGroup(session);
+  const pause = session.pause_state;
   return (
     <span className="flex min-w-0 items-center gap-1.5">
-      <LiveLine {...live} />
+      {pause ? (
+        <span className="min-w-0 truncate text-xs text-amber-600 dark:text-amber-400">
+          {pauseSubtitle({
+            state: pause,
+            until: session.paused_until
+              ? Date.parse(`${session.paused_until.replace(" ", "T")}Z`)
+              : null,
+          })}
+        </span>
+      ) : (
+        <LiveLine {...live} />
+      )}
       {group && (
         <span
           className="text-muted-foreground/70 hidden min-w-0 shrink items-center gap-1 truncate text-xs @[14rem]:flex"
@@ -72,9 +85,14 @@ export function RowSubtitle({
           <span className="truncate">{group.text}</span>
         </span>
       )}
-      {(project || detail || usage) && (
+      {(project || detail || usage || session.placed_note) && (
         <span className="text-muted-foreground/70 min-w-0 truncate text-xs">
-          {[usage && usageLabel(usage), detail?.slice(0, 200), project]
+          {[
+            usage && usageLabel(usage),
+            detail?.slice(0, 200),
+            session.placed_note,
+            project,
+          ]
             .filter(Boolean)
             .join(" · ")}
         </span>

package/components/SessionList/SessionRowMenu.tsx

@@ -17,6 +17,7 @@ import {
   Loader2,
   Pencil,
   Pin,
+  Pause,
   Play,
   Repeat,
   ChefHat,
@@ -35,7 +36,13 @@ import { rowGroup } from "@/lib/recipes/chip";
 import { finishActions } from "@/lib/sidebar/row-actions";
 import { useArchiveAction, useDoneAction } from "./useDoneAction";
 import { useShelfActions } from "./useShelfActions";
-import { SNOOZE_PRESETS, snoozePreset, wakeLabel } from "@/lib/sidebar/snooze";
+import {
+  PAUSE_PRESETS,
+  SNOOZE_PRESETS,
+  pauseUntil,
+  snoozePreset,
+  wakeLabel,
+} from "@/lib/sidebar/snooze";
 import type { SidebarRow } from "@/lib/sidebar/shelves";
 import { useRowContext } from "./RowContext";
 import { MoveMenuItems } from "@/components/Tasks/MoveMenuItems";
@@ -399,6 +406,47 @@ export function SessionRowMenu({
               </Sub>
             )
           )}
+          {session.task_status || session.view === "chat" ? (
+            session.pause_state === "paused" ||
+            session.pause_state === "pausing" ? (
+              <Item onClick={() => shelf.resume(session)}>
+                <Play className={icon} />
+                {session.pause_state === "paused"
+                  ? "Resume now"
+                  : "Keep running"}
+              </Item>
+            ) : session.pause_state ? null : (
+              <Sub>
+                <SubTrigger>
+                  <Pause className={icon} />
+                  Pause
+                </SubTrigger>
+                <SubContent>
+                  {PAUSE_PRESETS.map((p) => {
+                    const at = pauseUntil(p.key);
+                    return (
+                      <Item
+                        key={p.key}
+                        onClick={() => shelf.pause(session, p.key)}
+                      >
+                        {p.label}
+                        {at && (
+                          <span className="text-muted-foreground ml-3 text-xs">
+                            {wakeLabel(at.getTime())}
+                          </span>
+                        )}
+                      </Item>
+                    );
+                  })}
+                  <Item
+                    onClick={() => shelf.pause(session, "until-resumed", true)}
+                  >
+                    Pause now (interrupt its step)
+                  </Item>
+                </SubContent>
+              </Sub>
+            )
+          ) : null}
           {plain &&
             (row.settled ? (
               <Item onClick={() => shelf.reopen(session)}>

package/components/SessionList/useShelfActions.ts

@@ -1,16 +1,25 @@
 import { toast } from "sonner";
 import type { Session } from "@/lib/db";
-import { useSettleSession, useSnoozeSession } from "@/data/sessions/shelf";
 import {
+  usePauseSession,
+  useResumeSession,
+  useSettleSession,
+  useSnoozeSession,
+} from "@/data/sessions/shelf";
+import {
+  pauseUntil,
   snoozePreset,
   wakeLabel,
+  type PausePreset,
   type SnoozePreset,
 } from "@/lib/sidebar/snooze";
 
-// A row menu's Snooze, Unsnooze, Mark done and Reopen, each with an Undo.
+// A row menu's Snooze, Unsnooze, Pause, Resume, Mark done and Reopen.
 export function useShelfActions() {
   const snooze = useSnoozeSession();
   const settle = useSettleSession();
+  const pause = usePauseSession();
+  const resume = useResumeSession();
   const unsnooze = (session: Session) =>
     snooze.mutate({ id: session.id, until: null });
   return {
@@ -28,6 +37,34 @@ export function useShelfActions() {
       );
     },
     unsnooze,
+    // Stops its agent at the end of the step (or now) and starts it again at
+    // the time. A refusal (it is waiting on you, merging) is the toast.
+    pause: (session: Session, preset: PausePreset, now = false) => {
+      const until = pauseUntil(preset);
+      pause.mutate(
+        { id: session.id, until, mode: now ? "now" : "turn" },
+        {
+          onSuccess: () =>
+            toast.success(
+              until
+                ? `Pausing until ${wakeLabel(until.getTime())}`
+                : "Pausing until you resume",
+              {
+                action: {
+                  label: "Keep running",
+                  onClick: () => resume.mutate({ id: session.id }),
+                },
+              }
+            ),
+          onError: (e) => toast.error(e.message),
+        }
+      );
+    },
+    resume: (session: Session) =>
+      resume.mutate(
+        { id: session.id },
+        { onError: (e) => toast.error(e.message) }
+      ),
     settle: (session: Session) =>
       settle.mutate(
         { id: session.id, settled: true },

package/components/Tasks/task-state-labels.ts

@@ -1,19 +1,19 @@
+import type { Tone } from "@/lib/config/client-config-types";
 import type { TaskState } from "@/lib/tasks/state";
+import { TASK_STATE_LABELS } from "@/lib/tasks/state-labels";
 
-// How a task's state reads, and its tone, wherever a task is shown.
-export const TASK_STATE: Record<TaskState, { label: string; tone: string }> = {
-  working: { label: "Working", tone: "text-muted-foreground" },
-  "needs-input": {
-    label: "Needs input",
-    tone: "text-amber-600 dark:text-amber-400",
-  },
-  blocked: { label: "Blocked", tone: "text-amber-600 dark:text-amber-400" },
-  "plan-ready": { label: "Plan ready", tone: "text-primary" },
-  review: { label: "Ready for review", tone: "text-primary" },
-  "checks-failing": { label: "Checks failing", tone: "text-destructive" },
-  exited: { label: "Agent exited", tone: "text-amber-600 dark:text-amber-400" },
-  merged: { label: "Merged", tone: "text-emerald-600 dark:text-emerald-400" },
-  dropped: { label: "Dropped", tone: "text-muted-foreground/60" },
-  done: { label: "Done", tone: "text-emerald-600 dark:text-emerald-400" },
-  moving: { label: "Moving", tone: "text-amber-600 dark:text-amber-400" },
+export const TONE_TEXT: Record<Tone, string> = {
+  muted: "text-muted-foreground",
+  warning: "text-amber-600 dark:text-amber-400",
+  primary: "text-primary",
+  destructive: "text-destructive",
+  success: "text-emerald-600 dark:text-emerald-400",
 };
+
+// How a task's state reads, and its tone class, wherever a task is shown.
+export const TASK_STATE = Object.fromEntries(
+  Object.entries(TASK_STATE_LABELS).map(([k, v]) => [
+    k,
+    { label: v.label, tone: TONE_TEXT[v.tone] },
+  ])
+) as Record<TaskState, { label: string; tone: string }>;

package/data/chat/useChat.ts

@@ -146,6 +146,7 @@ export function useChat(
   const [commands, setCommands] = useState<ChatCommand[]>([]);
   const [models, setModels] = useState<ChatModel[]>([]);
   const [model, setModelState] = useState("");
+  const [modelLabel, setModelLabel] = useState<string | undefined>();
   const [refreshingCommands, setRefreshingCommands] = useState(false);
   const refreshTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
   const [access, setAccessState] = useState<ChatAccess>("full");
@@ -251,6 +252,7 @@ export function useChat(
           setCommands(m.commands);
           setModels(m.models);
           setModelState(m.model);
+          setModelLabel(m.modelLabel);
           setAccessState(m.access);
           setPlanState(m.plan);
           setCanBackground(!!m.background);
@@ -519,6 +521,7 @@ export function useChat(
     refreshingCommands,
     models,
     model,
+    modelLabel,
     send,
     interrupt,
     setModel,

package/data/sessions/shelf.ts

@@ -83,3 +83,53 @@ export function useSettleSession() {
         : { settled_at: null, active_at: now }
   );
 }
+
+async function send(method: string, url: string, body?: object) {
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok)
+    throw new Error(
+      (await res.json().catch(() => null))?.error ?? "Request failed"
+    );
+}
+
+// until null: until resumed. The row moves to "pausing" at once; the server
+// stops the agent at the end of its step (or now) and the push settles it.
+export function usePauseSession() {
+  return useShelfMutation<{
+    id: string;
+    until: Date | null;
+    mode: "turn" | "now";
+  }>(
+    ({ id, until, mode }) =>
+      send("POST", `/api/sessions/${id}/pause`, {
+        until: until?.toISOString() ?? null,
+        mode,
+      }),
+    ({ until }) => ({
+      pause_state: "pausing",
+      paused_until: until ? toSqliteTime(until) : null,
+    })
+  );
+}
+
+// Resume now, or keep running while it is still pausing.
+export function useResumeSession() {
+  return useShelfMutation<{ id: string }>(
+    ({ id }) => send("DELETE", `/api/sessions/${id}/pause`),
+    () => ({ pause_state: "resuming", paused_until: null })
+  );
+}
+
+export function useChangeResumeTime() {
+  return useShelfMutation<{ id: string; until: Date | null }>(
+    ({ id, until }) =>
+      send("PATCH", `/api/sessions/${id}/pause`, {
+        until: until?.toISOString() ?? null,
+      }),
+    ({ until }) => ({ paused_until: until ? toSqliteTime(until) : null })
+  );
+}

package/data/tasks/index.ts

@@ -1,6 +1,7 @@
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
 import type { TaskView } from "@/lib/tasks";
 import type { QueuedTaskView } from "@/lib/tasks/queue";
+import type { Priority } from "@/lib/tasks/schedule-types";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "./keys";
 import { usePollWhenOffline } from "../push/connection";
@@ -43,6 +44,7 @@ export function useCreateTask() {
       projectId: string;
       prompt: string;
       model?: string;
+      priority?: Priority;
       baseBranch?: string;
       hostId?: string;
       view?: "chat" | "terminal";

package/data/tasks/queue.ts

@@ -1,6 +1,11 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type { QueuedTaskView, StartOutcome } from "@/lib/tasks/queue";
-import { queueRequest, type QueueMenuAction } from "@/lib/sidebar/queued";
+import {
+  priorityRequest,
+  queueRequest,
+  type QueueMenuAction,
+} from "@/lib/sidebar/queued";
+import type { Priority } from "@/lib/tasks/schedule-types";
 import { sessionKeys } from "../sessions/keys";
 import { taskKeys } from "./keys";
 import { usePollWhenOffline } from "../push/connection";
@@ -40,3 +45,35 @@ export function useQueueAction() {
     },
   });
 }
+
+// Changes where a waiting task stands; the line re-ranks from the push.
+export function useSetPriority() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      id,
+      priority,
+    }: {
+      id: string;
+      priority: Priority;
+    }) => {
+      const { url, init } = priorityRequest(id, priority);
+      return json<unknown>(await fetch(url, init));
+    },
+    onMutate: async ({ id, priority }) => {
+      await queryClient.cancelQueries({ queryKey: taskKeys.queue() });
+      const previous = queryClient.getQueryData<QueuedTaskView[]>(
+        taskKeys.queue()
+      );
+      queryClient.setQueryData<QueuedTaskView[]>(taskKeys.queue(), (old) =>
+        old?.map((q) => (q.id === id ? { ...q, priority } : q))
+      );
+      return { previous };
+    },
+    onError: (_e, _v, context) => {
+      if (context?.previous)
+        queryClient.setQueryData(taskKeys.queue(), context.previous);
+    },
+    onSettled: () => queryClient.invalidateQueries({ queryKey: taskKeys.all }),
+  });
+}

package/lib/bus/index.ts

@@ -15,6 +15,7 @@ import { deliverToPane, type Delivery } from "./delivery";
 import { resolveRef, wasNames, type Candidate } from "./resolve";
 import { tmuxPane } from "./tmux-pane";
 import { hostLink } from "../hosts/remote-api";
+import { pauseHoldOf, pausedNote } from "../tasks/pause-hold";
 import { relayToHeldTask } from "../tasks/held-remote";
 import { heldOrchestrator, heldTarget } from "./held-reply";
 import { HUMAN, overRateLimit, wakeLine, type BusMessageView } from "./format";
@@ -215,6 +216,16 @@ export async function deliver(
       return { state: "failed", why };
     }
   }
+  // A paused terminal has no agent: the message waits for the resume prompt.
+  const paused = pauseHoldOf(to.id);
+  if (paused) {
+    if (from.messageId)
+      db.prepare(`UPDATE bus_messages SET held_pause_id = ? WHERE id = ?`).run(
+        paused.pauseId,
+        from.messageId
+      );
+    return { state: "queued" };
+  }
   if (!statusDetector.sessionExists(to.tmux_name))
     return { state: "failed", why: "its terminal isn't running" };
   try {
@@ -298,7 +309,10 @@ export async function sendMessage(opts: {
         : opts.origin,
     }
   );
-  if (delivery.state !== "failed") {
+  // A message held for a paused terminal isn't delivered until it resumes.
+  const hold = pauseHoldOf(to.id);
+  const parked = !!hold && to.view !== "chat";
+  if (delivery.state !== "failed" && !parked) {
     db.prepare(
       `UPDATE bus_messages SET delivered_at = datetime('now') WHERE id = ?`
     ).run(id);
@@ -308,7 +322,12 @@ export async function sendMessage(opts: {
       `UPDATE bus_messages SET read_at = datetime('now') WHERE id = ?`
     ).run(id);
   const message = toView(db.prepare(`${SELECT} WHERE m.id = ?`).get(id) as Row);
-  return { message, delivery, note };
+  const heldNote = hold ? pausedNote(to.name, hold) : null;
+  return {
+    message,
+    delivery,
+    note: [note, heldNote].filter(Boolean).join("; ") || undefined,
+  };
 }
 
 function storeForHolder(

package/lib/chat/access-levels.ts

@@ -0,0 +1,24 @@
+// What each chat access level is called and does, for every client. Synced to
+// the native app, so it may only import synced files.
+import type { ChatAccess } from "./events";
+
+export const ACCESS_LEVELS: Record<
+  ChatAccess,
+  { label: string; description: string }
+> = {
+  ask: {
+    label: "Ask first",
+    description: "Asks before edits and commands it isn't already allowed",
+  },
+  edits: {
+    label: "Accept edits",
+    description: "Edits files on its own, asks before other commands",
+  },
+  full: {
+    label: "Full access",
+    description: "Does everything without asking",
+  },
+};
+
+// The access a new chat starts with when the client doesn't pick one.
+export const DEFAULT_NEW_CHAT_ACCESS: ChatAccess = "edits";

package/lib/chat/events.ts

@@ -359,6 +359,8 @@ export type ChatServerMessage =
       commands: ChatCommand[];
       models: ChatModel[];
       model: string;
+      // A readable name for `model` when it is not one of `models`.
+      modelLabel?: string;
       access: ChatAccess;
       // Plan mode: on, or null when the session can't use it.
       plan: boolean | null;

package/lib/chat/hold.ts

@@ -1,7 +1,8 @@
 /**
  * Holding a chat still while something outside it works on its task: a
  * move to another machine (its row is 'moving'), or a Land of the stack it
- * sits in (the stack is 'landing'). Both are facts in SQLite, so the worker
+ * sits in (the stack is 'landing'), or a timed pause (lib/tasks/pause.ts).
+ * All are facts in SQLite, so the worker
  * process sees the hold too: it neither starts what's queued (queued.ts) nor
  * a turn for a message sent meanwhile, which waits in the queue instead.
  *
@@ -17,6 +18,8 @@ export const HELD_SQL = `(
   EXISTS (SELECT 1 FROM sessions WHERE id = @sid AND task_status = 'moving')
   OR EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
              WHERE i.session_id = @sid AND s.status = 'landing')
+  OR EXISTS (SELECT 1 FROM sessions WHERE id = @sid
+             AND pause_state IN ('pausing', 'paused'))
 )`;
 
 export const isHeld = (sessionId: string): boolean =>
@@ -45,12 +48,14 @@ interface HoldRow {
   moved_to: string | null;
   quick_of: string | null;
   landing: number;
+  pause_state: string | null;
+  paused_until: string | null;
 }
 
 const holdRow = (sessionId: string) =>
   db
     .prepare(
-      `SELECT task_status, moved_to, quick_of,
+      `SELECT task_status, moved_to, quick_of, pause_state, paused_until,
          EXISTS (SELECT 1 FROM stack_items i JOIN stacks s ON s.id = i.stack_id
                  WHERE i.session_id = @sid AND s.status = 'landing') AS landing
        FROM sessions WHERE id = @sid`
@@ -63,6 +68,10 @@ export function chatHold(sessionId: string): string | null {
   if (row?.task_status === "moving" && collecting.has(sessionId))
     return "It's sent once the move to another machine finishes";
   if (row?.landing) return "It's sent once its stack has landed";
+  if (row?.pause_state === "pausing" || row?.pause_state === "paused")
+    return row.paused_until
+      ? "It's sent when the session resumes, with anything else held meanwhile"
+      : "It's sent when the session is resumed, with anything else held meanwhile";
   return null;
 }
 

package/lib/chat/settings.ts

@@ -7,7 +7,7 @@ import { effectiveChatAccess, noApprovalsOn } from "../approvals/no-approvals";
 import os from "os";
 import { db, type Session } from "../db";
 import { agentEnv } from "../agents/launch";
-import { resolveModelForAgent } from "../model-catalog";
+import { modelDisplayName, resolveModelForAgent } from "../model-catalog";
 import { chatDriverFor } from "./drivers";
 import {
   CHAT_ACCESS,
@@ -69,11 +69,15 @@ function visibleCommands(caps: Capabilities): ChatCommand[] {
 export function emitCapabilities(session: Session, listener?: Listener): void {
   const caps = registry.caps.get(capsKey(session));
   if (!caps) return;
+  const model = chatModel(session);
   const m: ChatServerMessage = {
     type: "capabilities",
     commands: visibleCommands(caps),
     models: caps.models,
-    model: chatModel(session),
+    model,
+    modelLabel:
+      caps.models.find((o) => o.value === model)?.label ??
+      modelDisplayName(model),
     access: effectiveChatAccess(session.chat_access),
     plan: canPlan(session) ? !!session.chat_plan && !noApprovalsOn() : null,
     background: chatDriverFor(session.agent_type)?.backgroundTasks === true,

package/lib/config/client-config-types.ts

@@ -0,0 +1,29 @@
+// Read-only config a client renders with. Additive: a new field never bumps
+// `v`; only a change that breaks an old reader does, and then the old field
+// keeps being served beside the new one for a release. Synced to the native
+// app, so it must stay pure: no imports.
+export const CLIENT_CONFIG_VERSION = 1;
+
+export type Tone = "muted" | "warning" | "primary" | "destructive" | "success";
+
+export interface LabelTone {
+  label: string;
+  tone: Tone;
+}
+
+export interface AccessLevel {
+  value: string;
+  label: string;
+  description: string;
+}
+
+// Keys are strings on purpose, so an older app can accept a state it doesn't
+// know yet; each client narrows them through its own typed lookups.
+export interface ClientConfig {
+  v: number;
+  server: { version: string | null; startedAt: string };
+  access: { levels: AccessLevel[]; default: string };
+  taskStates: Record<string, LabelTone>;
+  runStatuses: Record<string, LabelTone>;
+  runTriggers: Record<string, string>;
+}

package/lib/config/client-config.ts

@@ -0,0 +1,28 @@
+import { ACCESS_LEVELS, DEFAULT_NEW_CHAT_ACCESS } from "../chat/access-levels";
+import { CHAT_ACCESS } from "../chat/events";
+import {
+  RUN_STATUS_LABELS,
+  RUN_TRIGGER_LABELS,
+} from "../recipes/status-labels";
+import { TASK_STATE_LABELS } from "../tasks/state-labels";
+import { cachedCheck } from "../updates/check";
+import {
+  CLIENT_CONFIG_VERSION,
+  type ClientConfig,
+} from "./client-config-types";
+
+const startedAt = new Date(Date.now() - process.uptime() * 1000).toISOString();
+
+export function clientConfig(): ClientConfig {
+  return {
+    v: CLIENT_CONFIG_VERSION,
+    server: { version: cachedCheck()?.current?.version ?? null, startedAt },
+    access: {
+      levels: CHAT_ACCESS.map((value) => ({ value, ...ACCESS_LEVELS[value] })),
+      default: DEFAULT_NEW_CHAT_ACCESS,
+    },
+    taskStates: TASK_STATE_LABELS,
+    runStatuses: RUN_STATUS_LABELS,
+    runTriggers: RUN_TRIGGER_LABELS,
+  };
+}