@mondaydotcomorg/z2h-cli 0.15.0 → 0.15.2-feat-eitantsh-z2h-admin-panel-package-388aad6

package/src/commands/create-workspace.ts

@@ -1,21 +1,13 @@
 import path from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { ensureDir, writeFile, pathExists, readdir, copy } from 'fs-extra';
-import { info, output, setOutputMode } from '../util/logger';
+import { info, output } from '../util/logger';
 import { getWorkspaceHome } from '../util/workspace';
 import { getTemplatesDir } from '../util/templates';
 import { runYarnInstall } from '../util/npm/install';
 import { workspaceNpmrcContents, workspaceYarnrcContents } from '../util/npm/broker-config';
 
-export interface CreateWorkspaceOptions {
-  json?: boolean;
-}
-
-export async function createWorkspaceCommand(opts: CreateWorkspaceOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
+export async function createWorkspaceCommand(): Promise<void> {
   const home = getWorkspaceHome();
   const templatesDir = getTemplatesDir();
   const wsTemplatesDir = path.join(templatesDir, 'workspace');

package/src/commands/create.ts

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { ensureDir, pathExists, readdir, writeFile, copy } from 'fs-extra';
-import { info, warn, output, setOutputMode } from '../util/logger';
+import { info, warn, output } from '../util/logger';
 import { assertWorkspace } from '../util/workspace';
 import { getTemplatesDir, renderTemplate, APP_TEMPLATES, type AppTemplate } from '../util/templates';
 import { APP_NAME_PATTERN } from '../constants';
@@ -19,7 +19,6 @@ export interface CreateOptions {
   htmlFile?: string;
   remote?: RemoteType;
   repoUrl?: string;
-  json?: boolean;
 }
 
 // Names reserved by the host MF (mf-bigbrain-zth) for platform pages under
@@ -50,10 +49,6 @@ async function isDirEmpty(dir: string): Promise<boolean> {
 }
 
 export async function createCommand(appName: string, opts: CreateOptions = {}): Promise<void> {
-  if (opts.json) {
-    setOutputMode('json');
-  }
-
   // Validate workspace.
   const workspace = await assertWorkspace();
 

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)'