@saadnvd1/agent-os 0.3.520 → 0.3.523

package/lib/chat/worker/client.ts

@@ -41,6 +41,11 @@ export class WorkerClient {
 
   private files = new Map<string, (r: FileSuggestion[] | null) => void>();
 
+  private backgrounds = new Map<
+    string,
+    (r: { ok?: boolean; error?: string }) => void
+  >();
+
   private constructor(
     private socket: net.Socket,
     private handlers: WorkerHandlers
@@ -55,6 +60,9 @@ export class WorkerClient {
       this.undos.clear();
       for (const f of this.files.values()) f(null);
       this.files.clear();
+      for (const b of this.backgrounds.values())
+        b({ error: "The chat worker went away" });
+      this.backgrounds.clear();
       handlers.onClose(this.detached);
     });
     socket.on("error", () => socket.destroy());
@@ -101,6 +109,11 @@ export class WorkerClient {
       else u?.reject(new Error(e.error ?? "Undo failed"));
       return;
     }
+    if (e.type === "background_result") {
+      this.backgrounds.get(e.reqId)?.({ ok: e.ok, error: e.error });
+      this.backgrounds.delete(e.reqId);
+      return;
+    }
     if (e.type === "files_result") {
       this.files.get(e.reqId)?.(e.files ?? null);
       this.files.delete(e.reqId);
@@ -121,6 +134,26 @@ export class WorkerClient {
     });
   }
 
