fix(cli): preserve usage-error exits for lazy reparses

Pandah97 · web-flow · commit 68e234f9e24a · 2026-06-13T21:33:30.000+08:00
Reparse nested lazy commands from the Commander root so unknown options keep the original argv and exit non-zero. Adds nested lazy-command coverage for the root rawArgs path. Fixes #92069.
diff --git a/src/cli/program/action-reparse.test.ts b/src/cli/program/action-reparse.test.ts
@@ -16,6 +16,10 @@ vi.mock("./helpers.js", () => ({
   resolveCommandOptionArgs: resolveCommandOptionArgsMock,
 }));
 
+function setRawArgs(command: Command, rawArgs: string[]): void {
+  (command as Command & { rawArgs: string[] }).rawArgs = rawArgs;
+}
+
 describe("reparseProgramFromActionArgs", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -26,12 +30,11 @@ describe("reparseProgramFromActionArgs", () => {
 
   it("uses action command name + args as fallback argv", async () => {
     const program = new Command().name("openclaw");
+    setRawArgs(program, ["node", "openclaw", "status", "--json"]);
     const parseAsync = vi.spyOn(program, "parseAsync").mockResolvedValue(program);
     const actionCommand = {
       name: () => "status",
-      parent: {
-        rawArgs: ["node", "openclaw", "status", "--json"],
-      },
+      parent: program,
     } as unknown as Command;
     resolveActionArgsMock.mockReturnValue(["--json"]);
 
@@ -47,18 +50,19 @@ describe("reparseProgramFromActionArgs", () => {
 
   it("falls back to action args without command name when action has no name", async () => {
     const program = new Command().name("openclaw");
+    setRawArgs(program, ["node", "openclaw"]);
     const parseAsync = vi.spyOn(program, "parseAsync").mockResolvedValue(program);
     const actionCommand = {
       name: () => "",
-      parent: {},
+      parent: program,
     } as unknown as Command;
     resolveActionArgsMock.mockReturnValue(["--json"]);
 
     await reparseProgramFromActionArgs(program, [actionCommand]);
 
     expect(buildParseArgvMock).toHaveBeenCalledWith({
       programName: "openclaw",
-      rawArgs: undefined,
+      rawArgs: ["node", "openclaw"],
       fallbackArgv: ["--json"],
     });
     expect(parseAsync).toHaveBeenCalledWith(["node", "openclaw", "status"]);
@@ -85,6 +89,27 @@ describe("reparseProgramFromActionArgs", () => {
     expect(parseAsync).toHaveBeenCalledWith(["node", "openclaw", "status"]);
   });
 
+  it("uses root raw args and reparses the root for nested lazy commands", async () => {
+    const root = new Command().name("openclaw");
+    setRawArgs(root, ["node", "openclaw", "workspaces", "audit", "export", "--since", "1"]);
+    const workspaces = root.command("workspaces");
+    const audit = workspaces.command("audit");
+    const exportCommand = audit.command("export");
+    const parseAsync = vi.spyOn(root, "parseAsync").mockResolvedValue(root);
+    const auditParseAsync = vi.spyOn(audit, "parseAsync");
+    resolveActionArgsMock.mockReturnValue(["--since", "1"]);
+
+    await reparseProgramFromActionArgs(audit, [exportCommand]);
+
+    expect(buildParseArgvMock).toHaveBeenCalledWith({
+      programName: "openclaw",
+      rawArgs: ["node", "openclaw", "workspaces", "audit", "export", "--since", "1"],
+      fallbackArgv: ["export", "--since", "1"],
+    });
+    expect(parseAsync).toHaveBeenCalledWith(["node", "openclaw", "status"]);
+    expect(auditParseAsync).not.toHaveBeenCalled();
+  });
+
   it("uses program root when action command is missing", async () => {
     const program = new Command().name("openclaw");
     const parseAsync = vi.spyOn(program, "parseAsync").mockResolvedValue(program);
diff --git a/src/cli/program/action-reparse.ts b/src/cli/program/action-reparse.ts
@@ -12,19 +12,31 @@ function buildFallbackArgv(program: Command, actionCommand: Command | undefined)
     : [...parentOptionArgs, ...actionArgsList];
 }
 
+function findRootCommand(cmd: Command): Command {
+  let current: Command = cmd;
+  while (current.parent) {
+    current = current.parent;
+  }
+  return current;
+}
+
 /** Rebuild argv from Commander action args and re-run parsing after lazy registration. */
 export async function reparseProgramFromActionArgs(
   program: Command,
   actionArgs: unknown[],
 ): Promise<void> {
   const actionCommand = actionArgs.at(-1) as Command | undefined;
-  const root = actionCommand?.parent ?? program;
-  const rawArgs = (root as Command & { rawArgs?: string[] }).rawArgs;
+  // Use the true root program for argv reconstruction and parsing.
+  // For nested lazy commands (e.g. workspaces → audit), `program` is a sub-command
+  // whose rawArgs is cleared by Commander's restoreStateBeforeParse(). Only the
+  // root program retains the rawArgs set by _prepareUserArgs.
+  const rootProgram = findRootCommand(actionCommand ?? program);
+  const rawArgs = (rootProgram as Command & { rawArgs?: string[] }).rawArgs;
   const fallbackArgv = buildFallbackArgv(program, actionCommand);
   const parseArgv = buildParseArgv({
-    programName: program.name(),
+    programName: rootProgram.name(),
     rawArgs,
     fallbackArgv,
   });
-  await program.parseAsync(parseArgv);
+  await rootProgram.parseAsync(parseArgv);
 }
