fix(cli): detect proxied connect sessions in session reporting

Session detection identified a sandbox by its SSH host alias
(`openshell-<name>.default`). Newer OpenShell connects every sandbox
through one fixed `sandbox` alias and names the target only with
`--sandbox-id` on its proxy command, so an attached `connect` session
matched nothing: `list` drew no active-session dot, `status` reported
"SSH sessions: none", and `list --json` reported activeSessionCount 0.

Match the proxied shape by the sandbox's durable OpenShell ID as well.
The dashboard forward runs through the same proxy and the same ID, so
only a command requesting a TTY counts as a session; otherwise every
Ready sandbox would report one. The ID is resolved at most once per
sandbox and only when the process list actually contains a proxied
connection, and a failed lookup leaves detection on SSH-host matching.

Fixes #9316

Signed-off-by: Yanyun Liao <yanyunl@nvidia.com>

Author: yanyunl1991

src/lib/list-command-deps.ts

@@ -50,6 +50,12 @@ export function buildListCommandDeps(): ListSandboxesCommandDeps {
   // Cache the SSH process probe once for all sandboxes — avoids spawning ps
   // per sandbox row. The getSshProcesses() call is the expensive part (5s timeout).
   let cachedSshOutput: string | null | undefined;
+
+  // Resolving a sandbox ID costs one OpenShell call, so only pay it when the
+  // process list actually contains a proxied connection that needs one (#9316).
+  const resolveSandboxIdForSessions = (sshOutput: string, name: string): string | null =>
+    sshOutput.includes("--sandbox-id") ? (sessionDeps?.resolveSandboxId?.(name) ?? null) : null;
+
   const getCachedSshOutput = () => {
     if (cachedSshOutput === undefined && sessionDeps) {
       try {
@@ -86,7 +92,8 @@ export function buildListCommandDeps(): ListSandboxesCommandDeps {
           try {
             const sshOutput = getCachedSshOutput();
             if (sshOutput === null) return null;
-            return parseSshProcesses(sshOutput, name).length;
+            return parseSshProcesses(sshOutput, name, resolveSandboxIdForSessions(sshOutput, name))
+              .length;
           } catch {
             return null;
           }

src/lib/state/sandbox-session.test.ts

@@ -102,6 +102,48 @@ describe("parseSshProcesses", () => {
     });
   });
 
+  // Newer OpenShell routes every sandbox through one fixed `sandbox` alias and
+  // names the target only on its proxy command, so the SSH host carries no
+  // sandbox reference at all (#9316).
+  const PROXY = (id: string) =>
+    `ssh -o ProxyCommand=/usr/local/bin/openshell ssh-proxy --gateway 'https://127.0.0.1:8080' --sandbox-id ${id} --token t --gateway-name nemoclaw -o StrictHostKeyChecking=no`;
+  const SANDBOX_ID = "de7eab7a-002f-41e9-acad-5fd4749e07bb";
+  const interactiveLine = `12345 ${PROXY(SANDBOX_ID)} -tt -o RequestTTY=force -o SetEnv=TERM=xterm-256color sandbox`;
+  const forwardLine = `12300 ${PROXY(SANDBOX_ID)} -N -o ExitOnForwardFailure=yes -L 127.0.0.1:18789:127.0.0.1:18789 sandbox`;
+
+  it("detects a proxied interactive session by sandbox ID (#9316)", () => {
+    expect(parseSshProcesses(interactiveLine, "my-sandbox", SANDBOX_ID)).toEqual([
+      {
+        sandboxName: "my-sandbox",
+        pid: 12345,
+        sshHost: "openshell-my-sandbox.default",
+      },
+    ]);
+  });
+
+  it("does not count the dashboard forward as a session (#9316)", () => {
+    // The forward runs through the same proxy and sandbox ID; only the
+    // interactive session requests a TTY. Counting it would report a session
+    // on every Ready sandbox.
+    expect(parseSshProcesses(forwardLine, "my-sandbox", SANDBOX_ID)).toEqual([]);
+    expect(
+      parseSshProcesses(`${forwardLine}\n${interactiveLine}`, "my-sandbox", SANDBOX_ID),
+    ).toHaveLength(1);
+  });
+
+  it("does not attribute a proxied session without a known sandbox ID (#9316)", () => {
+    // The command line carries no sandbox name, so guessing would attribute one
+    // sandbox's session to another.
+    expect(parseSshProcesses(interactiveLine, "my-sandbox")).toEqual([]);
+    expect(parseSshProcesses(interactiveLine, "my-sandbox", "")).toEqual([]);
+  });
+
+  it("does not match another sandbox's ID (#9316)", () => {
+    expect(
+      parseSshProcesses(interactiveLine, "other-sandbox", "aaaaaaaa-0000-0000-0000-000000000000"),
+    ).toEqual([]);
+  });
+
   it("detects a legacy SSH process during the upgrade window", () => {
     const output = `12345 ssh -F /tmp/config openshell-my-sandbox
 67890 ssh -F /tmp/config openshell-other-sandbox`;

src/lib/state/sandbox-session.ts

@@ -14,6 +14,7 @@
  */
 
 import { spawnSync } from "node:child_process";
+import { parseOpenShellSandboxId } from "../adapters/openshell/sandbox-identity";
 import { openshellSandboxSshHost } from "../adapters/openshell/sandbox-ssh-host";
 
 // ---------------------------------------------------------------------------
@@ -95,21 +96,39 @@ export function parseForwardList(output: string | null | undefined): ForwardEntr
   return entries;
 }
 
+/**
+ * Does this command line belong to an interactive shell rather than a forward?
+ *
+ * OpenShell starts the dashboard port-forward through the same proxy and the
+ * same `sandbox` host alias as `connect`, so the sandbox reference alone cannot
+ * tell them apart. The interactive session is the one that asks for a TTY; the
+ * forward runs `-N` with no remote command. Counting the forward would report a
+ * session on every Ready sandbox.
+ */
+function isInteractiveSshCommand(command: string): boolean {
+  return /(?:^|\s)-tt(?:\s|$)/.test(command) || /RequestTTY=force/.test(command);
+}
+
 /**
  * Parse process list output to find SSH processes targeting a specific sandbox.
  *
- * Current SSH connections use `openshell-<sandboxName>.default`. During the
- * supported v0.0.85 to v0.0.99 upgrade window, an already-running connection
- * may still target the legacy `openshell-<sandboxName>` alias. We recognize
- * both as complete tokens to avoid false positives when one sandbox name is a
- * prefix of another (e.g., `dev` vs `dev-staging`).
+ * Two shapes are recognized. OpenShell used to place the sandbox in the SSH
+ * host itself (`openshell-<sandboxName>.default`, and the legacy
+ * `openshell-<sandboxName>` from the v0.0.85 to v0.0.99 upgrade window); those
+ * are matched as complete tokens so one sandbox name cannot match another it is
+ * a prefix of (`dev` vs `dev-staging`). Newer OpenShell connects every sandbox
+ * through the fixed `sandbox` alias and identifies the target with
+ * `--sandbox-id <id>` on its proxy command instead, which left interactive
+ * sessions invisible to every session-reporting surface (#9316). When the
+ * caller knows the durable sandbox ID, that form is matched too.
  *
  * Input format: one line per process — `<PID> <full command line>`
  * (compatible with both `pgrep -a` on Linux and `ps -axo pid,command`)
  */
 export function parseSshProcesses(
   pgrepOutput: string | null | undefined,
   sandboxName: string,
+  sandboxId?: string | null,
 ): SandboxSession[] {
   if (!pgrepOutput || typeof pgrepOutput !== "string") return [];
   if (!sandboxName) return [];
@@ -118,6 +137,10 @@ export function parseSshProcesses(
   const hostPatterns = sshHosts.map(
     (sshHost) => [sshHost, new RegExp(`(?:^|\\s)${escapeRegExp(sshHost)}(?:\\s|$)`)] as const,
   );
+  const idPattern =
+    sandboxId && sandboxId.trim()
+      ? new RegExp(`--sandbox-id[=\\s]+${escapeRegExp(sandboxId.trim())}(?:\\s|$)`)
+      : null;
   const sessions: SandboxSession[] = [];
   const lines = pgrepOutput.split("\n").filter(Boolean);
 
@@ -126,10 +149,17 @@ export function parseSshProcesses(
     if (!pidMatch) continue;
 
     const pid = Number.parseInt(pidMatch[1], 10);
+    const command = pidMatch[2];
 
-    const sshHost = hostPatterns.find(([, pattern]) => pattern.test(pidMatch[2]))?.[0];
+    const sshHost = hostPatterns.find(([, pattern]) => pattern.test(command))?.[0];
     if (sshHost) {
       sessions.push({ sandboxName, pid, sshHost });
+      continue;
+    }
+    // The proxied form carries no sandbox name, so it is only attributable
+    // when the caller resolved the sandbox's durable ID.
+    if (idPattern?.test(command) && isInteractiveSshCommand(command)) {
+      sessions.push({ sandboxName, pid, sshHost: openshellSandboxSshHost(sandboxName) });
     }
   }
 
@@ -216,6 +246,12 @@ export interface SessionDetectionDeps {
   getForwardList: () => string | null;
   /** Run `pgrep -a ssh` and return stdout. Null if unavailable. */
   getSshProcesses: () => string | null;
+  /**
+   * Resolve the sandbox's durable OpenShell ID, or null when it cannot be
+   * determined. Only consulted when the process list contains a proxied
+   * connection, which is the only shape that needs it (#9316).
+   */
+  resolveSandboxId?: (sandboxName: string) => string | null;
 }
 
 /**
@@ -244,7 +280,12 @@ export function getActiveSandboxSessions(
     return { detected: false, sessions: [] };
   }
 
-  const sshSessions = parseSshProcesses(pgrepOutput, sandboxName);
+  // Resolving the ID costs an OpenShell call, so only pay it for the proxied
+  // shape that cannot be attributed from the SSH host alone (#9316).
+  const sandboxId = pgrepOutput.includes("--sandbox-id")
+    ? (deps.resolveSandboxId?.(sandboxName) ?? null)
+    : null;
+  const sshSessions = parseSshProcesses(pgrepOutput, sandboxName, sandboxId);
 
   return {
     detected: true,
@@ -298,5 +339,34 @@ export function createSystemDeps(openshellBinary: string): SessionDetectionDeps
       }
     },
     getSshProcesses: querySshProcesses,
+    resolveSandboxId: createOpenshellSandboxIdResolver(openshellBinary),
+  };
+}
+
+/**
+ * Read a sandbox's durable ID via `openshell sandbox get`, memoized per process
+ * and failing soft. Detection stays on SSH-host matching when the lookup fails,
+ * so an unavailable OpenShell client never breaks the surrounding command.
+ */
+function createOpenshellSandboxIdResolver(
+  openshellBinary: string,
+): (sandboxName: string) => string | null {
+  const cache = new Map<string, string | null>();
+  return (sandboxName: string): string | null => {
+    const cached = cache.get(sandboxName);
+    if (cached !== undefined) return cached;
+    let resolved: string | null = null;
+    try {
+      const result = spawnSync(openshellBinary, ["sandbox", "get", sandboxName], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 5000,
+      });
+      resolved = result.status === 0 ? parseOpenShellSandboxId(result.stdout || "") : null;
+    } catch {
+      resolved = null;
+    }
+    cache.set(sandboxName, resolved);
+    return resolved;
   };
 }

src/lib/status-command-deps.ts

@@ -248,6 +248,12 @@ export function buildStatusCommandDeps(rootDir: string): ShowStatusCommandDeps {
   // Cache the SSH process probe once per command invocation — avoids
   // spawning ps per sandbox row. #2604; mirrors buildListCommandDeps.
   let cachedSshOutput: string | null | undefined;
+
+  // Resolving a sandbox ID costs one OpenShell call, so only pay it when the
+  // process list actually contains a proxied connection that needs one (#9316).
+  const resolveSandboxIdForSessions = (sshOutput: string, name: string): string | null =>
+    sshOutput.includes("--sandbox-id") ? (sessionDeps?.resolveSandboxId?.(name) ?? null) : null;
+
   const getCachedSshOutput = (): string | null => {
     if (cachedSshOutput === undefined && sessionDeps) {
       try {
@@ -278,7 +284,8 @@ export function buildStatusCommandDeps(rootDir: string): ShowStatusCommandDeps {
           try {
             const sshOutput = getCachedSshOutput();
             if (sshOutput === null) return null;
-            return parseSshProcesses(sshOutput, name).length;
+            return parseSshProcesses(sshOutput, name, resolveSandboxIdForSessions(sshOutput, name))
+              .length;
           } catch {
             return null;
           }