@membranehq/cli 0.1.1

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@membranehq/cli",
+  "version": "0.1.1",
+  "description": "",
+  "source": "./src/index.ts",
+  "bin": {
+    "membrane": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "dist/index.js",
+  "keywords": [],
+  "author": "",
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.1",
+    "@faker-js/faker": "^9.8.0",
+    "@inkjs/ui": "^2.0.0",
+    "@integration-app/sdk": "^1.14.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "archiver": "^7.0.1",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.3",
+    "commander": "^12.0.0",
+    "conf": "^14.0.0",
+    "fastmcp": "^3.5.0",
+    "form-data": "^4.0.3",
+    "ink": "^5.2.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "js-yaml": "^4.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.8",
+    "open": "^8.4.2",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "swr": "^2.3.4",
+    "unzipper": "^0.12.3"
+  }
+}

package/scripts/add-shebang.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# Add shebang to the built index.js file for proper binary execution
+
+echo '#!/usr/bin/env node' | cat - dist/index.js > dist/index.js.tmp
+mv dist/index.js.tmp dist/index.js
+chmod +x dist/index.js

package/scripts/prepare-package-json.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import { readFile, writeFile } from 'fs/promises'
+import path from 'path'
+
+const PKG = path.join(process.cwd(), './package.json')
+
+const removeScripts = async () => {
+  const packageJson = JSON.parse(await readFile(PKG, 'utf-8'))
+  delete packageJson.scripts
+  console.log('Scripts removed')
+
+  delete packageJson.devDependencies
+  console.log('Dev dependencies removed')
+
+  await writeFile(PKG, JSON.stringify(packageJson, null, 2), 'utf-8')
+  console.log('Package.json updated')
+}
+
+const main = async () => {
+  try {
+    await removeScripts()
+  } catch (error) {
+    console.error('Failed to remove scripts', error)
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch(() => process.exit(1))

package/src/agent.tsx

@@ -0,0 +1,50 @@
+import { resolve } from 'node:path'
+
+import { render } from 'ink'
+import minimist from 'minimist'
+import { SWRConfig } from 'swr'
+
+import { Main } from './components/Main'
+import { FileWatcherProvider } from './contexts/FileWatcherContext'
+import { createAccountApiFetcher } from './modules/api/account-api-client'
+import { CwdProvider } from './modules/config/cwd-context'
+import { ProjectConfigProvider } from './modules/config/project'
+import { FileWatcher } from './modules/file-watcher'
+import { WorkspaceElementService } from './modules/workspace-element-service'
+import { Logger } from './utils/logger'
+
+// Parse CLI args
+const argv = minimist(process.argv.slice(2))
+const cwd = argv.cwd ? resolve(argv.cwd) : process.cwd()
+
+async function startBackgroundServices() {
+  try {
+    await workspaceElementService.init()
+    // ToDo: enable when our workspaces sync functionality works in a basic version
+    //await fileWatcher.start()
+  } catch (error) {
+    Logger.error(error.toString())
+    process.exit(1)
+  }
+}
+
+const fileWatcher = new FileWatcher({ cwd })
+const workspaceElementService = new WorkspaceElementService(fileWatcher)
+
+const App = () => (
+  <CwdProvider cwd={cwd}>
+    <FileWatcherProvider fileWatcher={fileWatcher}>
+      <ProjectConfigProvider>
+        {/* TODO: Enhance this to use project config API URI when React version compatibility is resolved */}
+        <SWRConfig value={{ fetcher: createAccountApiFetcher() }}>
+          <Main />
+        </SWRConfig>
+      </ProjectConfigProvider>
+    </FileWatcherProvider>
+  </CwdProvider>
+)
+
+export function runAgent() {
+  void startBackgroundServices()
+  render(<App />)
+}

package/src/cli.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import chalk from 'chalk'
+import { Command } from 'commander'
+
+import { setupOpenCommand } from './commands/open.command'
+import { setupPullCommand } from './commands/pull.command'
+import { setupPushCommand } from './commands/push.command'
+import { setupTestCommand } from './commands/test.command'
+
+const getPackageVersion = () => {
+  try {
+    const __filename = fileURLToPath(import.meta.url)
+    const __dirname = dirname(__filename)
+    const packagePath = join(__dirname, '..', 'package.json')
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'))
+    return packageJson.version
+  } catch {
+    return '1.0.0'
+  }
+}
+
+const VERSION = getPackageVersion()
+
+export function runCLI() {
+  const program = new Command()
+    .name('membrane')
+    .description('Command-line interface for Membrane Agent')
+    .version(VERSION, '-v, --version', 'Output the version number')
+
+  program.configureHelp({
+    sortSubcommands: true,
+    subcommandTerm: (cmd) => chalk.cyan(cmd.name()),
+    commandUsage: (cmd) => {
+      if (cmd.name() === 'membrane') {
+        return `${chalk.cyan(cmd.name())} ${chalk.gray('[options]')} ${chalk.cyan('[command]')}`
+      }
+      return cmd.usage()
+    },
+    optionTerm: (option) => {
+      const flag = option.flags
+      return `${chalk.gray('▸')} ${chalk.cyan(flag)}`
+    },
+    subcommandDescription: (cmd) => chalk.gray(cmd.description()),
+    optionDescription: (option) => chalk.gray(option.description),
+    commandDescription: (cmd) => chalk.gray(cmd.description()),
+  })
+
+  program.addHelpText(
+    'beforeAll',
+    `
+${chalk.bold.cyan('Membrane Agent CLI')} ${chalk.gray(`v${VERSION}`)}
+
+`,
+  )
+
+  setupPullCommand(program)
+  setupPushCommand(program)
+  setupTestCommand(program)
+  setupOpenCommand(program)
+
+  if (process.argv.length === 2) {
+    program.outputHelp()
+    process.exit(0)
+  }
+
+  program.parse()
+}

package/src/commands/open.command.ts

@@ -0,0 +1,51 @@
+import { Command } from 'commander'
+
+import { getWorkspaceId } from '../modules/api/workspace-api-client'
+import { readProjectConfig } from '../modules/config/project/readProjectConfig'
+import { Logger } from '../utils/logger'
+
+export function setupOpenCommand(program: Command): void {
+  program
+    .command('open')
+    .description('Open the workspace in the browser')
+    .addHelpText(
+      'after',
+      ['', 'Examples:', '  membrane open                     # Open workspace in browser', ''].join('\n'),
+    )
+    .action(async () => {
+      try {
+        Logger.header('Opening Workspace in Browser')
+
+        Logger.info('Loading configuration...')
+        const workspaceConfig = readProjectConfig()
+
+        if (!workspaceConfig) {
+          throw new Error('No membrane.config.yml found. Please run `membrane init` first.')
+        }
+
+        if (!workspaceConfig.workspaceKey || !workspaceConfig.workspaceSecret) {
+          throw new Error('Missing workspace credentials')
+        }
+
+        Logger.info('Retrieving workspace ID...')
+        const workspaceId = await getWorkspaceId(process.cwd())
+
+        const consoleUrl = `https://console.integration.app/w/${workspaceId}`
+
+        Logger.info(`Opening ${consoleUrl}...`)
+
+        // Use dynamic import for 'open' package since it's an ESM module
+        const { default: open } = await import('open')
+        await open(consoleUrl)
+
+        Logger.success('Browser opened successfully')
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          Logger.error(error.message)
+          process.exit(1)
+        }
+        Logger.error('An unknown error occurred')
+        process.exit(1)
+      }
+    })
+}

package/src/commands/pull.command.ts

@@ -0,0 +1,75 @@
+import { IntegrationAppClient } from '@integration-app/sdk'
+import { Command } from 'commander'
+import jwt from 'jsonwebtoken'
+
+import { pullWorkspace } from '../legacy/commands/pullWorkspace'
+import { readProjectConfig } from '../modules/config/project/readProjectConfig'
+import { getPaths } from '../utils/constants'
+import { Logger } from '../utils/logger'
+
+const DEFAULT_WORKSPACE_ALIAS = 'default'
+
+// Helper function to generate access token
+async function generateAccessToken(key: string, secret: string): Promise<string> {
+  const payload = {
+    iss: key,
+    exp: Math.floor(Date.now() / 1000) + 3600, // 1 hour
+    isAdmin: true,
+  }
+  return jwt.sign(payload, secret)
+}
+
+export function setupPullCommand(program: Command): void {
+  program
+    .command('pull')
+    .description('Pull workspace data from specified workspace')
+    .option('-w, --workspace <workspace>', 'Workspace to pull from', DEFAULT_WORKSPACE_ALIAS)
+    .option('-a, --all-connectors', 'Include store connectors in export', false)
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Examples:',
+        '  membrane pull                     # Pull from default workspace',
+        '  membrane pull -w prod             # Pull from prod workspace',
+        '  membrane pull -w dev              # Pull from dev workspace',
+        '  membrane pull -a                  # Pull with all connectors',
+        '  membrane pull -w dev -a           # Pull from dev workspace with all connectors',
+        '',
+      ].join('\n'),
+    )
+    .action(async (options: { workspace: string; allConnectors: boolean }) => {
+      Logger.header('Pulling Workspace Data')
+      Logger.divider()
+
+      Logger.info('Loading configuration...')
+      const workspaceConfig = readProjectConfig()
+
+      if (!workspaceConfig) {
+        throw new Error('No membrane.config.yml found. Please run `membrane init` first.')
+      }
+
+      if (!workspaceConfig.workspaceKey || !workspaceConfig.workspaceSecret) {
+        throw new Error('Missing workspace credentials')
+      }
+
+      const paths = getPaths()
+
+      // Create client
+      const client = new IntegrationAppClient({
+        token: await generateAccessToken(workspaceConfig.workspaceKey, workspaceConfig.workspaceSecret),
+        apiUri: workspaceConfig.apiUri,
+      })
+
+      // Perform pull using the full legacy logic
+      Logger.info(`Pulling from workspace...`)
+      await pullWorkspace({
+        allConnectors: options.allConnectors,
+        outputPath: paths.membraneDirPath,
+        client,
+      })
+
+      Logger.divider()
+      Logger.success('Pull completed successfully')
+    })
+}

