sharetribe-cli 1.15.0

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "sharetribe-cli",
+  "version": "1.15.0",
+  "description": "Unofficial Sharetribe CLI - 100% compatible with flex-cli",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "sharetribe-cli": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "node build.js",
+    "build:dev": "node build.js --dev",
+    "dev": "node build.js --dev --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "sharetribe",
+    "flex",
+    "cli",
+    "marketplace",
+    "transaction-process"
+  ],
+  "author": "",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jayenashar/sharetribe-cli"
+  },
+  "dependencies": {
+    "@types/yargs": "^17.0.35",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "inquirer": "^9.2.23",
+    "jsedn": "^0.4.1",
+    "sharetribe-flex-build-sdk": "1.15.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.17.10",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "esbuild": "^0.27.2",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "vitest": "^4.0.16"
+  }
+}

package/src/commands/assets/index.ts

@@ -0,0 +1,338 @@
+/**
+ * Assets commands - manage marketplace assets
+ */
+
+import { Command } from 'commander';
+import {
+  pullAssets as sdkPullAssets,
+  pushAssets as sdkPushAssets,
+} from 'sharetribe-flex-build-sdk';
+import { printError } from '../../util/output.js';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import edn from 'jsedn';
+
+
+interface AssetMetadata {
+  version: string;
+  assets: Array<{ path: string; 'content-hash': string }>;
+}
+
+/**
+ * Reads asset metadata from .flex-cli/asset-meta.edn
+ */
+function readAssetMetadata(basePath: string): AssetMetadata | null {
+  const metaPath = join(basePath, '.flex-cli', 'asset-meta.edn');
+  if (!existsSync(metaPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(metaPath, 'utf-8');
+    const parsed = edn.parse(content);
+
+    // Convert EDN map to JavaScript object
+    const version = parsed.at(edn.kw(':version'));
+    const assets = parsed.at(edn.kw(':assets'));
+
+    const assetList: Array<{ path: string; 'content-hash': string }> = [];
+    if (assets && assets.val) {
+      for (const asset of assets.val) {
+        assetList.push({
+          path: asset.at(edn.kw(':path')),
+          'content-hash': asset.at(edn.kw(':content-hash')),
+        });
+      }
+    }
+
+    return { version, assets: assetList };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes asset metadata to .flex-cli/asset-meta.edn
+ */
+function writeAssetMetadata(basePath: string, metadata: AssetMetadata): void {
+  const metaDir = join(basePath, '.flex-cli');
+  if (!existsSync(metaDir)) {
+    mkdirSync(metaDir, { recursive: true });
+  }
+
+  const assets = metadata.assets.map(a =>
+    new edn.Map([
+      edn.kw(':path'), a.path,
+      edn.kw(':content-hash'), a['content-hash']
+    ])
+  );
+
+  const ednMap = new edn.Map([
+    edn.kw(':version'), metadata.version,
+    edn.kw(':assets'), new edn.Vector(assets)
+  ]);
+
+  const metaPath = join(basePath, '.flex-cli', 'asset-meta.edn');
+  writeFileSync(metaPath, edn.encode(ednMap), 'utf-8');
+}
+
+/**
+ * Calculates SHA-1 hash of file content
+ */
+function calculateHash(data: Buffer): string {
+  return createHash('sha1').update(data).digest('hex');
+}
+
+/**
+ * Reads all assets from a directory
+ */
+function readLocalAssets(basePath: string): Array<{ path: string; data: Buffer; hash: string }> {
+  const assets: Array<{ path: string; data: Buffer; hash: string }> = [];
+
+  function scanDir(dir: string, relativePath: string = '') {
+    const entries = readdirSync(dir);
+
+    for (const entry of entries) {
+      if (entry === '.flex-cli') continue; // Skip metadata directory
+
+      const fullPath = join(dir, entry);
+      const relPath = relativePath ? join(relativePath, entry) : entry;
+      const stat = statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        scanDir(fullPath, relPath);
+      } else if (stat.isFile()) {
+        const data = readFileSync(fullPath);
+        const hash = calculateHash(data);
+        assets.push({ path: relPath, data, hash });
+      }
+    }
+  }
+
+  scanDir(basePath);
+  return assets;
+}
+
+/**
+ * Validates JSON files
+ */
+function validateJsonAssets(assets: Array<{ path: string; data: Buffer }>): void {
+  for (const asset of assets) {
+    if (asset.path.endsWith('.json')) {
+      try {
+        JSON.parse(asset.data.toString('utf-8'));
+      } catch (error) {
+        throw new Error(`Invalid JSON in ${asset.path}: ${error}`);
+      }
+    }
+  }
+}
+
+/**
+ * Pulls assets from remote
+ */
+async function pullAssets(
+  marketplace: string,
+  path: string,
+  version?: string,
+  prune?: boolean
+): Promise<void> {
+  try {
+    // Validate path
+    if (!existsSync(path)) {
+      mkdirSync(path, { recursive: true });
+    }
+
+    const stat = statSync(path);
+    if (!stat.isDirectory()) {
+      throw new Error(`${path} is not a directory`);
+    }
+
+    // Fetch assets from API
+    const result = await sdkPullAssets(undefined, marketplace, version ? { version } : undefined);
+    const remoteVersion = result.version;
+
+    // Read current metadata
+    const currentMeta = readAssetMetadata(path);
+
+    // Check if up to date
+    if (currentMeta && currentMeta.version === remoteVersion && result.assets.length === currentMeta.assets.length) {
+      console.log('Assets are up to date.');
+      return;
+    }
+
+    // Write assets to disk
+    const newAssets: Array<{ path: string; 'content-hash': string }> = [];
+    for (const asset of result.assets) {
+      const assetPath = join(path, asset.path);
+      const assetDir = dirname(assetPath);
+
+      if (!existsSync(assetDir)) {
+        mkdirSync(assetDir, { recursive: true });
+      }
+
+      // Decode base64 data
+      const data = Buffer.from(asset.dataRaw, 'base64');
+      writeFileSync(assetPath, data);
+
+      const hash = calculateHash(data);
+      newAssets.push({ path: asset.path, 'content-hash': asset.contentHash || hash });
+    }
+
+    // Prune deleted assets if requested
+    if (prune && currentMeta) {
+      const remotePaths = new Set(result.assets.map(a => a.path));
+      for (const localAsset of currentMeta.assets) {
+        if (!remotePaths.has(localAsset.path)) {
+          const assetPath = join(path, localAsset.path);
+          if (existsSync(assetPath)) {
+            unlinkSync(assetPath);
+          }
+        }
+      }
+    }
+
+    // Update metadata
+    writeAssetMetadata(path, {
+      version: remoteVersion,
+      assets: newAssets,
+    });
+
+    console.log(`Version ${remoteVersion} successfully pulled.`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to pull assets');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Pushes assets to remote
+ */
+async function pushAssets(
+  marketplace: string,
+  path: string,
+  prune?: boolean
+): Promise<void> {
+  try {
+    // Validate path
+    if (!existsSync(path) || !statSync(path).isDirectory()) {
+      throw new Error(`${path} is not a valid directory`);
+    }
+
+    // Read current metadata
+    const currentMeta = readAssetMetadata(path);
+    const currentVersion = currentMeta?.version || 'nil';
+
+    // Read local assets
+    const localAssets = readLocalAssets(path);
+
+    // Validate JSON files
+    validateJsonAssets(localAssets);
+
+    // Build operations
+    const operations: Array<{
+      path: string;
+      op: 'upsert' | 'delete';
+      data?: Buffer;
+    }> = [];
+
+    // Find assets to upsert (new or changed)
+    const localAssetMap = new Map(localAssets.map(a => [a.path, a]));
+    const currentAssetMap = new Map((currentMeta?.assets || []).map(a => [a.path, a['content-hash']]));
+
+    for (const [assetPath, asset] of localAssetMap) {
+      const currentHash = currentAssetMap.get(assetPath);
+      if (!currentHash || currentHash !== asset.hash) {
+        operations.push({
+          path: assetPath,
+          op: 'upsert',
+          data: asset.data,
+        });
+      }
+    }
+
+    // Find assets to delete (if prune enabled)
+    if (prune && currentMeta) {
+      for (const currentAsset of currentMeta.assets) {
+        if (!localAssetMap.has(currentAsset.path)) {
+          operations.push({
+            path: currentAsset.path,
+            op: 'delete',
+          });
+        }
+      }
+    }
+
+    // Check if there are any changes
+    if (operations.length === 0) {
+      console.log('Assets are up to date.');
+      return;
+    }
+
+    // Upload to API
+    const result = await sdkPushAssets(undefined, marketplace, currentVersion, operations);
+
+    // Update local metadata
+    writeAssetMetadata(path, {
+      version: result.version,
+      assets: result.assets.map(a => ({
+        path: a.path,
+        'content-hash': a.contentHash,
+      })),
+    });
+
+    console.log(`New version ${result.version} successfully created.`);
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to push assets');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Registers assets commands
+ */
+export function registerAssetsCommands(program: Command): void {
+  const assetsCmd = program.command('assets').description('manage marketplace assets');
+
+  // assets pull
+  assetsCmd
+    .command('pull')
+    .description('pull assets from remote')
+    .requiredOption('--path <PATH>', 'path to directory where assets will be stored')
+    .option('--version <VERSION>', 'version of assets to pull')
+    .option('--prune', 'delete local files no longer present as remote assets')
+    .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 pullAssets(marketplace, opts.path, opts.version, opts.prune);
+    });
+
+  // assets push
+  assetsCmd
+    .command('push')
+    .description('push assets to remote')
+    .requiredOption('--path <PATH>', 'path to directory with assets')
+    .option('--prune', 'delete remote assets no longer present locally')
+    .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 pushAssets(marketplace, opts.path, opts.prune);
+    });
+}

package/src/commands/events/index.ts

@@ -0,0 +1,289 @@
+/**
+ * Events command - query marketplace events
+ */
+
+import { Command } from 'commander';
+import { printTable, printError } from '../../util/output.js';
+import {
+  queryEvents as sdkQueryEvents,
+  pollEvents as sdkPollEvents,
+  type EventData as SdkEventData
+} from 'sharetribe-flex-build-sdk';
+
+interface EventsQueryOptions {
+  resourceId?: string;
+  relatedResourceId?: string;
+  eventTypes?: string;
+  sequenceId?: number;
+  afterSeqId?: number;
+  beforeSeqId?: number;
+  afterTs?: string;
+  beforeTs?: string;
+  limit?: number;
+  json?: boolean;
+  jsonPretty?: boolean;
+}
+
+/**
+ * Validates query parameters
+ */
+function validateParams(opts: EventsQueryOptions): void {
+  const exclusiveParams = [
+    opts.sequenceId !== undefined,
+    opts.afterSeqId !== undefined,
+    opts.beforeSeqId !== undefined,
+    opts.afterTs !== undefined,
+    opts.beforeTs !== undefined,
+  ];
+
+  if (exclusiveParams.filter(Boolean).length > 1) {
+    throw new Error(
+      'Only one of --seqid, --after-seqid, --before-seqid, --after-ts, or --before-ts can be specified'
+    );
+  }
+
+  if (opts.resourceId && opts.relatedResourceId) {
+    throw new Error('Only one of --resource or --related-resource can be specified');
+  }
+}
+
+/**
+ * Formats timestamp to match flex-cli format: YYYY-MM-DD H:MM:SS AM/PM
+ */
+function formatTimestamp(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;
+  }
+}
+
+/**
+ * Queries events from API
+ */
+async function queryEvents(
+  marketplace: string,
+  opts: EventsQueryOptions
+): Promise<void> {
+  try {
+    validateParams(opts);
+
+    const events = await sdkQueryEvents(
+      undefined, // Use auth from file
+      marketplace,
+      {
+        resourceId: opts.resourceId,
+        relatedResourceId: opts.relatedResourceId,
+        eventTypes: opts.eventTypes,
+        sequenceId: opts.sequenceId,
+        afterSeqId: opts.afterSeqId,
+        beforeSeqId: opts.beforeSeqId,
+        afterTs: opts.afterTs,
+        beforeTs: opts.beforeTs,
+        limit: opts.limit,
+      }
+    );
+
+    if (events.length === 0) {
+      console.log('No events found.');
+      return;
+    }
+
+    // Output format
+    if (opts.json) {
+      for (const event of events) {
+        // Exclude auditEmails to match flex-cli JSON format
+        const { auditEmails, ...eventWithoutEmails } = event;
+        console.log(JSON.stringify(eventWithoutEmails));
+      }
+    } else if (opts.jsonPretty) {
+      for (const event of events) {
+        // Exclude auditEmails to match flex-cli JSON format
+        const { auditEmails, ...eventWithoutEmails } = event;
+        console.log(JSON.stringify(eventWithoutEmails, null, 2));
+      }
+    } else {
+      printTable(
+        ['Seq ID', 'Resource ID', 'Event type', 'Created at local time', 'Source', 'Actor'],
+        events.map((event) => {
+          const actor = event.auditEmails?.userEmail || event.auditEmails?.adminEmail || '';
+          const source = event.source?.replace('source/', '') || '';
+
+          return {
+            'Seq ID': event.sequenceId.toString(),
+            'Resource ID': event.resourceId,
+            'Event type': event.eventType,
+            'Created at local time': formatTimestamp(event.createdAt),
+            'Source': source,
+            'Actor': actor,
+          };
+        })
+      );
+    }
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to query events');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Tails events (live streaming)
+ */
+async function tailEvents(
+  marketplace: string,
+  opts: EventsQueryOptions
+): Promise<void> {
+  try {
+    validateParams(opts);
+
+    console.log('Tailing events... Press Ctrl+C to stop');
+    console.log('');
+
+    const stopPolling = sdkPollEvents(
+      undefined, // Use auth from file
+      marketplace,
+      {
+        resourceId: opts.resourceId,
+        relatedResourceId: opts.relatedResourceId,
+        eventTypes: opts.eventTypes,
+        limit: opts.limit || 10,
+      },
+      (events: SdkEventData[]) => {
+        // Output events
+        if (opts.json) {
+          for (const event of events) {
+            // Exclude auditEmails to match flex-cli JSON format
+            const { auditEmails, ...eventWithoutEmails } = event;
+            console.log(JSON.stringify(eventWithoutEmails));
+          }
+        } else if (opts.jsonPretty) {
+          for (const event of events) {
+            // Exclude auditEmails to match flex-cli JSON format
+            const { auditEmails, ...eventWithoutEmails } = event;
+            console.log(JSON.stringify(eventWithoutEmails, null, 2));
+          }
+        } else {
+          printTable(
+            ['Seq ID', 'Resource ID', 'Event type', 'Created at local time', 'Source', 'Actor'],
+            events.map((event) => {
+              const actor = event.auditEmails?.userEmail || event.auditEmails?.adminEmail || '';
+              const source = event.source?.replace('source/', '') || '';
+
+              return {
+                'Seq ID': event.sequenceId.toString(),
+                'Resource ID': event.resourceId,
+                'Event type': event.eventType,
+                'Created at local time': formatTimestamp(event.createdAt),
+                'Source': source,
+                'Actor': actor,
+              };
+            })
+          );
+        }
+      },
+      5000 // 5 second poll interval
+    );
+
+    // Handle graceful shutdown
+    const shutdown = () => {
+      console.log('\nStopping tail...');
+      stopPolling();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+  } catch (error) {
+    if (error && typeof error === 'object' && 'message' in error) {
+      printError(error.message as string);
+    } else {
+      printError('Failed to tail events');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Registers events command
+ */
+export function registerEventsCommand(program: Command): void {
+  const cmd = program
+    .command('events')
+    .description('Get a list of events.')
+    .option('--resource <RESOURCE_ID>', 'show events for specific resource ID')
+    .option('--related-resource <RELATED_RESOURCE_ID>', 'show events related to specific resource ID')
+    .option('--filter <EVENT_TYPES>', 'filter by event types (comma-separated)')
+    .option('--seqid <SEQUENCE_ID>', 'get event with specific sequence ID', parseInt)
+    .option('--after-seqid <SEQUENCE_ID>', 'show events after sequence ID (exclusive)', parseInt)
+    .option('--before-seqid <SEQUENCE_ID>', 'show events before sequence ID (exclusive)', parseInt)
+    .option('--after-ts <TIMESTAMP>', 'show events after timestamp')
+    .option('--before-ts <TIMESTAMP>', 'show events before timestamp')
+    .option('-l, --limit <NUMBER>', 'limit results (default: 100, max: 100)', parseInt)
+    .option('--json', 'output as single-line JSON strings')
+    .option('--json-pretty', 'output as indented multi-line JSON')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier');
+
+  // Default action - query
+  cmd.action(async (opts) => {
+    const marketplace = opts.marketplace || program.opts().marketplace;
+    if (!marketplace) {
+      console.error('Could not parse arguments:');
+      console.error('--marketplace is required');
+      process.exit(1);
+    }
+
+    await queryEvents(marketplace, {
+      resourceId: opts.resource,
+      relatedResourceId: opts.relatedResource,
+      eventTypes: opts.filter,
+      sequenceId: opts.seqid,
+      afterSeqId: opts.afterSeqid,
+      beforeSeqId: opts.beforeSeqid,
+      afterTs: opts.afterTs,
+      beforeTs: opts.beforeTs,
+      limit: opts.limit || 100,
+      json: opts.json,
+      jsonPretty: opts.jsonPretty,
+    });
+  });
+
+  // tail subcommand
+  cmd
+    .command('tail')
+    .description('Tail events live as they happen')
+    .option('--resource <RESOURCE_ID>', 'show events for specific resource ID')
+    .option('--related-resource <RELATED_RESOURCE_ID>', 'show events related to specific resource ID')
+    .option('--filter <EVENT_TYPES>', 'filter by event types (comma-separated)')
+    .option('-l, --limit <NUMBER>', 'limit results per poll (default: 10, max: 100)', parseInt)
+    .option('--json', 'output as single-line JSON strings')
+    .option('--json-pretty', 'output as indented multi-line JSON')
+    .option('-m, --marketplace <MARKETPLACE_ID>', 'marketplace identifier')
+    .action(async (opts) => {
+      const marketplace = opts.marketplace || program.opts().marketplace;
+      if (!marketplace) {
+        console.error('Could not parse arguments:');
+        console.error('--marketplace is required');
+        process.exit(1);
+      }
+
+      await tailEvents(marketplace, {
+        resourceId: opts.resource,
+        relatedResourceId: opts.relatedResource,
+        eventTypes: opts.filter,
+        limit: opts.limit || 10,
+        json: opts.json,
+        jsonPretty: opts.jsonPretty,
+      });
+    });
+}

package/src/commands/help.ts

@@ -0,0 +1,19 @@
+/**
+ * Help command - displays help information
+ *
+ * Note: Top-level help may differ from flex-cli due to new commands
+ * Subcommand help must match flex-cli exactly
+ */
+
+import { Command } from 'commander';
+
+/**
+ * Registers help command
+ *
+ * Commander.js handles this automatically, but we can customize if needed
+ */
+export function registerHelpCommand(program: Command): void {
+  // Commander.js provides built-in help functionality
+  // This function exists for future customization if needed
+  program.addHelpCommand('help [command]', 'display help for command');
+}