Merge remote-tracking branch 'origin/e2e-phase6-telegram-injection' into e2e-phase6-telegram-injection

Author: cv

docs/reference/commands-nemohermes.mdx

@@ -432,7 +432,7 @@ The exit code is the remote command's exit code.
 
 | Flag | Description |
 |------|-------------|
-| `--workdir <dir>` | Working directory inside the sandbox |
+| `--workdir <dir>` | Working directory inside the sandbox. The directory is checked before the command runs; if it does not exist, NemoClaw reports `error: --workdir: <dir> does not exist inside the sandbox` and exits with status `1` without invoking the inner command. |
 | `--tty` / `--no-tty` | Allocate a pseudo-terminal; defaults to auto-detection (on when stdin and stdout are terminals) |
 | `--timeout <seconds>` | Timeout in seconds (`0` means no timeout) |
 
@@ -622,7 +622,7 @@ nemohermes my-assistant exec [--workdir <dir>] [--tty|--no-tty] [--timeout <s>]
 
 | Flag | Description |
 |------|-------------|
-| `--workdir <dir>` | Set the working directory inside the sandbox |
+| `--workdir <dir>` | Set the working directory inside the sandbox. The directory is checked before the command runs; if it does not exist, NemoClaw reports `error: --workdir: <dir> does not exist inside the sandbox` and exits with status `1` without invoking the inner command. |
 | `--tty`, `--no-tty` | Allocate or disable a pseudo-terminal; defaults to auto-detection |
 | `--timeout <s>` | Timeout in seconds. Use `0` for no timeout |
 

docs/reference/commands.mdx

@@ -537,7 +537,7 @@ The exit code is the remote command's exit code.
 
 | Flag | Description |
 |------|-------------|
-| `--workdir <dir>` | Working directory inside the sandbox |
+| `--workdir <dir>` | Working directory inside the sandbox. The directory is checked before the command runs; if it does not exist, NemoClaw reports `error: --workdir: <dir> does not exist inside the sandbox` and exits with status `1` without invoking the inner command. |
 | `--tty` / `--no-tty` | Allocate a pseudo-terminal; defaults to auto-detection (on when stdin and stdout are terminals) |
 | `--timeout <seconds>` | Timeout in seconds (`0` means no timeout) |
 
@@ -807,7 +807,7 @@ $$nemoclaw my-assistant exec [--workdir <dir>] [--tty|--no-tty] [--timeout <s>]
 
 | Flag | Description |
 |------|-------------|
-| `--workdir <dir>` | Set the working directory inside the sandbox |
+| `--workdir <dir>` | Set the working directory inside the sandbox. The directory is checked before the command runs; if it does not exist, NemoClaw reports `error: --workdir: <dir> does not exist inside the sandbox` and exits with status `1` without invoking the inner command. |
 | `--tty`, `--no-tty` | Allocate or disable a pseudo-terminal; defaults to auto-detection |
 | `--timeout <s>` | Timeout in seconds. Use `0` for no timeout |
 

src/lib/actions/sandbox/exec.test.ts

@@ -1,9 +1,16 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
-import { buildOpenshellExecArgs, computeExitCode } from "./exec";
+import {
+  buildOpenshellExecArgs,
+  buildWorkdirProbeArgs,
+  computeExitCode,
+  evaluateWorkdirProbe,
+  validateWorkdirOrFail,
+  workdirMissingMessage,
+} from "./exec";
 
 describe("buildOpenshellExecArgs", () => {
   it("targets the sandbox by name and forwards the user command after --", () => {
@@ -115,3 +122,109 @@ describe("computeExitCode", () => {
     });
   });
 });
