@mondaydotcomorg/z2h-cli 0.13.1 → 0.14.0

package/dist/commands/__tests__/doctor.test.d.ts

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

package/dist/commands/__tests__/doctor.test.d.ts.map

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

package/dist/commands/delete.d.ts

@@ -0,0 +1,6 @@
+export interface DeleteOptions {
+    yes?: boolean;
+    json?: boolean;
+}
+export declare function deleteCommand(opts?: DeleteOptions): Promise<void>;
+//# sourceMappingURL=delete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../src/commands/delete.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAkBD,wBAAsB,aAAa,CAAC,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC3E"}

package/dist/commands/delete.js

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const node_readline = require('node:readline');
+const util_logger = require('../util/logger.js');
+const util_appName = require('../util/app-name.js');
+const constants = require('../constants.js');
+const util_auth_authStore = require('../util/auth/auth-store.js');
+
+// Type-the-app-name confirmation. The caller must retype the de-scoped app
+// name (what they see in the URL) to guard against accidental deletes.
+async function confirmByName(appSlug) {
+    const rl = node_readline.createInterface({ input: process.stdin, output: process.stderr });
+    const answer = await new Promise(resolve => {
+        rl.question(`This permanently deletes "${appSlug}" and takes it offline. This cannot be undone.\n` +
+            `Type the app name to confirm: `, resolve);
+    });
+    rl.close();
+    return answer.trim() === appSlug;
+}
+// Should be run from the consumer app directory — uses process.cwd() to locate it.
+async function deleteCommand(opts = {}) {
+    if (opts.json) {
+        util_logger.setOutputMode('json');
+    }
+    const cwdName = util_appName.getCwdAppName();
+    if (!cwdName) {
+        throw new Error('Run this from inside a consumer app directory (the one with your package.json).');
+    }
+    const appSlug = util_appName.cleanAppName(cwdName); // user-facing name (matches the bigbrain.me URL)
+    const appName = util_appName.mfAppName(cwdName); // canonical mf- bundle name the backend keys on
+    // Confirmation. --json is always non-interactive, so it requires --yes.
+    if (!opts.yes) {
+        if (opts.json || !process.stdin.isTTY) {
+            throw new Error('Refusing to delete without confirmation — pass --yes to delete non-interactively.');
+        }
+        if (!(await confirmByName(appSlug))) {
+            throw new Error(`Name did not match "${appSlug}" — aborted, nothing was deleted.`);
+        }
+    }
+    const { token } = await util_auth_authStore.readZthAuth();
+    util_logger.info(`deleting "${appName}"`);
+    const res = await fetch(`${constants.brokerBaseUrl()}/z2h-apps/${encodeURIComponent(appName)}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${token}`, ...constants.routingHeaders() },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Delete failed (${res.status}): ${text.slice(0, 1024)}`);
+    }
+    util_logger.output(`[z2h-cli] "${appName}" deleted ✅ — it is now offline.`, { ok: true, appName, deleted: true });
+}
+
+exports.deleteCommand = deleteCommand;

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+export interface DoctorOptions {
+    json?: boolean;
+}
+export declare function doctorCommand(opts?: DoctorOptions): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAiSD,wBAAsB,aAAa,CAAC,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyE3E"}

package/dist/commands/doctor.js

@@ -0,0 +1,334 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const node_module = require('node:module');
+const promises = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const execa = require('execa');
+const semver = require('semver');
+const fs = require('fs-extra');
+const pc = require('picocolors');
+const util_logger = require('../util/logger.js');
+const util_workspace = require('../util/workspace.js');
+const util_auth_authStore = require('../util/auth/auth-store.js');
+const constants = require('../constants.js');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const os__default = /*#__PURE__*/_interopDefault(os);
+const path__default = /*#__PURE__*/_interopDefault(path);
+const semver__default = /*#__PURE__*/_interopDefault(semver);
+const pc__default = /*#__PURE__*/_interopDefault(pc);
+
+const HOME = os__default.default.homedir();
+const Z2H_REPO_ROOT = path__default.default.join(HOME, 'Development', 'bigbrain-z2h');
+const BOOTSTRAP_CMD = `bash ${path__default.default.join(Z2H_REPO_ROOT, 'z2h/setup/bootstrap.sh')}`;
+const UPDATE_CMD = `bash ${path__default.default.join(Z2H_REPO_ROOT, 'z2h/setup/update.sh')}`;
+const CLAUDE_PLUGINS_JSON = path__default.default.join(HOME, '.claude', 'plugins', 'installed_plugins.json');
+const SSL_CERT_PATH = path__default.default.join(HOME, 'Library', 'Application Support', 'devcert', 'domains', 'webpack.llama.fan', 'certificate.crt');
+// ── helpers ───────────────────────────────────────────────────────────────────
+async function checkTool(label, opts) {
+    const { cmd, args, failStatus = 'fail', getVersion, fix } = opts;
+    let stdout;
+    try {
+        ({ stdout } = await execa.execa(cmd, args));
+        stdout = stdout.trim();
+    }
+    catch {
+        return { label, status: failStatus, detail: 'not found', fix };
+    }
+    let version;
+    try {
+        version = getVersion ? await getVersion(stdout) : stdout;
+    }
+    catch {
+        /* best-effort */
+    }
+    return { label, status: 'ok', detail: version };
+}
+// ── checks ───────────────────────────────────────────────────────────────────
+function checkNvm() {
+    const nvmScript = path__default.default.join(HOME, '.nvm', 'nvm.sh');
+    return checkTool('nvm', {
+        cmd: 'bash',
+        args: ['-c', `source "${nvmScript}" && nvm --version`],
+        failStatus: 'warn',
+        fix: BOOTSTRAP_CMD,
+    });
+}
+async function checkNode() {
+    try {
+        const { stdout } = await execa.execa('node', ['--version']);
+        const current = stdout.trim();
+        let requiredNodeVersion;
+        try {
+            const nvmrc = (await promises.readFile(path__default.default.join(Z2H_REPO_ROOT, '.nvmrc'), 'utf8')).trim();
+            requiredNodeVersion = semver__default.default.coerce(nvmrc)?.version;
+        }
+        catch {
+            // repo not cloned — skip version comparison
+        }
+        if (!requiredNodeVersion) {
+            return { label: 'node', status: 'ok', detail: current };
+        }
+        const matches = semver__default.default.satisfies(current, `~${requiredNodeVersion}`);
+        return {
+            label: 'node',
+            status: matches ? 'ok' : 'fail',
+            detail: matches ? current : `${current} (expected ${requiredNodeVersion})`,
+            fix: matches ? undefined : BOOTSTRAP_CMD,
+        };
+    }
+    catch {
+        return { label: 'node', status: 'fail', detail: 'not found', fix: BOOTSTRAP_CMD };
+    }
+}
+function checkYarn() {
+    return checkTool('yarn', { cmd: 'yarn', args: ['--version'], fix: BOOTSTRAP_CMD });
+}
+function checkAws() {
+    return checkTool('aws', { cmd: 'aws', args: ['--version'], getVersion: s => s.split(/\s/)[0], fix: BOOTSTRAP_CMD });
+}
+function checkGitRemoteS3() {
+    return checkTool('git-remote-s3', {
+        cmd: 'which',
+        args: ['git-remote-s3'],
+        getVersion: async () => {
+            const { stdout: pipxOut } = await execa.execa('pipx', ['runpip', 'git-remote-s3', 'show', 'git-remote-s3']);
+            return pipxOut.match(/^Version:\s+(.+)/m)?.[1]?.trim();
+        },
+        fix: BOOTSTRAP_CMD,
+    });
+}
+async function checkZ2hCli() {
+    const { version } = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('commands/doctor.js', document.baseURI).href)))('../../package.json');
+    let latestVersion;
+    try {
+        const token = util_auth_authStore.tryReadAuthTokenSync();
+        if (token) {
+            const res = await fetch(`${constants.brokerNpmRegistryUrl()}/@mondaydotcomorg%2Fz2h-cli`, {
+                headers: { Authorization: `Bearer ${token}`, ...constants.routingHeaders() },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                latestVersion = data['dist-tags']?.latest;
+            }
+        }
+    }
+    catch {
+        // version check is best-effort — no network / token not ready
+    }
+    if (latestVersion && latestVersion !== version) {
+        return { label: 'z2h-cli', status: 'warn', detail: `${version} (latest: ${latestVersion})`, fix: UPDATE_CMD };
+    }
+    return { label: 'z2h-cli', status: 'ok', detail: latestVersion ? `${version} (up to date)` : version };
+}
+async function checkAuthToken() {
+    try {
+        const parsed = (await fs.readJson(util_auth_authStore.Z2H_AUTH_FILE));
+        if (!parsed.token) {
+            return {
+                label: 'auth token',
+                status: 'fail',
+                detail: `${util_auth_authStore.Z2H_AUTH_FILE} missing token field`,
+                fix: 'z2h-cli generate-z2h-token',
+            };
+        }
+        return { label: 'auth token', status: 'ok', detail: util_auth_authStore.Z2H_AUTH_FILE };
+    }
+    catch (err) {
+        let detail;
+        if (err.code === 'ENOENT') {
+            detail = `${util_auth_authStore.Z2H_AUTH_FILE} not found`;
+        }
+        else if (err instanceof SyntaxError) {
+            detail = `${util_auth_authStore.Z2H_AUTH_FILE} could not be parsed`;
+        }
+        else {
+            detail = `${util_auth_authStore.Z2H_AUTH_FILE} is unreadable`;
+        }
+        return { label: 'auth token', status: 'fail', detail, fix: 'z2h-cli generate-z2h-token' };
+    }
+}
+async function checkNpmTokenInProfile() {
+    const profiles = [
+        path__default.default.join(HOME, 'dotfiles', '.bash_profile'),
+        path__default.default.join(HOME, '.zshrc'),
+        path__default.default.join(HOME, '.bash_profile'),
+    ];
+    for (const profile of profiles) {
+        if (!(await fs.pathExists(profile))) {
+            continue;
+        }
+        try {
+            const content = await promises.readFile(profile, 'utf8');
+            if (content.includes('export Z2H_NPM_TOKEN')) {
+                return { label: 'npm token in profile', status: 'ok', detail: path__default.default.basename(profile) };
+            }
+        }
+        catch {
+            // skip unreadable profile
+        }
+    }
+    return {
+        label: 'npm token in profile',
+        status: 'fail',
+        detail: 'export Z2H_NPM_TOKEN not found in any shell profile',
+        fix: BOOTSTRAP_CMD,
+    };
+}
+async function checkWorkspace() {
+    const home = util_workspace.getWorkspaceHome();
+    const ok = await util_workspace.isZ2hWorkspace(home);
+    return {
+        label: 'workspace',
+        status: ok ? 'ok' : 'fail',
+        detail: ok ? home : `${home} not initialized`,
+        fix: ok ? undefined : 'z2h-cli create-workspace',
+    };
+}
+async function checkReactVersion() {
+    const REACT_VERSION_LABEL = 'react version';
+    const REQUIRED_REACT_VERSION = '18.x';
+    const reactVersionFail = detail => ({
+        label: REACT_VERSION_LABEL,
+        status: 'fail',
+        detail,
+        fix: BOOTSTRAP_CMD,
+    });
+    const home = util_workspace.getWorkspaceHome();
+    let pkg;
+    try {
+        pkg = (await fs.readJson(path__default.default.join(home, 'package.json')));
+    }
+    catch {
+        return reactVersionFail('could not read workspace package.json');
+    }
+    const reactVersion = pkg.dependencies?.react;
+    if (!reactVersion) {
+        return reactVersionFail('react not in workspace dependencies');
+    }
+    const coerced = semver__default.default.coerce(reactVersion)?.version;
+    if (!coerced || !semver__default.default.satisfies(coerced, REQUIRED_REACT_VERSION)) {
+        return reactVersionFail(`invalid react version: ${reactVersion} (expected ${REQUIRED_REACT_VERSION})`);
+    }
+    return {
+        label: REACT_VERSION_LABEL,
+        status: 'ok',
+        detail: reactVersion,
+    };
+}
+async function checkSslCert() {
+    const ok = await fs.pathExists(SSL_CERT_PATH);
+    return {
+        label: 'SSL cert',
+        status: ok ? 'ok' : 'warn',
+        detail: ok ? 'webpack.llama.fan' : 'not found — auto-installs on first z2h-cli dev',
+        fix: ok ? undefined : 'z2h-cli dev',
+    };
+}
+async function checkPlugin(pluginKey, label, isMandatory, pluginsJson) {
+    const missingStatus = isMandatory ? 'fail' : 'warn';
+    if (!pluginsJson) {
+        return { label, status: missingStatus, detail: `${CLAUDE_PLUGINS_JSON} not found`, fix: BOOTSTRAP_CMD };
+    }
+    const entries = pluginsJson.plugins?.[pluginKey];
+    if (!entries?.length) {
+        return { label, status: missingStatus, detail: `plugin ${pluginKey} not registered`, fix: BOOTSTRAP_CMD };
+    }
+    const installPath = entries[0].installPath;
+    if (!installPath) {
+        return { label, status: missingStatus, detail: 'installPath missing', fix: BOOTSTRAP_CMD };
+    }
+    const exists = await fs.pathExists(installPath);
+    return {
+        label,
+        status: exists ? 'ok' : missingStatus,
+        detail: exists ? installPath : `${installPath} not found`,
+        fix: exists ? undefined : BOOTSTRAP_CMD,
+    };
+}
+// ── rendering ─────────────────────────────────────────────────────────────────
+const STATUS_ICON = {
+    ok: pc__default.default.green('✅'),
+    warn: pc__default.default.yellow('⚠️ '),
+    fail: pc__default.default.red('❌'),
+};
+function renderCheck(c) {
+    const icon = STATUS_ICON[c.status];
+    const label = c.label.padEnd(22);
+    const detail = c.detail ? pc__default.default.dim(c.detail) : '';
+    process.stdout.write(`  ${icon} ${label}${detail}\n`);
+}
+// ── command ───────────────────────────────────────────────────────────────────
+async function doctorCommand(opts = {}) {
+    if (opts.json) {
+        util_logger.setOutputMode('json');
+    }
+    let pluginsJson = null;
+    try {
+        if (await fs.pathExists(CLAUDE_PLUGINS_JSON)) {
+            pluginsJson = (await fs.readJson(CLAUDE_PLUGINS_JSON));
+        }
+    }
+    catch {
+        // treat as missing
+    }
+    const systemChecks = await Promise.all([checkNvm(), checkNode(), checkYarn(), checkAws(), checkGitRemoteS3()]);
+    const cliChecks = await Promise.all([checkZ2hCli(), checkAuthToken(), checkNpmTokenInProfile()]);
+    const workspaceChecks = await Promise.all([checkWorkspace(), checkReactVersion(), checkSslCert()]);
+    const pluginChecks = await Promise.all([
+        checkPlugin('z2h@bigbrain-z2h', 'z2h plugin', true, pluginsJson),
+        checkPlugin('cf-external-claude-plugin@client-foundations-ai-tools', 'cf-external plugin', false, pluginsJson),
+        checkPlugin('pr-guardrails@agentic-builders-hub', 'pr-guardrails plugin', false, pluginsJson),
+    ]);
+    const sections = [
+        { title: 'System tools', checks: systemChecks },
+        { title: 'CLI & auth', checks: cliChecks },
+        { title: 'Workspace', checks: workspaceChecks },
+        { title: 'Plugins', checks: pluginChecks },
+    ];
+    const allChecks = sections.flatMap(s => s.checks);
+    const issues = allChecks.filter(c => c.status !== 'ok');
+    if (opts.json) {
+        util_logger.output('', {
+            ok: issues.filter(c => c.status === 'fail').length === 0,
+            checks: allChecks,
+        });
+        return;
+    }
+    for (const section of sections) {
+        process.stdout.write(`\n${pc__default.default.bold(section.title)}\n`);
+        for (const check of section.checks) {
+            renderCheck(check);
+        }
+    }
+    process.stdout.write('\n');
+    if (issues.length === 0) {
+        process.stdout.write(pc__default.default.bold(pc__default.default.green('No issues detected 🚀\n')));
+    }
+    else {
+        const fails = issues.filter(c => c.status === 'fail').length;
+        const warns = issues.filter(c => c.status === 'warn').length;
+        const parts = [
+            fails && `${fails} failure${fails > 1 ? 's' : ''}`,
+            warns && `${warns} warning${warns > 1 ? 's' : ''}`,
+        ].filter(Boolean);
+        process.stdout.write(pc__default.default.yellow(`${parts.join(', ')} found\n`));
+        // Deduplicated fixes in the order they were first encountered
+        const fixes = [...new Set(issues.map(c => c.fix).filter(Boolean))];
+        if (fixes.length > 0) {
+            process.stdout.write('\n');
+            process.stdout.write(pc__default.default.bold(pc__default.default.red('In order to fix these issues, run the following commands:')));
+            process.stdout.write('\n');
+            for (const fix of fixes) {
+                process.stdout.write(`  ${pc__default.default.cyan(fix)}\n`);
+            }
+        }
+        process.stdout.write('\n');
+    }
+}
+
+exports.doctorCommand = doctorCommand;

package/dist/esm/commands/__tests__/doctor.test.d.ts

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

package/dist/esm/commands/__tests__/doctor.test.d.ts.map

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

package/dist/esm/commands/delete.d.ts

@@ -0,0 +1,6 @@
+export interface DeleteOptions {
+    yes?: boolean;
+    json?: boolean;
+}
+export declare function deleteCommand(opts?: DeleteOptions): Promise<void>;
+//# sourceMappingURL=delete.d.ts.map

package/dist/esm/commands/delete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/commands/delete.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAkBD,wBAAsB,aAAa,CAAC,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC3E"}

package/dist/esm/commands/delete.mjs

@@ -0,0 +1,51 @@
+import { createInterface } from 'node:readline';
+import { setOutputMode, info, output } from '../util/logger.mjs';
+import { getCwdAppName, cleanAppName, mfAppName } from '../util/app-name.mjs';
+import { brokerBaseUrl, routingHeaders } from '../constants.mjs';
+import { readZthAuth } from '../util/auth/auth-store.mjs';
+
+// Type-the-app-name confirmation. The caller must retype the de-scoped app
+// name (what they see in the URL) to guard against accidental deletes.
+async function confirmByName(appSlug) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    const answer = await new Promise(resolve => {
+        rl.question(`This permanently deletes "${appSlug}" and takes it offline. This cannot be undone.\n` +
+            `Type the app name to confirm: `, resolve);
+    });
+    rl.close();
+    return answer.trim() === appSlug;
+}
+// Should be run from the consumer app directory — uses process.cwd() to locate it.
+async function deleteCommand(opts = {}) {
+    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).');
+    }
+    const appSlug = cleanAppName(cwdName); // user-facing name (matches the bigbrain.me URL)
+    const appName = mfAppName(cwdName); // canonical mf- bundle name the backend keys on
+    // Confirmation. --json is always non-interactive, so it requires --yes.
+    if (!opts.yes) {
+        if (opts.json || !process.stdin.isTTY) {
+            throw new Error('Refusing to delete without confirmation — pass --yes to delete non-interactively.');
+        }
+        if (!(await confirmByName(appSlug))) {
+            throw new Error(`Name did not match "${appSlug}" — aborted, nothing was deleted.`);
+        }
+    }
+    const { token } = await readZthAuth();
+    info(`deleting "${appName}"`);
+    const res = await fetch(`${brokerBaseUrl()}/z2h-apps/${encodeURIComponent(appName)}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${token}`, ...routingHeaders() },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Delete failed (${res.status}): ${text.slice(0, 1024)}`);
+    }
+    output(`[z2h-cli] "${appName}" deleted ✅ — it is now offline.`, { ok: true, appName, deleted: true });
+}
+
+export { deleteCommand };

package/dist/esm/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+export interface DoctorOptions {
+    json?: boolean;
+}
+export declare function doctorCommand(opts?: DoctorOptions): Promise<void>;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/esm/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/commands/doctor.ts"],"names":[],"mappings":"AA4BA,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAiSD,wBAAsB,aAAa,CAAC,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyE3E"}