@saadnvd1/agent-os 0.3.728 → 0.3.731

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/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.731",
   "description": "Self-hosted web UI for managing Claude Code sessions",
   "bin": {
     "agent-os": "scripts/agent-os"