sharetribe-cli 1.15.0

package/src/commands/process/index.ts

@@ -0,0 +1,309 @@
+/**
+ * Process command - main entry point for process subcommands
+ */
+
+import { Command } from 'commander';
+import { listProcesses } from './list.js';
+import { createProcess } from './create.js';
+import { pushProcess } from './push.js';
+import { pullProcess } from './pull.js';
+import { createAlias, updateAlias, deleteAlias } from './aliases.js';
+import { createOrPushAndCreateOrUpdateAlias } from './combined.js';
+
+/**
+ * Registers all process subcommands
+ */
+export function registerProcessCommands(program: Command): void {
+  // Register the parent 'process' command for help display
+  const processCmd = program
+    .command('process')
+    .description('describe a process file')
+    .option('--path <PROCESS_DIR>', 'path to the directory where the process.edn file is')
+    .option('--transition <TRANSITION_NAME>', 'transition name, e.g. transition/request to get more details of it')
+    .action(async (options) => {
+      // Process describe functionality
+      if (options.path) {
+        console.log(`Describing process at: ${options.path}`);
+        if (options.transition) {
+          console.log(`Transition: ${options.transition}`);
+        }
+        // TODO: Implement actual process file parsing and description
+        console.log('Process description not yet implemented');
+      } else {
+        // If no options, show help
+        processCmd.outputHelp();
+      }
+    });
+
+  // Register subcommands - these are registered as BOTH subcommands (for help) and top-level (for routing)
+
+  // process list (as subcommand)
+  processCmd
+    .command('list')
+    .description('list all transaction processes')
+    .option('--process <PROCESS_NAME>', 'print version and alias info of a specific process')
+    .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 listProcesses(marketplace, options.process);
+    });
+
+  // process create
+  processCmd
+    .command('create')
+    .description('create a new transaction process')
+    .requiredOption('--process <PROCESS_NAME>', 'name for the new process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory where the process.edn file is')
+    .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 createProcess(marketplace, options.process, options.path);
+    });
+
+  // process push
+  processCmd
+    .command('push')
+    .description('push a process file to the remote')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory where the process.edn file is')
+    .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 pushProcess(marketplace, options.process, options.path);
+    });
+
+  // process pull
+  processCmd
+    .command('pull')
+    .description('fetch a process file')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path where to save the process')
+    .option('--version <VERSION_NUM>', 'version number')
+    .option('--alias <PROCESS_ALIAS>', 'alias name')
+    .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 pullProcess(marketplace, options.process, options.path, options.version, options.alias);
+    });
+
+  // process create-alias
+  processCmd
+    .command('create-alias')
+    .description('create a new alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--version <VERSION_NUM>', 'version number')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .allowUnknownOption(false)
+    .action(async (options) => {
+      const marketplace = options.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Error: --marketplace is required');
+        process.exit(1);
+      }
+      await createAlias(marketplace, options.process, parseInt(options.version), options.alias);
+    });
+
+  // process update-alias
+  processCmd
+    .command('update-alias')
+    .description('update an existing alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--version <VERSION_NUM>', 'version number')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 updateAlias(marketplace, options.process, parseInt(options.version), options.alias);
+    });
+
+  // process delete-alias
+  processCmd
+    .command('delete-alias')
+    .description('delete an existing alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 deleteAlias(marketplace, options.process, options.alias);
+    });
+
+  // process deploy (combined command: create-or-push-and-create-or-update-alias)
+  processCmd
+    .command('deploy')
+    .description('deploy a process file with alias (create/push + alias create/update)')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory with the process files')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 createOrPushAndCreateOrUpdateAlias(
+        marketplace,
+        options.process,
+        options.path,
+        options.alias
+      );
+    });
+
+  // Register top-level command aliases for routing (hidden from help)
+  // These handle the routed commands like 'process-pull' that avoid Commander's parent/child option conflicts
+
+  program
+    .command('process-list', { hidden: true })
+    .description('list all transaction processes')
+    .option('--process <PROCESS_NAME>', 'print version and alias info of a specific process')
+    .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 listProcesses(marketplace, options.process);
+    });
+
+  program
+    .command('process-create', { hidden: true })
+    .description('create a new transaction process')
+    .requiredOption('--process <PROCESS_NAME>', 'name for the new process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory where the process.edn file is')
+    .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 createProcess(marketplace, options.process, options.path);
+    });
+
+  program
+    .command('process-push', { hidden: true })
+    .description('push a process file to the remote')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory where the process.edn file is')
+    .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 pushProcess(marketplace, options.process, options.path);
+    });
+
+  program
+    .command('process-pull', { hidden: true })
+    .description('fetch a process file')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path where to save the process')
+    .option('--version <VERSION_NUM>', 'version number')
+    .option('--alias <PROCESS_ALIAS>', 'alias name')
+    .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 pullProcess(marketplace, options.process, options.path, options.version, options.alias);
+    });
+
+  program
+    .command('process-create-alias', { hidden: true })
+    .description('create a new alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--version <VERSION_NUM>', 'version number')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 createAlias(marketplace, options.process, parseInt(options.version), options.alias);
+    });
+
+  program
+    .command('process-update-alias', { hidden: true })
+    .description('update an existing alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--version <VERSION_NUM>', 'version number')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 updateAlias(marketplace, options.process, parseInt(options.version), options.alias);
+    });
+
+  program
+    .command('process-delete-alias', { hidden: true })
+    .description('delete an existing alias')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 deleteAlias(marketplace, options.process, options.alias);
+    });
+
+  program
+    .command('process-deploy', { hidden: true })
+    .description('deploy a process file with alias (create/push + alias create/update)')
+    .requiredOption('--process <PROCESS_NAME>', 'name of the process')
+    .requiredOption('--path <LOCAL_PROCESS_DIR>', 'path to the directory with the process files')
+    .requiredOption('--alias <ALIAS>', 'alias name')
+    .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 createOrPushAndCreateOrUpdateAlias(
+        marketplace,
+        options.process,
+        options.path,
+        options.alias
+      );
+    });
+}

