@mondaydotcomorg/z2h-cli 0.15.0 → 0.15.1

package/src/commands/delete.ts

@@ -1,12 +1,11 @@
 import { createInterface } from 'node:readline';
-import { output, info, setOutputMode } from '../util/logger';
+import { output, info, getOutputMode } from '../util/logger';
 import { getCwdAppName, cleanAppName, mfAppName } from '../util/app-name';
 import { brokerBaseUrl, routingHeaders } from '../constants';
 import { readZthAuth } from '../util/auth/auth-store';
 
 export interface DeleteOptions {
   yes?: boolean;
-  json?: boolean;
 }
 
 // Type-the-app-name confirmation. The caller must retype the de-scoped app
@@ -26,10 +25,6 @@ async function confirmByName(appSlug: string): Promise<boolean> {
 
 // Should be run from the consumer app directory — uses process.cwd() to locate it.
 export async function deleteCommand(opts: DeleteOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   const cwdName = getCwdAppName();
   if (!cwdName) {
     throw new Error('Run this from inside a consumer app directory (the one with your package.json).');
@@ -39,7 +34,7 @@ export async function deleteCommand(opts: DeleteOptions = {}): Promise<void> {
 
   // Confirmation. --json is always non-interactive, so it requires --yes.
   if (!opts.yes) {
-    if (opts.json || !process.stdin.isTTY) {
+    if (getOutputMode() === 'json' || !process.stdin.isTTY) {
       throw new Error('Refusing to delete without confirmation — pass --yes to delete non-interactively.');
     }
     if (!(await confirmByName(appSlug))) {

package/src/commands/deploy.ts

@@ -2,7 +2,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { createInterface } from 'node:readline';
 import { pathExists, readJson } from 'fs-extra';
-import { info, warn, output, setOutputMode, getOutputMode } from '../util/logger';
+import { info, warn, output, getOutputMode } from '../util/logger';
 import { resolveConsumerPaths } from '../shadow/paths';
 import { fetchAppTags, fetchTagCatalog, setAppTags } from '../util/tags';
 import { type AssetManifestFile, type ManifestEntry } from '../util/manifest';
@@ -21,17 +21,12 @@ import { buildCommand } from './build';
 
 export interface DeployOptions {
   dryRun?: boolean;
-  json?: boolean;
   remote?: RemoteType;
   repoUrl?: string;
 }
 
 // Should be run from the consumer app directory — uses process.cwd() to locate it.
 export async function deployCommand(opts: DeployOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   const paths = resolveConsumerPaths(process.cwd());
   const consumerPkg = (await readJson(paths.consumerPkg)) as { name?: string };
   if (!consumerPkg.name) {
@@ -90,7 +85,7 @@ export async function deployCommand(opts: DeployOptions = {}): Promise<void> {
   const url = `${BUCKET_READ_DNS_URL}/${keyPrefix}`;
 
   info('building');
-  await buildCommand({ json: opts.json, publicUrl: url });
+  await buildCommand({ publicUrl: url });
 
   if (!(await pathExists(paths.shadowBuild))) {
     throw new Error(`No build output at ${paths.shadowBuild} after build step.`);
@@ -149,7 +144,7 @@ export async function deployCommand(opts: DeployOptions = {}): Promise<void> {
     // The two are separate endpoints, so the CLI picks based on the version it
     // was handed.
     if (nextVersion === 1) {
-      const visibility = await resolveFirstDeployVisibility(appName, opts.json);
+      const visibility = await resolveFirstDeployVisibility(appName);
       info(`registering app "${appName}" → v${nextVersion} (${visibility})`);
       await registerApp(appName, token, nextVersion, entry, visibility, gitRemote);
     } else {
@@ -262,8 +257,8 @@ async function updateApp(
 // First deploy only: decide whether the app is born public or private. The
 // choice is passed to the register endpoint (default private). Non-interactive
 // runs (--json or no TTY) always default to private.
-async function resolveFirstDeployVisibility(appName: string, json?: boolean): Promise<'public' | 'private'> {
-  if (json || !process.stdout.isTTY) {
+async function resolveFirstDeployVisibility(appName: string): Promise<'public' | 'private'> {
+  if (getOutputMode() === 'json' || !process.stdout.isTTY) {
     return 'private';
   }
 

package/src/commands/dev.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { readJson, writeFile } from 'fs-extra';
 import { watch } from 'chokidar';
 import { execa } from 'execa';
-import { info, warn, errorLog, output, setOutputMode } from '../util/logger';
+import { info, warn, errorLog, output } from '../util/logger';
 import { prepareShadow } from '../shadow/prepare';
 import { ensureConsumerPkg } from '../shadow/consumer-pkg';
 import { syncShadow } from '../shadow/sync';
@@ -11,7 +11,6 @@ import { openInBrowser } from '../util/open-browser';
 import type { ConsumerPkg } from '../types';
 
 export interface DevOptions {
-  json?: boolean;
   open?: boolean;
 }
 
@@ -19,10 +18,6 @@ const TRIDENT_READY_PATTERN = /Server started at/i;
 
 // Should be run from the consumer app directory — uses process.cwd() to locate it.
 export async function devCommand(opts: DevOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   const ctx = await prepareShadow();
   const { port } = ctx;
   const url = `https://bigbrain.me/bigbrain-vibe/${ctx.appName}?zth_local=${port}`;

package/src/commands/doctor.ts

@@ -6,7 +6,7 @@ import { execa } from 'execa';
 import semver from 'semver';
 import { pathExists, readJson } from 'fs-extra';
 import pc from 'picocolors';
-import { setOutputMode, output } from '../util/logger';
+import { output, getOutputMode } from '../util/logger';
 import { isZ2hWorkspace, getWorkspaceHome } from '../util/workspace';
 import { Z2H_AUTH_FILE, tryReadAuthTokenSync } from '../util/auth/auth-store';
 import { brokerNpmRegistryUrl, routingHeaders } from '../constants';
@@ -26,10 +26,6 @@ const SSL_CERT_PATH = path.join(
   'certificate.crt'
 );
 
-export interface DoctorOptions {
-  json?: boolean;
-}
-
 type Status = 'ok' | 'warn' | 'fail';
 
 interface CheckResult {
@@ -317,11 +313,7 @@ function renderCheck(c: CheckResult): void {
 
 // ── command ───────────────────────────────────────────────────────────────────
 
-export async function doctorCommand(opts: DoctorOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
+export async function doctorCommand(): Promise<void> {
   let pluginsJson: InstalledPluginsJson | null = null;
   try {
     if (await pathExists(CLAUDE_PLUGINS_JSON)) {
@@ -350,7 +342,7 @@ export async function doctorCommand(opts: DoctorOptions = {}): Promise<void> {
   const allChecks = sections.flatMap(s => s.checks);
   const issues = allChecks.filter(c => c.status !== 'ok');
 
-  if (opts.json) {
+  if (getOutputMode() === 'json') {
     output('', {
       ok: issues.filter(c => c.status === 'fail').length === 0,
       checks: allChecks,

package/src/commands/edit.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { pathExists } from 'fs-extra';
-import { info, warn, output, setOutputMode } from '../util/logger';
+import { info, warn, output } from '../util/logger';
 import { assertWorkspace } from '../util/workspace';
 import { mfAppName } from '../util/app-name';
 import { fetchApp } from '../util/broker/app';
@@ -9,15 +9,7 @@ import { cloneRepo, pullAndResolve } from '../util/git/repo';
 import { runYarnInstall } from '../util/npm/install';
 import { prepareShadow } from '../shadow/prepare';
 
-export interface EditOptions {
-  json?: boolean;
-}
-
-export async function editCommand(appName: string, opts: EditOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
+export async function editCommand(appName: string): Promise<void> {
   const workspace = await assertWorkspace();
   const mfName = mfAppName(appName);
 

package/src/commands/generate-z2h-token.ts

@@ -1,6 +1,6 @@
 import readline from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
-import { info, warn, output, setOutputMode } from '../util/logger';
+import { info, warn, output } from '../util/logger';
 import { writeZthAuth, validateJwtPattern } from '../util/auth/write-auth';
 import { startLoopbackServer } from '../util/auth/loopback-server';
 import { openInBrowser } from '../util/open-browser';
@@ -18,7 +18,6 @@ export interface GenerateZ2HTokenOptions {
   noBrowser?: boolean;
   /** Override the page URL — useful when pointing at staging. */
   url?: string;
-  json?: boolean;
 }
 
 async function promptForToken(): Promise<string> {
@@ -76,10 +75,6 @@ async function runLoopbackFlow(pageUrl: string): Promise<string | null> {
 }
 
 export async function generateZ2HTokenCommand(opts: GenerateZ2HTokenOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   const pageUrl = opts.url ?? process.env.Z2H_TOKEN_PAGE_URL ?? DEFAULT_TOKEN_PAGE_URL;
 
   // --no-browser bypasses both auto-open and the loopback round-trip — the

package/src/commands/grant.ts

@@ -1,4 +1,4 @@
-import { output, setOutputMode } from '../util/logger';
+import { output } from '../util/logger';
 import { getCwdAppName, mfAppName } from '../util/app-name';
 import { brokerBaseUrl, routingHeaders } from '../constants';
 import { readZthAuth } from '../util/auth/auth-store';
@@ -6,7 +6,6 @@ import { readZthAuth } from '../util/auth/auth-store';
 export interface GrantOptions {
   public?: boolean;
   level?: 'owner' | 'editor' | 'viewer';
-  json?: boolean;
 }
 
 async function postGrant(
@@ -26,9 +25,6 @@ async function postGrant(
 }
 
 export async function grantCommand(email: string | undefined, opts: GrantOptions): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
   if (!opts.public && !email) {
     throw new Error('Specify what to grant — e.g. --public or provide an email');
   }
@@ -59,9 +55,6 @@ export async function grantCommand(email: string | undefined, opts: GrantOptions
 }
 
 export async function revokeCommand(email: string | undefined, opts: GrantOptions): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
   if (!opts.public && !email) {
     throw new Error('Specify what to revoke — e.g. --public or provide an email');
   }
@@ -86,14 +79,7 @@ export async function revokeCommand(email: string | undefined, opts: GrantOption
   output(msg, { ok: true, appName, revoked });
 }
 
-export interface TransferOwnerOptions {
-  json?: boolean;
-}
-
-export async function transferOwnerCommand(email: string | undefined, opts: TransferOwnerOptions): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
+export async function transferOwnerCommand(email: string | undefined): Promise<void> {
   if (!email) {
     throw new Error('Specify the new owner — e.g. z2h-cli transfer-owner someone@monday.com');
   }

package/src/commands/migrate.ts

@@ -1,15 +1,148 @@
-import { setOutputMode } from '../util/logger';
-import { autoMigrate } from '../migrations/auto-migrate';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pathExists, readJson, writeJson } from 'fs-extra';
+import semver from 'semver';
+import { errorLog, info, warn } from '../util/logger';
+import { getWorkspaceHome, isZ2hWorkspace, ensureWorkspaceNx, runYarnInstall } from '../util/workspace';
+
+const STATE_FILE = '.z2h-migrations-state.json';
+
+interface MigrationState {
+  lastMigratedVersion: string;
+}
+
+interface MigrationEntry {
+  version: string;
+  description: string;
+  migrate: string;
+}
+
+interface MigrationsJson {
+  migrations: Record<string, MigrationEntry>;
+}
+
+// ─── Helpers ───
+
+async function readMigrationState(workspaceHome: string): Promise<MigrationState | null> {
+  const statePath = path.join(workspaceHome, STATE_FILE);
+  if (!(await pathExists(statePath))) {
+    return null;
+  }
+  try {
+    return (await readJson(statePath)) as MigrationState;
+  } catch {
+    return null;
+  }
+}
+
+async function writeMigrationState(workspaceHome: string, state: MigrationState): Promise<void> {
+  const statePath = path.join(workspaceHome, STATE_FILE);
+  await writeJson(statePath, state, { spaces: 2 });
+}
+
+// ─── Main ───
 
 export interface MigrateOptions {
   dryRun?: boolean;
-  json?: boolean;
 }
 
 export async function migrateCommand(cliVersion: string, opts: MigrateOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
+  const workspaceHome = getWorkspaceHome();
+  if (!(await isZ2hWorkspace(workspaceHome))) {
+    warn('no Z2H workspace found');
+    return;
+  }
+
+  const state = await readMigrationState(workspaceHome);
+  const lastVersion = state?.lastMigratedVersion ?? '0.0.0';
+
+  if (!semver.gt(cliVersion, lastVersion)) {
+    info('workspace is up to date — no migrations pending');
+    return;
+  }
+
+  info(`migrating workspace from v${lastVersion} → v${cliVersion}...`);
+
+  // migrations.json is at the package root — two dirs up from dist/migrations/
+  const thisDir = path.dirname(fileURLToPath(import.meta.url));
+  const migrationsJsonPath = path.resolve(thisDir, '..', '..', 'migrations.json');
+
+  if (!(await pathExists(migrationsJsonPath))) {
+    warn('migrations.json not found — skipping migrations');
+    return;
+  }
+
+  const migrationsJson = (await readJson(migrationsJsonPath)) as MigrationsJson;
+
+  // Filter to pending migrations (version > lastVersion AND <= cliVersion).
+  // CONVENTION: a migration's `version` field must equal the CLI release it
+  // ships with (not the feature branch version). This ensures the `gt` check
+  // always catches a migration on the exact upgrade that introduces it.
+  const pending = Object.entries(migrationsJson.migrations)
+    .filter(([, entry]) => semver.gt(entry.version, lastVersion) && semver.lte(entry.version, cliVersion))
+    .sort(([, a], [, b]) => semver.compare(a.version, b.version));
+
+  if (opts.dryRun) {
+    info(`${pending.length} pending migration(s) (dry-run — no changes will be applied):`);
+    for (const [, entry] of pending) {
+      info(`  - ${entry.description} (v${entry.version})`);
+    }
+    return;
+  }
+
+  if (pending.length === 0) {
+    await writeMigrationState(workspaceHome, { lastMigratedVersion: cliVersion });
+    return;
+  }
+
+  const nxReady = await ensureWorkspaceNx(workspaceHome);
+  if (!nxReady) {
+    return;
+  }
+
+  info(`applying ${pending.length} workspace migration(s)...`);
+
+  // Resolve NX from the workspace's node_modules (not from CLI's own deps)
+  const wsRequire = createRequire(path.join(workspaceHome, 'package.json'));
+  const { FsTree, flushChanges } = wsRequire('nx/src/generators/tree') as {
+    FsTree: new (root: string, isVerbose: boolean) => import('@nx/devkit').Tree & {
+      listChanges(): { type: string; path: string }[];
+    };
+    flushChanges: (root: string, changes: { type: string; path: string; content?: Buffer | null }[]) => void;
+  };
+
+  let needsInstall = false;
+
+  for (const [name, entry] of pending) {
+    const tree = new FsTree(workspaceHome, false);
+    try {
+      const factoryPath = path.resolve(path.dirname(migrationsJsonPath), entry.migrate);
+      const mod = require(factoryPath);
+      const fn = mod.default || mod;
+      fn(tree);
+
+      const changes = tree.listChanges();
+      if (changes.length > 0) {
+        if (changes.some(c => c.path.endsWith('package.json'))) {
+          needsInstall = true;
+        }
+        flushChanges(workspaceHome, changes);
+        info(`  ✓ ${entry.description}`);
+      } else {
+        info(`  ○ ${entry.description} (no changes needed)`);
+      }
+    } catch (err) {
+      const errorMessage = `migration "${name}" failed: ${(err as Error).message}`;
+      errorLog(`${errorMessage}\nSkipping remaining migrations — run "z2h-cli migrate" to retry.`);
+      throw new Error(errorMessage);
+    }
+  }
+
+  if (needsInstall) {
+    await runYarnInstall(workspaceHome, 'package.json changed');
   }
 
-  await autoMigrate(cliVersion, opts.dryRun);
+  await writeMigrationState(workspaceHome, { lastMigratedVersion: cliVersion });
+  info('workspace migrations complete.');
 }

package/src/commands/tag.ts

@@ -3,7 +3,7 @@ import { stdin, stdout } from 'node:process';
 import { readJson } from 'fs-extra';
 import { resolveConsumerPaths } from '../shadow/paths';
 import { mfAppName } from '../util/app-name';
-import { info, output, setOutputMode } from '../util/logger';
+import { info, output, getOutputMode } from '../util/logger';
 import {
   fetchAppTags,
   fetchTagCatalog,
@@ -17,7 +17,6 @@ import {
 export interface TagOptions {
   /** Repeatable `--tag` — sets the full tag set non-interactively. */
   tag?: string[];
-  json?: boolean;
 }
 
 /** Render an app's tags as `name (Type), ...` — or `(none)`. */
@@ -100,10 +99,6 @@ export async function promptForTags(appSlug: string, catalog: CatalogEntry[], cu
 }
 
 export async function tagCommand(appArg: string | undefined, opts: TagOptions): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   const appSlug = await resolveAppSlug(appArg);
 
   // Non-interactive write: `--tag` flags set the full set directly.
@@ -118,7 +113,7 @@ export async function tagCommand(appArg: string | undefined, opts: TagOptions):
   // Read-only listing: agents (`--json`) and any non-TTY caller get the catalog
   // + current tags without a prompt — then they set tags via `--tag`. This also
   // avoids hanging on `readline` when no human is attached to stdin.
-  if (opts.json || !process.stdin.isTTY) {
+  if (getOutputMode() === 'json' || !process.stdin.isTTY) {
     output(
       `[z2h-cli] "${appSlug}"\n  catalog: ${
         catalog.map(t => `${t.name} (${TAG_TYPE_LABELS[t.type]})`).join(', ') || '(none)'

package/src/index.ts

@@ -17,7 +17,7 @@ import { migrateCommand } from './commands/migrate';
 import { tagCommand } from './commands/tag';
 import { editCommand } from './commands/edit';
 import { doctorCommand } from './commands/doctor';
-import { errorLog, fail, getOutputMode } from './util/logger';
+import { errorLog, fail, getOutputMode, setOutputMode } from './util/logger';
 import { trackDuration } from './util/tracker';
 import { getCwdAppName } from './util/app-name';
 
@@ -69,15 +69,20 @@ async function main(): Promise<void> {
         '  2  system error (yarn install or trident build failed)',
       ].join('\n')
     )
-    .version(version);
+    .version(version)
+    .option('--json', 'emit structured JSON on stdout')
+    .hook('preAction', (_thisCommand, actionCommand) => {
+      if (actionCommand.optsWithGlobals<{ json?: boolean }>().json) {
+        setOutputMode('json');
+      }
+    });
 
   program
     .command('build')
     .description('Build the consumer into its .zth/ shadow and copy artifacts to ./build/')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { json?: boolean }) => {
+    .action(async () => {
       try {
-        await trackDuration('z2h_app_build_success', () => buildCommand(opts), { app_name: getCwdAppName() });
+        await trackDuration('z2h_app_build_success', () => buildCommand(), { app_name: getCwdAppName() });
       } catch (err) {
         await fail(`build failed: ${(err as Error).message}`, { command: 'build' }, 2);
       }
@@ -87,8 +92,7 @@ async function main(): Promise<void> {
     .command('dev')
     .description('Start the Trident dev server against .zth/ with native Vite HMR')
     .option('--open', 'open the browser automatically when the dev server is ready')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { open?: boolean; json?: boolean }) => {
+    .action(async (opts: { open?: boolean }) => {
       try {
         await devCommand(opts);
       } catch (err) {
@@ -99,10 +103,9 @@ async function main(): Promise<void> {
   program
     .command('clean')
     .description('Delete <consumer>/.zth/ and <consumer>/build/')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { json?: boolean }) => {
+    .action(async () => {
       try {
-        await cleanCommand(opts);
+        await cleanCommand();
       } catch (err) {
         await fail(`clean failed: ${(err as Error).message}`, { command: 'clean' }, 2);
       }
@@ -112,7 +115,6 @@ async function main(): Promise<void> {
     .command('deploy')
     .description('Build, upload to S3, and register the app with the Z2H backend')
     .option('--dry-run', 'print what would happen without uploading anything')
-    .option('--json', 'emit structured JSON on stdout')
     .option(
       '--remote <type>',
       'First deploy only: source control remote to initialise — s3 (shared storage) or github (your repo). Error if the app already has a git remote.'
@@ -121,7 +123,7 @@ async function main(): Promise<void> {
       '--repo-url <url>',
       'First deploy only: GitHub repo URL — required when --remote=github. Error if the app already has a git remote.'
     )
-    .action(async (opts: { dryRun?: boolean; json?: boolean; remote?: string; repoUrl?: string }) => {
+    .action(async (opts: { dryRun?: boolean; remote?: string; repoUrl?: string }) => {
       try {
         await trackDuration(
           'z2h_app_deploy_success',
@@ -139,8 +141,7 @@ async function main(): Promise<void> {
     .command('tag [app-name]')
     .description("Set an app's category tags — app type & team (interactive unless --tag or --json is given)")
     .option('--tag <tag>', 'set a tag (repeatable); full-replaces the tag set non-interactively', collectTag, [])
-    .option('--json', "read-only: print the popular catalog + the app's current tags as JSON (no prompt)")
-    .action(async (appName: string | undefined, opts: { tag?: string[]; json?: boolean }) => {
+    .action(async (appName: string | undefined, opts: { tag?: string[] }) => {
       try {
         await trackDuration('z2h_app_tag_success', () => tagCommand(appName, opts), {
           app_name: appName ?? getCwdAppName(),
@@ -153,10 +154,9 @@ async function main(): Promise<void> {
   program
     .command('create-workspace')
     .description(`Bootstrap the ${getWorkspaceHome()}/ yarn workspace (one-time setup)`)
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { json?: boolean }) => {
+    .action(async () => {
       try {
-        await createWorkspaceCommand(opts);
+        await createWorkspaceCommand();
       } catch (err) {
         await fail(`create-workspace failed: ${(err as Error).message}`, { command: 'create-workspace' }, 1);
       }
@@ -169,8 +169,7 @@ async function main(): Promise<void> {
     )
     .option('--no-browser', "don't auto-open the browser; print the URL and prompt for manual paste")
     .option('--url <url>', 'Override the token page URL (e.g. for staging)')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { noBrowser?: boolean; url?: string; json?: boolean }) => {
+    .action(async (opts: { noBrowser?: boolean; url?: string }) => {
       try {
         await generateZ2HTokenCommand(opts);
       } catch (err) {
@@ -185,12 +184,8 @@ async function main(): Promise<void> {
     .option('--html-file <path>', 'Path to an HTML file to embed (implies --template html-embed)')
     .option('--remote <type>', 'Source control remote: s3 (shared storage) or github (your repo)')
     .option('--repo-url <url>', 'GitHub repo URL — required when --remote=github')
-    .option('--json', 'emit structured JSON on stdout')
     .action(
-      async (
-        appName: string,
-        opts: { template?: string; htmlFile?: string; remote?: string; repoUrl?: string; json?: boolean }
-      ) => {
+      async (appName: string, opts: { template?: string; htmlFile?: string; remote?: string; repoUrl?: string }) => {
         try {
           await trackDuration('z2h_app_created', () => createCommand(appName, opts as CreateOptions), {
             app_name: appName,
@@ -206,10 +201,9 @@ async function main(): Promise<void> {
   program
     .command('edit <app-name>')
     .description(`Pull the latest version of an app into ${getWorkspaceHome()}/<app-name>, cloning it first if needed`)
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (appName: string, opts: { json?: boolean }) => {
+    .action(async (appName: string) => {
       try {
-        await trackDuration('z2h_app_edit_pulled', () => editCommand(appName, opts), {
+        await trackDuration('z2h_app_edit_pulled', () => editCommand(appName), {
           app_name: appName,
         });
       } catch (err) {
@@ -222,8 +216,7 @@ async function main(): Promise<void> {
     .description('Grant access to the current app (email, --public, or both)')
     .option('--public', 'make the app visible to all monday.com employees')
     .option('--level <level>', 'access level for user grants: owner, editor, or viewer (default: viewer)')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (email: string | undefined, opts: { public?: boolean; level?: string; json?: boolean }) => {
+    .action(async (email: string | undefined, opts: { public?: boolean; level?: string }) => {
       try {
         await grantCommand(email, opts as Parameters<typeof grantCommand>[1]);
       } catch (err) {
@@ -235,8 +228,7 @@ async function main(): Promise<void> {
     .command('revoke [email]')
     .description('Revoke access to the current app (email or --public; owners/admins only)')
     .option('--public', 'remove the public grant, making the app visible to owners/admins only')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (email: string | undefined, opts: { public?: boolean; json?: boolean }) => {
+    .action(async (email: string | undefined, opts: { public?: boolean }) => {
       try {
         await revokeCommand(email, opts as Parameters<typeof revokeCommand>[1]);
       } catch (err) {
@@ -247,10 +239,9 @@ async function main(): Promise<void> {
   program
     .command('transfer-owner [email]')
     .description('Transfer ownership of the current app to another monday.com user')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (email: string | undefined, opts: { json?: boolean }) => {
+    .action(async (email: string | undefined) => {
       try {
-        await transferOwnerCommand(email, opts);
+        await transferOwnerCommand(email);
       } catch (err) {
         await fail(`transfer-owner failed: ${(err as Error).message}`, { command: 'transfer-owner' }, 1);
       }
@@ -260,8 +251,7 @@ async function main(): Promise<void> {
     .command('delete')
     .description('Permanently delete the current app and take it offline (owners/admins only)')
     .option('--yes', 'skip the confirmation prompt (required for --json / non-interactive)')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { yes?: boolean; json?: boolean }) => {
+    .action(async (opts: { yes?: boolean }) => {
       try {
         await trackDuration('z2h_app_delete_success', () => deleteCommand(opts), {
           app_name: getCwdAppName(),
@@ -275,8 +265,7 @@ async function main(): Promise<void> {
     .command('migrate')
     .description('Run pending workspace migrations')
     .option('--dry-run', 'show pending migrations without applying any changes')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { dryRun?: boolean; json?: boolean }) => {
+    .action(async (opts: { dryRun?: boolean }) => {
       try {
         await migrateCommand(version, opts);
       } catch (err) {
@@ -287,10 +276,9 @@ async function main(): Promise<void> {
   program
     .command('doctor')
     .description('Check that all Z2H tools, auth, workspace, and plugins are correctly set up')
-    .option('--json', 'emit structured JSON on stdout')
-    .action(async (opts: { json?: boolean }) => {
+    .action(async () => {
       try {
-        await doctorCommand(opts);
+        await doctorCommand();
       } catch (err) {
         await fail(`doctor failed: ${(err as Error).message}`, { command: 'doctor' }, 1);
       }