pandora-cli-skills 1.1.32 → 1.1.33

package/cli/lib/command_router.cjs

@@ -131,6 +131,7 @@ function createCommandRouter(deps = {}) {
       suggest: async (handlerArgs, handlerContext) => runSuggestCommand(handlerArgs, handlerContext),
       resolve: async (handlerArgs, handlerContext) => runResolveCommand(handlerArgs, handlerContext),
       lp: async (handlerArgs, handlerContext) => runLpCommand(handlerArgs, handlerContext),
+      schema: async (handlerArgs, handlerContext) => deps.runSchemaCommand(handlerArgs, handlerContext),
       launch: async (handlerArgs, handlerContext) => {
         if (handlerContext.outputMode === 'json') {
           throw new CliError(

package/cli/lib/lp_command_service.cjs

@@ -0,0 +1,56 @@
+function requireDep(deps, name) {
+  if (!deps || typeof deps[name] !== 'function') {
+    throw new Error(`createRunLpCommand requires deps.${name}()`);
+  }
+  return deps[name];
+}
+
+/**
+ * Creates the `lp` command runner.
+ * @param {object} deps
+ * @returns {(args: string[], context: {outputMode: string}) => Promise<void>}
+ */
+function createRunLpCommand(deps) {
+  const includesHelpFlag = requireDep(deps, 'includesHelpFlag');
+  const emitSuccess = requireDep(deps, 'emitSuccess');
+  const commandHelpPayload = requireDep(deps, 'commandHelpPayload');
+  const parseLpFlags = requireDep(deps, 'parseLpFlags');
+  const runLp = requireDep(deps, 'runLp');
+  const renderSingleEntityTable = requireDep(deps, 'renderSingleEntityTable');
+  const CliError = requireDep(deps, 'CliError');
+
+  return async function runLpCommand(args, context) {
+    if (includesHelpFlag(args)) {
+      if (context.outputMode === 'json') {
+        emitSuccess(
+          context.outputMode,
+          'lp.help',
+          commandHelpPayload(
+            'pandora [--output table|json] lp add|remove|positions [--market-address <address>] [--wallet <address>] [--amount-usdc <n>] [--lp-tokens <n>] [--dry-run|--execute] [--chain-id <id>] [--rpc-url <url>] [--private-key <hex>] [--usdc <address>] [--deadline-seconds <n>] [--indexer-url <url>] [--timeout-ms <ms>]',
+          ),
+        );
+      } else {
+        // eslint-disable-next-line no-console
+        console.log(
+          'Usage: pandora [--output table|json] lp add|remove|positions [--market-address <address>] [--wallet <address>] [--amount-usdc <n>] [--lp-tokens <n>] [--dry-run|--execute] [--chain-id <id>] [--rpc-url <url>] [--private-key <hex>] [--usdc <address>] [--deadline-seconds <n>] [--indexer-url <url>] [--timeout-ms <ms>]',
+        );
+      }
+      return;
+    }
+    const options = parseLpFlags(args);
+    let payload;
+    try {
+      payload = await runLp(options);
+    } catch (err) {
+      if (err && err.code) {
+        throw new CliError(err.code, err.message || 'lp command failed.', err.details);
+      }
+      throw err;
+    }
+    emitSuccess(context.outputMode, 'lp', payload, renderSingleEntityTable);
+  };
+}
+
+module.exports = {
+  createRunLpCommand,
+};

package/cli/lib/parsers/lp_flags.cjs

@@ -0,0 +1,156 @@
+function requireDep(deps, name) {
+  if (!deps || typeof deps[name] !== 'function') {
+    throw new Error(`createParseLpFlags requires deps.${name}()`);
+  }
+  return deps[name];
+}
+
+function requireNumericDep(deps, name) {
+  const value = deps ? deps[name] : undefined;
+  if (!Number.isFinite(value)) {
+    throw new Error(`createParseLpFlags requires numeric deps.${name}`);
+  }
+  return value;
+}
+
+/**
+ * Creates parser for `lp add|remove|positions` command flags.
+ * @param {object} deps
+ * @returns {(args: string[]) => object}
+ */
+function createParseLpFlags(deps) {
+  const CliError = requireDep(deps, 'CliError');
+  const parseAddressFlag = requireDep(deps, 'parseAddressFlag');
+  const requireFlagValue = requireDep(deps, 'requireFlagValue');
+  const parsePositiveNumber = requireDep(deps, 'parsePositiveNumber');
+  const parseInteger = requireDep(deps, 'parseInteger');
+  const parsePositiveInteger = requireDep(deps, 'parsePositiveInteger');
+  const isValidPrivateKey = requireDep(deps, 'isValidPrivateKey');
+  const defaultTimeoutMs = requireNumericDep(deps, 'defaultTimeoutMs');
+
+  return function parseLpFlags(args) {
+    const action = args[0];
+    if (!action || !['add', 'remove', 'positions'].includes(action)) {
+      throw new CliError('INVALID_ARGS', 'lp requires subcommand add|remove|positions.');
+    }
+
+    const rest = args.slice(1);
+    const options = {
+      action,
+      marketAddress: null,
+      wallet: null,
+      amountUsdc: null,
+      lpTokens: null,
+      chainId: null,
+      dryRun: false,
+      execute: false,
+      rpcUrl: null,
+      privateKey: null,
+      usdc: null,
+      deadlineSeconds: 1800,
+      indexerUrl: null,
+      timeoutMs: defaultTimeoutMs,
+    };
+
+    for (let i = 0; i < rest.length; i += 1) {
+      const token = rest[i];
+      if (token === '--market-address') {
+        options.marketAddress = parseAddressFlag(requireFlagValue(rest, i, '--market-address'), '--market-address');
+        i += 1;
+        continue;
+      }
+      if (token === '--wallet') {
+        options.wallet = parseAddressFlag(requireFlagValue(rest, i, '--wallet'), '--wallet');
+        i += 1;
+        continue;
+      }
+      if (token === '--amount-usdc') {
+        options.amountUsdc = parsePositiveNumber(requireFlagValue(rest, i, '--amount-usdc'), '--amount-usdc');
+        i += 1;
+        continue;
+      }
+      if (token === '--lp-tokens') {
+        options.lpTokens = parsePositiveNumber(requireFlagValue(rest, i, '--lp-tokens'), '--lp-tokens');
+        i += 1;
+        continue;
+      }
+      if (token === '--chain-id') {
+        options.chainId = parseInteger(requireFlagValue(rest, i, '--chain-id'), '--chain-id');
+        i += 1;
+        continue;
+      }
+      if (token === '--rpc-url') {
+        options.rpcUrl = requireFlagValue(rest, i, '--rpc-url');
+        i += 1;
+        continue;
+      }
+      if (token === '--private-key') {
+        const value = requireFlagValue(rest, i, '--private-key');
+        if (!isValidPrivateKey(value)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--private-key must be 0x + 64 hex chars.');
+        }
+        options.privateKey = value;
+        i += 1;
+        continue;
+      }
+      if (token === '--usdc') {
+        options.usdc = parseAddressFlag(requireFlagValue(rest, i, '--usdc'), '--usdc');
+        i += 1;
+        continue;
+      }
+      if (token === '--deadline-seconds') {
+        options.deadlineSeconds = parsePositiveInteger(requireFlagValue(rest, i, '--deadline-seconds'), '--deadline-seconds');
+        if (options.deadlineSeconds < 60) {
+          throw new CliError('INVALID_FLAG_VALUE', '--deadline-seconds must be >= 60.');
+        }
+        i += 1;
+        continue;
+      }
+      if (token === '--indexer-url') {
+        options.indexerUrl = requireFlagValue(rest, i, '--indexer-url');
+        i += 1;
+        continue;
+      }
+      if (token === '--timeout-ms') {
+        options.timeoutMs = parsePositiveInteger(requireFlagValue(rest, i, '--timeout-ms'), '--timeout-ms');
+        i += 1;
+        continue;
+      }
+      if (token === '--dry-run') {
+        options.dryRun = true;
+        continue;
+      }
+      if (token === '--execute') {
+        options.execute = true;
+        continue;
+      }
+      throw new CliError('UNKNOWN_FLAG', `Unknown flag for lp ${action}: ${token}`);
+    }
+
+    if (action === 'positions') {
+      if (!options.wallet) {
+        throw new CliError('MISSING_REQUIRED_FLAG', 'Missing wallet address. Use --wallet <address>.');
+      }
+      return options;
+    }
+
+    if (!options.marketAddress) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing market address. Use --market-address <address>.');
+    }
+    if (action === 'add' && options.amountUsdc === null) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing liquidity amount. Use --amount-usdc <amount>.');
+    }
+    if (action === 'remove' && options.lpTokens === null) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing LP token amount. Use --lp-tokens <amount>.');
+    }
+    if (options.dryRun === options.execute) {
+      throw new CliError('INVALID_ARGS', 'Use exactly one mode: --dry-run or --execute.');
+    }
+
+    return options;
+  };
+}
+
+module.exports = {
+  createParseLpFlags,
+};

package/cli/lib/parsers/polymarket_flags.cjs

@@ -0,0 +1,242 @@
+function requireDep(deps, name) {
+  if (!deps || typeof deps[name] !== 'function') {
+    throw new Error(`Polymarket parser factory requires deps.${name}()`);
+  }
+  return deps[name];
+}
+
+function requireNumericDep(deps, name) {
+  const value = deps ? deps[name] : undefined;
+  if (!Number.isFinite(value)) {
+    throw new Error(`Polymarket parser factory requires numeric deps.${name}`);
+  }
+  return value;
+}
+
+/**
+ * Creates parser for shared polymarket auth/network flags.
+ * @param {object} deps
+ * @returns {(args: string[], actionLabel: string) => object}
+ */
+function createParsePolymarketSharedFlags(deps) {
+  const CliError = requireDep(deps, 'CliError');
+  const requireFlagValue = requireDep(deps, 'requireFlagValue');
+  const parseAddressFlag = requireDep(deps, 'parseAddressFlag');
+  const isValidPrivateKey = requireDep(deps, 'isValidPrivateKey');
+  const isSecureHttpUrlOrLocal = requireDep(deps, 'isSecureHttpUrlOrLocal');
+
+  return function parsePolymarketSharedFlags(args, actionLabel) {
+    const options = {
+      rpcUrl: null,
+      privateKey: null,
+      funder: null,
+    };
+
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i];
+      if (token === '--rpc-url') {
+        const rpcUrl = requireFlagValue(args, i, '--rpc-url');
+        if (!isSecureHttpUrlOrLocal(rpcUrl)) {
+          throw new CliError(
+            'INVALID_FLAG_VALUE',
+            '--rpc-url must use https:// (or http://localhost/127.0.0.1 for local testing).',
+          );
+        }
+        options.rpcUrl = rpcUrl;
+        i += 1;
+        continue;
+      }
+      if (token === '--private-key') {
+        const value = requireFlagValue(args, i, '--private-key');
+        if (!isValidPrivateKey(value)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--private-key must be 0x + 64 hex chars.');
+        }
+        options.privateKey = value;
+        i += 1;
+        continue;
+      }
+      if (token === '--funder') {
+        options.funder = parseAddressFlag(requireFlagValue(args, i, '--funder'), '--funder');
+        i += 1;
+        continue;
+      }
+      throw new CliError('UNKNOWN_FLAG', `Unknown flag for polymarket ${actionLabel}: ${token}`);
+    }
+
+    return options;
+  };
+}
+
+/**
+ * Creates parser for `polymarket approve`.
+ * @param {object} deps
+ * @returns {(args: string[]) => object}
+ */
+function createParsePolymarketApproveFlags(deps) {
+  const CliError = requireDep(deps, 'CliError');
+  const parsePolymarketSharedFlags = requireDep(deps, 'parsePolymarketSharedFlags');
+
+  return function parsePolymarketApproveFlags(args) {
+    const options = {
+      dryRun: false,
+      execute: false,
+      rpcUrl: null,
+      privateKey: null,
+      funder: null,
+    };
+
+    const sharedArgs = [];
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i];
+      if (token === '--dry-run') {
+        options.dryRun = true;
+        continue;
+      }
+      if (token === '--execute') {
+        options.execute = true;
+        continue;
+      }
+      sharedArgs.push(token);
+    }
+
+    if (options.dryRun === options.execute) {
+      throw new CliError('INVALID_ARGS', 'polymarket approve requires exactly one mode: --dry-run or --execute.');
+    }
+
+    const shared = parsePolymarketSharedFlags(sharedArgs, 'approve');
+    options.rpcUrl = shared.rpcUrl;
+    options.privateKey = shared.privateKey;
+    options.funder = shared.funder;
+    return options;
+  };
+}
+
+/**
+ * Creates parser for `polymarket trade`.
+ * @param {object} deps
+ * @returns {(args: string[]) => object}
+ */
+function createParsePolymarketTradeFlags(deps) {
+  const CliError = requireDep(deps, 'CliError');
+  const requireFlagValue = requireDep(deps, 'requireFlagValue');
+  const parsePositiveNumber = requireDep(deps, 'parsePositiveNumber');
+  const parsePositiveInteger = requireDep(deps, 'parsePositiveInteger');
+  const parsePolymarketSharedFlags = requireDep(deps, 'parsePolymarketSharedFlags');
+  const isSecureHttpUrlOrLocal = requireDep(deps, 'isSecureHttpUrlOrLocal');
+  const defaultTimeoutMs = requireNumericDep(deps, 'defaultTimeoutMs');
+
+  return function parsePolymarketTradeFlags(args) {
+    const options = {
+      conditionId: null,
+      slug: null,
+      token: null,
+      tokenId: null,
+      side: 'buy',
+      amountUsdc: null,
+      dryRun: false,
+      execute: false,
+      host: null,
+      timeoutMs: defaultTimeoutMs,
+      rpcUrl: null,
+      privateKey: null,
+      funder: null,
+    };
+
+    const sharedArgs = [];
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i];
+      if (token === '--condition-id' || token === '--market-id') {
+        options.conditionId = requireFlagValue(args, i, token);
+        i += 1;
+        continue;
+      }
+      if (token === '--slug') {
+        options.slug = requireFlagValue(args, i, '--slug');
+        i += 1;
+        continue;
+      }
+      if (token === '--token') {
+        const value = String(requireFlagValue(args, i, '--token')).trim().toLowerCase();
+        if (!['yes', 'no'].includes(value)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--token must be yes|no.');
+        }
+        options.token = value;
+        i += 1;
+        continue;
+      }
+      if (token === '--token-id') {
+        options.tokenId = requireFlagValue(args, i, '--token-id');
+        i += 1;
+        continue;
+      }
+      if (token === '--side') {
+        const value = String(requireFlagValue(args, i, '--side')).trim().toLowerCase();
+        if (!['buy', 'sell'].includes(value)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--side must be buy|sell.');
+        }
+        options.side = value;
+        i += 1;
+        continue;
+      }
+      if (token === '--amount-usdc') {
+        options.amountUsdc = parsePositiveNumber(requireFlagValue(args, i, '--amount-usdc'), '--amount-usdc');
+        i += 1;
+        continue;
+      }
+      if (token === '--polymarket-host') {
+        const host = requireFlagValue(args, i, '--polymarket-host');
+        if (!isSecureHttpUrlOrLocal(host)) {
+          throw new CliError(
+            'INVALID_FLAG_VALUE',
+            '--polymarket-host must use https:// (or http://localhost/127.0.0.1 for local testing).',
+          );
+        }
+        options.host = host;
+        i += 1;
+        continue;
+      }
+      if (token === '--timeout-ms') {
+        options.timeoutMs = parsePositiveInteger(requireFlagValue(args, i, '--timeout-ms'), '--timeout-ms');
+        i += 1;
+        continue;
+      }
+      if (token === '--dry-run') {
+        options.dryRun = true;
+        continue;
+      }
+      if (token === '--execute') {
+        options.execute = true;
+        continue;
+      }
+      sharedArgs.push(token);
+    }
+
+    if (options.dryRun === options.execute) {
+      throw new CliError('INVALID_ARGS', 'polymarket trade requires exactly one mode: --dry-run or --execute.');
+    }
+    if (options.amountUsdc === null) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing --amount-usdc <amount>.');
+    }
+    if (!options.tokenId && !options.token) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Provide --token yes|no (or --token-id <id>).');
+    }
+    if (!options.tokenId && !options.conditionId && !options.slug) {
+      throw new CliError(
+        'MISSING_REQUIRED_FLAG',
+        'Provide --condition-id <id> or --slug <slug> when --token-id is not set.',
+      );
+    }
+
+    const shared = parsePolymarketSharedFlags(sharedArgs, 'trade');
+    options.rpcUrl = shared.rpcUrl;
+    options.privateKey = shared.privateKey;
+    options.funder = shared.funder;
+    return options;
+  };
+}
+
+module.exports = {
+  createParsePolymarketSharedFlags,
+  createParsePolymarketApproveFlags,
+  createParsePolymarketTradeFlags,
+};