package/src/commands/process/list.ts

@@ -0,0 +1,75 @@
+/**
+ * Process list command - lists all transaction processes
+ */
+
+import {
+  listProcesses as sdkListProcesses,
+  listProcessVersions as sdkListProcessVersions,
+} from 'sharetribe-flex-build-sdk';
+import { printTable, printError } from '../../util/output.js';
+
+
+/**
+ * Formats timestamp to match flex-cli format for process list
+ */
+function formatProcessTimestamp(timestamp: string): string {
+  try {
+    const date = new Date(timestamp);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const timeString = date.toLocaleTimeString('en-US');
+
+    return `${year}-${month}-${day} ${timeString}`;
+  } catch {
+    return timestamp;
+  }
+}
+
+/**
+ * Lists all processes for a marketplace
+ */
+export async function listProcesses(marketplace: string, processName?: string): Promise<void> {
+  try {
+    // If processName is specified, show version history for that process
+    if (processName) {
+      const versions = await sdkListProcessVersions(undefined, marketplace, processName);
+
+      if (versions.length === 0) {
+        console.log(`No versions found for process: ${processName}`);
+        return;
+      }
+
+      const versionRows = versions.map((v) => ({
+        'Created': formatProcessTimestamp(v.createdAt),
+        'Version': v.version.toString(),
+        'Aliases': v.aliases?.join(', ') || '',
+        'Transactions': v.transactionCount?.toString() || '0',
+      }));
+
+      printTable(['Created', 'Version', 'Aliases', 'Transactions'], versionRows);
+    } else {
+      // List all processes
+      const processes = await sdkListProcesses(undefined, marketplace);
+
+      if (processes.length === 0) {
+        console.log('No processes found.');
+        return;
+      }
+
+      const processRows = processes.map((p) => ({
+        'Name': p.name,
+        'Latest version': p.version?.toString() || '',
+      }));
+
+      printTable(['Name', 'Latest version'], processRows);
+    }
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to list processes');
+    }
+    process.exit(1);
+  }
+}

package/src/commands/process/pull.ts

