sharetribe-cli 1.15.0

package/src/commands/search/index.ts

@@ -0,0 +1,254 @@
+/**
+ * Search command - manage search schemas
+ */
+
+import { Command } from 'commander';
+import {
+  listSearchSchemas as sdkListSearchSchemas,
+  setSearchSchema as sdkSetSearchSchema,
+  unsetSearchSchema as sdkUnsetSearchSchema,
+} from 'sharetribe-flex-build-sdk';
+import { printTable, printError } from '../../util/output.js';
+
+interface SetSchemaOptions {
+  key: string;
+  scope: string;
+  type: string;
+  doc?: string;
+  default?: string;
+  schemaFor?: string;
+}
+
+interface UnsetSchemaOptions {
+  key: string;
+  scope: string;
+  schemaFor?: string;
+}
+
+/**
+ * Scope label mapping
+ */
+const SCOPE_LABELS: Record<string, string> = {
+  metadata: 'Metadata',
+  private: 'Private data',
+  protected: 'Protected data',
+  public: 'Public data',
+};
+
+/**
+ * Sets a search schema field
+ */
+async function setSearchSchema(marketplace: string, opts: SetSchemaOptions): Promise<void> {
+  try {
+    await sdkSetSearchSchema(undefined, marketplace, {
+      key: opts.key,
+      scope: opts.scope,
+      type: opts.type,
+      doc: opts.doc,
+      defaultValue: opts.default,
+      schemaFor: opts.schemaFor,
+    });
+
+    const schemaFor = opts.schemaFor || 'listing';
+    const scopeLabel = SCOPE_LABELS[opts.scope] || opts.scope;
+    console.log(`${scopeLabel} schema, ${opts.key} is successfully set for ${schemaFor}.`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to set search schema');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Unsets a search schema field
+ */
+async function unsetSearchSchema(marketplace: string, opts: UnsetSchemaOptions): Promise<void> {
+  try {
+    await sdkUnsetSearchSchema(undefined, marketplace, {
+      key: opts.key,
+      scope: opts.scope,
+      schemaFor: opts.schemaFor,
+    });
+
+    const schemaFor = opts.schemaFor || 'listing';
+    const scopeLabel = SCOPE_LABELS[opts.scope] || opts.scope;
+    console.log(`${scopeLabel} schema, ${opts.key} is successfully unset for ${schemaFor}.`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to unset search schema');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Converts default value to display string
+ */
+function getDefaultValueLabel(value: unknown): string {
+  if (value === undefined || value === null) {
+    return '';
+  }
+
+  if (Array.isArray(value)) {
+    return value.join(', ');
+  }
+
+  return String(value);
+}
+
+/**
+ * Lists all search schemas
+ */
+async function listSearchSchemas(marketplace: string): Promise<void> {
+  try {
+    const schemas = await sdkListSearchSchemas(undefined, marketplace);
+
+    if (schemas.length === 0) {
+      console.log('No search schemas found.');
+      return;
+    }
+
+    // Map and sort the data (by schema-for, scope, key)
+    const rows = schemas
+      .map((s) => ({
+        'Schema for': s.schemaFor,
+        'Scope': s.scope,
+        'Key': s.key,
+        'Type': s.type,
+        'Default value': getDefaultValueLabel(s.defaultValue),
+        'Doc': s.doc || '',
+      }))
+      .sort((a, b) => {
+        // Sort by schema-for, then scope, then key
+        if (a['Schema for'] !== b['Schema for']) {
+          return a['Schema for'].localeCompare(b['Schema for']);
+        }
+        if (a['Scope'] !== b['Scope']) {
+          return a['Scope'].localeCompare(b['Scope']);
+        }
+        return a['Key'].localeCompare(b['Key']);
+      });
+
+    // Print table using flex-cli compatible formatting
+    const headers = ['Schema for', 'Scope', 'Key', 'Type', 'Default value', 'Doc'];
+
+    // Calculate column widths
+    // flex-cli uses keywords (e.g., :version) which when stringified include the ':' prefix
+    // To match flex-cli widths, we add 1 to header length to simulate the ':' prefix
+    const widths: Record<string, number> = {};
+    for (const h of headers) {
+      widths[h] = h.length + 1;
+    }
+    for (const row of rows) {
+      for (const h of headers) {
+        const value = row[h] || '';
+        widths[h] = Math.max(widths[h], value.length);
+      }
+    }
+
+    // Print empty line before table
+    console.log('');
+
+    // Print header
+    // flex-cli search format: each column padded to max_width, with 2 space separator between columns
+    // Last column: padding with trailing space
+    const headerParts = headers.map((h, i) => {
+      const width = widths[h] || 0;
+      const padded = h.padEnd(width);
+      return i === headers.length - 1 ? padded + ' ' : padded + '  ';
+    });
+    console.log(headerParts.join(''));
+
+    // Print rows
+    for (const row of rows) {
+      const rowParts = headers.map((h, i) => {
+        const value = row[h] || '';
+        const width = widths[h] || 0;
+        const padded = value.padEnd(width);
+        return i === headers.length - 1 ? padded + ' ' : padded + '  ';
+      });
+      console.log(rowParts.join(''));
+    }
+
+    // Print empty line after table
+    console.log('');
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to list search schemas');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Registers search commands
+ */
+export function registerSearchCommands(program: Command): void {
+  const searchCmd = program
+    .command('search')
+    .description('list all search schemas')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .action(async (options) => {
+      const marketplace = options.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Error: --marketplace is required');
+        process.exit(1);
+      }
+      await listSearchSchemas(marketplace);
+    });
+
+  // search set
+  searchCmd
+    .command('set')
+    .description('set search schema')
+    .requiredOption('--key <KEY>', 'schema key')
+    .requiredOption('--scope <SCOPE>', 'schema scope')
+    .requiredOption('--type <TYPE>', 'value type (enum, multi-enum, boolean, long, or text)')
+    .option('--doc <DOC>', 'description of the schema')
+    .option('--default <DEFAULT>', 'default value for search if value is not set')
+    .option('--schema-for <SCHEMA_FOR>', 'subject of the schema (listing, userProfile, or transaction)')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .action(async (opts) => {
+      const marketplace = opts.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Error: --marketplace is required');
+        process.exit(1);
+      }
+      await setSearchSchema(marketplace, {
+        key: opts.key,
+        scope: opts.scope,
+        type: opts.type,
+        doc: opts.doc,
+        default: opts.default,
+        schemaFor: opts.schemaFor,
+      });
+    });
+
+  // search unset
+  searchCmd
+    .command('unset')
+    .description('unset search schema')
+    .requiredOption('--key <KEY>', 'schema key')
+    .requiredOption('--scope <SCOPE>', 'schema scope')
+    .option('--schema-for <SCHEMA_FOR>', 'subject of the schema (listing, userProfile, or transaction)')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .action(async (opts) => {
+      const marketplace = opts.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Error: --marketplace is required');
+        process.exit(1);
+      }
+      await unsetSearchSchema(marketplace, {
+        key: opts.key,
+        scope: opts.scope,
+        schemaFor: opts.schemaFor,
+      });
+    });
+}

package/src/commands/stripe/index.ts

@@ -0,0 +1,114 @@
+/**
+ * Stripe command - manage Stripe integration
+ */
+
+import { Command } from 'commander';
+import { updateStripeVersion as sdkUpdateStripeVersion, SUPPORTED_STRIPE_VERSIONS } from 'sharetribe-flex-build-sdk';
+import { printError } from '../../util/output.js';
+import inquirer from 'inquirer';
+
+
+/**
+ * Prompts for version selection
+ */
+async function promptForVersion(): Promise<string> {
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'version',
+      message: 'Select Stripe API version:',
+      choices: [...SUPPORTED_STRIPE_VERSIONS],
+    },
+  ]);
+
+  return answers.version;
+}
+
+/**
+ * Prompts for confirmation
+ */
+async function promptForConfirmation(): Promise<boolean> {
+  console.log('');
+  console.log('WARNING: Changing Stripe API version may affect your integration.');
+  console.log('');
+  console.log('After updating the Stripe API version, you may need to:');
+  console.log('- Handle new Capabilities requirements');
+  console.log('- Update identity verification settings');
+  console.log('');
+  console.log('See Stripe documentation for details:');
+  console.log('https://stripe.com/docs/connect/capabilities-overview');
+  console.log('https://stripe.com/docs/connect/identity-verification');
+  console.log('');
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Do you want to continue?',
+      default: false,
+    },
+  ]);
+
+  return answers.confirmed;
+}
+
+/**
+ * Updates Stripe API version
+ */
+async function updateStripeVersion(
+  marketplace: string,
+  version?: string,
+  force?: boolean
+): Promise<void> {
+  try {
+    // Get version if not provided
+    let selectedVersion = version;
+    if (!selectedVersion) {
+      selectedVersion = await promptForVersion();
+    }
+
+    // Get confirmation unless --force flag is used
+    if (!force) {
+      const confirmed = await promptForConfirmation();
+      if (!confirmed) {
+        console.log('Cancelled.');
+        process.exit(0);
+      }
+    }
+
+    // Update via API (SDK validates version)
+    await sdkUpdateStripeVersion(undefined, marketplace, selectedVersion);
+
+    console.log(`Stripe API version successfully changed to ${selectedVersion}`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to update Stripe API version');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Registers stripe commands
+ */
+export function registerStripeCommands(program: Command): void {
+  const stripeCmd = program.command('stripe').description('manage Stripe integration');
+
+  // stripe update-version
+  stripeCmd
+    .command('update-version')
+    .description('update Stripe API version in use')
+    .option('--version <VERSION>', 'Stripe API version to update to')
+    .option('-f, --force', 'skip confirmation prompt and force update')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .action(async (opts) => {
+      const marketplace = opts.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Error: --marketplace is required');
+        process.exit(1);
+      }
+      await updateStripeVersion(marketplace, opts.version, opts.force);
+    });
+}

package/src/commands/version.ts

@@ -0,0 +1,40 @@
+/**
+ * Version command - displays the CLI version
+ *
+ * Must match flex-cli output format exactly
+ */
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+/**
+ * Finds package.json by traversing up from current file
+ */
+function findPackageJson(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  let currentDir = dirname(__filename);
+
+  // Traverse up to find package.json
+  while (currentDir !== '/') {
+    try {
+      const pkgPath = join(currentDir, 'package.json');
+      const content = readFileSync(pkgPath, 'utf-8');
+      return content;
+    } catch {
+      currentDir = dirname(currentDir);
+    }
+  }
+
+  throw new Error('Could not find package.json');
+}
+
+/**
+ * Displays the version of the CLI
+ *
+ * Output must match flex-cli exactly
+ */
+export function version(): void {
+  const packageJson = JSON.parse(findPackageJson());
+  console.log(packageJson.version);
+}

package/src/index.ts

@@ -0,0 +1,131 @@
+/**
+ * Sharetribe CLI - Unofficial 100% compatible implementation
+ *
+ * Main entry point for the CLI application
+ */
+
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { version } from './commands/version.js';
+import { login } from './commands/login.js';
+import { logout } from './commands/logout.js';
+import { registerProcessCommands } from './commands/process/index.js';
+import { registerSearchCommands } from './commands/search/index.js';
+import { registerAssetsCommands } from './commands/assets/index.js';
+import { registerNotificationsCommands } from './commands/notifications/index.js';
+import { registerListingApprovalCommand } from './commands/listing-approval.js';
+import { registerEventsCommand } from './commands/events/index.js';
+import { registerStripeCommands } from './commands/stripe/index.js';
+import { configureHelp } from './util/help-formatter.js';
+import { routeProcessCommand } from './util/command-router.js';
+
+// Get package.json for version info
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(
+  readFileSync(join(__dirname, '../package.json'), 'utf-8')
+);
+
+// Route argv to handle process subcommands
+const routedArgv = routeProcessCommand(process.argv);
+
+const program = new Command();
+
+// Configure custom help formatter to match flex-cli
+configureHelp(program);
+
+// Configure output to add trailing newline (flex-cli behavior)
+program.configureOutput({
+  writeOut: (str) => process.stdout.write(str + '\n'),
+  writeErr: (str) => process.stderr.write(str + '\n'),
+});
+
+// Configure the main program
+program
+  .name('sharetribe-cli')
+  .description('CLI to interact with Sharetribe Flex')
+  .version(packageJson.version, '-V', 'output the version number')
+  .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier');
+
+// Register commands
+
+// version command
+program
+  .command('version')
+  .description('show version')
+  .action(() => {
+    version();
+  });
+
+// login command
+program
+  .command('login')
+  .description('log in with API key')
+  .action(async () => {
+    await login();
+  });
+
+// logout command
+program
+  .command('logout')
+  .description('logout')
+  .action(async () => {
+    await logout();
+  });
+
+// Register process commands
+registerProcessCommands(program);
+
+// Register search commands
+registerSearchCommands(program);
+
+// Register assets commands
+registerAssetsCommands(program);
+
+// Register notifications commands
+registerNotificationsCommands(program);
+
+// Register listing-approval command
+registerListingApprovalCommand(program);
+
+// Register events command
+registerEventsCommand(program);
+
+// Register stripe commands
+registerStripeCommands(program);
+
+// Register custom help command (to support "help process list" syntax)
+program
+  .command('help [command...]')
+  .description('display help for Flex CLI')
+  .action((commandPath: string[]) => {
+    if (!commandPath || commandPath.length === 0) {
+      program.outputHelp();
+      return;
+    }
+
+    // Navigate to the nested command
+    let targetCmd: Command = program;
+    for (const cmdName of commandPath) {
+      const subCmd = targetCmd.commands.find(c => c.name() === cmdName);
+      if (!subCmd) {
+        console.error(`Unknown command: ${commandPath.join(' ')}`);
+        process.exit(1);
+      }
+      targetCmd = subCmd;
+    }
+
+    // Show help for the target command
+    targetCmd.outputHelp();
+  });
+
+// If no command specified, show help and exit with status 0
+if (!routedArgv.slice(2).length) {
+  program.outputHelp();
+  // Don't call process.exit() - let Commander handle it naturally with exitOverride
+} else {
+  // Parse command line arguments with routed argv
+  program.parse(routedArgv);
+}

package/src/types/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Type definitions for sharetribe-cli
+ */
+
+export interface CommandContext {
+  apiClient?: unknown; // Will be defined when API client is implemented
+  marketplace?: string;
+  apiKey?: string;
+}
+
+export interface CommandOptions {
+  marketplace?: string;
+  help?: boolean;
+  version?: boolean;
+}
+
+export interface ProcessDefinition {
+  // Will be expanded as we implement process handling
+  name: string;
+  version?: number;
+}

package/src/util/command-router.ts

@@ -0,0 +1,41 @@
+/**
+ * Custom command router to handle Commander.js limitations
+ *
+ * Commander.js cannot handle parent and child commands with the same option names.
+ * This router intercepts argv and routes to the correct command handler.
+ */
+
+/**
+ * Routes process subcommands to avoid Commander parent/child option conflicts
+ *
+ * This is necessary because Commander validates parent command options before
+ * subcommand actions run, causing conflicts when both use --path.
+ */
+export function routeProcessCommand(argv: string[]): string[] {
+  // Check if this is a process subcommand
+  const processIndex = argv.findIndex(arg => arg === 'process');
+  if (processIndex === -1) {
+    return argv;
+  }
+
+  // Check for subcommands
+  const nextArg = argv[processIndex + 1];
+  const subcommands = ['list', 'create', 'push', 'pull', 'create-alias', 'update-alias', 'delete-alias', 'deploy'];
+
+  if (nextArg && subcommands.includes(nextArg)) {
+    // This is a subcommand - remove 'process' from argv and make the subcommand top-level
+    // e.g. ['node', 'cli', 'process', 'pull', ...] => ['node', 'cli', 'process-pull', ...]
+    const newArgv = [
+      ...argv.slice(0, processIndex),
+      `process-${nextArg}`,
+      ...argv.slice(processIndex + 2)
+    ];
+
+    // Special handling: If this is an alias command with --version option,
+    // we need to filter out the global --version flag from program
+    // by ensuring the routed command is properly isolated
+    return newArgv;
+  }
+
+  return argv;
+}