@workflow/cli 5.0.0-beta.46 → 5.0.0-beta.48

package/dist/commands/cancel.d.ts

@@ -3,6 +3,15 @@ export default class Cancel extends BaseCommand {
     static description: string;
     static aliases: string[];
     static examples: string[];
+    /**
+     * Recorded in `run()` so `catch()` can tell a Vercel 403 from any other
+     * one. oclif hands `catch` the error alone, with no parsed flags.
+     *
+     * Assigned after `this.parse()`, so a `catch` reached by a parse failure
+     * sees `undefined`. That costs nothing: a parse failure is not an API
+     * error, so there is no 403 to classify.
+     */
+    private backend?;
     catch(error: any): Promise<void>;
     static args: {
         readonly runId: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
@@ -25,7 +34,7 @@ export default class Cancel extends BaseCommand {
         noBrowser: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         localUi: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         standalone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/cancel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAezC,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW;IAC7C,MAAM,CAAC,WAAW,SAC4C;IAE9D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAKb;IAEI,KAAK,CAAC,KAAK,EAAE,GAAG;IAUtB,MAAM,CAAC,IAAI;;MAKA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;MAmCV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwDlC"}
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAczC,MAAM,CAAC,OAAO,OAAO,MAAO,SAAQ,WAAW;IAC7C,MAAM,CAAC,WAAW,SAC4C;IAE9D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAKb;IAEF;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,CAAC,CAAS;IAEnB,KAAK,CAAC,KAAK,EAAE,GAAG;IActB,MAAM,CAAC,IAAI;;MAKA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;MAmCV;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAyDlC"}

package/dist/commands/cancel.js

@@ -4,9 +4,9 @@ import { cancelRun } from '@workflow/core/runtime';
 import { WorkflowRunStatusSchema } from '@workflow/world';
 import chalk from 'chalk';
 import { BaseCommand } from '../base.js';
-import { CANCELLABLE_STATUSES, CLI_CANCEL_REASON, performBulkCancel, validateBulkCancelLimit, } from '../lib/bulk-cancel.js';
+import { BULK_CANCEL_MAX_LIMIT, BULK_CANCEL_MIN_LIMIT, CANCELLABLE_STATUSES, CLI_CANCEL_REASON, performBulkCancel, validateBulkCancelLimit, } from '../lib/bulk-cancel.js';
 import { LOGGING_CONFIG, logger } from '../lib/config/log.js';
-import { getObservabilityUpgradeRequiredMessage, isObservabilityUpgradeRequiredError, } from '../lib/inspect/errors.js';
+import { reportActionableApiError } from '../lib/inspect/errors.js';
 import { cliFlags } from '../lib/inspect/flags.js';
 import { setupCliWorld } from '../lib/inspect/setup.js';
 export default class Cancel extends BaseCommand {
@@ -18,12 +18,24 @@ export default class Cancel extends BaseCommand {
         '$ workflow cancel --status=running --workflowName=myWorkflow',
         '$ workflow cancel --status=running -y',
     ];
+    /**
+     * Recorded in `run()` so `catch()` can tell a Vercel 403 from any other
+     * one. oclif hands `catch` the error alone, with no parsed flags.
+     *
+     * Assigned after `this.parse()`, so a `catch` reached by a parse failure
+     * sees `undefined`. That costs nothing: a parse failure is not an API
+     * error, so there is no 403 to classify.
+     */
+    backend;
     async catch(error) {
-        if (isObservabilityUpgradeRequiredError(error)) {
-            logger.error(getObservabilityUpgradeRequiredMessage());
+        // Print the errors that name something the caller can fix. Only the plan
+        // gate was handled before, so an argument the World rejected locally —
+        // `--limit` above the listing cap, say — reached oclif's default handler
+        // and exited 1 with nothing on screen unless -v was set.
+        if (reportActionableApiError(error, this.backend)) {
             process.exit(1);
         }
-        else if (LOGGING_CONFIG.VERBOSE_MODE) {
+        if (LOGGING_CONFIG.VERBOSE_MODE) {
             console.error(error);
         }
         throw error;
@@ -54,7 +66,7 @@ export default class Cancel extends BaseCommand {
             helpLabel: '-n, --workflowName',
         }),
         limit: Flags.integer({
-            description: 'Max runs to cancel in bulk mode (1-500)',
+            description: `Max runs to cancel in bulk mode (${BULK_CANCEL_MIN_LIMIT}-${BULK_CANCEL_MAX_LIMIT})`,
             required: false,
             default: 50,
             helpGroup: 'Bulk Cancel',
@@ -72,6 +84,7 @@ export default class Cancel extends BaseCommand {
     };
     async run() {
         const { flags, args } = await this.parse(Cancel);
+        this.backend = flags.backend;
         const world = await setupCliWorld(flags, this.config.version);
         if (!world) {
             throw new Error('Failed to connect to backend. Check your configuration.');
@@ -132,4 +145,4 @@ async function promptConfirm(message) {
         });
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import readline from 'node:readline';\nimport { Args, Flags } from '@oclif/core';\nimport { cancelRun } from '@workflow/core/runtime';\nimport { WorkflowRunStatusSchema } from '@workflow/world';\nimport chalk from 'chalk';\nimport { BaseCommand } from '../base.js';\nimport {\n  CANCELLABLE_STATUSES,\n  CLI_CANCEL_REASON,\n  performBulkCancel,\n  validateBulkCancelLimit,\n} from '../lib/bulk-cancel.js';\nimport { LOGGING_CONFIG, logger } from '../lib/config/log.js';\nimport {\n  getObservabilityUpgradeRequiredMessage,\n  isObservabilityUpgradeRequiredError,\n} from '../lib/inspect/errors.js';\nimport { cliFlags } from '../lib/inspect/flags.js';\nimport { setupCliWorld } from '../lib/inspect/setup.js';\n\nexport default class Cancel extends BaseCommand {\n  static description =\n    'Cancel a workflow run, or bulk-cancel runs by status/name';\n\n  static aliases = ['c'];\n\n  static examples = [\n    '$ workflow cancel <run-id>',\n    '$ workflow cancel --status=running',\n    '$ workflow cancel --status=running --workflowName=myWorkflow',\n    '$ workflow cancel --status=running -y',\n  ];\n\n  async catch(error: any) {\n    if (isObservabilityUpgradeRequiredError(error)) {\n      logger.error(getObservabilityUpgradeRequiredMessage());\n      process.exit(1);\n    } else if (LOGGING_CONFIG.VERBOSE_MODE) {\n      console.error(error);\n    }\n    throw error;\n  }\n\n  static args = {\n    runId: Args.string({\n      description: 'ID of the run to cancel (omit for bulk mode with filters)',\n      required: false,\n    }),\n  } as const;\n\n  static flags = {\n    ...cliFlags,\n    status: Flags.string({\n      // Only cancellable statuses are offered: cancelling a terminal run\n      // (completed / failed / cancelled) is a no-op, so pinning one would list\n      // the same page on every rerun and never advance.\n      description: 'Filter runs by status for bulk cancel (pending or running)',\n      required: false,\n      options: [...CANCELLABLE_STATUSES],\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--status',\n    }),\n    workflowName: Flags.string({\n      description: 'Filter runs by workflow name for bulk cancel',\n      required: false,\n      char: 'n',\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-n, --workflowName',\n    }),\n    limit: Flags.integer({\n      description: 'Max runs to cancel in bulk mode (1-500)',\n      required: false,\n      default: 50,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--limit',\n      helpValue: 'NUMBER',\n    }),\n    confirm: Flags.boolean({\n      description: 'Skip interactive confirmation prompt',\n      required: false,\n      char: 'y',\n      default: false,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-y, --confirm',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags, args } = await this.parse(Cancel);\n\n    const world = await setupCliWorld(flags, this.config.version);\n    if (!world) {\n      throw new Error(\n        'Failed to connect to backend. Check your configuration.'\n      );\n    }\n\n    // Single-run cancel (existing behavior)\n    if (args.runId) {\n      await cancelRun(world, args.runId, {\n        cancelReason: CLI_CANCEL_REASON,\n      });\n      logger.log(chalk.green(`Cancelled run ${args.runId}`));\n      return;\n    }\n\n    // Bulk mode requires at least one filter\n    if (!flags.status && !flags.workflowName) {\n      logger.error(\n        'Provide a run ID or use --status/--workflowName to bulk cancel.\\n' +\n          'Examples:\\n' +\n          '  workflow cancel <run-id>\\n' +\n          '  workflow cancel --status=running\\n' +\n          '  workflow cancel --status=running --workflowName=myWorkflow'\n      );\n      process.exit(1);\n    }\n\n    const limit = flags.limit ?? 50;\n    const limitError = validateBulkCancelLimit(limit);\n    if (limitError) {\n      logger.error(limitError);\n      process.exit(1);\n    }\n\n    const status = flags.status\n      ? WorkflowRunStatusSchema.parse(flags.status)\n      : undefined;\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status,\n      workflowName: flags.workflowName,\n      limit,\n      confirm: flags.confirm,\n      logger,\n      promptConfirm,\n    });\n\n    if (exitCode !== 0) {\n      process.exit(exitCode);\n    }\n  }\n}\n\nasync function promptConfirm(message: string): Promise<boolean> {\n  // Non-TTY: abort since user cannot confirm interactively (use -y/--confirm to skip prompt)\n  if (!process.stdin.isTTY) {\n    return false;\n  }\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise<boolean>((resolve) => {\n    rl.question(`${message} [y/N] `, (answer) => {\n      rl.close();\n      resolve(answer.trim().toLowerCase() === 'y');\n    });\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancel.js","sourceRoot":"","sources":["../../src/commands/cancel.ts"],"names":[],"mappings":"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","sourcesContent":["import readline from 'node:readline';\nimport { Args, Flags } from '@oclif/core';\nimport { cancelRun } from '@workflow/core/runtime';\nimport { WorkflowRunStatusSchema } from '@workflow/world';\nimport chalk from 'chalk';\nimport { BaseCommand } from '../base.js';\nimport {\n  BULK_CANCEL_MAX_LIMIT,\n  BULK_CANCEL_MIN_LIMIT,\n  CANCELLABLE_STATUSES,\n  CLI_CANCEL_REASON,\n  performBulkCancel,\n  validateBulkCancelLimit,\n} from '../lib/bulk-cancel.js';\nimport { LOGGING_CONFIG, logger } from '../lib/config/log.js';\nimport { reportActionableApiError } from '../lib/inspect/errors.js';\nimport { cliFlags } from '../lib/inspect/flags.js';\nimport { setupCliWorld } from '../lib/inspect/setup.js';\n\nexport default class Cancel extends BaseCommand {\n  static description =\n    'Cancel a workflow run, or bulk-cancel runs by status/name';\n\n  static aliases = ['c'];\n\n  static examples = [\n    '$ workflow cancel <run-id>',\n    '$ workflow cancel --status=running',\n    '$ workflow cancel --status=running --workflowName=myWorkflow',\n    '$ workflow cancel --status=running -y',\n  ];\n\n  /**\n   * Recorded in `run()` so `catch()` can tell a Vercel 403 from any other\n   * one. oclif hands `catch` the error alone, with no parsed flags.\n   *\n   * Assigned after `this.parse()`, so a `catch` reached by a parse failure\n   * sees `undefined`. That costs nothing: a parse failure is not an API\n   * error, so there is no 403 to classify.\n   */\n  private backend?: string;\n\n  async catch(error: any) {\n    // Print the errors that name something the caller can fix. Only the plan\n    // gate was handled before, so an argument the World rejected locally —\n    // `--limit` above the listing cap, say — reached oclif's default handler\n    // and exited 1 with nothing on screen unless -v was set.\n    if (reportActionableApiError(error, this.backend)) {\n      process.exit(1);\n    }\n    if (LOGGING_CONFIG.VERBOSE_MODE) {\n      console.error(error);\n    }\n    throw error;\n  }\n\n  static args = {\n    runId: Args.string({\n      description: 'ID of the run to cancel (omit for bulk mode with filters)',\n      required: false,\n    }),\n  } as const;\n\n  static flags = {\n    ...cliFlags,\n    status: Flags.string({\n      // Only cancellable statuses are offered: cancelling a terminal run\n      // (completed / failed / cancelled) is a no-op, so pinning one would list\n      // the same page on every rerun and never advance.\n      description: 'Filter runs by status for bulk cancel (pending or running)',\n      required: false,\n      options: [...CANCELLABLE_STATUSES],\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--status',\n    }),\n    workflowName: Flags.string({\n      description: 'Filter runs by workflow name for bulk cancel',\n      required: false,\n      char: 'n',\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-n, --workflowName',\n    }),\n    limit: Flags.integer({\n      description: `Max runs to cancel in bulk mode (${BULK_CANCEL_MIN_LIMIT}-${BULK_CANCEL_MAX_LIMIT})`,\n      required: false,\n      default: 50,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '--limit',\n      helpValue: 'NUMBER',\n    }),\n    confirm: Flags.boolean({\n      description: 'Skip interactive confirmation prompt',\n      required: false,\n      char: 'y',\n      default: false,\n      helpGroup: 'Bulk Cancel',\n      helpLabel: '-y, --confirm',\n    }),\n  };\n\n  public async run(): Promise<void> {\n    const { flags, args } = await this.parse(Cancel);\n    this.backend = flags.backend;\n\n    const world = await setupCliWorld(flags, this.config.version);\n    if (!world) {\n      throw new Error(\n        'Failed to connect to backend. Check your configuration.'\n      );\n    }\n\n    // Single-run cancel (existing behavior)\n    if (args.runId) {\n      await cancelRun(world, args.runId, {\n        cancelReason: CLI_CANCEL_REASON,\n      });\n      logger.log(chalk.green(`Cancelled run ${args.runId}`));\n      return;\n    }\n\n    // Bulk mode requires at least one filter\n    if (!flags.status && !flags.workflowName) {\n      logger.error(\n        'Provide a run ID or use --status/--workflowName to bulk cancel.\\n' +\n          'Examples:\\n' +\n          '  workflow cancel <run-id>\\n' +\n          '  workflow cancel --status=running\\n' +\n          '  workflow cancel --status=running --workflowName=myWorkflow'\n      );\n      process.exit(1);\n    }\n\n    const limit = flags.limit ?? 50;\n    const limitError = validateBulkCancelLimit(limit);\n    if (limitError) {\n      logger.error(limitError);\n      process.exit(1);\n    }\n\n    const status = flags.status\n      ? WorkflowRunStatusSchema.parse(flags.status)\n      : undefined;\n\n    const { exitCode } = await performBulkCancel({\n      world,\n      status,\n      workflowName: flags.workflowName,\n      limit,\n      confirm: flags.confirm,\n      logger,\n      promptConfirm,\n    });\n\n    if (exitCode !== 0) {\n      process.exit(exitCode);\n    }\n  }\n}\n\nasync function promptConfirm(message: string): Promise<boolean> {\n  // Non-TTY: abort since user cannot confirm interactively (use -y/--confirm to skip prompt)\n  if (!process.stdin.isTTY) {\n    return false;\n  }\n\n  const rl = readline.createInterface({\n    input: process.stdin,\n    output: process.stdout,\n  });\n\n  return new Promise<boolean>((resolve) => {\n    rl.question(`${message} [y/N] `, (answer) => {\n      rl.close();\n      resolve(answer.trim().toLowerCase() === 'y');\n    });\n  });\n}\n"]}

package/dist/commands/inspect-flag-forwarding.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inspect-flag-forwarding.test.d.ts.map

package/dist/commands/inspect-flag-forwarding.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-flag-forwarding.test.d.ts","sourceRoot":"","sources":["../../src/commands/inspect-flag-forwarding.test.ts"],"names":[],"mappings":""}

package/dist/commands/inspect-flag-forwarding.test.js

@@ -0,0 +1,121 @@
+import { fileURLToPath } from 'node:url';
+import { Config } from '@oclif/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { toInspectOptions } from './inspect.js';
+const state = vi.hoisted(() => ({
+    setupCliWorld: vi.fn(),
+    listEvents: vi.fn(),
+    listAttributes: vi.fn(),
+}));
+vi.mock('../lib/inspect/setup.js', () => ({
+    setupCliWorld: state.setupCliWorld,
+}));
+// Only the two listings these cases dispatch to are replaced; the rest of the
+// module is kept so the command's imports still resolve.
+vi.mock('../lib/inspect/output.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    listEvents: state.listEvents,
+    listAttributes: state.listAttributes,
+}));
+const { default: Inspect } = await import('./inspect.js');
+const VALID_RUN = 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE';
+const VALID_HOOK = 'hook_01K4BZQ5T2J8HXFM6WD3PNAVCE';
+const runInspect = async (argv) => {
+    const config = await Config.load(fileURLToPath(new URL('../..', import.meta.url)));
+    const exit = vi
+        .spyOn(process, 'exit')
+        .mockImplementation((() => undefined));
+    try {
+        await Inspect.run(argv, config).catch(() => undefined);
+    }
+    finally {
+        exit.mockRestore();
+    }
+};
+beforeEach(() => {
+    state.setupCliWorld.mockReset().mockResolvedValue({});
+    state.listEvents.mockReset().mockResolvedValue(undefined);
+    state.listAttributes.mockReset().mockResolvedValue(undefined);
+    process.exitCode = 0;
+});
+/**
+ * A flag that parses, clears validation, and is then dropped before any
+ * listing reads it is indistinguishable from a successful unfiltered answer.
+ * Unit tests on the listings cannot see it: they pass options directly and so
+ * skip the projection where the drop happens. These go through `Inspect.run`.
+ */
+describe('flag forwarding through the command', () => {
+    it('forwards --hookId to the events listing', async () => {
+        await runInspect(['events', '--runId', VALID_RUN, '--hookId', VALID_HOOK]);
+        expect(state.listEvents).toHaveBeenCalled();
+        expect(state.listEvents.mock.calls[0][1]).toMatchObject({
+            hookId: VALID_HOOK,
+            runId: VALID_RUN,
+        });
+    });
+    it('forwards --stepId to the events listing', async () => {
+        await runInspect([
+            'events',
+            '--runId',
+            VALID_RUN,
+            '--stepId',
+            'step_01K4BZQ5T2J8HXFM6WD3PNAVCE',
+        ]);
+        expect(state.listEvents.mock.calls[0][1]).toMatchObject({
+            stepId: 'step_01K4BZQ5T2J8HXFM6WD3PNAVCE',
+        });
+    });
+    // The warning `listAttributes` prints for this flag was unreachable from
+    // the CLI while the projection dropped it.
+    it('forwards --hookId far enough for the attributes listing to warn', async () => {
+        await runInspect(['attributes', '--hookId', VALID_HOOK]);
+        expect(state.listAttributes.mock.calls[0][1]).toMatchObject({
+            hookId: VALID_HOOK,
+        });
+    });
+});
+/**
+ * The projection itself, pinned key by key. Every filtering flag the listings
+ * read has to appear here; `--hookId` was declared as a flag and read by
+ * `listEvents` but never copied across.
+ */
+describe('toInspectOptions', () => {
+    it('copies every filtering flag through', () => {
+        const options = toInspectOptions({
+            json: true,
+            runId: VALID_RUN,
+            stepId: 'step_x',
+            hookId: 'hook_x',
+            cursor: 'c',
+            sort: 'asc',
+            limit: 25,
+            workflowName: 'orderWorkflow',
+            status: 'failed',
+            since: '7d',
+            until: '1h',
+            withData: true,
+            decrypt: true,
+            backend: 'vercel',
+            interactive: true,
+        }, { tenant: 'acme' });
+        expect(options).toEqual({
+            json: true,
+            runId: VALID_RUN,
+            stepId: 'step_x',
+            hookId: 'hook_x',
+            cursor: 'c',
+            sort: 'asc',
+            limit: 25,
+            workflowName: 'orderWorkflow',
+            attributes: { tenant: 'acme' },
+            status: 'failed',
+            since: '7d',
+            until: '1h',
+            withData: true,
+            decrypt: true,
+            backend: 'vercel',
+            interactive: true,
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inspect-flag-forwarding.test.js","sourceRoot":"","sources":["../../src/commands/inspect-flag-forwarding.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { fileURLToPath } from 'node:url';\nimport { Config } from '@oclif/core';\nimport { beforeEach, describe, expect, it, vi } from 'vitest';\nimport { toInspectOptions } from './inspect.js';\n\nconst state = vi.hoisted(() => ({\n  setupCliWorld: vi.fn(),\n  listEvents: vi.fn(),\n  listAttributes: vi.fn(),\n}));\n\nvi.mock('../lib/inspect/setup.js', () => ({\n  setupCliWorld: state.setupCliWorld,\n}));\n\n// Only the two listings these cases dispatch to are replaced; the rest of the\n// module is kept so the command's imports still resolve.\nvi.mock('../lib/inspect/output.js', async (importOriginal) => ({\n  ...(await importOriginal<typeof import('../lib/inspect/output.js')>()),\n  listEvents: state.listEvents,\n  listAttributes: state.listAttributes,\n}));\n\nconst { default: Inspect } = await import('./inspect.js');\n\nconst VALID_RUN = 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE';\nconst VALID_HOOK = 'hook_01K4BZQ5T2J8HXFM6WD3PNAVCE';\n\nconst runInspect = async (argv: string[]): Promise<void> => {\n  const config = await Config.load(\n    fileURLToPath(new URL('../..', import.meta.url))\n  );\n  const exit = vi\n    .spyOn(process, 'exit')\n    .mockImplementation((() => undefined) as never);\n  try {\n    await Inspect.run(argv, config).catch(() => undefined);\n  } finally {\n    exit.mockRestore();\n  }\n};\n\nbeforeEach(() => {\n  state.setupCliWorld.mockReset().mockResolvedValue({});\n  state.listEvents.mockReset().mockResolvedValue(undefined);\n  state.listAttributes.mockReset().mockResolvedValue(undefined);\n  process.exitCode = 0;\n});\n\n/**\n * A flag that parses, clears validation, and is then dropped before any\n * listing reads it is indistinguishable from a successful unfiltered answer.\n * Unit tests on the listings cannot see it: they pass options directly and so\n * skip the projection where the drop happens. These go through `Inspect.run`.\n */\ndescribe('flag forwarding through the command', () => {\n  it('forwards --hookId to the events listing', async () => {\n    await runInspect(['events', '--runId', VALID_RUN, '--hookId', VALID_HOOK]);\n\n    expect(state.listEvents).toHaveBeenCalled();\n    expect(state.listEvents.mock.calls[0][1]).toMatchObject({\n      hookId: VALID_HOOK,\n      runId: VALID_RUN,\n    });\n  });\n\n  it('forwards --stepId to the events listing', async () => {\n    await runInspect([\n      'events',\n      '--runId',\n      VALID_RUN,\n      '--stepId',\n      'step_01K4BZQ5T2J8HXFM6WD3PNAVCE',\n    ]);\n\n    expect(state.listEvents.mock.calls[0][1]).toMatchObject({\n      stepId: 'step_01K4BZQ5T2J8HXFM6WD3PNAVCE',\n    });\n  });\n\n  // The warning `listAttributes` prints for this flag was unreachable from\n  // the CLI while the projection dropped it.\n  it('forwards --hookId far enough for the attributes listing to warn', async () => {\n    await runInspect(['attributes', '--hookId', VALID_HOOK]);\n\n    expect(state.listAttributes.mock.calls[0][1]).toMatchObject({\n      hookId: VALID_HOOK,\n    });\n  });\n});\n\n/**\n * The projection itself, pinned key by key. Every filtering flag the listings\n * read has to appear here; `--hookId` was declared as a flag and read by\n * `listEvents` but never copied across.\n */\ndescribe('toInspectOptions', () => {\n  it('copies every filtering flag through', () => {\n    const options = toInspectOptions(\n      {\n        json: true,\n        runId: VALID_RUN,\n        stepId: 'step_x',\n        hookId: 'hook_x',\n        cursor: 'c',\n        sort: 'asc',\n        limit: 25,\n        workflowName: 'orderWorkflow',\n        status: 'failed',\n        since: '7d',\n        until: '1h',\n        withData: true,\n        decrypt: true,\n        backend: 'vercel',\n        interactive: true,\n      },\n      { tenant: 'acme' }\n    );\n\n    expect(options).toEqual({\n      json: true,\n      runId: VALID_RUN,\n      stepId: 'step_x',\n      hookId: 'hook_x',\n      cursor: 'c',\n      sort: 'asc',\n      limit: 25,\n      workflowName: 'orderWorkflow',\n      attributes: { tenant: 'acme' },\n      status: 'failed',\n      since: '7d',\n      until: '1h',\n      withData: true,\n      decrypt: true,\n      backend: 'vercel',\n      interactive: true,\n    });\n  });\n});\n"]}

package/dist/commands/inspect-flag-scope.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inspect-flag-scope.test.d.ts.map

package/dist/commands/inspect-flag-scope.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-flag-scope.test.d.ts","sourceRoot":"","sources":["../../src/commands/inspect-flag-scope.test.ts"],"names":[],"mappings":""}

package/dist/commands/inspect-flag-scope.test.js

@@ -0,0 +1,161 @@
+import { fileURLToPath } from 'node:url';
+import { Config } from '@oclif/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const state = vi.hoisted(() => ({ setupCliWorld: vi.fn() }));
+// The property under test is that these checks run *before* any backend work,
+// so the setup module is replaced rather than exercised. A call to it means
+// validation let the arguments through.
+vi.mock('../lib/inspect/setup.js', () => ({
+    setupCliWorld: state.setupCliWorld,
+}));
+const { default: Inspect } = await import('./inspect.js');
+/**
+ * Run the command and return the message it rejected with.
+ *
+ * `logError` delegates to oclif's `this.error`, which throws; that rejection
+ * is captured here. `process.exit` is stubbed because `BaseCommand.finally`
+ * calls it. Note that stubbing `process.stderr.write` to read the message
+ * instead deadlocks vitest's reporter — hence spying on the command.
+ */
+const runInspect = async (argv) => {
+    // `fileURLToPath`, not `.pathname`: on Windows the latter yields
+    // `/D:/a/...` — a leading slash before the drive letter — which
+    // `Config.load` cannot resolve, so it reports a missing package.json.
+    const config = await Config.load(fileURLToPath(new URL('../..', import.meta.url)));
+    const messages = [];
+    const logError = vi
+        // `logError` is protected; the cast reaches it without widening the
+        // public surface.
+        .spyOn(Inspect.prototype, 'logError')
+        .mockImplementation((message) => {
+        messages.push(message);
+    });
+    const exit = vi
+        .spyOn(process, 'exit')
+        .mockImplementation((() => undefined));
+    try {
+        await Inspect.run(argv, config).catch(() => undefined);
+        return messages.join('\n');
+    }
+    finally {
+        exit.mockRestore();
+        logError.mockRestore();
+    }
+};
+const VALID_RUN = 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE';
+beforeEach(() => {
+    state.setupCliWorld.mockReset();
+    process.exitCode = 0;
+});
+describe('inspect flag validation runs before any backend setup', () => {
+    // --attribute was parsed on every resource but consumed only by the runs
+    // listing, so these returned a normal, unfiltered answer.
+    it.each([
+        ['steps', ['steps', '--runId', VALID_RUN]],
+        ['events', ['events', '--runId', VALID_RUN]],
+        ['hooks', ['hooks']],
+        ['attributes', ['attributes']],
+    ])('rejects --attribute on %s without reaching a backend', async (_label, argv) => {
+        const message = await runInspect([...argv, '--attribute', 'tenant=acme']);
+        expect(message).toContain('--attribute filters run listings only');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it('rejects --attribute alongside a run ID', async () => {
+        const message = await runInspect([
+            'run',
+            VALID_RUN,
+            '--attribute',
+            'tenant=acme',
+        ]);
+        expect(message).toContain('already names one run');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it.each([
+        ['an out-of-range limit', ['runs', '--limit', '5000'], '--limit must be'],
+        ['a malformed runId', ['steps', '--runId', 'nope'], '--runId must be'],
+    ])('rejects %s', async (_label, argv, expected) => {
+        expect(await runInspect(argv)).toContain(expected);
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it('lets --attribute through on the runs listing', async () => {
+        const message = await runInspect([
+            'runs',
+            '--attribute',
+            'tenant=acme',
+            '--backend',
+            'local',
+        ]);
+        expect(message).not.toContain('--attribute');
+        expect(state.setupCliWorld).toHaveBeenCalled();
+    });
+});
+describe('inspect --attribute cannot reach the web UI', () => {
+    // Both of these return before `toInspectOptions` parses the filter, so the
+    // flag used to be accepted, never validated, and the view opened unfiltered.
+    it.each([
+        ['--url', ['runs', '--attribute', 'tenant=acme', '--url']],
+        ['--web', ['runs', '--attribute', 'tenant=acme', '--web']],
+        ['the web resource', ['web', '--attribute', 'tenant=acme']],
+    ])('rejects --attribute with %s', async (_label, argv) => {
+        const message = await runInspect(argv);
+        expect(message).toContain('cannot be forwarded to the web UI');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    // Previously bypassed validation entirely on this path.
+    it('rejects a malformed pair even with --url', async () => {
+        const message = await runInspect([
+            'runs',
+            '--attribute',
+            'tenant',
+            '--url',
+        ]);
+        expect(message).toContain('cannot be forwarded to the web UI');
+    });
+});
+describe('inspect --attribute conflicts and syntax', () => {
+    it('rejects --attribute with --withData', async () => {
+        const message = await runInspect([
+            'runs',
+            '--attribute',
+            'tenant=acme',
+            '--withData',
+        ]);
+        expect(message).toContain('cannot be combined with --withData');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    // Previously parsed inside toInspectOptions, after setupCliWorld, so a
+    // syntax error cost a full auth and project lookup first.
+    it.each([
+        ['a missing separator', ['runs', '--attribute', 'tenant']],
+        ['an empty key', ['runs', '--attribute', '=acme']],
+    ])('rejects %s before backend setup', async (_label, argv) => {
+        const message = await runInspect(argv);
+        expect(message).toContain('--attribute must be key=value');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it('rejects more than the allowed pairs before backend setup', async () => {
+        const argv = ['runs'];
+        for (let i = 0; i < 9; i += 1)
+            argv.push('--attribute', `k${i}=v`);
+        const message = await runInspect(argv);
+        expect(message).toContain('--attribute may be given at most 8 times');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it('rejects a duplicate key before backend setup', async () => {
+        const message = await runInspect([
+            'runs',
+            '--attribute',
+            'tenant=a',
+            '--attribute',
+            'tenant=b',
+        ]);
+        expect(message).toContain('was given more than once');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+    it('rejects a limit above the smallest listing cap', async () => {
+        const message = await runInspect(['runs', '--limit', '500']);
+        expect(message).toContain('--limit must be an integer between 1 and 100');
+        expect(state.setupCliWorld).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inspect-flag-scope.test.js","sourceRoot":"","sources":["../../src/commands/inspect-flag-scope.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { fileURLToPath } from 'node:url';\nimport { Config } from '@oclif/core';\nimport { beforeEach, describe, expect, it, vi } from 'vitest';\n\nconst state = vi.hoisted(() => ({ setupCliWorld: vi.fn() }));\n\n// The property under test is that these checks run *before* any backend work,\n// so the setup module is replaced rather than exercised. A call to it means\n// validation let the arguments through.\nvi.mock('../lib/inspect/setup.js', () => ({\n  setupCliWorld: state.setupCliWorld,\n}));\n\nconst { default: Inspect } = await import('./inspect.js');\n\n/**\n * Run the command and return the message it rejected with.\n *\n * `logError` delegates to oclif's `this.error`, which throws; that rejection\n * is captured here. `process.exit` is stubbed because `BaseCommand.finally`\n * calls it. Note that stubbing `process.stderr.write` to read the message\n * instead deadlocks vitest's reporter — hence spying on the command.\n */\nconst runInspect = async (argv: string[]): Promise<string> => {\n  // `fileURLToPath`, not `.pathname`: on Windows the latter yields\n  // `/D:/a/...` — a leading slash before the drive letter — which\n  // `Config.load` cannot resolve, so it reports a missing package.json.\n  const config = await Config.load(\n    fileURLToPath(new URL('../..', import.meta.url))\n  );\n  const messages: string[] = [];\n  const logError = vi\n    // `logError` is protected; the cast reaches it without widening the\n    // public surface.\n    .spyOn(\n      Inspect.prototype as unknown as Record<string, (message: string) => void>,\n      'logError'\n    )\n    .mockImplementation((message: string) => {\n      messages.push(message);\n    });\n  const exit = vi\n    .spyOn(process, 'exit')\n    .mockImplementation((() => undefined) as never);\n  try {\n    await Inspect.run(argv, config).catch(() => undefined);\n    return messages.join('\\n');\n  } finally {\n    exit.mockRestore();\n    logError.mockRestore();\n  }\n};\n\nconst VALID_RUN = 'wrun_01K4BZQ5T2J8HXFM6WD3PNAVCE';\n\nbeforeEach(() => {\n  state.setupCliWorld.mockReset();\n  process.exitCode = 0;\n});\n\ndescribe('inspect flag validation runs before any backend setup', () => {\n  // --attribute was parsed on every resource but consumed only by the runs\n  // listing, so these returned a normal, unfiltered answer.\n  it.each([\n    ['steps', ['steps', '--runId', VALID_RUN]],\n    ['events', ['events', '--runId', VALID_RUN]],\n    ['hooks', ['hooks']],\n    ['attributes', ['attributes']],\n  ])('rejects --attribute on %s without reaching a backend', async (_label, argv) => {\n    const message = await runInspect([...argv, '--attribute', 'tenant=acme']);\n    expect(message).toContain('--attribute filters run listings only');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it('rejects --attribute alongside a run ID', async () => {\n    const message = await runInspect([\n      'run',\n      VALID_RUN,\n      '--attribute',\n      'tenant=acme',\n    ]);\n    expect(message).toContain('already names one run');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it.each([\n    ['an out-of-range limit', ['runs', '--limit', '5000'], '--limit must be'],\n    ['a malformed runId', ['steps', '--runId', 'nope'], '--runId must be'],\n  ])('rejects %s', async (_label, argv, expected) => {\n    expect(await runInspect(argv)).toContain(expected);\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it('lets --attribute through on the runs listing', async () => {\n    const message = await runInspect([\n      'runs',\n      '--attribute',\n      'tenant=acme',\n      '--backend',\n      'local',\n    ]);\n    expect(message).not.toContain('--attribute');\n    expect(state.setupCliWorld).toHaveBeenCalled();\n  });\n});\n\ndescribe('inspect --attribute cannot reach the web UI', () => {\n  // Both of these return before `toInspectOptions` parses the filter, so the\n  // flag used to be accepted, never validated, and the view opened unfiltered.\n  it.each([\n    ['--url', ['runs', '--attribute', 'tenant=acme', '--url']],\n    ['--web', ['runs', '--attribute', 'tenant=acme', '--web']],\n    ['the web resource', ['web', '--attribute', 'tenant=acme']],\n  ])('rejects --attribute with %s', async (_label, argv) => {\n    const message = await runInspect(argv);\n    expect(message).toContain('cannot be forwarded to the web UI');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  // Previously bypassed validation entirely on this path.\n  it('rejects a malformed pair even with --url', async () => {\n    const message = await runInspect([\n      'runs',\n      '--attribute',\n      'tenant',\n      '--url',\n    ]);\n    expect(message).toContain('cannot be forwarded to the web UI');\n  });\n});\n\ndescribe('inspect --attribute conflicts and syntax', () => {\n  it('rejects --attribute with --withData', async () => {\n    const message = await runInspect([\n      'runs',\n      '--attribute',\n      'tenant=acme',\n      '--withData',\n    ]);\n    expect(message).toContain('cannot be combined with --withData');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  // Previously parsed inside toInspectOptions, after setupCliWorld, so a\n  // syntax error cost a full auth and project lookup first.\n  it.each([\n    ['a missing separator', ['runs', '--attribute', 'tenant']],\n    ['an empty key', ['runs', '--attribute', '=acme']],\n  ])('rejects %s before backend setup', async (_label, argv) => {\n    const message = await runInspect(argv);\n    expect(message).toContain('--attribute must be key=value');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it('rejects more than the allowed pairs before backend setup', async () => {\n    const argv = ['runs'];\n    for (let i = 0; i < 9; i += 1) argv.push('--attribute', `k${i}=v`);\n    const message = await runInspect(argv);\n    expect(message).toContain('--attribute may be given at most 8 times');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it('rejects a duplicate key before backend setup', async () => {\n    const message = await runInspect([\n      'runs',\n      '--attribute',\n      'tenant=a',\n      '--attribute',\n      'tenant=b',\n    ]);\n    expect(message).toContain('was given more than once');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n\n  it('rejects a limit above the smallest listing cap', async () => {\n    const message = await runInspect(['runs', '--limit', '500']);\n    expect(message).toContain('--limit must be an integer between 1 and 100');\n    expect(state.setupCliWorld).not.toHaveBeenCalled();\n  });\n});\n"]}

package/dist/commands/inspect.d.ts

@@ -1,4 +1,5 @@
 import { BaseCommand } from '../base.js';
+import type { InspectCLIOptions } from '../lib/config/types.js';
 export default class Inspect extends BaseCommand {
     static description: string;
     static aliases: string[];
@@ -23,12 +24,13 @@ export default class Inspect extends BaseCommand {
         readonly noBrowser: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         readonly localUi: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         readonly standalone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        readonly sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        readonly sort: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         readonly interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         readonly runId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly stepId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly hookId: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        readonly attribute: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly workflowName: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         readonly since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -38,4 +40,14 @@ export default class Inspect extends BaseCommand {
     };
     run(): Promise<void>;
 }
+/**
+ * Project parsed flags onto the options the listings read.
+ *
+ * Every filtering flag must be copied through: a flag missing here parses,
+ * clears validation, and is then dropped silently, which reads as a
+ * successful unfiltered answer. `inspect-flag-forwarding.test.ts` pins the
+ * mapping, and checks it through `Inspect.run` as well as directly: a listing's
+ * own unit tests pass options in, so they cannot see a drop that happens here.
+ */
+export declare function toInspectOptions(flags: any, attributes: Record<string, string> | undefined): InspectCLIOptions;
 //# sourceMappingURL=inspect.d.ts.map

package/dist/commands/inspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/commands/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAuBzC,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,WAAW;IAC9C,MAAM,CAAC,WAAW,SAA6C;IAE/D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAOb;IAEI,KAAK,CAAC,KAAK,EAAE,GAAG;IAgBtB,MAAM,CAAC,IAAI;;;MA+BA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8ED;IAEE,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAwHlC"}
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/commands/inspect.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAuBhE,MAAM,CAAC,OAAO,OAAO,OAAQ,SAAQ,WAAW;IAC9C,MAAM,CAAC,WAAW,SAA6C;IAE/D,MAAM,CAAC,OAAO,WAAS;IAEvB,MAAM,CAAC,QAAQ,WAQb;IAEI,KAAK,CAAC,KAAK,EAAE,GAAG;IAgBtB,MAAM,CAAC,IAAI;;;MAmCA;IAEX,MAAM,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuFD;IAEE,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA2JlC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,GAAG,EACV,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC7C,iBAAiB,CAwBnB"}