@optima-chat/dev-skills 0.7.35 → 0.7.36

package/AGENTS.md

@@ -13,6 +13,7 @@ Prefer the installed CLI tools over reimplementing long shell workflows:
 - `optima-grant-balance <email> --amount <usd> [options]`
 - `optima-product <create|update|add-channel|toggle-channel|show> [options]` — manage paid-plugin marketplace Products + Stripe channels (Wave 1.5 admin endpoints; stage default)
 - `optima-entitlement <grant|revoke|list> [options]` — admin-grant / revoke / list paid-plugin entitlements (refuses revoke of PAYMENT / PARTNER source)
+- `optima-plugin <show|set-paid|set-default> [options]` — flip a plugin's skills-side paid/free state (isPaid) + defaultForUser (the user-facing gate; pairs with optima-product for the billing side)
 
 For code-reading tasks across Optima repositories, use `gh` commands against `Optima-Chat/<repo>`.
 

package/bin/helpers/billing-http.ts

@@ -43,6 +43,7 @@ const DEV_SKILLS_CLIENT_SECRET_KEY = 'DEV_SKILLS_OAUTH_CLIENT_SECRET';
 //     retry; any transient failure surfaces immediately. Re-run the CLI.
 const tokenCache: Record<string, string> = {};
 const billingUrlCache: Record<string, string> = {};