package/cli/lib/parsers/resolve_flags.cjs

@@ -0,0 +1,102 @@
+function requireDep(deps, name) {
+  if (!deps || typeof deps[name] !== 'function') {
+    throw new Error(`createParseResolveFlags requires deps.${name}()`);
+  }
+  return deps[name];
+}
+
+/**
+ * Creates the resolve command flags parser.
+ * @param {object} deps
+ * @returns {(args: string[]) => object}
+ */
+function createParseResolveFlags(deps) {
+  const CliError = requireDep(deps, 'CliError');
+  const parseAddressFlag = requireDep(deps, 'parseAddressFlag');
+  const requireFlagValue = requireDep(deps, 'requireFlagValue');
+  const parseInteger = requireDep(deps, 'parseInteger');
+  const isValidPrivateKey = requireDep(deps, 'isValidPrivateKey');
+
+  return function parseResolveFlags(args) {
+    const options = {
+      pollAddress: null,
+      answer: null,
+      reason: null,
+      dryRun: false,
+      execute: false,
+      chainId: null,
+      rpcUrl: null,
+      privateKey: null,
+    };
+
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i];
+      if (token === '--poll-address') {
+        options.pollAddress = parseAddressFlag(requireFlagValue(args, i, '--poll-address'), '--poll-address');
+        i += 1;
+        continue;
+      }
+      if (token === '--answer') {
+        const answer = requireFlagValue(args, i, '--answer').toLowerCase();
+        if (!['yes', 'no', 'invalid'].includes(answer)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--answer must be yes|no|invalid.');
+        }
+        options.answer = answer;
+        i += 1;
+        continue;
+      }
+      if (token === '--reason') {
+        options.reason = requireFlagValue(args, i, '--reason');
+        i += 1;
+        continue;
+      }
+      if (token === '--dry-run') {
+        options.dryRun = true;
+        continue;
+      }
+      if (token === '--execute') {
+        options.execute = true;
+        continue;
+      }
+      if (token === '--chain-id') {
+        options.chainId = parseInteger(requireFlagValue(args, i, '--chain-id'), '--chain-id');
+        i += 1;
+        continue;
+      }
+      if (token === '--rpc-url') {
+        options.rpcUrl = requireFlagValue(args, i, '--rpc-url');
+        i += 1;
+        continue;
+      }
+      if (token === '--private-key') {
+        const value = requireFlagValue(args, i, '--private-key');
+        if (!isValidPrivateKey(value)) {
+          throw new CliError('INVALID_FLAG_VALUE', '--private-key must be 0x + 64 hex chars.');
+        }
+        options.privateKey = value;
+        i += 1;
+        continue;
+      }
+      throw new CliError('UNKNOWN_FLAG', `Unknown flag for resolve: ${token}`);
+    }
+
+    if (!options.pollAddress) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing poll address. Use --poll-address <address>.');
+    }
+    if (!options.answer) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing answer. Use --answer yes|no|invalid.');
+    }
+    if (!options.reason) {
+      throw new CliError('MISSING_REQUIRED_FLAG', 'Missing reason. Use --reason <text>.');
+    }
+    if (options.dryRun === options.execute) {
+      throw new CliError('INVALID_ARGS', 'Use exactly one mode: --dry-run or --execute.');
+    }
+
+    return options;
+  };
+}
+
+module.exports = {
+  createParseResolveFlags,
+};