@thinger-io/cli-core 0.4.1 → 0.5.0

package/lib/commands/grammar.js

@@ -0,0 +1,279 @@
+// @ts-check
+import { Command } from 'commander';
+import { CATALOG } from '../mcp/catalog.js';
+import {
+    CORE_COMMANDS,
+    actionName,
+    commandPath,
+    idArgs,
+    parentArgs,
+    registerResourceCommands,
+    TYPE_AT,
+} from './resources.js';
+
+/**
+ * The grammar every CLI on the core follows, as a check its tests run over
+ * the whole command tree: `<cli> <noun> [<noun>…] <verb> [<parent ids>…]
+ * [<id>] [<extra>] [options]`.
+ *
+ * - Groups are nouns (kebab case, at most 3 below the root, `admin` not
+ *   counted) and run nothing themselves; leaves are verbs of a closed set.
+ * - Positionals are ids, outermost parent first, named after their noun
+ *   (`<device> <property>`), never `deviceId` or `device_id`, and described.
+ * - Short options keep one meaning everywhere (RESERVED); on create, update
+ *   and clone `-n`/`-d` are name and description.
+ * - Commands that send JSON take `--from` and `-s, --set`; deletes take
+ *   `-y`; lists take `--search --filter --count --index`; every command
+ *   that runs something takes `-j, --json`.
+ * - Every catalog type has its commands at commandPath(type), and a command
+ *   written by hand in the place of a generated one takes at least its
+ *   arguments and options. The operations of the core's types and actions
+ *   (bucket_data, storage_file, doc…) have theirs at CORE_COMMANDS.
+ * - Every command is in a help group; the root's are ROOT_GROUPS.
+ *
+ * A CLI states what it adds or does otherwise in `exceptions`.
+ */
+
+/** Help groups of the root, in the order the help shows them. */
+export const ROOT_GROUPS = [
+    'Resources:',
+    'Administration:',
+    'Configuration:',
+    'Integration:',
+    'Operations:',
+];
+
+/** Help groups inside a noun, first; a CLI's own come after. */
+export const NOUN_GROUPS = ['Records:', 'Data:', 'Actions:', 'Subresources:'];
+
+/** Verbs a leaf may be named after. */
+export const VERBS = {
+    records: ['list', 'get', 'create', 'update', 'delete', 'clone', 'describe', 'set'],
+    data: ['read', 'write', 'send', 'export', 'import', 'overview', 'call', 'upload', 'download'],
+    actions: ['set-product', 'apply', 'replace-all', 'stats'],
+    local: ['init', 'dev', 'publish', 'login', 'logout', 'use', 'current', 'add'],
+};
+
+/** Short options and the one long option each stands for. */
+export const RESERVED = {
+    '-h': '--help',
+    '-V': '--version',
+    '-u': '--user',
+    '-j': '--json',
+    '-o': '--output',
+    '-y': '--yes',
+    '-s': '--set',
+    '-q': '--query',
+    '-X': '--method',
+    '-f': '--field',
+};
+
+/** Commands at the root that are not resources. */
+const ROOT_COMMANDS = ['admin', 'profile', 'login', 'logout', 'api', 'mcp', 'doc'];
+
+/** Verbs whose body comes from `--from` and `-s`. */
+const BODY_VERBS = ['create', 'update', 'clone', 'call', 'send', 'write'];
+
+/**
+ * @typedef {object} GrammarExceptions
+ * @property {string[]} [root]   Root commands the CLI adds (`agent`, `playbook`).
+ * @property {string[]} [verbs]  Leaf names the CLI adds (`exec`, `ls`, `tcp`…).
+ * @property {Record<string, Record<string, string>>} [shorts]
+ *   Per command path, short options with another meaning:
+ *   `{ 'device logs': { '-f': '--follow' } }`.
+ * @property {Record<string, Array<'json' | 'body' | 'yes' | 'list' | 'parents'>>} [skip]
+ *   Per command path, rules it does not follow: `json` (no -j), `body`
+ *   (no --from/-s), `yes` (a delete without -y), `list` (no list options),
+ *   `parents` (does not take the ids of the nouns above it).
+ */
+
+/** What the core's own commands do otherwise. */
+const CORE_EXCEPTIONS = {
+    shorts: {
+        'dashboard init': { '-s': '--storage' },
+        'dashboard publish': { '-s': '--storage' },
+    },
+    skip: {
+        // Interactive, or a server on stdio.
+        login: ['json'],
+        logout: ['json'],
+        mcp: ['json'],
+        // Local profiles, and lists that are not server collections.
+        'profile list': ['list'],
+        'profile delete': ['yes'],
+        'device resource list': ['list'],
+        'storage file list': ['list'],
+        'doc list': ['list'],
+    },
+};
+
+const KEBAB = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+
+const visible = (cmd) => cmd.commands.filter((c) => !c._hidden);
+const find = (root, path) =>
+    path.reduce((cmd, name) => cmd?.commands.find((c) => c.name() === name), root);
+const longs = (cmd) => new Set(cmd.options.map((o) => o.long).filter(Boolean));
+
+/**
+ * Check a CLI's command tree against the grammar.
+ *
+ * @param {Command} program  As buildProgram makes it.
+ * @param {{ exceptions?: GrammarExceptions }} [opts]
+ * @returns {string[]}  The problems found, one line each: none when it follows it.
+ */
+export function checkGrammar(program, { exceptions = {} } = {}) {
+    const problems = [];
+    const say = (path, message) => problems.push(`${path.join(' ') || '(root)'}: ${message}`);
+    const skip = (key, rule) =>
+        [...(CORE_EXCEPTIONS.skip[key] || []), ...(exceptions.skip?.[key] || [])].includes(rule);
+    const shortFor = (key, short) =>
+        exceptions.shorts?.[key]?.[short] ?? CORE_EXCEPTIONS.shorts[key]?.[short];
+
+    const catalogActions = Object.entries(CATALOG).flatMap(([t, s]) =>
+        Object.keys(s.actions || {}).map((a) => actionName(t, a)),
+    );
+    const verbs = new Set([
+        ...Object.values(VERBS).flat(),
+        ...catalogActions,
+        ...(exceptions.verbs || []),
+    ]);
+    const rootNames = new Set([
+        ...Object.keys(CATALOG).map((t) => commandPath(t)[0]),
+        ...ROOT_COMMANDS,
+        ...(exceptions.root || []),
+    ]);
+
+    // Options of the root (-u, --profile) are never redefined below it.
+    for (const o of program.options) {
+        if (o.short && RESERVED[o.short] && RESERVED[o.short] !== o.long) {
+            say([], `${o.short} is ${o.long}, not ${RESERVED[o.short]}`);
+        }
+    }
+
+    const walk = (cmd, path) => {
+        for (const sub of visible(cmd)) {
+            const at = [...path, sub.name()];
+            const key = at.join(' ');
+            const nouns = (sub.commands.length ? at : path).filter((n, i) => i || n !== 'admin');
+            if (!KEBAB.test(sub.name())) say(at, 'not kebab case');
+            if (nouns.length > 3) say(at, `${nouns.length} nouns (at most 3)`);
+            if (!sub.helpGroup()) say(at, 'in no help group');
+            if (!path.length) {
+                if (!rootNames.has(sub.name())) say(at, 'not a command of the root');
+                if (!ROOT_GROUPS.includes(sub.helpGroup())) {
+                    say(at, `help group "${sub.helpGroup()}" is not one of the root's`);
+                }
+            }
+            if (sub.commands.length) {
+                // @ts-ignore -- commander keeps the handler private
+                if (sub._actionHandler) say(at, 'a group that runs something');
+                if (VERBS.records.includes(sub.name())) say(at, 'a group named after a verb');
+                walk(sub, at);
+                continue;
+            }
+            if (path.length && !verbs.has(sub.name())) say(at, 'not a verb of the grammar');
+            checkArguments(sub, path, at, key);
+            checkOptions(sub, at, key);
+        }
+    };
+
+    /** Positionals: kebab case, described, the parents' ids first, then the own id. */
+    const checkArguments = (leaf, path, at, key) => {
+        const names = leaf.registeredArguments.map((a) => a.name());
+        for (const arg of leaf.registeredArguments) {
+            if (!KEBAB.test(arg.name())) say(at, `argument <${arg.name()}> is not kebab case`);
+            if (!arg.description) say(at, `argument <${arg.name()}> has no description`);
+        }
+        if (!path.length || skip(key, 'parents')) return;
+        // The ids of the types above the leaf's group, outermost first.
+        const parents = path.slice(0, -1).flatMap((_, i) => {
+            const type = TYPE_AT.get(path.slice(0, i + 1).join(' '));
+            return type ? idArgs(type) : [];
+        });
+        const own = TYPE_AT.get(path.join(' '));
+        const verb = leaf.name();
+        const expected = own && verb !== 'describe' ? [...parentArgs(own)] : parents;
+        if (verb === 'describe') {
+            if (names.length) say(at, 'describe takes no arguments');
+            return;
+        }
+        if (names.slice(0, expected.length).join(' ') !== expected.join(' ')) {
+            say(at, `arguments <${names.join('> <')}> do not start with <${expected.join('> <')}>`);
+        }
+        if (own && ['get', 'update', 'delete', 'clone', 'set'].includes(verb)) {
+            const ids = idArgs(own);
+            const mine = names.slice(expected.length, expected.length + ids.length);
+            if (mine.join(' ') !== ids.join(' ')) {
+                say(at, `the id of a ${own} is <${ids.join('> <')}>, not <${mine.join('> <')}>`);
+            }
+        }
+    };
+
+    const checkOptions = (leaf, at, key) => {
+        const verb = leaf.name();
+        const has = longs(leaf);
+        for (const o of leaf.options) {
+            if (o.short === '-u' || o.long === '--user' || o.long === '--profile') {
+                say(at, `${o.flags} redefines an option of the root`);
+            }
+            const meaning = shortFor(key, o.short) ?? RESERVED[o.short];
+            if (o.short && meaning && meaning !== o.long) {
+                say(at, `${o.short} is ${o.long}, not ${meaning}`);
+            }
+            if (['create', 'update', 'clone'].includes(verb)) {
+                if (o.short === '-n' && o.long !== '--name') say(at, `-n is ${o.long}, not --name`);
+                if (o.short === '-d' && o.long !== '--description') {
+                    say(at, `-d is ${o.long}, not --description`);
+                }
+            }
+        }
+        const short = (long) => leaf.options.find((o) => o.long === long)?.short;
+        if (!skip(key, 'json') && short('--json') !== '-j') say(at, 'no -j, --json');
+        if (BODY_VERBS.includes(verb) && !skip(key, 'body')) {
+            if (!has.has('--from') || short('--set') !== '-s') say(at, 'no --from and -s, --set');
+        }
+        if ((verb === 'delete' || verb === 'replace-all') && !skip(key, 'yes')) {
+            if (short('--yes') !== '-y') say(at, 'no -y, --yes');
+        }
+        if (verb === 'list' && !skip(key, 'list')) {
+            for (const o of ['--search', '--filter', '--count', '--index']) {
+                if (!has.has(o)) say(at, `no ${o}`);
+            }
+        }
+    };
+
+    walk(program, []);
+
+    // Every type has its commands, and a command written by hand in the
+    // place of a generated one takes at least its arguments and options.
+    const generated = new Command();
+    registerResourceCommands(generated);
+    for (const type of Object.keys(CATALOG)) {
+        const path = commandPath(type);
+        const mine = find(program, path);
+        if (!mine) {
+            say(path, `no commands for ${type}`);
+            continue;
+        }
+        for (const ref of find(generated, path).commands.filter((c) => !c.commands.length)) {
+            const at = [...path, ref.name()];
+            const leaf = mine.commands.find((c) => c.name() === ref.name());
+            if (!leaf || leaf._hidden) {
+                say(at, `missing (${type})`);
+                continue;
+            }
+            const args = (c) => c.registeredArguments.map((a) => a.name()).join(' ');
+            if (args(leaf) !== args(ref)) {
+                say(at, `takes <${args(leaf)}> where the generated command takes <${args(ref)}>`);
+            }
+            const has = longs(leaf);
+            const lacking = [...longs(ref)].filter((o) => !has.has(o));
+            if (lacking.length) say(at, `lacks ${lacking.join(', ')} of the generated command`);
+        }
+    }
+    for (const [op, words] of Object.entries(CORE_COMMANDS)) {
+        const leaf = find(program, words.split(' '));
+        if (!leaf || leaf._hidden || leaf.commands.length) say(words.split(' '), `missing (${op})`);
+    }
+    return problems;
+}