+
+describe("buildWorkdirProbeArgs", () => {
+  it("targets the sandbox by name and probes the directory with test -d", () => {
+    expect(buildWorkdirProbeArgs("alpha", "/sandbox/workspace")).toEqual([
+      "sandbox",
+      "exec",
+      "--name",
+      "alpha",
+      "--",
+      "test",
+      "-d",
+      "/sandbox/workspace",
+    ]);
+  });
+
+  it("does not split a path argument that contains whitespace", () => {
+    const argv = buildWorkdirProbeArgs("alpha", "/sandbox/with spaces/dir");
+    expect(argv[argv.length - 1]).toBe("/sandbox/with spaces/dir");
+  });
+});
+
+describe("workdirMissingMessage", () => {
+  it("renders a user-facing CLI error with the offending path", () => {
+    expect(workdirMissingMessage("/sandbox/workspace")).toBe(
+      "error: --workdir: /sandbox/workspace does not exist inside the sandbox",
+    );
+  });
+});
+
+describe("evaluateWorkdirProbe", () => {
+  it("returns 'ok' when the probe exits 0", () => {
+    expect(evaluateWorkdirProbe({ status: 0 })).toBe("ok");
+  });
+
+  it("returns 'missing' only for the canonical test -d failure (exit 1)", () => {
+    expect(evaluateWorkdirProbe({ status: 1 })).toBe("missing");
+  });
+
+  it("returns 'unclear' for any other exit code so the main exec surfaces it", () => {
+    expect(evaluateWorkdirProbe({ status: 2 })).toBe("unclear");
+    expect(evaluateWorkdirProbe({ status: 127 })).toBe("unclear");
+    expect(evaluateWorkdirProbe({ status: null })).toBe("unclear");
+  });
+
+  it("returns 'unclear' when spawn reports a transport error", () => {
+    expect(evaluateWorkdirProbe({ status: null, error: new Error("ENOENT") })).toBe("unclear");
+  });
+});
+
+describe("validateWorkdirOrFail", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("passes through when the directory exists", () => {
+    const run = vi.fn(() => ({ status: 0 }));
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => {
+      throw new Error("process.exit should not be called for ok outcome");
+    }) as never);
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    validateWorkdirOrFail("openshell", "alpha", "/sandbox/workspace", run);
+
+    expect(run).toHaveBeenCalledWith("openshell", [
+      "sandbox",
+      "exec",
+      "--name",
+      "alpha",
+      "--",
+      "test",
+      "-d",
+      "/sandbox/workspace",
+    ]);
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+
+  it("prints a friendly error and exits 1 when the directory is missing", () => {
+    const run = vi.fn(() => ({ status: 1 }));
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => {
+      throw new Error("exit");
+    }) as never);
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    expect(() => validateWorkdirOrFail("openshell", "alpha", "/sandbox/workspace", run)).toThrow(
+      "exit",
+    );
+    expect(errSpy).toHaveBeenCalledWith(
+      "error: --workdir: /sandbox/workspace does not exist inside the sandbox",
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("does not abort when the probe outcome is unclear (lets main exec surface it)", () => {
+    const run = vi.fn(() => ({ status: 127 }));
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(((_code?: number) => {
+      throw new Error("process.exit should not be called for unclear outcome");
+    }) as never);
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    validateWorkdirOrFail("openshell", "alpha", "/sandbox/workspace", run);
+
+    expect(exitSpy).not.toHaveBeenCalled();
+    expect(errSpy).not.toHaveBeenCalled();
+  });
+});

src/lib/actions/sandbox/exec.ts

@@ -16,6 +16,15 @@ type SpawnLikeResult = {
   error?: Error;
 };
 
