@saadnvd1/agent-os 0.3.728 → 0.3.733

package/lib/ports/whoHolds.ts

@@ -0,0 +1,155 @@
+import fs from "fs";
+import { db } from "@/lib/db";
+import { parsePorts } from "./allocatePorts";
+import type {
+  DevServerPortRow,
+  Holder,
+  Listener,
+  PortCheck,
+  SessionPortRow,
+} from "./types";
+
+const inside = (cwd: string, dir: string) =>
+  cwd === dir || cwd.startsWith(dir.endsWith("/") ? dir : `${dir}/`);
+
+const holdsPort = (s: SessionPortRow, port: number) =>
+  s.devServerPort === port || Object.values(s.ports ?? {}).includes(port);
+
+const asSession = (
+  s: SessionPortRow,
+  pid: number | null,
+  listening: boolean
+): Holder => ({
+  kind: "session",
+  sessionId: s.id,
+  name: s.name,
+  project: s.project,
+  pid,
+  listening,
+});
+
+/**
+ * Who holds a port: the session whose worktree the listener runs in, the
+ * Dev Servers panel's server, a Windows process, or a process outside
+ * AgentOS. A listener whose cwd can't be read falls to the session that
+ * holds the port, if any. With nothing listening, a session or panel server
+ * that holds the port still has it. Null when it's free.
+ */
+export function whoHolds(
+  port: number,
+  listeners: Listener[],
+  sessions: SessionPortRow[],
+  devServers: DevServerPortRow[]
+): Holder | null {
+  const l = listeners.find((x) => x.port === port);
+  const reserving = sessions.find((s) => holdsPort(s, port));
+  const panel = devServers.find((d) => d.ports.includes(port));
+  if (l) {
+    if (l.cwd) {
+      const s = sessions.find((x) => x.worktree && inside(l.cwd!, x.worktree));
+      if (s) return asSession(s, l.pid, true);
+    }
+    const byPid = devServers.find((d) => d.pid !== null && d.pid === l.pid);
+    if (byPid)
+      return { kind: "dev-server", id: byPid.id, name: byPid.name, pid: l.pid };
+    if (l.windows) return { kind: "windows", pid: l.pid };
+    if (!l.cwd && reserving) return asSession(reserving, l.pid, true);
+    return { kind: "outside", pid: l.pid, command: l.command, cwd: l.cwd };
+  }
+  if (reserving) return asSession(reserving, null, false);
+  if (panel)
+    return {
+      kind: "dev-server",
+      id: panel.id,
+      name: panel.name,
+      pid: panel.pid,
+    };
+  return null;
+}
+
+export function judgePort(
+  askerId: string,
+  name: string | null,
+  port: number,
+  listeners: Listener[] | null,
+  sessions: SessionPortRow[],
+  devServers: DevServerPortRow[]
+): PortCheck {
+  const holder = whoHolds(port, listeners ?? [], sessions, devServers);
+  const mine = holder?.kind === "session" && holder.sessionId === askerId;
+  const free =
+    holder === null
+      ? listeners === null
+        ? null
+        : true
+      : mine && !holder.listening;
+  return { name, port, free, holder, mine };
+}
+
+const real = (p: string) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+
+// This machine's sessions that run in a worktree or hold ports.
+export function localPortRows(): {
+  sessions: SessionPortRow[];
+  devServers: DevServerPortRow[];
+} {
+  const rows = db
+    .prepare(
+      `SELECT s.id, s.name, p.name AS project, s.worktree_path, s.ports, s.dev_server_port
+       FROM sessions s LEFT JOIN projects p ON p.id = s.project_id
+       WHERE (s.host_id IS NULL OR s.host_id = 'local')
+         AND ((s.worktree_path IS NOT NULL AND s.archived_at IS NULL)
+              OR s.ports IS NOT NULL OR s.dev_server_port IS NOT NULL)`
+    )
+    .all() as {
+    id: string;
+    name: string;
+    project: string | null;
+    worktree_path: string | null;
+    ports: string | null;
+    dev_server_port: number | null;
+  }[];
+  const servers = db
+    .prepare(
+      `SELECT id, name, pid, ports FROM dev_servers WHERE status IN ('running', 'starting')`
+    )
+    .all() as { id: string; name: string; pid: number | null; ports: string }[];
+  return {
+    sessions: rows.map((r) => ({
+      id: r.id,
+      name: r.name,
+      project: r.project,
+      worktree: r.worktree_path ? real(r.worktree_path) : null,
+      ports: parsePorts(r.ports),
+      devServerPort: r.dev_server_port,
+    })),
+    devServers: servers.map((d) => {
+      let ports: number[] = [];
+      try {
+        const parsed = JSON.parse(d.ports) as unknown;
+        if (Array.isArray(parsed))
+          ports = parsed.filter((p): p is number => Number.isInteger(p));
+      } catch {}
+      return { id: d.id, name: d.name, pid: d.pid, ports };
+    }),
+  };
+}
+
+export function describeHolder(h: Holder): string {
+  switch (h.kind) {
+    case "session":
+      return `session "${h.name}"${h.project ? ` (project ${h.project})` : ""}${h.pid ? `, pid ${h.pid}` : ""}${h.listening ? "" : ", which holds it but isn't listening yet"}`;
+    case "dev-server":
+      return `the Dev Servers panel's "${h.name}"${h.pid ? `, pid ${h.pid}` : ""}`;
+    case "windows":
+      return `a Windows process${h.pid ? ` (pid ${h.pid})` : ""}`;
+    case "outside":
+      return `${h.pid ? `pid ${h.pid}` : "a process"}${h.command ? ` (${h.command})` : ""}${h.cwd ? ` in ${h.cwd}` : ""}, outside AgentOS`;
+  }
+}