package/src/commands/push.command.ts

@@ -0,0 +1,79 @@
+import { IntegrationAppClient } from '@integration-app/sdk'
+import { Command } from 'commander'
+import jwt from 'jsonwebtoken'
+
+import { pushWorkspace } from '../legacy/commands/pushWorkspace'
+import { readProjectConfig } from '../modules/config/project/readProjectConfig'
+import { getPaths } from '../utils/constants'
+import { Logger } from '../utils/logger'
+
+const DEFAULT_WORKSPACE_ALIAS = 'default'
+
+// Helper function to generate access token
+async function generateAccessToken(key: string, secret: string): Promise<string> {
+  const payload = {
+    iss: key,
+    exp: Math.floor(Date.now() / 1000) + 3600, // 1 hour
+    isAdmin: true,
+  }
+  return jwt.sign(payload, secret)
+}
+
+export function setupPushCommand(program: Command): void {
+  program
+    .command('push')
+    .description('Push workspace data to specified workspace')
+    .option('-w, --workspace <workspace>', 'Workspace to push to', DEFAULT_WORKSPACE_ALIAS)
+    .addHelpText(
+      'after',
+      [
+        '',
+        'Examples:',
+        '  membrane push                     # Push to default workspace',
+        '  membrane push -w prod             # Push to prod workspace',
+        '  membrane push -w dev              # Push to dev workspace',
+        '',
+      ].join('\n'),
+    )
+    .action(async (options: { workspace: string }) => {
+      try {
+        Logger.header('Pushing Workspace Data')
+
+        Logger.info('Loading configuration...')
+        const workspaceConfig = readProjectConfig()
+
+        if (!workspaceConfig) {
+          throw new Error('No membrane.config.yml found. Please run `membrane init` first.')
+        }
+
+        if (!workspaceConfig.workspaceKey || !workspaceConfig.workspaceSecret) {
+          throw new Error('Missing workspace credentials')
+        }
+
+        const currentWorkspace = options.workspace || DEFAULT_WORKSPACE_ALIAS
+
+        Logger.info('Preparing push configuration...')
+        const client = new IntegrationAppClient({
+          token: await generateAccessToken(workspaceConfig.workspaceKey, workspaceConfig.workspaceSecret),
+          apiUri: workspaceConfig.apiUri,
+        })
+
+        const paths = getPaths()
+
+        // Initial push
+        Logger.info(`Pushing to workspace ${currentWorkspace}...`)
+        await pushWorkspace({
+          basePath: paths.membraneDirPath,
+          client,
+        })
+        Logger.success(`Push to workspace ${currentWorkspace} completed successfully`)
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          Logger.error(error.message)
+          process.exit(1)
+        }
+        Logger.error('An unknown error occurred')
+        process.exit(1)
+      }
+    })
+}