+export type WorkdirProbeResult = {
+  status: number | null;
+  error?: Error;
+};
+
+export type WorkdirProbeOutcome = "ok" | "missing" | "unclear";
+
+export type WorkdirProbeRunner = (binary: string, args: readonly string[]) => WorkdirProbeResult;
+
 export function buildOpenshellExecArgs(
   sandboxName: string,
   command: readonly string[],
@@ -32,6 +41,21 @@ export function buildOpenshellExecArgs(
   return argv;
 }
 
+export function buildWorkdirProbeArgs(sandboxName: string, workdir: string): string[] {
+  return ["sandbox", "exec", "--name", sandboxName, "--", "test", "-d", workdir];
+}
+
+export function workdirMissingMessage(workdir: string): string {
+  return `error: --workdir: ${workdir} does not exist inside the sandbox`;
+}
+
+export function evaluateWorkdirProbe(probe: WorkdirProbeResult): WorkdirProbeOutcome {
+  if (probe.error) return "unclear";
+  if (probe.status === 0) return "ok";
+  if (probe.status === 1) return "missing";
+  return "unclear";
+}
+
 export function computeExitCode(result: SpawnLikeResult): {
   code: number;
   errorMessage?: string;
@@ -56,6 +80,24 @@ function exitWithSpawnResult(result: SpawnLikeResult): never {
   process.exit(code);
 }
 
+const defaultWorkdirProbeRunner: WorkdirProbeRunner = (binary, args) => {
+  const probe = spawnSync(binary, args, { stdio: ["ignore", "ignore", "ignore"] });
+  return { status: probe.status, error: probe.error };
+};
+
+export function validateWorkdirOrFail(
+  binary: string,
+  sandboxName: string,
+  workdir: string,
+  run: WorkdirProbeRunner = defaultWorkdirProbeRunner,
+): void {
+  const outcome = evaluateWorkdirProbe(run(binary, buildWorkdirProbeArgs(sandboxName, workdir)));
+  if (outcome === "missing") {
+    console.error(workdirMissingMessage(workdir));
+    process.exit(1);
+  }
+}
+
 export async function execSandbox(
   sandboxName: string,
   command: readonly string[],
@@ -69,10 +111,12 @@ export async function execSandbox(
     );
     process.exit(2);
   }
-  const result = spawnSync(
-    getOpenshellBinary(),
-    buildOpenshellExecArgs(sandboxName, command, options),
-    { stdio: "inherit" },
-  );
+  const binary = getOpenshellBinary();
+  if (options.workdir) {
+    validateWorkdirOrFail(binary, sandboxName, options.workdir);
+  }
+  const result = spawnSync(binary, buildOpenshellExecArgs(sandboxName, command, options), {
+    stdio: "inherit",
+  });
   exitWithSpawnResult(result);
 }

src/lib/agent/defs.ts

@@ -530,13 +530,24 @@ export function loadAgent(name: string): AgentDefinition {
  * OpenClaw is listed first as the default.
  */
 export function getAgentChoices(): AgentChoice[] {
-  const agents = listAgents().map((name) => {
-    const agent = loadAgent(name);
-    return {
-      name: agent.name,
-      displayName: agent.displayName,
-      description: agent.description ?? "",
-    };
+  // Build the menu defensively: a single malformed non-default manifest must
+  // not abort interactive onboarding (e.g. an OpenClaw user accepting the
+  // default). Skip agents that fail to load and surface a warning instead.
+  const agents = listAgents().flatMap((name) => {
+    try {
+      const agent = loadAgent(name);
+      return [
+        {
+          name: agent.name,
+          displayName: agent.displayName,
+          description: agent.description ?? "",
+        },
+      ];
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      console.error(`  Warning: skipping agent '${name}' — failed to load manifest: ${reason}`);
+      return [];
+    }
   });
 
   agents.sort((left, right) => {

src/lib/inventory/index.test.ts

@@ -134,6 +134,64 @@ describe("inventory commands", () => {
     expect(getLiveInference).not.toHaveBeenCalled();
   });
 
+  it("normalizes invalid configured inference fields out of inventory rows", async () => {
+    const inventory = await getSandboxInventory({
+      recoverRegistryEntries: async () => ({
+        sandboxes: [
+          { name: "blank-provider", provider: "", model: "nvidia/test" },
+          { name: "blank-model", provider: "nvidia-prod", model: "   " },
+          { name: "configured", provider: "nvidia-prod", model: "nvidia/test" },
+        ],
+        defaultSandbox: "blank-provider",
+      }),
+      getLiveInference: () => null,
+      loadLastSession: () => null,
+    });
+
+    expect(inventory.sandboxes).toMatchObject([
+      { name: "blank-provider", provider: null, model: "nvidia/test" },
+      { name: "blank-model", provider: "nvidia-prod", model: null },
+      { name: "configured", provider: "nvidia-prod", model: "nvidia/test" },
+    ]);
+  });
+
+  it("normalizes invalid configured inference fields out of status rows", () => {
+    const report = getStatusReport({
+      listSandboxes: () => ({
+        sandboxes: [
+          { name: "blank-provider", provider: "", model: "nvidia/test" },
+          { name: "blank-model", provider: "nvidia-prod", model: "   " },
+          { name: "configured", provider: "nvidia-prod", model: "nvidia/test" },
+        ],
+        defaultSandbox: "blank-provider",
+      }),
+      getLiveInference: () => null,
+      showServiceStatus: vi.fn(),
+    });
+
+    expect(report.sandboxes).toMatchObject([
+      { name: "blank-provider", provider: null, model: "nvidia/test" },
+      { name: "blank-model", provider: "nvidia-prod", model: null },
+      { name: "configured", provider: "nvidia-prod", model: "nvidia/test" },
+    ]);
+  });
+
+  it("omits invalid configured inference fields from status text", () => {
+    const lines: string[] = [];
+    showStatusCommand({
+      listSandboxes: () => ({
+        sandboxes: [{ name: "alpha", provider: "", model: "   " }],
+        defaultSandbox: "alpha",
+      }),
+      getLiveInference: () => null,
+      showServiceStatus: vi.fn(),
+      log: (message = "") => lines.push(message),
+    });
+
+    expect(lines).toContain("    alpha *");
+    expect(lines.some((line) => line.includes("Inference:"))).toBe(false);
+  });
+
   it("prints the empty-state onboarding hint when no sandboxes exist", async () => {
     const lines: string[] = [];
     await listSandboxesCommand({