@saadnvd1/agent-os 0.3.575 → 0.3.576

package/lib/away/run.ts

@@ -55,6 +55,7 @@ import {
 import { checkDeploy } from "./deploy";
 import { buildAwayReport, phoneSummary, reportMarkdown } from "./report";
 import { awayOnLine } from "./brief";
+import { shutFinishedTaskSimulators } from "../simulator";
 
 const PHONE_SOURCE = "away";
 const PHONE_LINES = 8;
@@ -582,6 +583,9 @@ export function awayTick(now = Date.now()): void {
         console.error(`[away] sweep of ${workspaceId}:`, error);
       }
     }
+    await shutFinishedTaskSimulators().catch((error) =>
+      console.error("[away] simulator sweep:", error)
+    );
     // Ended meanwhile: the report's summary says what's waiting.
     const still = activeAway();
     if (still?.id === away.id) notifyBatch(still, Date.now());

package/lib/sessions/end.ts

@@ -2,10 +2,11 @@ import type { Session } from "../db";
 import { stopChat } from "../chat/runner";
 import { waitForExit } from "../chat/worker/client";
 import { endTmuxSession } from "../tmux/end";
-import { releaseOnEnd } from "../simulator";
+import { releaseOnEnd, shutTaskSimulators } from "../simulator";
 import { forgetPlanWait } from "../models/plan-step";
 
-type Agent = Pick<Session, "id" | "host_id" | "tmux_name">;
+type Agent = Pick<Session, "id" | "host_id" | "tmux_name"> &
+  Partial<Pick<Session, "worktree_path" | "branch_name">>;
 
 // A session's agent, ended: its chat worker, and its own tmux session (a
 // chat session can still own one). The one call that delete, done, drop and
@@ -15,6 +16,8 @@ export async function endSessionAgent(s: Agent): Promise<void> {
   stopChat(s.id);
   // The task's simulator goes with it; no row, no work.
   releaseOnEnd(s.id, { remove: true });
+  // And any the project's own scripts booted for it; shut down only.
+  shutTaskSimulators(s);
   void waitForExit(s.id).catch(() => {});
   await endTmuxSession(s.host_id, s.tmux_name);
 }

package/lib/simulator/index.ts

@@ -60,6 +60,7 @@ export class SimulatorError extends Error {
 }
 
 export { simulatorAvailable };
+export { shutTaskSimulators, shutFinishedTaskSimulators } from "./task-devices";
 
 const session = (id: string) =>
   db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id) as

package/lib/simulator/simctl.ts

@@ -142,6 +142,16 @@ export async function shutdownDevice(device: {
   }
 }
 