+  // Moves a blocking call (or all of them) to the background: whether
+  // anything moved, or why not (an error, or no answer in time).
+  background(
+    toolUseId?: string,
+    timeoutMs = 5000
+  ): Promise<{ ok?: boolean; error?: string }> {
+    const reqId = randomUUID();
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.backgrounds.delete(reqId);
+        resolve({ error: "timeout" });
+      }, timeoutMs);
+      this.backgrounds.set(reqId, (r) => {
+        clearTimeout(timer);
+        resolve(r);
+      });
+      this.command({ type: "background_task", reqId, toolUseId });
+    });
+  }
+
   // The agent's own matches for an @mention; null when it can't say (an
   // older worker, an error, no answer in time).
   fileSuggestions(

package/lib/chat/worker/host.ts

@@ -712,6 +712,19 @@ export class ChatHost {
         return this.conversation.respond(cmd.id, cmd);
       case "stop_task":
         return this.conversation.stopTask(cmd.taskId);
+      case "background_task":
+        try {
+          if (!this.conversation.backgroundTask) throw new Error("unsupported");
+          const ok = await this.conversation.backgroundTask(cmd.toolUseId);
+          this.emit({ type: "background_result", reqId: cmd.reqId, ok });
+        } catch (error) {
+          this.emit({
+            type: "background_result",
+            reqId: cmd.reqId,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+        return;
       case "undo":
         try {
           const result = await this.conversation.undo(

package/lib/chat/worker/main.ts

@@ -76,7 +76,7 @@ async function main(sessionId: string) {
         state: host.state,
         compacting: host.compactingNow,
         streaming: [...host.streaming.values()],
-        caps: ["plan", "queue", "retire", "fresh"],
+        caps: ["plan", "queue", "retire", "fresh", "background"],
       } satisfies WorkerEvent)}\n`
     );
     client.on(

package/lib/chat/worker/protocol.ts

@@ -55,6 +55,7 @@ export type WorkerCommand =
   | ({ type: "respond"; id: string } & ApprovalDecision)
   | { type: "undo"; reqId: string; checkpoint: string; dryRun: boolean }
   | { type: "stop_task"; taskId: string }
+  | { type: "background_task"; reqId: string; toolUseId?: string }
   // It runs an older build: it takes no new message into its agent (they
   // wait in the queue) and closes at its next turn boundary, so a current
   // worker resumes the conversation with today's tools.
@@ -99,6 +100,7 @@ export type WorkerEvent =
   // The agent's guess at the next message, or null once it's stale.
   | { type: "suggestion"; text: string | null }
   | { type: "undo_result"; reqId: string; result?: UndoResult; error?: string }
+  | { type: "background_result"; reqId: string; ok?: boolean; error?: string }
   | {
       type: "files_result";
       reqId: string;

package/lib/db/migrations.ts

@@ -1754,6 +1754,20 @@ const migrations: Migration[] = [
           db.exec(`ALTER TABLE ${table} ADD COLUMN plan_only INTEGER`);
     },
   },
+  {
+    id: 76,
+    name: "welcome_backfill",
+    up: (db) => {
+      // An install that already has a session or a project of its own has
+      // been set up; mark it so the first-run welcome never shows there.
+      db.exec(
+        `INSERT OR IGNORE INTO settings (key, value)
+         SELECT 'welcome.completed_at', 'existing-install'
+         WHERE EXISTS (SELECT 1 FROM sessions)
+            OR EXISTS (SELECT 1 FROM projects WHERE is_uncategorized = 0)`
+      );
+    },
+  },
 ];
 
 // `upTo`: stop after this id (tests that start from an older database).

package/lib/security/auth.ts

@@ -162,8 +162,18 @@ export function authorize(req: AuthRequest, policy: AuthPolicy): AuthResult {
 
 function decide(req: AuthRequest, policy: AuthPolicy): AuthResult {
   const trusted = req.tunnel ? null : networkTrust(req, policy);
-  if (trusted) return { ok: true, via: trusted };
   const token = readToken(req.headers);
+  if (trusted) {
+    // Identity only: network trust already decided access, so a token that
+    // is unknown, revoked or fails to resolve never turns this into a refusal.
+    let deviceId: string | undefined;
+    try {
+      deviceId = (token ? policy.lookup(token) : null)?.id;
+    } catch {}
+    return deviceId
+      ? { ok: true, via: trusted, deviceId }
+      : { ok: true, via: trusted };
+  }
   const device = token ? policy.lookup(token) : null;
   if (device) return { ok: true, via: "device", deviceId: device.id };
   // AGENTOS_AUTH=off is for a login proxy on this side of the network.

package/lib/settings-url.ts

@@ -12,6 +12,7 @@ export const SETTINGS_SECTIONS = [
   "notifications",
   "schedules",
   "audits",
+  "setup",
 ] as const;
 
 export type SettingsSection = (typeof SETTINGS_SECTIONS)[number];

package/lib/welcome-url.ts

@@ -0,0 +1,33 @@
+// The welcome has its own address: `/?welcome=<step>`, beside `?settings=`
+// and `?session=`. `/welcome` redirects here.
+
+export const WELCOME_PARAM = "welcome";
+
+export const WELCOME_STEPS = ["agents", "project", "finish"] as const;
+
+export type WelcomeStep = (typeof WELCOME_STEPS)[number];
+
+export interface WelcomeLocation {
+  open: boolean;
+  step: WelcomeStep;
+}
+
+const BASE = "http://agentos.invalid";
+
+export const isWelcomeStep = (v: unknown): v is WelcomeStep =>
+  (WELCOME_STEPS as readonly unknown[]).includes(v);
+
+/** What the address says; a bare or unknown step starts at the first. */
+export function welcomeFromHref(href: string): WelcomeLocation {
+  const value = new URL(href, BASE).searchParams.get(WELCOME_PARAM);
+  if (value === null) return { open: false, step: WELCOME_STEPS[0] };
+  return { open: true, step: isWelcomeStep(value) ? value : WELCOME_STEPS[0] };
+}
+
+/** The same address with the welcome set (or removed), as path+query+hash. */
+export function hrefWithWelcome(href: string, at: WelcomeLocation): string {
+  const url = new URL(href, BASE);
+  if (at.open) url.searchParams.set(WELCOME_PARAM, at.step);
+  else url.searchParams.delete(WELCOME_PARAM);
+  return url.pathname + url.search + url.hash;
+}

package/lib/welcome.ts

@@ -0,0 +1,88 @@
+/**
+ * First-run welcome: shown once on a fresh install, never on one that
+ * already has work. Completion is the server's (one server, many devices),
+ * kept in `settings` as an ISO time, or "existing-install" when the install
+ * was already in use.
+ */
+
+import type Database from "better-sqlite3";
+import { db } from "./db";
+
+export const WELCOME_KEY = "welcome.completed_at";
+export const EXISTING_INSTALL = "existing-install";
+
+export interface WelcomeGate {
+  // The welcome should open now.
+  show: boolean;
+  // No sessions and no project of the user's own.
+  fresh: boolean;
+  completedAt: string | null;
+}
+
+export interface GateInput {
+  completedAt: string | null;
+  sessionCount: number;
+  // Projects other than the built-in Uncategorized one.
+  projectCount: number;
+  demo: boolean;
+  skip: boolean;
+}
+
+export function welcomeGate(i: GateInput): WelcomeGate {
+  const fresh = i.sessionCount === 0 && i.projectCount === 0;
+  return {
+    show: !i.completedAt && fresh && !i.demo && !i.skip,
+    fresh,
+    completedAt: i.completedAt,
+  };
+}
+
+export function readCompletedAt(d: Database.Database = db): string | null {
+  const row = d
+    .prepare(`SELECT value FROM settings WHERE key = ?`)
+    .get(WELCOME_KEY) as { value: string } | undefined;
+  return row?.value ?? null;
+}
+
+// Keeps the first stamp unless `overwrite`.
+export function completeWelcome(
+  value: string = new Date().toISOString(),
+  d: Database.Database = db,
+  overwrite = false
+): void {
+  d.prepare(
+    overwrite
+      ? `INSERT INTO settings (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+      : `INSERT OR IGNORE INTO settings (key, value) VALUES (?, ?)`
+  ).run(WELCOME_KEY, value);
+}
+
+export function counts(d: Database.Database = db) {
+  const n = (sql: string) => (d.prepare(sql).get() as { n: number }).n;
+  return {
+    sessionCount: n(`SELECT COUNT(*) AS n FROM sessions`),
+    projectCount: n(
+      `SELECT COUNT(*) AS n FROM projects WHERE is_uncategorized = 0`
+    ),
+  };
+}
+
+/** The gate for this server. An install found in use is stamped as such. */
+export function readWelcomeGate(
+  demo: boolean,
+  d: Database.Database = db
+): WelcomeGate {
+  const c = counts(d);
+  let completedAt = readCompletedAt(d);
+  if (!completedAt && (c.sessionCount > 0 || c.projectCount > 0)) {
+    completeWelcome(EXISTING_INSTALL, d);
+    completedAt = readCompletedAt(d);
+  }
+  return welcomeGate({
+    completedAt,
+    ...c,
+    demo,
+    skip: !!process.env.AGENTOS_SKIP_WELCOME,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saadnvd1/agent-os",
-  "version": "0.3.520",
+  "version": "0.3.523",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"

package/stores/addProject.ts

@@ -13,14 +13,32 @@ export const addProjectUi = proxy<{
   } | null;
 }>({ open: null });
 
+// Who asked for the dialog and wants the new project instead of the draft
+// that opens in it. A function, so it stays out of the proxy.
+let onProjectAdded: ((projectId: string) => void) | null = null;
+
 export const addProjectActions = {
-  show: (kind: AddProjectKind, hostId: string) => {
+  show: (
+    kind: AddProjectKind,
+    hostId: string,
+    onDone?: (projectId: string) => void
+  ) => {
+    onProjectAdded = onDone ?? null;
     addProjectUi.open = { kind, hostId, workspaceId: sidebarUi.workspaceId };
   },
+  /** Called once a project is made; false if nobody took it over. */
+  finish: (projectId: string): boolean => {
+    const handler = onProjectAdded;
+    addProjectActions.close();
+    if (!handler) return false;
+    handler(projectId);
+    return true;
+  },
   setWorkspace: (workspaceId: string | null) => {
     if (addProjectUi.open) addProjectUi.open.workspaceId = workspaceId;
   },
   close: () => {
+    onProjectAdded = null;
     addProjectUi.open = null;
   },
 };

package/stores/welcomeUi.ts

@@ -0,0 +1,26 @@
+import { proxy } from "valtio";
+import type { WelcomeStep } from "@/lib/welcome-url";
+
+// The first-run welcome: whether it is on show, the step, and the project
+// the user made (or picked) to start in.
+export const welcomeUi = proxy<{
+  open: boolean;
+  step: WelcomeStep;
+  projectId: string | null;
+}>({ open: false, step: "agents", projectId: null });
+
+export const welcomeUiActions = {
+  open: (step: WelcomeStep = "agents") => {
+    welcomeUi.step = step;
+    welcomeUi.open = true;
+  },
+  go: (step: WelcomeStep) => {
+    welcomeUi.step = step;
+  },
+  setProject: (projectId: string | null) => {
+    welcomeUi.projectId = projectId;
+  },
+  close: () => {
+    welcomeUi.open = false;
+  },
+};