package/lib/project-config/brief.ts

@@ -19,15 +19,17 @@ export function runningBrief(
   config: ProjectConfig,
   ports: Record<string, number>,
   database: SessionDatabase | null = null,
-  warning: string | null = null
+  warning: string | null = null,
+  hardcoded: string[] = []
 ): string {
   const lines: string[] = [];
   if (warning) lines.push(`- ${warning}`);
   const names = Object.entries(ports);
   if (names.length)
     lines.push(
-      `- Your ports, exported in your shell and no other session's: ${names.map(([n, p]) => `${n}=${p}`).join(", ")}. Start servers on these; never stop a process you didn't start (kill by your port: \`lsof -ti tcp:<port> -sTCP:LISTEN | xargs kill\`).`
+      `- Your ports, exported in your shell and no other session's: ${names.map(([n, p]) => `${n}=${p}`).join(", ")}. Start servers on these; never stop a process you didn't start (kill by your port: \`lsof -ti tcp:<port> -sTCP:LISTEN | xargs kill\`). If one is taken, never wait for it: \`aos port\` names the holder and gives you a free one.`
     );
+  for (const note of hardcoded) lines.push(`- ${note}`);
   if (config.dev)
     lines.push(`- Dev server: \`${withPorts(config.dev, ports)}\``);
   const ready = readyCommand(config, ports);

package/lib/project-config/session.ts

@@ -9,7 +9,8 @@ import os from "os";
 import { sessionTmpDir } from "../sessions/leftovers";
 import { db } from "../db";
 import { getProject } from "../projects";
-import { sessionPorts } from "../ports";
+import { sessionPorts } from "../ports/allocatePorts";
+import { findHardcodedPorts, hardcodedNote } from "../ports/findHardcodedPorts";
 import {
   loadProjectConfig,
   NONE,
@@ -71,12 +72,27 @@ export function sessionProjectEnv(sessionId: string): Record<string, string> {
   }
 }
 
+// With no config file the section is only the session's ports, so an agent
+// in a project without agentos.json still knows it has them.
 export function sessionRunningBrief(sessionId: string): string {
   try {
     const { config, source, warning, ports } = sessionConfig(sessionId);
+    if (!source && !ports) return "";
+    const dir = projectPathOf(sessionId);
+    const primary = ports ? Object.values(ports)[0] : undefined;
+    const hardcoded =
+      dir && primary !== undefined
+        ? findHardcodedPorts(dir, config.dev, primary).map(hardcodedNote)
+        : [];
     return source
-      ? runningBrief(config, ports ?? {}, sessionDatabase(sessionId), warning)
-      : "";
+      ? runningBrief(
+          config,
+          ports ?? {},
+          sessionDatabase(sessionId),
+          warning,
+          hardcoded
+        )
+      : runningBrief({}, ports ?? {}, null, null, hardcoded);
   } catch (error) {
     console.error(`[project-config] brief for ${sessionId}:`, error);
     return "";

package/lib/sidebar/groupDrop.ts

@@ -0,0 +1,36 @@
+// Drag a session onto a group to file it there, or onto the list outside any
+// group to take it out. Pure, so the rules are testable without a DOM.
+
+export type DraggedSession = {
+  id: string;
+  groupId: string | null;
+  // The session's workspace, by the same rule the server files by.
+  workspaceId: string | null;
+};
+
+export type DropTarget = { groupId: string; workspaceId: string | null };
+
+// What a drop should do: the group to file into (null = out of any group), or
+// null when nothing should happen. A group of another workspace never takes
+// the session (the server refuses it too); dropping on its own group, or an
+// ungrouped session outside any group, changes nothing.
+export function dropOutcome(
+  dragged: DraggedSession,
+  target: DropTarget | null
+): { groupId: string | null } | null {
+  if (!target) return dragged.groupId ? { groupId: null } : null;
+  if ((target.workspaceId ?? null) !== (dragged.workspaceId ?? null))
+    return null;
+  return target.groupId === dragged.groupId
+    ? null
+    : { groupId: target.groupId };
+}
+
+export const DRAG_TYPE = "application/x-agentos-session";
+
+// dragover can't read the payload, so the one drag in flight is kept here.
+let current: DraggedSession | null = null;
+export const dragging = () => current;
+export const setDragging = (d: DraggedSession | null) => {
+  current = d;
+};

package/lib/updates/banner.ts

@@ -44,6 +44,7 @@ export type UpdateRefusal =
   | "diverged"
   | "up_to_date"
   | "unknown"
+  | "no_restart"
   | "forbidden";
 
 export interface UpdateView {
@@ -61,6 +62,8 @@ export interface UpdateView {
   checkError: string | null;
   bannerEnabled: boolean;
   bannerLocked: boolean;
+  /** False when the server has no command to restart itself with. */
+  canRestart: boolean;
   canUpdate: { ok: boolean; code?: UpdateRefusal; reason?: string };
   run: UpdateRun | null;
   pending: { requestedAt: number } | null;

package/lib/updates/run.ts

@@ -197,6 +197,9 @@ export function readLog(deps: Pick<RunDeps, "logFile">, lines = 30): string[] {
 export type Refusal = { code: UpdateRefusal; error: string };
 
 /** Why this checkout can't be updated now; null when it can. No network. */
+export const NO_RESTART =
+  "This server can't restart itself, so an update would leave the old build running on new files. Set AGENTOS_RESTART to its restart command, or start it with agent-os start.";
+
 export async function preflight(
   check: CheckResult | null,
   deps: RunDeps
@@ -258,6 +261,8 @@ export async function preflight(
     };
   if (!check.available)
     return { code: "up_to_date", error: "AgentOS is up to date." };
+  if (!(await deps.restartCommand()))
+    return { code: "no_restart", error: NO_RESTART };
   return null;
 }
 
@@ -339,14 +344,14 @@ async function begin(
     toVersion: result.latest!.version,
     startedAt: deps.now(),
   });
-  const restart = await deps.restartCommand();
+  const restart = (await deps.restartCommand())!;
   const env = { ...deps.env } as NodeJS.ProcessEnv;
   // The restarted server must work out its own build, not inherit this one.
   delete env.AGENTOS_BUILD;
   delete env.AGENTOS_RESTART;
   env.AGENTOS_UPDATE_STATE = deps.stateFile;
   env.AGENTOS_UPDATE_ID = id;
-  if (restart) env.AGENTOS_RESTART = restart;
+  env.AGENTOS_RESTART = restart;
   if (deps.env.PORT) env.PORT = deps.env.PORT;
   deps.spawnRunner(env, deps.logFile);
   return { ok: true, pending: false };

package/lib/updates/view.ts

@@ -53,6 +53,7 @@ export async function updateView(
   const pending = readPending(deps);
   const active = isActivePhase(run?.phase);
   const refusal = mayUpdate ? await preflight(check, deps) : null;
+  const canRestart = !!(await deps.restartCommand());
   const wantsWorking = !active && !!(check?.available || pending);
   return {
     current: check?.current ?? null,
@@ -64,6 +65,7 @@ export async function updateView(
     checkError: check?.error ?? null,
     bannerEnabled: bannerEnabled(deps.env),
     bannerLocked: bannerLocked(deps.env),
+    canRestart,
     canUpdate: !mayUpdate
       ? { ok: false, code: "forbidden", reason: NOT_ALLOWED }
       : refusal

package/lib/windows-ports.ts

@@ -16,45 +16,55 @@ const execFileAsync = promisify(execFile);
 const TTL_MS = 3000;
 
 /**
- * Listening ports in `netstat.exe -ano -p TCP` output. A listener has a
- * wildcard peer (0.0.0.0:0 or [::]:0), which holds in every Windows locale;
- * the state column ("LISTENING") is translated.
+ * Listening ports in `netstat.exe -ano -p TCP` output, each with the pid
+ * that holds it. A listener has a wildcard peer (0.0.0.0:0 or [::]:0), which
+ * holds in every Windows locale; the state column ("LISTENING") is
+ * translated.
  */
-export function parseNetstatListeners(out: string): Set<number> {
-  const ports = new Set<number>();
+export function parseNetstatOwners(out: string): Map<number, number | null> {
+  const owners = new Map<number, number | null>();
   for (const line of out.split(/\r?\n/)) {
     const cols = line.trim().split(/\s+/);
     if (cols.length < 4 || cols[0].toUpperCase() !== "TCP") continue;
     const [, local, peer] = cols;
     if (!/^(0\.0\.0\.0|\[::\]):0$/.test(peer)) continue;
     const port = Number(local.slice(local.lastIndexOf(":") + 1));
-    if (Number.isInteger(port) && port > 0) ports.add(port);
+    const pid = Number(cols[cols.length - 1]);
+    if (Number.isInteger(port) && port > 0 && !owners.has(port))
+      owners.set(port, Number.isInteger(pid) && pid > 0 ? pid : null);
   }
-  return ports;
+  return owners;
 }
 
+export const parseNetstatListeners = (out: string): Set<number> =>
+  new Set(parseNetstatOwners(out).keys());
+
 type Run = (file: string, args: string[]) => Promise<string>;
 
 const defaultRun: Run = async (file, args) =>
   (await execFileAsync(file, args, { timeout: 4000, maxBuffer: 8 << 20 }))
     .stdout;
 
-let cache: { at: number; ports: Set<number> | null } | undefined;
-let inflight: Promise<Set<number> | null> | undefined;
+type Owners = Map<number, number | null>;
 
-/** The ports Windows listens on, or null when unknown (not WSL 2, or it failed). */
-export async function windowsListeningPorts(
-  opts: { wsl?: number; run?: Run; now?: number } = {}
-): Promise<Set<number> | null> {
+let cache: { at: number; owners: Owners | null } | undefined;
+let inflight: Promise<Owners | null> | undefined;
+
+type Opts = { wsl?: number; run?: Run; now?: number };
+
+/** Windows' listening ports and their pids, or null when unknown (not WSL 2, or it failed). */
+export async function windowsListeners(
+  opts: Opts = {}
+): Promise<Owners | null> {
   if ((opts.wsl ?? wslVersion()) !== 2) return null;
   const now = opts.now ?? Date.now();
-  if (cache && now - cache.at < TTL_MS) return cache.ports;
+  if (cache && now - cache.at < TTL_MS) return cache.owners;
   inflight ??= (opts.run ?? defaultRun)("netstat.exe", ["-ano", "-p", "TCP"])
-    .then((out) => parseNetstatListeners(out))
+    .then((out) => parseNetstatOwners(out))
     .catch(() => null)
-    .then((ports) => {
-      cache = { at: now, ports };
-      return ports;
+    .then((owners) => {
+      cache = { at: now, owners };
+      return owners;
     })
     .finally(() => {
       inflight = undefined;
@@ -62,6 +72,14 @@ export async function windowsListeningPorts(
   return inflight;
 }
 
+/** The ports Windows listens on, or null when unknown (not WSL 2, or it failed). */
+export async function windowsListeningPorts(
+  opts: Opts = {}
+): Promise<Set<number> | null> {
+  const owners = await windowsListeners(opts);
+  return owners ? new Set(owners.keys()) : null;
+}
+
 export function resetWindowsPortsCache() {
   cache = undefined;
   inflight = undefined;

package/package.json

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

package/scripts/redeploy

@@ -2,6 +2,7 @@
 # Update a running checkout to origin's branch: pull, install, build beside
 # the live server, swap the build in and restart, so neither a build in
 # progress nor a failed one takes the running server down.
+# Without AGENTOS_RESTART it builds and checks but swaps nothing in.
 # Restart with: AGENTOS_RESTART="<command>" scripts/redeploy
 # Put the previous build back: AGENTOS_RESTART="<command>" scripts/redeploy --rollback
 set -euo pipefail
@@ -49,6 +50,14 @@ else
   echo "::phase building"
   # A build that fails on the new dependencies puts the old ones back.
   build_beside || { [ "$swapped" = 1 ] && restore_deps; exit 1; }
+  if [ -z "${AGENTOS_RESTART:-}" ]; then
+    # Nothing can restart the server, and a new build or node_modules under
+    # the old process breaks its pages: leave the live tree as it was.
+    [ "$swapped" = 1 ] && restore_deps
+    echo "Built and verified in $NEXT_BUILD, but not swapped in: nothing here can restart the server."
+    echo "Set AGENTOS_RESTART to its restart command and run scripts/redeploy again to swap and restart."
+    exit 0
+  fi
   swap_build
 fi
 
@@ -68,4 +77,4 @@ if [ -n "${AGENTOS_RESTART:-}" ]; then
   echo "AgentOS did not come back on $port within ${AGENTOS_UP_WAIT:-600}s; scripts/redeploy --rollback puts the last build back" >&2
   exit 1
 fi
-echo "Built. Restart your AgentOS server to run it."
+echo "Rolled back. Restart your AgentOS server to run it."

package/scripts/redeploy.test.ts

@@ -0,0 +1,77 @@
+import { spawnSync } from "node:child_process";
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, it } from "vitest";
+import { tempDir } from "@/lib/test-temp";
+
+// Runs the real scripts/redeploy (--pulled, so no git) in a scratch tree with
+// stub install, build and pnpm.
+let dir: string;
+beforeEach(() => {
+  dir = tempDir("aos-redeploy-");
+  mkdirSync(join(dir, "scripts/lib"), { recursive: true });
+  for (const f of [
+    "redeploy",
+    "lib/build-swap.sh",
+    "lib/pnpm.sh",
+    "lib/deps-swap.sh",
+  ])
+    copyFileSync(join(import.meta.dirname, f), join(dir, "scripts", f));
+  chmodSync(join(dir, "scripts/redeploy"), 0o755);
+  mkdirSync(join(dir, ".next"));
+  writeFileSync(join(dir, ".next/BUILD_ID"), "old");
+  mkdirSync(join(dir, "bin"));
+  for (const name of ["pnpm"])
+    writeFileSync(join(dir, "bin", name), "#!/bin/sh\nexit 0\n", {
+      mode: 0o755,
+    });
+  for (const f of ["package.json", "pnpm-lock.yaml", "pnpm-workspace.yaml"])
+    writeFileSync(join(dir, f), "{}");
+});
+
+const redeploy = (restart?: string) => {
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    HOME: dir,
+    PATH: `${join(dir, "bin")}:${process.env.PATH}`,
+    AGENTOS_INSTALL_CMD: "mkdir -p node_modules",
+    AGENTOS_NATIVE_CHECK: "true",
+    AGENTOS_BUILD_CMD:
+      'mkdir -p "$AGENTOS_DIST_DIR" && echo new > "$AGENTOS_DIST_DIR/BUILD_ID"',
+    AGENTOS_UP_WAIT: "1",
+    PORT: "1",
+  };
+  delete env.AGENTOS_RESTART;
+  if (restart) env.AGENTOS_RESTART = restart;
+  return spawnSync("bash", [join(dir, "scripts/redeploy"), "--pulled"], {
+    cwd: dir,
+    encoding: "utf8",
+    env,
+  });
+};
+const liveBuild = () =>
+  readFileSync(join(dir, ".next/BUILD_ID"), "utf8").trim();
+
+describe("scripts/redeploy", () => {
+  it("without a restart command builds but leaves the live build in place", () => {
+    const r = redeploy();
+    expect(r.status).toBe(0);
+    expect(r.stdout).toContain("not swapped in");
+    expect(liveBuild()).toBe("old");
+    expect(existsSync(join(dir, ".next-prev"))).toBe(false);
+  });
+
+  it("with a restart command swaps the build in and restarts", () => {
+    const r = redeploy(`touch ${join(dir, "restarted")}`);
+    expect(liveBuild()).toBe("new");
+    expect(existsSync(join(dir, "restarted"))).toBe(true);
+    expect(r.stdout).toContain("::phase restarting");
+  });
+});