package/src/commands/test.command.ts

@@ -0,0 +1,99 @@
+import chalk from 'chalk'
+import { Command } from 'commander'
+
+import { TestRunner } from '../testing/runners/test.runner'
+import { Logger } from '../utils/logger'
+
+// Helper function to create the experimental warning box
+const createExperimentalWarning = (): string => {
+  return [
+    chalk.yellow('┌─────────────────────────────────────────────────────────────────┐'),
+    chalk.yellow('│                 ⚠️  EXPERIMENTAL FEATURE WARNING                 │'),
+    chalk.yellow('├─────────────────────────────────────────────────────────────────┤'),
+    chalk.yellow('│ The test command is experimental and subject to rapid changes.  │'),
+    chalk.yellow('│ Features, APIs, and file structures may change without notice.  │'),
+    chalk.yellow('│ Use in production environments is not recommended.              │'),
+    chalk.yellow('└─────────────────────────────────────────────────────────────────┘'),
+    '',
+  ].join('\n')
+}
+
+interface TestOptions {
+  testPath: string
+  fix?: boolean
+  path?: string
+}
+
+export function setupTestCommand(program: Command): void {
+  const testCommand = program
+    .command('test')
+    .description(
+      '⚠️ EXPERIMENTAL: Test management commands - This feature is experimental and will be changing rapidly. Use at your own risk.',
+    )
+    .addHelpText('after', createExperimentalWarning())
+    .action(async () => {
+      console.warn(createExperimentalWarning())
+      Logger.error('Please specify a subcommand. Use --help for available options.')
+      process.exit(1)
+    })
+
+  testCommand
+    .command('run')
+    .description('Run integration tests for various membrane components')
+    .argument(
+      '<testPath>',
+      'Test path (e.g., "connectors/netsuite", "actions/create-contact", "connectors/hubspot/data/contacts", "connectors/netsuite/data/contacts/create")',
+    )
+    .option('-p, --path <path>', 'Additional path filter within the test scope')
+    .option('--fix', 'Enable auto-fix for test issues')
+    .addHelpText(
+      'after',
+      [
+        '',
+        chalk.bold('Examples:'),
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/netsuite')}                           # Test all data collections for netsuite connector`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/netsuite/data/contacts')}             # Test specific data collection`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/netsuite/data/contacts/create')}      # Test specific method for data collection`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/netsuite/data/contacts/delete')}      # Test delete method for data collection`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run actions/create-contact')}                        # Test specific action`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/hubspot/events')}                     # Test events for hubspot`,
+        `  ${chalk.gray('▸')} ${chalk.cyan('membrane test run connectors/salesforce --fix')}                   # Run tests with auto-fix enabled`,
+        '',
+        chalk.gray('For more information, visit:'),
+        chalk.blue('  https://docs.integration.app/cli'),
+        '',
+        createExperimentalWarning(),
+      ].join('\n'),
+    )
+    .action(async (testPath: string, options: TestOptions) => {
+      try {
+        // Show experimental warning
+        console.warn(createExperimentalWarning())
+
+        if (!testPath) {
+          Logger.error('Test path is required')
+          process.exit(1)
+        }
+
+        Logger.header(`Testing: ${testPath}`)
+
+        const runner = new TestRunner({
+          testPath,
+          path: options.path,
+          fix: options.fix,
+        })
+
+        await runner.initialize()
+        await runner.run()
+
+        Logger.success('Tests completed')
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          Logger.error(error.message)
+          process.exit(1)
+        }
+        Logger.error('An unknown error occurred')
+        process.exit(1)
+      }
+    })
+}