package/lib/commands/product.js

@@ -2,138 +2,139 @@
 import {
     createProduct,
     deleteProduct,
-    deleteProductProperty,
-    getProduct,
     getProductApi,
-    getProductProperties,
-    getProductProperty,
     getProducts,
     productExists,
-    setProductProperty,
 } from '../product.js';
 import { runPool } from '../concurrency.js';
-import { alreadyExistsError } from '../errors.js';
+import { alreadyExistsError, inputError } from '../errors.js';
 import { hint, info, label, success } from '../format.js';
 import { classifyError, createSpinner, isJsonMode, printErr, printOk } from '../output.js';
+import {
+    hasListOptions,
+    listOptions,
+    listRecords,
+    projectsOption,
+    setProjects,
+} from './resources.js';
 import {
     applyJsonFlag,
+    bodyFromOptions,
+    bodyOptions,
     confirmDestructive,
     ensureConfigured,
     getGlobalUser,
-    parseJsonValue,
     parsePositiveInt,
-    readJsonArgument,
     runCommand,
 } from './_shared.js';
 
 /**
- * `<cli> product <action> <productId> …` — products and their
- * product-level properties.
+ * `<cli> product <verb> <product> …` — the product records written by hand
+ * (list as a table with API counts, create from the CLI's template,
+ * delete); the rest of the group (get, update, property, profile, export,
+ * apply…) comes from the tool and resource commands.
  */
 export function registerProductCommands(program) {
     const product = program
         .command('product')
-        .helpGroup('Operations:')
-        .description('Products: list, inspect, create, delete and product properties');
+        .helpGroup('Resources:')
+        .description('Products: records, properties, profile and their export');
 
-    product
-        .command('list')
-        .helpGroup('Discovery:')
-        .description('List every product configured on the account')
-        .option('-j, --json', 'Output as JSON')
-        .option(
-            '-c, --concurrency <n>',
-            'Max parallel API-resource lookups (default: 10)',
-            parsePositiveInt('concurrency'),
-            10,
-        )
-        .action(async (opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
+    listOptions(
+        product
+            .command('list')
+            .helpGroup('Records:')
+            .description('List the products of the account, with their API resources')
+            .option('-j, --json', 'Output as JSON')
+            .option(
+                '-c, --concurrency <n>',
+                'Max parallel API-resource lookups (default: 10)',
+                parsePositiveInt('concurrency'),
+                10,
+            ),
+    ).action(async (opts, cmd) => {
+        applyJsonFlag(opts);
+        ensureConfigured();
+        const user = getGlobalUser(cmd);
 
-            const spinner = createSpinner('Fetching products...').start();
-            let products;
-            try {
-                products = await getProducts(user);
-            } catch (error) {
-                spinner.fail('Failed to fetch products');
-                const { message, code } = classifyError(error);
-                printErr(message, { code });
-                return;
-            }
+        const spinner = createSpinner('Fetching products...').start();
+        let products;
+        try {
+            products = hasListOptions(opts)
+                ? await listRecords('product', opts, user)
+                : await getProducts(user);
+        } catch (error) {
+            spinner.fail('Failed to fetch products');
+            const { message, code } = classifyError(error);
+            printErr(message, { code });
+            return;
+        }
 
-            // API-resource counts come from each product's profile.
-            // Parallelise so a large catalogue doesn't crawl serially.
-            const apiResults = await runPool(products, opts.concurrency, async (p) => {
-                const apis = await getProductApi(p.product, user);
-                return Object.keys(apis || {}).length;
-            });
-            const rows = products.map((p, i) => ({
-                product: p.product,
-                name: p.name && p.name !== p.product ? p.name : null,
-                enabled: !!p.enabled,
-                api_resources: apiResults[i]?.ok ? apiResults[i].value : null,
-            }));
+        // API-resource counts come from each product's profile.
+        // Parallelise so a large catalogue doesn't crawl serially.
+        const apiResults = await runPool(products, opts.concurrency, async (p) => {
+            const apis = await getProductApi(p.product, user);
+            return Object.keys(apis || {}).length;
+        });
+        const rows = products.map((p, i) => ({
+            product: p.product,
+            name: p.name && p.name !== p.product ? p.name : null,
+            enabled: !!p.enabled,
+            api_resources: apiResults[i]?.ok ? apiResults[i].value : null,
+        }));
 
-            spinner.succeed(`Found ${rows.length} product(s)`);
+        spinner.succeed(`Found ${rows.length} product(s)`);
 
-            if (isJsonMode()) {
-                printOk({ products: rows });
-                return;
-            }
-
-            const idWidth = rows.reduce((w, r) => Math.max(w, String(r.product ?? '').length), 0);
-            for (const r of rows) {
-                const flag = r.enabled ? success('enabled ') : hint('disabled');
-                const id = label(String(r.product ?? '(no id)').padEnd(idWidth));
-                const name = r.name ? hint(`(${r.name})`) : '';
-                const apis = r.api_resources ? hint(`${r.api_resources} API resource(s)`) : '';
-                const extras = [name, apis].filter(Boolean).join('  ');
-                console.log(`  ${flag}  ${id}${extras ? '  ' + extras : ''}`);
-            }
-        });
+        if (isJsonMode()) {
+            printOk({ products: rows });
+            return;
+        }
 
-    product
-        .command('info <productId>')
-        .helpGroup('Discovery:')
-        .description('Print the full product document (config and profile) as JSON')
-        .option('-j, --json', 'Output as JSON envelope')
-        .action(async (productId, opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
-            await runCommand({
-                start: `Fetching ${productId}...`,
-                fn: () => getProduct(productId, user),
-                success: null,
-                failure: 'Failed to read product',
-                onSuccess: (doc) => {
-                    if (isJsonMode()) printOk(doc);
-                    else console.log(JSON.stringify(doc, null, 2));
-                },
-            });
-        });
+        const idWidth = rows.reduce((w, r) => Math.max(w, String(r.product ?? '').length), 0);
+        for (const r of rows) {
+            const flag = r.enabled ? success('enabled ') : hint('disabled');
+            const id = label(String(r.product ?? '(no id)').padEnd(idWidth));
+            const name = r.name ? hint(`(${r.name})`) : '';
+            const apis = r.api_resources ? hint(`${r.api_resources} API resource(s)`) : '';
+            const extras = [name, apis].filter(Boolean).join('  ');
+            console.log(`  ${flag}  ${id}${extras ? '  ' + extras : ''}`);
+        }
+    });
 
-    product
-        .command('create <productId>')
-        .helpGroup('Records:')
-        .description('Create a product, bare or from a JSON document (config + profile)')
-        .option('-n, --name <name>', 'Display name')
-        .option('-d, --description <text>', 'Description')
-        .option('--from <file>', 'JSON document with `config` and/or `profile` ("-" for stdin)')
+    projectsOption(
+        bodyOptions(
+            product
+                .command('create [product]')
+                .helpGroup('Records:')
+                .description(
+                    'Create a product, bare or from a JSON document (config + profile); the CLI template fills in the rest',
+                )
+                .option('-n, --name <name>', 'Display name')
+                .option('-d, --description <text>', 'Description'),
+        ),
+    )
         .option('-j, --json', 'Output as JSON')
-        .action(async (productId, opts, cmd) => {
+        .action(async (id, opts, cmd) => {
             applyJsonFlag(opts);
             ensureConfigured();
             const user = getGlobalUser(cmd);
+            let productId = id;
             await runCommand({
-                start: `Creating ${productId}...`,
+                start: `Creating ${id ?? 'product'}...`,
                 fn: async () => {
+                    const doc = (await bodyFromOptions(opts)) ?? {};
+                    if (typeof doc !== 'object' || doc === null || Array.isArray(doc)) {
+                        throw inputError('create takes a JSON object');
+                    }
+                    productId ??= doc.product;
+                    if (!productId) {
+                        throw inputError(
+                            'give the product id: <product>, or the body field "product"',
+                        );
+                    }
                     if (await productExists(productId, user)) {
                         throw alreadyExistsError(`Product "${productId}" already exists`);
                     }
-                    const doc = opts.from ? await readJsonArgument(opts.from) : {};
                     await createProduct(productId, user, {
                         name: opts.name || doc.name,
                         description: opts.description || doc.description,
@@ -141,8 +142,9 @@ export function registerProductCommands(program) {
                         config: doc.config,
                         profile: doc.profile,
                     });
+                    if (opts.projects) await setProjects('product', productId, opts.projects, user);
                 },
-                success: `Created product ${productId}`,
+                success: () => `Created product ${productId}`,
                 failure: 'Failed to create product',
                 onSuccess: () => {
                     if (isJsonMode()) printOk({ product: productId });
@@ -151,143 +153,31 @@ export function registerProductCommands(program) {
         });
 
     product
-        .command('delete <productId>')
+        .command('delete <product>')
         .helpGroup('Records:')
         .description('Delete a product (its devices stay, unassigned)')
         .option('-y, --yes', 'Skip the interactive confirmation prompt')
         .option('-j, --json', 'Output as JSON')
-        .action(async (productId, opts, cmd) => {
+        .action(async (id, opts, cmd) => {
             applyJsonFlag(opts);
             ensureConfigured();
             const user = getGlobalUser(cmd);
-            if (
-                !(await confirmDestructive(
-                    opts,
-                    `Delete product ${productId}? This cannot be undone.`,
-                ))
-            ) {
+            if (!(await confirmDestructive(opts, `Delete product ${id}? This cannot be undone.`))) {
                 console.log(hint('Cancelled.'));
                 return;
             }
             try {
-                const removed = await deleteProduct(productId, user);
+                const removed = await deleteProduct(id, user);
                 if (isJsonMode()) {
-                    printOk({ product: productId, removed });
+                    printOk({ product: id, removed });
                     return;
                 }
-                console.log(
-                    removed
-                        ? `Deleted ${info(productId)}`
-                        : `Product ${info(productId)} did not exist`,
-                );
+                console.log(removed ? `Deleted ${info(id)}` : `Product ${info(id)} did not exist`);
             } catch (error) {
                 const { message, code } = classifyError(error);
                 printErr(message, { code });
             }
         });
 
-    product
-        .command('property-list <productId>')
-        .helpGroup('Product properties:')
-        .description('List the names of the properties attached to a product')
-        .option('-j, --json', 'Output as JSON')
-        .action(async (productId, opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
-            await runCommand({
-                start: `Getting properties of ${productId}...`,
-                fn: () => getProductProperties(productId, user),
-                success: null,
-                failure: 'Property retrieval failed',
-                onSuccess: (list) => {
-                    const names = Array.isArray(list)
-                        ? list.map((p) => p.property).filter(Boolean)
-                        : [];
-                    if (isJsonMode()) {
-                        printOk({ product: productId, properties: names });
-                        return;
-                    }
-                    if (!names.length) {
-                        console.log(`No properties on product ${info(productId)}`);
-                        return;
-                    }
-                    console.log(`Properties of product ${info(productId)}:`);
-                    for (const n of names) console.log(`- ${n}`);
-                },
-            });
-        });
-
-    product
-        .command('property-get <productId> <propertyId>')
-        .helpGroup('Product properties:')
-        .description('Read a property attached to a product')
-        .option('-j, --json', 'Output as JSON')
-        .action(async (productId, propertyId, opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
-            await runCommand({
-                start: `Reading ${propertyId}...`,
-                fn: () => getProductProperty(productId, propertyId, user),
-                success: null,
-                failure: 'Property retrieval failed',
-                onSuccess: (value) => {
-                    if (isJsonMode()) printOk({ product: productId, property: propertyId, value });
-                    else console.log(JSON.stringify(value, null, 2));
-                },
-            });
-        });
-
-    product
-        .command('property-set <productId> <propertyId> <value>')
-        .helpGroup('Product properties:')
-        .description('Create or overwrite a product property (value parsed as JSON)')
-        .option('-j, --json', 'Output as JSON')
-        .action(async (productId, propertyId, value, opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
-            const parsed = parseJsonValue(value);
-            await runCommand({
-                start: `Saving ${propertyId} on ${productId}...`,
-                fn: () => setProductProperty(productId, propertyId, parsed, user),
-                success: `Saved ${propertyId} on ${productId}`,
-                failure: 'Failed to save property',
-                onSuccess: () => {
-                    if (isJsonMode())
-                        printOk({ product: productId, property: propertyId, value: parsed });
-                },
-            });
-        });
-
-    product
-        .command('property-delete <productId> <propertyId>')
-        .helpGroup('Product properties:')
-        .description('Delete a product property (idempotent)')
-        .option('-j, --json', 'Output as JSON')
-        .action(async (productId, propertyId, opts, cmd) => {
-            applyJsonFlag(opts);
-            ensureConfigured();
-            const user = getGlobalUser(cmd);
-            await runCommand({
-                start: `Deleting ${propertyId}...`,
-                fn: () => deleteProductProperty(productId, propertyId, user),
-                success: null,
-                failure: 'Failed to delete property',
-                onSuccess: (removed) => {
-                    if (isJsonMode()) {
-                        printOk({ product: productId, property: propertyId, removed });
-                        return;
-                    }
-                    console.log(
-                        removed
-                            ? `Deleted ${info(propertyId)} from ${info(productId)}`
-                            : `Property ${info(propertyId)} was not set on ${info(productId)}`,
-                    );
-                },
-            });
-        });
-
     return product;
 }