@optima-chat/dev-skills 0.7.32 → 0.7.35

package/dist/bin/helpers/entitlement/list.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runList = runList;
+const billing_http_1 = require("../billing-http");
+const db_utils_1 = require("../db-utils");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-entitlement list --email <user-email> [options]
+
+Required:
+  --email <user-email>             Resolved to userId via user-auth DB
+
+Optional:
+  --env stage|prod                 (default: stage)`);
+        process.exit(0);
+    }
+    const out = { env: 'stage' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--email':
+                out.email = next;
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.email)
+        throw new Error('--email required');
+    return out;
+}
+async function runList(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    const cfg = (0, db_utils_1.getInfisicalConfig)();
+    const token = (0, db_utils_1.getInfisicalToken)(cfg);
+    const userId = await (0, db_utils_1.resolveUserId)(args.email, args.env, cfg, token);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'GET', `/api/billing/admin/entitlements?userId=${encodeURIComponent(userId)}`);
+    const rows = res.body.entitlements ?? [];
+    if (rows.length === 0) {
+        console.log(`(no entitlements for ${args.email} on ${args.env})`);
+        return;
+    }
+    // Newest first per spec
+    rows.sort((a, b) => b.purchasedAt.localeCompare(a.purchasedAt));
+    console.log(`${rows.length} entitlement(s) for ${args.email}:\n`);
+    console.log('id'.padEnd(38) + ' | ' + 'productKey'.padEnd(32) + ' | ' + 'status'.padEnd(9) + ' | ' + 'source'.padEnd(12) + ' | purchasedAt              | refundedAt');
+    console.log('-'.repeat(140));
+    for (const r of rows) {
+        console.log(r.id.padEnd(38) + ' | ' +
+            r.productKey.padEnd(32) + ' | ' +
+            r.status.padEnd(9) + ' | ' +
+            r.source.padEnd(12) + ' | ' +
+            r.purchasedAt.padEnd(24) + ' | ' +
+            (r.refundedAt ?? ''));
+    }
+}

package/dist/bin/helpers/entitlement/revoke.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRevoke = runRevoke;
+const billing_http_1 = require("../billing-http");
+const confirm_prompt_1 = require("../confirm-prompt");
+const db_utils_1 = require("../db-utils");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-entitlement revoke --email <user> --product-key <slug> --reason "..." [options]
+
+Required:
+  --email <user-email>             Resolved to userId via user-auth DB
+  --product-key <productKey>
+  --reason "..."                   Required by billing (400 otherwise); stored on entitlement.refundReason
+
+Optional:
+  --yes                            Skip prod confirmation prompt (no-op on stage)
+  --env stage|prod                 (default: stage)
+
+Refuses non-ADMIN_GRANT sources (PAYMENT, PARTNER) with source-specific
+error pointing to the right reversal flow.`);
+        process.exit(0);
+    }
+    const out = { env: 'stage', yes: false };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--email':
+                out.email = next;
+                i++;
+                break;
+            case '--product-key':
+                out.productKey = next;
+                i++;
+                break;
+            case '--reason':
+                out.reason = next;
+                i++;
+                break;
+            case '--yes':
+                out.yes = true;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.email)
+        throw new Error('--email required');
+    if (!out.productKey)
+        throw new Error('--product-key required');
+    if (!out.reason)
+        throw new Error('--reason required (billing returns 400 otherwise)');
+    return out;
+}
+const PAYMENT_REFUSAL = `refusing to revoke a PAYMENT-source entitlement via CLI; this would leave the customer charged but unentitled. Use the Stripe refund flow which calls Stripe refund API + records refundedAmountCents + emits webhook. Manual psql is the escape hatch if absolutely necessary.`;
+const PARTNER_REFUSAL = `refusing to revoke a PARTNER-source entitlement via CLI; PARTNER grants are issued out-of-band and must be reversed via the partner contract / process that issued them. Manual psql is the escape hatch if absolutely necessary.`;
+async function runRevoke(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    const cfg = (0, db_utils_1.getInfisicalConfig)();
+    const token = (0, db_utils_1.getInfisicalToken)(cfg);
+    const userId = await (0, db_utils_1.resolveUserId)(args.email, args.env, cfg, token);
+    // Step 1: Fetch user's entitlements
+    const listRes = await (0, billing_http_1.callBilling)(args.env, 'GET', `/api/billing/admin/entitlements?userId=${encodeURIComponent(userId)}`);
+    const all = listRes.body.entitlements ?? [];
+    // Step 2: Filter for ACTIVE + matching productKey
+    const matches = all.filter((e) => e.status === 'ACTIVE' && e.productKey === args.productKey);
+    // Step 3: Validate count (partial unique index enforces ≤1 ACTIVE)
+    if (matches.length === 0) {
+        throw new Error(`no active entitlement for (user=${args.email}, product=${args.productKey}) on ${args.env}`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`unexpected: ${matches.length} ACTIVE entitlements for (user, product) — partial unique constraint should prevent this. Inspect with: optima-entitlement list --email ${args.email}`);
+    }
+    const target = matches[0];
+    // Step 4: Validate source
+    if (target.source === 'PAYMENT')
+        throw new Error(PAYMENT_REFUSAL);
+    if (target.source === 'PARTNER')
+        throw new Error(PARTNER_REFUSAL);
+    if (target.source !== 'ADMIN_GRANT')
+        throw new Error(`unknown entitlement source: ${target.source}`);
+    await (0, confirm_prompt_1.confirmIfProd)(args.env, `Action: REVOKE entitlement ${target.id} (productKey=${target.productKey}) for user ${args.email} (userId=${userId}) on ${args.env.toUpperCase()}\nReason: ${args.reason}`, args.yes);
+    // Step 5: Refund
+    // refundAmountCents=0 is always correct for ADMIN_GRANT (priceCents=0,
+    // no upstream charge). Pass explicitly so billing's auto-compute
+    // (which requires refundWindowDays on the Product) doesn't 400 with
+    // MANUAL_REFUND_AMOUNT_REQUIRED for products that lack a refund policy.
+    // PAYMENT/PARTNER sources are already refused in step 4 above, so
+    // this branch only ever runs for ADMIN_GRANT (priceCents=0) — Stripe
+    // refund path in billing (admin-products.ts:296-307) is gated on
+    // source=PAYMENT and won't trigger here.
+    console.log(`\n♻️  Revoking entitlement ${target.id} for ${args.email}...`);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'POST', '/api/billing/admin/refund-entitlement', {
+        entitlementId: target.id,
+        refundReason: args.reason,
+        refundAmountCents: 0,
+    });
+    console.log(`✓ Revoked entitlement (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/entitlement.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grant_1 = require("./entitlement/grant");
+const list_1 = require("./entitlement/list");
+const revoke_1 = require("./entitlement/revoke");
+function printHelp() {
+    console.log(`Usage: optima-entitlement <subcommand> [options]
+
+Subcommands:
+  grant      Admin-grant a product entitlement to a user
+  revoke     Revoke an admin-granted entitlement (refuses PAYMENT / PARTNER sources)
+  list       List a user's entitlements, newest first
+
+Run 'optima-entitlement <subcommand> --help' for subcommand-specific options.`);
+}
+async function main() {
+    const [, , subcommand, ...rest] = process.argv;
+    if (!subcommand || subcommand === '-h' || subcommand === '--help') {
+        printHelp();
+        process.exit(0);
+    }
+    switch (subcommand) {
+        case 'list':
+            await (0, list_1.runList)(rest);
+            break;
+        case 'grant':
+            await (0, grant_1.runGrant)(rest);
+            break;
+        case 'revoke':
+            await (0, revoke_1.runRevoke)(rest);
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((err) => { console.error(err.message); process.exit(1); });

package/dist/bin/helpers/grant-credits.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const db_utils_1 = require("./db-utils");
+function parseArgs(args) {
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        console.log(`Usage: optima-grant-credits <email> --amount <n> [options]
+
+Options:
+  --amount <n>          Credits to grant (required)
+  --type <type>         Credit type: bonus, referral (default: bonus)
+  --description <text>  Description (optional)
+  --env <env>           Environment: stage, prod (default: stage)
+  -h, --help            Show this help`);
+        process.exit(0);
+    }
+    const email = args[0];
+    let amount = 0;
+    let type = 'bonus';
+    let description = null;
+    let env = 'stage';
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--amount' && args[i + 1]) {
+            amount = parseInt(args[++i], 10);
+        }
+        else if (args[i] === '--type' && args[i + 1]) {
+            type = args[++i];
+        }
+        else if (args[i] === '--description' && args[i + 1]) {
+            description = args[++i];
+        }
+        else if (args[i] === '--env' && args[i + 1]) {
+            env = args[++i];
+        }
+    }
+    if (amount < 1) {
+        console.error('--amount is required and must be >= 1');
+        process.exit(1);
+    }
+    if (!['bonus', 'referral'].includes(type)) {
+        console.error(`Unknown type: ${type}. Available: bonus, referral`);
+        process.exit(1);
+    }
+    if (!['stage', 'prod'].includes(env)) {
+        console.error('Env must be stage or prod (billing DB not available in CI)');
+        process.exit(1);
+    }
+    return { email, amount, type, description, env };
+}
+async function main() {
+    const { email, amount, type, description, env } = parseArgs(process.argv.slice(2));
+    const infisicalConfig = (0, db_utils_1.getInfisicalConfig)();
+    const token = (0, db_utils_1.getInfisicalToken)(infisicalConfig);
+    console.log(`\n🎁 Granting ${amount} ${type} credits to ${email} [${env.toUpperCase()}]\n`);
+    const userId = await (0, db_utils_1.resolveUserId)(email, env, infisicalConfig, token);
+    const billing = await (0, db_utils_1.connectBillingDB)(env, infisicalConfig, token);
+    const bq = billing.query;
+    const now = new Date().toISOString();
+    const safeUserId = (0, db_utils_1.escapeSQL)(userId);
+    const safeType = (0, db_utils_1.escapeSQL)(type);
+    const safeDesc = (0, db_utils_1.escapeSQL)(description || `Admin ${type} credit grant`);
+    console.log(`Inserting ${amount} ${type} credits...`);
+    const ledgerId = bq(`INSERT INTO credit_ledger (id, user_id, type, description, initial_amount, remaining, created_at) VALUES (concat('crd_${safeType}_', substr(md5(random()::text), 1, 16)), '${safeUserId}', '${safeType}', '${safeDesc}', ${amount}, ${amount}, '${now}') RETURNING id`);
+    console.log(`✓ Credits granted (ledger ID: ${ledgerId})`);
+    const balance = bq(`SELECT COALESCE(SUM(remaining), 0) FROM credit_ledger WHERE user_id='${safeUserId}' AND remaining > 0 AND (expires_at IS NULL OR expires_at > NOW())`);
+    console.log(`\n✅ Done! ${email} now has ${balance} total credits\n`);
+}
+main().catch(error => {
+    console.error('\n❌ Error:', error.message);
+    process.exit(1);
+});

package/dist/bin/helpers/infisical-secrets.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchInfisicalSecret = fetchInfisicalSecret;
+const child_process_1 = require("child_process");
+const db_utils_1 = require("./db-utils");
+/**
+ * Fetch a single secret value from Infisical given env + path + name.
+ *
+ * env mapping: 'stage' → Infisical env slug 'staging'; 'prod' → 'prod'
+ * (matches dev-skills convention documented at
+ *  ~/.claude/projects/-mnt-d-work-projects-optima/memory/optima_infisical_env_naming.md).
+ *
+ * Returns the raw secretValue string. Throws if the secret is missing.
+ */
+function fetchInfisicalSecret(env, secretPath, secretName, config, token) {
+    const cfg = config ?? (0, db_utils_1.getInfisicalConfig)();
+    const tok = token ?? (0, db_utils_1.getInfisicalToken)(cfg);
+    const envSlug = env === 'stage' ? 'staging' : env;
+    const encodedPath = encodeURIComponent(secretPath);
+    const encodedName = encodeURIComponent(secretName);
+    const response = (0, child_process_1.execSync)(`curl -s "${cfg.url}/api/v3/secrets/raw/${encodedName}?workspaceId=${cfg.projectId}&environment=${envSlug}&secretPath=${encodedPath}" -H "Authorization: Bearer ${tok}"`, { encoding: 'utf-8' });
+    let parsed;
+    try {
+        parsed = JSON.parse(response);
+    }
+    catch {
+        throw new Error(`Infisical raw secret fetch returned non-JSON for ${secretPath}/${secretName} (${envSlug}): ${response.slice(0, 200)}`);
+    }
+    if (!parsed.secret?.secretValue) {
+        throw new Error(`Infisical secret not found: env=${envSlug} path=${secretPath} name=${secretName} (response: ${response.slice(0, 200)})`);
+    }
+    return parsed.secret.secretValue;
+}

package/dist/bin/helpers/product/add-channel.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAddChannel = runAddChannel;
+const billing_http_1 = require("../billing-http");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-product add-channel --key <productKey> --provider STRIPE --stripe-price-id <price_xxx> --price-cents N --currency USD [options]
+
+Required:
+  --key <productKey>
+  --provider STRIPE                v1 CLI accepts only STRIPE (schema supports more)
+  --stripe-price-id <price_xxx>    Pre-created in Stripe Dashboard; wire-mapped to externalProductId
+  --price-cents N                  MUST be > 0; should match Stripe Price's unit_amount (NOT verified)
+  --currency USD                   Should match Stripe Price's currency (NOT verified)
+
+Optional:
+  --enabled true|false             default: true
+  --metadata '<json>'
+  --env stage|prod                 (default: stage)`);
+        process.exit(0);
+    }
+    const out = { env: 'stage' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--key':
+                out.key = next;
+                i++;
+                break;
+            case '--provider':
+                out.provider = next;
+                i++;
+                break;
+            case '--stripe-price-id':
+                out.stripePriceId = next;
+                i++;
+                break;
+            case '--price-cents':
+                out.priceCents = parseInt(next, 10);
+                i++;
+                break;
+            case '--currency':
+                out.currency = next;
+                i++;
+                break;
+            case '--enabled':
+                out.enabled = next === 'true';
+                i++;
+                break;
+            case '--metadata':
+                out.metadata = JSON.parse(next);
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.key)
+        throw new Error('--key required');
+    if (!out.provider)
+        throw new Error('--provider required');
+    if (out.provider !== 'STRIPE')
+        throw new Error(`v1 CLI accepts only --provider STRIPE (got ${out.provider})`);
+    if (!out.stripePriceId)
+        throw new Error('--stripe-price-id required');
+    if (out.priceCents === undefined || !Number.isFinite(out.priceCents))
+        throw new Error('--price-cents required (integer)');
+    if (out.priceCents <= 0)
+        throw new Error('--price-cents must be > 0');
+    if (!out.currency)
+        throw new Error('--currency required');
+    return out;
+}
+async function runAddChannel(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    const body = {
+        provider: args.provider,
+        externalProductId: args.stripePriceId,
+        priceCents: args.priceCents,
+        currency: args.currency,
+    };
+    if (args.enabled !== undefined)
+        body.enabled = args.enabled;
+    if (args.metadata !== undefined)
+        body.metadata = args.metadata;
+    console.log(`\n💳 Adding ${args.provider} channel to ${args.key} on ${args.env.toUpperCase()}...`);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'POST', `/api/billing/admin/products/${encodeURIComponent(args.key)}/channels`, body);
+    console.log(`✓ Created Channel (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/product/create.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreate = runCreate;
+const billing_http_1 = require("../billing-http");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-product create --key <productKey> --plugins <slug1,slug2,...> --type <ProductType> [options]
+
+Required:
+  --key <productKey>             Unique slug
+  --plugins <slug1,slug2,...>    Comma-separated, >=1 plugin slug
+  --type <ProductType>           Only ONE_SHOT_SKILL accepted by v1 CLI policy
+
+Optional:
+  --name "..."                   Convenience flag, folded into metadata.name
+  --description "..."            Convenience flag, folded into metadata.description
+  --refund-window-days N
+  --refund-prorate-max-days N
+  --bundled-plan-id <planId>     (joint with --bundled-duration-days)
+  --bundled-duration-days N
+  --revoke-bundled-on-refund true|false
+  --metadata '<json>'            JSON object stored in product.metadata
+  --env stage|prod               (default: stage)`);
+        process.exit(0);
+    }
+    const out = { env: 'stage', revokeBundledOnRefund: undefined };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--key':
+                out.key = next;
+                i++;
+                break;
+            case '--plugins':
+                out.plugins = next.split(',').map((s) => s.trim()).filter(Boolean);
+                i++;
+                break;
+            case '--type':
+                out.type = next;
+                i++;
+                break;
+            case '--name':
+                out.name = next;
+                i++;
+                break;
+            case '--description':
+                out.description = next;
+                i++;
+                break;
+            case '--refund-window-days':
+                out.refundWindowDays = parseInt(next, 10);
+                i++;
+                break;
+            case '--refund-prorate-max-days':
+                out.refundProrateMaxDays = parseInt(next, 10);
+                i++;
+                break;
+            case '--bundled-plan-id':
+                out.bundledPlanId = next;
+                i++;
+                break;
+            case '--bundled-duration-days':
+                out.bundledDurationDays = parseInt(next, 10);
+                i++;
+                break;
+            case '--revoke-bundled-on-refund':
+                out.revokeBundledOnRefund = next === 'true';
+                i++;
+                break;
+            case '--metadata':
+                out.metadata = JSON.parse(next);
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.key)
+        throw new Error('--key required');
+    if (!out.plugins || out.plugins.length === 0)
+        throw new Error('--plugins required (>=1 slug)');
+    if (!out.type)
+        throw new Error('--type required');
+    if (out.type !== 'ONE_SHOT_SKILL') {
+        throw new Error(`v1 CLI accepts only --type ONE_SHOT_SKILL (got ${out.type}). See spec §5.1.`);
+    }
+    if ((out.bundledPlanId == null) !== (out.bundledDurationDays == null)) {
+        throw new Error('--bundled-plan-id and --bundled-duration-days must be set together');
+    }
+    return out;
+}
+async function runCreate(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    const body = {
+        productKey: args.key,
+        type: args.type,
+        pluginSlugs: args.plugins,
+    };
+    if (args.name !== undefined)
+        body.name = args.name;
+    if (args.description !== undefined)
+        body.description = args.description;
+    if (args.refundWindowDays !== undefined)
+        body.refundWindowDays = args.refundWindowDays;
+    if (args.refundProrateMaxDays !== undefined)
+        body.refundProrateMaxDays = args.refundProrateMaxDays;
+    if (args.bundledPlanId !== undefined)
+        body.bundledPlanId = args.bundledPlanId;
+    if (args.bundledDurationDays !== undefined)
+        body.bundledDurationDays = args.bundledDurationDays;
+    if (args.revokeBundledOnRefund !== undefined)
+        body.revokeBundledOnRefund = args.revokeBundledOnRefund;
+    if (args.metadata !== undefined)
+        body.metadata = args.metadata;
+    console.log(`\n🎁 Creating product ${args.key} (${args.plugins.length} plugin(s)) on ${args.env.toUpperCase()}...`);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'POST', '/api/billing/admin/products', body);
+    console.log(`✓ Created Product (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/product/show.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShow = runShow;
+const billing_http_1 = require("../billing-http");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-product show --key <productKey> [options]
+
+Required:
+  --key <productKey>
+
+Optional:
+  --env stage|prod                 (default: stage)
+
+Note: returns the bare Product row only — productPlugins and channels arrays
+are NOT included (billing's GET /api/internal/products/:key is a plain
+findUnique with no include). To inspect channels/plugins today, query the DB
+directly via optima-query-db. Tracked as follow-up in spec §7.`);
+        process.exit(0);
+    }
+    const out = { env: 'stage' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--key':
+                out.key = next;
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.key)
+        throw new Error('--key required');
+    return out;
+}
+async function runShow(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'GET', `/api/internal/products/${encodeURIComponent(args.key)}`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/product/toggle-channel.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runToggleChannel = runToggleChannel;
+const billing_http_1 = require("../billing-http");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-product toggle-channel --key <productKey> --provider STRIPE --enabled true|false [options]
+
+Required:
+  --key <productKey>
+  --provider STRIPE                v1 CLI accepts only STRIPE
+  --enabled true|false
+
+Optional:
+  --env stage|prod                 (default: stage)`);
+        process.exit(0);
+    }
+    const out = { env: 'stage' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = argv[i + 1];
+        switch (a) {
+            case '--key':
+                out.key = next;
+                i++;
+                break;
+            case '--provider':
+                out.provider = next;
+                i++;
+                break;
+            case '--enabled':
+                if (next !== 'true' && next !== 'false')
+                    throw new Error('--enabled must be true or false');
+                out.enabled = next === 'true';
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.key)
+        throw new Error('--key required');
+    if (!out.provider)
+        throw new Error('--provider required');
+    if (out.provider !== 'STRIPE')
+        throw new Error(`v1 CLI accepts only --provider STRIPE (got ${out.provider})`);
+    if (out.enabled === undefined)
+        throw new Error('--enabled required');
+    return out;
+}
+async function runToggleChannel(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    console.log(`\n🔁 Setting ${args.provider} channel enabled=${args.enabled} on ${args.key} (${args.env.toUpperCase()})...`);
+    const res = await (0, billing_http_1.callBilling)(args.env, 'PATCH', `/api/billing/admin/products/${encodeURIComponent(args.key)}/channels/${args.provider}`, { enabled: args.enabled });
+    console.log(`✓ Channel updated (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+}