@@ -0,0 +1,81 @@
+/**
+ * Process pull command
+ */
+
+import { getProcess } from 'sharetribe-flex-build-sdk';
+import { printError, printSuccess } from '../../util/output.js';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Pulls a process from the server
+ */
+export async function pullProcess(
+  marketplace: string,
+  processName: string,
+  path: string,
+  version?: string,
+  alias?: string
+): Promise<void> {
+  try {
+    const process = await getProcess(undefined, marketplace, processName, { version, alias });
+
+    if (!process.definition) {
+      throw new Error('No process definition in response');
+    }
+
+    // Ensure directory exists (print message if creating new directory)
+    const { existsSync } = await import('node:fs');
+    const dirExists = existsSync(path);
+    mkdirSync(path, { recursive: true });
+
+    if (!dirExists) {
+      console.error(`Creating a new directory: ${path}`);
+    }
+
+    // Write process.edn file
+    const processFilePath = join(path, 'process.edn');
+    writeFileSync(processFilePath, process.definition, 'utf-8');
+
+    // Write email templates if they exist
+    const templates = process.emailTemplates || [];
+
+    if (templates && Array.isArray(templates) && templates.length > 0) {
+      const templatesDir = join(path, 'templates');
+      mkdirSync(templatesDir, { recursive: true });
+
+      for (const template of templates) {
+        const templateName = template.name;
+        const htmlContent = template.html;
+        const subjectContent = template.subject;
+
+        if (templateName) {
+          // Create subdirectory for this template
+          const templateSubdir = join(templatesDir, templateName);
+          mkdirSync(templateSubdir, { recursive: true });
+
+          // Write HTML file
+          if (htmlContent) {
+            const htmlPath = join(templateSubdir, `${templateName}-html.html`);
+            writeFileSync(htmlPath, htmlContent, 'utf-8');
+          }
+
+          // Write subject file
+          if (subjectContent) {
+            const subjectPath = join(templateSubdir, `${templateName}-subject.txt`);
+            writeFileSync(subjectPath, subjectContent, 'utf-8');
+          }
+        }
+      }
+    }
+
+    console.error(`Saved process to ${path}`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to pull process');
+    }
+    process.exit(1);
+  }
+}

package/src/commands/process/push.ts

@@ -0,0 +1,67 @@
+/**
+ * Process push command
+ */
+
+import { pushProcess as sdkPushProcess } from 'sharetribe-flex-build-sdk';
+import { printError, printSuccess } from '../../util/output.js';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Reads email templates from the templates directory
+ */
+function readTemplates(path: string): Array<{ name: string; html: string; subject: string }> {
+  const templatesDir = join(path, 'templates');
+  const templates: Array<{ name: string; html: string; subject: string }> = [];
+
+  try {
+    const templateDirs = readdirSync(templatesDir);
+    for (const templateName of templateDirs) {
+      const templatePath = join(templatesDir, templateName);
+      const htmlFile = join(templatePath, `${templateName}-html.html`);
+      const subjectFile = join(templatePath, `${templateName}-subject.txt`);
+
+      try {
+        const html = readFileSync(htmlFile, 'utf-8');
+        const subject = readFileSync(subjectFile, 'utf-8');
+        templates.push({ name: templateName, html, subject });
+      } catch {
+        // Skip if files don't exist
+      }
+    }
+  } catch {
+    // No templates directory - return empty array
+  }
+
+  return templates;
+}
+
+/**
+ * Pushes a new version of an existing process
+ */
+export async function pushProcess(
+  marketplace: string,
+  processName: string,
+  path: string
+): Promise<void> {
+  try {
+    const processFilePath = join(path, 'process.edn');
+    const processContent = readFileSync(processFilePath, 'utf-8');
+    const templates = readTemplates(path);
+
+    const result = await sdkPushProcess(undefined, marketplace, processName, processContent, templates);
+
+    if (result.noChanges) {
+      console.log('No changes');
+    } else {
+      printSuccess(`Version ${result.version} successfully saved for process ${processName}.`);
+    }
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to push process');
+    }
+    process.exit(1);
+  }
+}