+const skillsUrlCache: Record<string, string> = {};
 
 function getBillingUrl(env: string): string {
   if (billingUrlCache[env]) return billingUrlCache[env];
@@ -51,6 +52,13 @@ function getBillingUrl(env: string): string {
   return url;
 }
 
+function getSkillsUrl(env: string): string {
+  if (skillsUrlCache[env]) return skillsUrlCache[env];
+  const url = fetchInfisicalSecret(env, '/shared-secrets/domain-urls', 'SKILLS_REGISTRY_URL');
+  skillsUrlCache[env] = url;
+  return url;
+}
+
 export function getServiceToken(env: string): string {
   if (tokenCache[env]) return tokenCache[env];
 
@@ -89,7 +97,7 @@ interface BillingErrorEnvelope {
   code?: string;
 }
 
-function formatBillingError(status: number, statusText: string, body: string): string {
+function formatServiceError(status: number, statusText: string, body: string): string {
   let parsed: BillingErrorEnvelope | null = null;
   try { parsed = JSON.parse(body); } catch { /* non-JSON */ }
 
@@ -114,24 +122,25 @@ function formatBillingError(status: number, statusText: string, body: string): s
   return `❌ Error [${status}] ${statusText}\n   Response body (first 500 bytes): ${body.slice(0, 500)}`;
 }
 
-// ───── Public: callBilling ──────────────────────────────────────────────────
-export interface BillingResponse<T> {
+// ───── Public: callService / callBilling / callSkills ───────────────────────
+export interface ServiceResponse<T> {
   status: number;
   body: T;
 }
 
 /**
- * Make an authenticated call to optima-billing. Returns `{status, body}` on
- * 2xx; throws Error with formatted message on non-2xx. Single retry on 5xx
- * (one-shot — no exponential backoff; admin CLI doesn't justify it).
+ * Authenticated call to an Optima service (billing or skills — same dev-skills
+ * M2M token works for both). Returns `{status, body}` on 2xx; throws Error with
+ * formatted message on non-2xx. Single retry on 5xx (no backoff — admin CLI).
  */
-export async function callBilling<T = unknown>(
+async function callService<T>(
+  baseUrl: string,
   env: string,
   method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE',
   path: string,
   body?: object,
-): Promise<BillingResponse<T>> {
-  const url = `${getBillingUrl(env)}${path}`;
+): Promise<ServiceResponse<T>> {
+  const url = `${baseUrl}${path}`;
   const token = getServiceToken(env);
 
   const doFetch = async () => fetch(url, {
@@ -145,18 +154,38 @@ export async function callBilling<T = unknown>(
 
   let res = await doFetch();
   if (res.status >= 500) {
-    // One retry on 5xx
     res = await doFetch();
   }
   const text = await res.text();
   if (!res.ok) {
-    throw new Error(formatBillingError(res.status, res.statusText, text));
+    throw new Error(formatServiceError(res.status, res.statusText, text));
   }
   let parsed: T;
   try {
     parsed = text ? (JSON.parse(text) as T) : (undefined as unknown as T);
   } catch {
-    throw new Error(`Billing returned non-JSON 2xx body: ${text.slice(0, 200)}`);
+    throw new Error(`Service returned non-JSON 2xx body: ${text.slice(0, 200)}`);
   }
   return { status: res.status, body: parsed };
 }
+
+/** Kept as an alias for billing-side callers that reference the response type. */
+export interface BillingResponse<T> extends ServiceResponse<T> {}
+
+export async function callBilling<T = unknown>(
+  env: string,
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE',
+  path: string,
+  body?: object,
+): Promise<ServiceResponse<T>> {
+  return callService<T>(getBillingUrl(env), env, method, path, body);
+}
+
+export async function callSkills<T = unknown>(
+  env: string,
+  method: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE',
+  path: string,
+  body?: object,
+): Promise<ServiceResponse<T>> {
+  return callService<T>(getSkillsUrl(env), env, method, path, body);
+}

package/bin/helpers/plugin/set-default.ts

@@ -0,0 +1,65 @@
+import { callSkills, validateEnv } from '../billing-http';
+import { confirmIfProd } from '../confirm-prompt';
+
+interface SetDefaultArgs {
+  slug: string;
+  default: boolean;
+  yes: boolean;
+  env: string;
+}
+
+function parseArgs(argv: string[]): SetDefaultArgs {
+  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+    console.log(`Usage: optima-plugin set-default --slug <slug> --default true|false [options]
+
+Required:
+  --slug <slug>
+  --default true|false   Sets Plugin.defaultForUser
+
+Optional:
+  --yes                  Skip prod confirmation prompt (no-op on stage)
+  --env stage|prod       (default: stage)
+
+Note: no skill-sync broadcast — changes what NEW user syncs receive; does not
+retroactively add/remove the plugin for existing users until their next sync.`);
+    process.exit(0);
+  }
+  const out: Partial<SetDefaultArgs> = { env: 'stage', yes: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = argv[i + 1];
+    switch (a) {
+      case '--slug': out.slug = next; i++; break;
+      case '--default':
+        if (next !== 'true' && next !== 'false') throw new Error('--default must be true or false');
+        out.default = next === 'true'; i++; break;
+      case '--yes': out.yes = true; break;
+      case '--env': out.env = next; i++; break;
+      default: throw new Error(`Unknown arg: ${a}`);
+    }
+  }
+  if (!out.slug) throw new Error('--slug required');
+  if (out.default === undefined) throw new Error('--default required (true|false)');
+  return out as SetDefaultArgs;
+}
+
+export async function runSetDefault(argv: string[]): Promise<void> {
+  const args = parseArgs(argv);
+  validateEnv(args.env);
+
+  await confirmIfProd(
+    args.env,
+    `Action: set defaultForUser=${args.default} on plugin '${args.slug}' (${args.env.toUpperCase()})`,
+    args.yes,
+  );
+
+  console.log(`\n🔧 Setting defaultForUser=${args.default} on ${args.slug} (${args.env.toUpperCase()})...`);
+  const res = await callSkills(
+    args.env,
+    'PATCH',
+    `/api/admin/plugins/${encodeURIComponent(args.slug)}`,
+    { defaultForUser: args.default },
+  );
+  console.log(`✓ Updated plugin (HTTP ${res.status}):`);
+  console.log(JSON.stringify(res.body, null, 2));
+}

package/bin/helpers/plugin/set-paid.ts

@@ -0,0 +1,69 @@
+import { callSkills, validateEnv } from '../billing-http';
+import { confirmIfProd } from '../confirm-prompt';
+
+interface SetPaidArgs {
+  slug: string;
+  paid: boolean;
+  yes: boolean;
+  env: string;
+}
+
+function parseArgs(argv: string[]): SetPaidArgs {
+  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+    console.log(`Usage: optima-plugin set-paid --slug <slug> --paid true|false [options]
+
+Required:
+  --slug <slug>
+  --paid true|false    Sets Plugin.isPaid (the user-facing paid/free gate)
+
+Optional:
+  --yes                Skip prod confirmation prompt (no-op on stage)
+  --env stage|prod     (default: stage)
+
+Note: salesUrl is NOT settable here (skills PATCH is strict; salesUrl is
+publish-time-only via plugin.json metadata). When isPaid=true and salesUrl is
+null, the 402 falls back to sales.optima.onl.`);
+    process.exit(0);
+  }
+  const out: Partial<SetPaidArgs> = { env: 'stage', yes: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = argv[i + 1];
+    switch (a) {
+      case '--slug': out.slug = next; i++; break;
+      case '--paid':
+        if (next !== 'true' && next !== 'false') throw new Error('--paid must be true or false');
+        out.paid = next === 'true'; i++; break;
+      case '--yes': out.yes = true; break;
+      case '--env': out.env = next; i++; break;
+      default: throw new Error(`Unknown arg: ${a}`);
+    }
+  }
+  if (!out.slug) throw new Error('--slug required');
+  if (out.paid === undefined) throw new Error('--paid required (true|false)');
+  return out as SetPaidArgs;
+}
+
+export async function runSetPaid(argv: string[]): Promise<void> {
+  const args = parseArgs(argv);
+  validateEnv(args.env);
+
+  await confirmIfProd(
+    args.env,
+    `Action: set isPaid=${args.paid} on plugin '${args.slug}' (${args.env.toUpperCase()})`,
+    args.yes,
+  );
+
+  console.log(`\n💰 Setting isPaid=${args.paid} on ${args.slug} (${args.env.toUpperCase()})...`);
+  const res = await callSkills(
+    args.env,
+    'PATCH',
+    `/api/admin/plugins/${encodeURIComponent(args.slug)}`,
+    { isPaid: args.paid },
+  );
+  console.log(`✓ Updated plugin (HTTP ${res.status}):`);
+  console.log(JSON.stringify(res.body, null, 2));
+  if (args.paid) {
+    console.log(`\nℹ️  Reminder: ensure a billing Product + channel exists for '${args.slug}' (optima-product) or users will 402 with no purchase path. salesUrl is publish-time-only (currently shown above).`);
+  }
+}

package/bin/helpers/plugin/show.ts

@@ -0,0 +1,42 @@
+import { callSkills, validateEnv } from '../billing-http';
+
+interface ShowArgs {
+  slug: string;
+  env: string;
+}
+
+function parseArgs(argv: string[]): ShowArgs {
+  if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+    console.log(`Usage: optima-plugin show --slug <slug> [options]
+
+Required:
+  --slug <slug>
+
+Optional:
+  --env stage|prod   (default: stage)
+
+Note: reads the public GET /api/plugins/:slug — shows isPaid, salesUrl, and
+descriptive fields, but NOT defaultForUser / status / trustLevel (public
+endpoint omits them). Returns 404 for non-ACTIVE plugins.`);
+    process.exit(0);
+  }
+  const out: Partial<ShowArgs> = { env: 'stage' };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = argv[i + 1];
+    switch (a) {
+      case '--slug': out.slug = next; i++; break;
+      case '--env': out.env = next; i++; break;
+      default: throw new Error(`Unknown arg: ${a}`);
+    }
+  }
+  if (!out.slug) throw new Error('--slug required');
+  return out as ShowArgs;
+}
+
+export async function runShow(argv: string[]): Promise<void> {
+  const args = parseArgs(argv);
+  validateEnv(args.env);
+  const res = await callSkills(args.env, 'GET', `/api/plugins/${encodeURIComponent(args.slug)}`);
+  console.log(JSON.stringify(res.body, null, 2));
+}

package/bin/helpers/plugin.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import { runShow } from './plugin/show';
+import { runSetPaid } from './plugin/set-paid';
+import { runSetDefault } from './plugin/set-default';
+
+function printHelp() {
+  console.log(`Usage: optima-plugin <subcommand> [options]
+
+Subcommands:
+  show          Show a plugin's marketplace state (isPaid, salesUrl, ... ACTIVE plugins only)
+  set-paid      Flip a plugin's isPaid flag (the user-facing paid/free gate)
+  set-default   Flip a plugin's defaultForUser flag
+
+Run 'optima-plugin <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 'show': await runShow(rest); break;
+    case 'set-paid': await runSetPaid(rest); break;
+    case 'set-default': await runSetDefault(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/billing-http.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateEnv = validateEnv;
 exports.getServiceToken = getServiceToken;
 exports.callBilling = callBilling;
+exports.callSkills = callSkills;
 const child_process_1 = require("child_process");
 const infisical_secrets_1 = require("./infisical-secrets");
 const db_utils_1 = require("./db-utils");
@@ -44,6 +45,7 @@ const DEV_SKILLS_CLIENT_SECRET_KEY = 'DEV_SKILLS_OAUTH_CLIENT_SECRET';
 //     retry; any transient failure surfaces immediately. Re-run the CLI.
 const tokenCache = {};
 const billingUrlCache = {};
+const skillsUrlCache = {};
 function getBillingUrl(env) {
     if (billingUrlCache[env])
         return billingUrlCache[env];
@@ -51,6 +53,13 @@ function getBillingUrl(env) {
     billingUrlCache[env] = url;
     return url;
 }
+function getSkillsUrl(env) {
+    if (skillsUrlCache[env])
+        return skillsUrlCache[env];
+    const url = (0, infisical_secrets_1.fetchInfisicalSecret)(env, '/shared-secrets/domain-urls', 'SKILLS_REGISTRY_URL');
+    skillsUrlCache[env] = url;
+    return url;
+}
 function getServiceToken(env) {
     if (tokenCache[env])
         return tokenCache[env];
@@ -77,7 +86,7 @@ function getServiceToken(env) {
     tokenCache[env] = parsed.access_token;
     return parsed.access_token;
 }
-function formatBillingError(status, statusText, body) {
+function formatServiceError(status, statusText, body) {
     let parsed = null;
     try {
         parsed = JSON.parse(body);
@@ -104,12 +113,12 @@ function formatBillingError(status, statusText, body) {
     return `❌ Error [${status}] ${statusText}\n   Response body (first 500 bytes): ${body.slice(0, 500)}`;
 }
 /**
- * Make an authenticated call to optima-billing. Returns `{status, body}` on
- * 2xx; throws Error with formatted message on non-2xx. Single retry on 5xx
- * (one-shot — no exponential backoff; admin CLI doesn't justify it).
+ * Authenticated call to an Optima service (billing or skills — same dev-skills
+ * M2M token works for both). Returns `{status, body}` on 2xx; throws Error with
+ * formatted message on non-2xx. Single retry on 5xx (no backoff — admin CLI).
  */
-async function callBilling(env, method, path, body) {
-    const url = `${getBillingUrl(env)}${path}`;
+async function callService(baseUrl, env, method, path, body) {
+    const url = `${baseUrl}${path}`;
     const token = getServiceToken(env);
     const doFetch = async () => fetch(url, {
         method,
@@ -121,19 +130,24 @@ async function callBilling(env, method, path, body) {
     });
     let res = await doFetch();
     if (res.status >= 500) {
-        // One retry on 5xx
         res = await doFetch();
     }
     const text = await res.text();
     if (!res.ok) {
-        throw new Error(formatBillingError(res.status, res.statusText, text));
+        throw new Error(formatServiceError(res.status, res.statusText, text));
     }
     let parsed;
     try {
         parsed = text ? JSON.parse(text) : undefined;
     }
     catch {
-        throw new Error(`Billing returned non-JSON 2xx body: ${text.slice(0, 200)}`);
+        throw new Error(`Service returned non-JSON 2xx body: ${text.slice(0, 200)}`);
     }
     return { status: res.status, body: parsed };
 }
+async function callBilling(env, method, path, body) {
+    return callService(getBillingUrl(env), env, method, path, body);
+}
+async function callSkills(env, method, path, body) {
+    return callService(getSkillsUrl(env), env, method, path, body);
+}

package/dist/bin/helpers/plugin/set-default.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetDefault = runSetDefault;
+const billing_http_1 = require("../billing-http");
+const confirm_prompt_1 = require("../confirm-prompt");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-plugin set-default --slug <slug> --default true|false [options]
+
+Required:
+  --slug <slug>
+  --default true|false   Sets Plugin.defaultForUser
+
+Optional:
+  --yes                  Skip prod confirmation prompt (no-op on stage)
+  --env stage|prod       (default: stage)
+
+Note: no skill-sync broadcast — changes what NEW user syncs receive; does not
+retroactively add/remove the plugin for existing users until their next sync.`);
+        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 '--slug':
+                out.slug = next;
+                i++;
+                break;
+            case '--default':
+                if (next !== 'true' && next !== 'false')
+                    throw new Error('--default must be true or false');
+                out.default = next === 'true';
+                i++;
+                break;
+            case '--yes':
+                out.yes = true;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.slug)
+        throw new Error('--slug required');
+    if (out.default === undefined)
+        throw new Error('--default required (true|false)');
+    return out;
+}
+async function runSetDefault(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    await (0, confirm_prompt_1.confirmIfProd)(args.env, `Action: set defaultForUser=${args.default} on plugin '${args.slug}' (${args.env.toUpperCase()})`, args.yes);
+    console.log(`\n🔧 Setting defaultForUser=${args.default} on ${args.slug} (${args.env.toUpperCase()})...`);
+    const res = await (0, billing_http_1.callSkills)(args.env, 'PATCH', `/api/admin/plugins/${encodeURIComponent(args.slug)}`, { defaultForUser: args.default });
+    console.log(`✓ Updated plugin (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/plugin/set-paid.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetPaid = runSetPaid;
+const billing_http_1 = require("../billing-http");
+const confirm_prompt_1 = require("../confirm-prompt");
+function parseArgs(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.log(`Usage: optima-plugin set-paid --slug <slug> --paid true|false [options]
+
+Required:
+  --slug <slug>
+  --paid true|false    Sets Plugin.isPaid (the user-facing paid/free gate)
+
+Optional:
+  --yes                Skip prod confirmation prompt (no-op on stage)
+  --env stage|prod     (default: stage)
+
+Note: salesUrl is NOT settable here (skills PATCH is strict; salesUrl is
+publish-time-only via plugin.json metadata). When isPaid=true and salesUrl is
+null, the 402 falls back to sales.optima.onl.`);
+        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 '--slug':
+                out.slug = next;
+                i++;
+                break;
+            case '--paid':
+                if (next !== 'true' && next !== 'false')
+                    throw new Error('--paid must be true or false');
+                out.paid = next === 'true';
+                i++;
+                break;
+            case '--yes':
+                out.yes = true;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.slug)
+        throw new Error('--slug required');
+    if (out.paid === undefined)
+        throw new Error('--paid required (true|false)');
+    return out;
+}
+async function runSetPaid(argv) {
+    const args = parseArgs(argv);
+    (0, billing_http_1.validateEnv)(args.env);
+    await (0, confirm_prompt_1.confirmIfProd)(args.env, `Action: set isPaid=${args.paid} on plugin '${args.slug}' (${args.env.toUpperCase()})`, args.yes);
+    console.log(`\n💰 Setting isPaid=${args.paid} on ${args.slug} (${args.env.toUpperCase()})...`);
+    const res = await (0, billing_http_1.callSkills)(args.env, 'PATCH', `/api/admin/plugins/${encodeURIComponent(args.slug)}`, { isPaid: args.paid });
+    console.log(`✓ Updated plugin (HTTP ${res.status}):`);
+    console.log(JSON.stringify(res.body, null, 2));
+    if (args.paid) {
+        console.log(`\nℹ️  Reminder: ensure a billing Product + channel exists for '${args.slug}' (optima-product) or users will 402 with no purchase path. salesUrl is publish-time-only (currently shown above).`);
+    }
+}

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

@@ -0,0 +1,45 @@
+"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-plugin show --slug <slug> [options]
+
+Required:
+  --slug <slug>
+
+Optional:
+  --env stage|prod   (default: stage)
+
+Note: reads the public GET /api/plugins/:slug — shows isPaid, salesUrl, and
+descriptive fields, but NOT defaultForUser / status / trustLevel (public
+endpoint omits them). Returns 404 for non-ACTIVE plugins.`);
+        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 '--slug':
+                out.slug = next;
+                i++;
+                break;
+            case '--env':
+                out.env = next;
+                i++;
+                break;
+            default: throw new Error(`Unknown arg: ${a}`);
+        }
+    }
+    if (!out.slug)
+        throw new Error('--slug 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.callSkills)(args.env, 'GET', `/api/plugins/${encodeURIComponent(args.slug)}`);
+    console.log(JSON.stringify(res.body, null, 2));
+}

package/dist/bin/helpers/plugin.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const show_1 = require("./plugin/show");
+const set_paid_1 = require("./plugin/set-paid");
+const set_default_1 = require("./plugin/set-default");
+function printHelp() {
+    console.log(`Usage: optima-plugin <subcommand> [options]
+
+Subcommands:
+  show          Show a plugin's marketplace state (isPaid, salesUrl, ... ACTIVE plugins only)
+  set-paid      Flip a plugin's isPaid flag (the user-facing paid/free gate)
+  set-default   Flip a plugin's defaultForUser flag
+
+Run 'optima-plugin <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 'show':
+            await (0, show_1.runShow)(rest);
+            break;
+        case 'set-paid':
+            await (0, set_paid_1.runSetPaid)(rest);
+            break;
+        case 'set-default':
+            await (0, set_default_1.runSetDefault)(rest);
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main().catch((err) => { console.error(err.message); process.exit(1); });