@saadnvd1/agent-os 0.3.477 → 0.3.481

package/lib/tasks/start.ts

@@ -8,6 +8,7 @@
 
 import { execFile } from "child_process";
 import { promisify } from "util";
+import { endTmuxSession } from "../tmux/end";
 import { db, type Session } from "../db";
 import { getProject } from "../projects";
 import { setupWorktree } from "../env-setup";
@@ -195,10 +196,7 @@ function earlierSetup(row: SetupColumns): TaskSetup | undefined {
   return undefined;
 }
 
-export const killTmux = (name: string) =>
-  execFileAsync("tmux", ["kill-session", "-t", `=${name}`], {
-    timeout: 5000,
-  }).catch(() => undefined);
+export const killTmux = (name: string) => endTmuxSession(null, name);
 
 const tmuxAlive = (name: string) =>
   execFileAsync("tmux", ["has-session", "-t", `=${name}`], {

package/lib/tmux/end.ts

@@ -0,0 +1,33 @@
+import { hostExec } from "../hosts";
+import { shellQuote } from "../hosts/ssh";
+import { isValidTmuxName } from "../hosts/tmux-name";
+
+// Run by sh on the machine the session lives on. The pane processes and
+// everything under them are read before tmux ends the session (the kill only
+// hangs up the panes' own shells), then asked to stop and, if any is still
+// there a second later, killed. Only pids found under this session's panes
+// are ever signalled.
+export function endTmuxScript(name: string): string {
+  return [
+    `t=${shellQuote(`=${name}`)}`,
+    `roots=$(tmux list-panes -s -t "$t" -F '#{pane_pid}' 2>/dev/null)`,
+    `tree=$(ps -Ao pid=,ppid= | awk -v roots="$roots" 'BEGIN{n=split(roots,r,/[ \\n]+/);for(i=1;i<=n;i++)if(r[i]!="")s[r[i]]=1} {p[$1]=$2;a[NR]=$1} END{do{c=0;for(i=1;i<=NR;i++){k=a[i];if(!(k in s)&&(p[k] in s)){s[k]=1;c=1}}}while(c);for(k in s)print k}')`,
+    `tmux kill-session -t "$t" 2>/dev/null`,
+    `if [ -n "$tree" ]; then`,
+    `  kill -TERM $tree 2>/dev/null`,
+    `  alive=; for p in $tree; do kill -0 "$p" 2>/dev/null && alive="$alive $p"; done`,
+    `  if [ -n "$alive" ]; then sleep 1; kill -KILL $alive 2>/dev/null; fi`,
+    `fi`,
+    `exit 0`,
+  ].join("\n");
+}
+
+// Ends a tmux session and what its panes started, on the machine it runs on.
+// A session that isn't there is nothing to do; this never throws.
+export async function endTmuxSession(
+  hostId: string | null | undefined,
+  name: string | null | undefined
+): Promise<void> {
+  if (!name || !isValidTmuxName(name)) return;
+  await hostExec(hostId, endTmuxScript(name), 15_000).catch(() => {});
+}

package/lib/tmux/orphans.ts

@@ -0,0 +1,146 @@
+import { db } from "../db";
+import { getManagedSessionPattern } from "../providers/registry";
+import { WORKER_TMUX_PREFIX } from "../chat/worker/protocol";
+import { isValidTmuxName } from "../hosts/tmux-name";
+import { endTmuxSession } from "./end";
+import { tmux } from "./exec";
+
+// tmux sessions AgentOS made whose session row is gone: deleted before every
+// end-of-life path ended the agent. Swept once at start. Only sessions that
+// carry AgentOS's own marks are ever touched: its names (<agent>-<uuid>,
+// aos-chat-<uuid>) or the AGENTOS_SESSION_ID it sets on the session at
+// launch. Dispatch's sessions and anyone's own terminals have neither.
+
+const UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const WORKER_NAME = new RegExp(`^${WORKER_TMUX_PREFIX}(${UUID})$`, "i");
+const AGENT_NAME = new RegExp(`(${UUID})$`, "i");
+
+export interface TmuxListing {
+  name: string;
+  // AGENTOS_SESSION_ID on the session itself; null when absent or when the
+  // whole tmux server carries one (every session would then).
+  taggedId: string | null;
+}
+
+export interface SessionRow {
+  id: string;
+  tmux_name: string | null;
+  host_id: string | null;
+}
+
+const isLocal = (hostId: string | null) => !hostId || hostId === "local";
+
+// The AgentOS session id a tmux session belongs to, or null if it isn't one
+// of AgentOS's.
+export function agentOsIdOf(
+  l: TmuxListing,
+  managed = getManagedSessionPattern()
+): string | null {
+  const worker = WORKER_NAME.exec(l.name);
+  if (worker) return worker[1].toLowerCase();
+  if (managed.test(l.name)) return AGENT_NAME.exec(l.name)![1].toLowerCase();
+  return l.taggedId && new RegExp(`^${UUID}$`, "i").test(l.taggedId)
+    ? l.taggedId.toLowerCase()
+    : null;
+}
+
+export function findOrphans(
+  listing: TmuxListing[],
+  rows: SessionRow[]
+): { name: string; id: string }[] {
+  const ids = new Set(rows.map((r) => r.id.toLowerCase()));
+  const names = new Set(
+    rows.filter((r) => isLocal(r.host_id)).map((r) => r.tmux_name)
+  );
+  const orphans: { name: string; id: string }[] = [];
+  for (const l of listing) {
+    const id = agentOsIdOf(l);
+    if (id && !ids.has(id) && !names.has(l.name))
+      orphans.push({ name: l.name, id });
+  }
+  return orphans;
+}
+
+async function taggedId(
+  name: string,
+  serverWide: boolean
+): Promise<string | null> {
+  if (serverWide) return null;
+  const out = await tmux(
+    ["show-environment", "-t", `=${name}`, "AGENTOS_SESSION_ID"],
+    5000
+  ).catch(() => "");
+  return /^AGENTOS_SESSION_ID=(.+)$/m.exec(out)?.[1].trim() ?? null;
+}
+
+async function listLocal(createdBefore: number): Promise<TmuxListing[]> {
+  const out = await tmux(
+    ["list-sessions", "-F", "#{session_created} #{session_name}"],
+    5000
+  ).catch(() => "");
+  // Sessions made after the cutoff belong to work this process started: their
+  // rows may not be committed yet, so they are never candidates.
+  const names = out
+    .split("\n")
+    .map((l) => /^(\d+) (.+)$/.exec(l))
+    .filter((m): m is RegExpExecArray => !!m && Number(m[1]) <= createdBefore)
+    .map((m) => m[2])
+    .filter(isValidTmuxName);
+  // A server started from inside an agent's shell has the variable in its
+  // own environment, which every session on it then shows.
+  const global = await tmux(
+    ["show-environment", "-g", "AGENTOS_SESSION_ID"],
+    5000
+  ).catch(() => "");
+  const serverWide = /^AGENTOS_SESSION_ID=/m.test(global);
+  const managed = getManagedSessionPattern();
+  const listing: TmuxListing[] = [];
+  for (const name of names) {
+    const byName = WORKER_NAME.test(name) || managed.test(name);
+    listing.push({
+      name,
+      taggedId: byName ? null : await taggedId(name, serverWide),
+    });
+  }
+  return listing;
+}
+
+const hasRow = (id: string, tmuxName: string) =>
+  !!db
+    .prepare(`SELECT 1 FROM sessions WHERE id = ? OR tmux_name = ?`)
+    .get(id, tmuxName);
+
+export async function sweepOrphanTmux(
+  opts: {
+    dryRun?: boolean;
+    rows?: SessionRow[];
+    // Epoch seconds; only tmux sessions created at or before it are swept.
+    // Defaults to when this process started.
+    createdBefore?: number;
+  } = {}
+): Promise<{ found: string[]; killed: string[] }> {
+  const none = { found: [], killed: [] };
+  const rows =
+    opts.rows ??
+    (db
+      .prepare(`SELECT id, tmux_name, host_id FROM sessions`)
+      .all() as SessionRow[]);
+  // An empty table is a fresh or wrong database, not proof that nothing is
+  // alive: never sweep against it.
+  if (!rows.length) return none;
+  const cutoff =
+    opts.createdBefore ?? Math.floor(Date.now() / 1000 - process.uptime());
+  const orphans = findOrphans(await listLocal(cutoff), rows);
+  const killed: string[] = [];
+  for (const o of orphans) {
+    if (opts.dryRun) continue;
+    // The snapshot is old by now: a row inserted since keeps its session.
+    if (!opts.rows && hasRow(o.id, o.name)) continue;
+    await endTmuxSession(null, o.name);
+    killed.push(o.name);
+    console.log(`[tmux-sweep] ended ${o.name}: session ${o.id} has no row`);
+  }
+  if (killed.length)
+    console.log(`[tmux-sweep] ended ${killed.length} orphaned tmux sessions`);
+  return { found: orphans.map((o) => o.name), killed };
+}

package/package.json

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

package/server.ts

@@ -61,6 +61,7 @@ import { installClaudeStatusHooks } from "./lib/program-status/claude-hooks";
 import os from "os";
 import { resumeHeldStarts, resumeTaskStarts } from "./lib/tasks/start";
 import { failInterruptedSetups } from "./lib/sessions/worktree-setup";
+import { sweepOrphanTmux } from "./lib/tmux/orphans";
 import { releaseInterruptedClaims } from "./lib/orchestrator/ask-approvals";
 import { resumeReviews } from "./lib/orchestrator/review";
 import { claimAgentosEnv } from "./lib/agents/self-env";
@@ -357,6 +358,14 @@ app.prepare().then(async () => {
   }
   // New sessions whose worktree setup a restart cut off.
   failInterruptedSetups();
+  // tmux sessions of sessions deleted before agents were ended with them.
+  // Production only: a dev or test instance has its own database but shares
+  // the default tmux server, so it would see the real instance's sessions as
+  // orphans.
+  if (!dev && process.env.AGENTOS_TMUX_SWEEP !== "off")
+    sweepOrphanTmux().catch((error) =>
+      console.error("Sweeping orphaned tmux sessions failed:", error)
+    );
   // Chat turns that kept running through a restart.
   void reattachChats();
   // Reviews this restart cut off run again and deliver their verdicts.