+// Shut down only, never delete or erase. Also used for devices a project's
+// own scripts made, matched to a finished task by name (task-devices.ts).
+export async function shutdownByUdid(udid: string): Promise<void> {
+  try {
+    await run(["shutdown", udid]);
+  } catch (error) {
+    if (!/current state: Shutdown/i.test(String(error))) throw error;
+  }
+}
+
 export async function deleteDevice(device: {
   udid: string;
   name: string;

package/lib/simulator/task-devices.ts

@@ -0,0 +1,160 @@
+/**
+ * Booted simulators that belong to a task, shut down when it ends. Two naming
+ * schemes: AgentOS's own (`aos-<instance>-<task id>`, from `aos sim`) and the
+ * agentos-mobile project's (`agentos-<branch>-<worktree hash>`, from its
+ * `npm run sim`). Shut down only: nothing here deletes or erases a device.
+ */
+
+import { createHash } from "crypto";
+import fs from "fs";
+import { db, type Session } from "../db";
+import { isRemoteHost } from "../hosts";
+import { simulatorAvailable } from "./available";
+import {
+  deviceNameFor,
+  listDevices,
+  shutdownByUdid,
+  type SimDevice,
+} from "./simctl";
+
+// Same as agentos-mobile's scripts/lib/sim-helpers.mjs (slug, simName); the
+// two must stay in step.
+export const simSlug = (text: string) =>
+  text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+
+export const projectSimName = (
+  branch: string | null | undefined,
+  worktreePath: string
+) =>
+  `agentos-${simSlug(branch || "detached") || "detached"}-${createHash("sha1")
+    .update(worktreePath)
+    .digest("hex")
+    .slice(0, 6)}`;
+
+export const FINISHED = new Set(["merged", "dropped", "done"]);
+
+export interface TaskRef {
+  id: string;
+  branch_name: string | null;
+  worktree_path: string | null;
+  task_status?: string | null;
+}
+
+// The script resolves its worktree through symlinks; the row may not.
+export function pathVariants(p: string | null): string[] {
+  if (!p) return [];
+  try {
+    return [...new Set([p, fs.realpathSync(p)])];
+  } catch {
+    return [p];
+  }
+}
+
+export function taskDeviceNames(
+  t: Pick<TaskRef, "id" | "branch_name">,
+  paths: string[]
+): string[] {
+  return [
+    ...new Set([
+      deviceNameFor(t.id),
+      ...paths.map((p) => projectSimName(t.branch_name, p)),
+    ]),
+  ];
+}
+
+const running = (d: SimDevice) => d.state === "Booted" || d.state === "Booting";
+
+// Running devices whose every matching task is finished: a task re-run on the
+// same branch and worktree keeps its device, and unmatched ones are not ours.
+export function planFinishedShutdowns(
+  devices: SimDevice[],
+  tasks: (TaskRef & { paths?: string[] })[]
+): SimDevice[] {
+  const owners = new Map<string, boolean[]>();
+  for (const t of tasks) {
+    const finished = FINISHED.has(t.task_status ?? "");
+    const paths = t.paths ?? pathVariants(t.worktree_path);
+    for (const name of taskDeviceNames(t, paths))
+      owners.set(name, [...(owners.get(name) ?? []), finished]);
+  }
+  return devices.filter((d) => {
+    const o = owners.get(d.name);
+    return running(d) && !!o && o.every(Boolean);
+  });
+}
+
+const enabled = () =>
+  simulatorAvailable() && process.env.AGENTOS_SIM_SHUTDOWN !== "off";
+
+async function shutAll(devices: SimDevice[], why: string): Promise<number> {
+  let n = 0;
+  for (const d of devices) {
+    try {
+      await shutdownByUdid(d.udid);
+      n++;
+      console.log(`[simulator] shut down ${d.name}: ${why}`);
+    } catch (error) {
+      console.error(`[simulator] shutdown ${d.name}:`, error);
+    }
+  }
+  return n;
+}
+
+// For a task that is ending. Never blocks and never throws into the cleanup.
+export function shutTaskSimulators(
+  s: Pick<Session, "id" | "host_id"> &
+    Partial<Pick<Session, "branch_name" | "worktree_path">>
+): void {
+  try {
+    if (!enabled() || isRemoteHost(s.host_id)) return;
+    // Before the caller removes the worktree, which realpath needs.
+    const names = new Set(
+      taskDeviceNames(
+        { id: s.id, branch_name: s.branch_name ?? null },
+        pathVariants(s.worktree_path ?? null)
+      )
+    );
+    void listDevices()
+      .then((devices) =>
+        shutAll(
+          devices.filter((d) => running(d) && names.has(d.name)),
+          "its task ended"
+        )
+      )
+      .catch((error) => console.error("[simulator] list:", error));
+  } catch (error) {
+    console.error("[simulator] shutTaskSimulators:", error);
+  }
+}
+
+let sweeping = false;
+
+// Shuts down booted simulators whose task is merged, dropped or done.
+export async function shutFinishedTaskSimulators(): Promise<number> {
+  if (!enabled() || sweeping) return 0;
+  sweeping = true;
+  try {
+    const devices = (await listDevices()).filter(
+      (d) =>
+        (running(d) && d.name.startsWith("agentos-")) ||
+        (running(d) && d.name.startsWith("aos-"))
+    );
+    if (devices.length === 0) return 0;
+    const tasks = (
+      db
+        .prepare(
+          `SELECT id, branch_name, worktree_path, task_status, host_id
+           FROM sessions WHERE task_status IS NOT NULL`
+        )
+        .all() as (TaskRef & { host_id: string })[]
+    ).filter((t) => !isRemoteHost(t.host_id));
+    const stale = planFinishedShutdowns(devices, tasks);
+    return await shutAll(stale, "its task is finished");
+  } finally {
+    sweeping = false;
+  }
+}

package/package.json

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

package/server.ts

@@ -79,7 +79,7 @@ import { claimAgentosEnv } from "./lib/agents/self-env";
 import { wslNotes, wslVersion } from "./lib/wsl";
 import { getAllProjects } from "./lib/projects";
 import { isRemoteHost } from "./lib/hosts";
-import { sweepSimulators } from "./lib/simulator";
+import { shutFinishedTaskSimulators, sweepSimulators } from "./lib/simulator";
 
 const dev = process.env.NODE_ENV !== "production";
 const hostname = "127.0.0.1";
@@ -385,6 +385,7 @@ app.prepare().then(async () => {
     sweepingSims = true;
     try {
       await sweepSimulators();
+      await shutFinishedTaskSimulators();
     } catch (error) {
       console.error("Sweeping simulators failed:", error);
     } finally {