@membranehq/cli 0.1.1 → 0.1.2

package/src/legacy/workspace-tools/integrationElements.ts

@@ -1,78 +0,0 @@
-import { WorkspaceElementType } from '@integration-app/sdk'
-
-export const INTEGRATION_ELEMENTS = {
-  [WorkspaceElementType.Integration]: {
-    element: 'integration',
-    elements: 'integrations',
-    exportable: false,
-    exportCleanup: (el) => {
-      return {
-        id: el.id,
-        key: el.key,
-        name: el.name,
-        connectorId: el.connectorId,
-        baseUri: el.baseUri,
-        connectorVersion: el.connectorVersion,
-      }
-    },
-  },
-  [WorkspaceElementType.Connector]: {
-    element: 'connector',
-    elements: 'connectors',
-    exportable: false,
-  },
-  [WorkspaceElementType.Action]: {
-    element: 'action',
-    elements: 'actions',
-    integrationSpecific: true,
-    exportCleanup: (el) => {
-      delete el.integration
-      return el
-    },
-  },
-  [WorkspaceElementType.AppDataSchema]: {
-    element: 'appDataSchema',
-    elements: 'appDataSchemas',
-  },
-  [WorkspaceElementType.AppEventType]: {
-    element: 'appEventType',
-    elements: 'appEventTypes',
-  },
-  [WorkspaceElementType.DataLinkTable]: {
-    element: 'dataLinkTable',
-    elements: 'dataLinkTables',
-  },
-  [WorkspaceElementType.DataSource]: {
-    element: 'dataSource',
-    elements: 'dataSources',
-    integrationSpecific: true,
-  },
-  [WorkspaceElementType.FieldMapping]: {
-    element: 'fieldMapping',
-    elements: 'fieldMappings',
-    integrationSpecific: true,
-    exportCleanup: (fieldMapping) => {
-      delete fieldMapping.dataSourceId
-      return fieldMapping
-    },
-  },
-  [WorkspaceElementType.Flow]: {
-    element: 'flow',
-    elements: 'flows',
-    integrationSpecific: true,
-  },
-}
-
-export function baseExportCleanup(element) {
-  delete element.workspaceId
-  delete element.createdAt
-  delete element.updatedAt
-  delete element.revision
-  delete element.parentRevision
-  Object.keys(element).map((key) => {
-    if (key.match(/universal.*Revision/g)) {
-      delete element[key]
-    }
-  })
-  return element
-}

package/src/legacy/workspace-tools/util.ts

@@ -1,149 +0,0 @@
-import { INTEGRATION_ELEMENTS, baseExportCleanup } from './integrationElements'
-import { Logger } from '../../utils/logger'
-import { WorkspaceData } from '../types'
-
-async function getWorkspaceData(iApp, logs = 'full'): Promise<WorkspaceData> {
-  const workspaceData: any = {}
-
-  Logger.info('Getting remote workspace data')
-
-  const integrations = await iApp.integrations.findAll()
-  workspaceData.integration = integrations.map((item) => cleanUpForExport('integration', item))
-
-  for (const elementType of Object.keys(INTEGRATION_ELEMENTS) as any[]) {
-    const element = INTEGRATION_ELEMENTS[elementType]
-    if (element.exportable === false) continue
-
-    const elementEnteties = []
-    Logger.info(`Reading ${element.elements} from remote workspace`)
-    // Get all universal elements
-    const elements = await iApp[element.elements].findAll()
-
-    elementEnteties.push(
-      ...elements.map((item) => {
-        return cleanUpForExport(elementType, item)
-      }),
-    )
-
-    // Get all integration specific elements
-    if (element.integrationSpecific) {
-      for (const integration of integrations) {
-        const integrationElements = await iApp[element.elements].findAll({
-          integrationId: integration.id,
-        })
-        elementEnteties.push(
-          ...integrationElements.map((item) => {
-            item.integrationKey = integration.key
-            return cleanUpForExport(elementType, item)
-          }),
-        )
-      }
-    }
-
-    if (elementEnteties.length > 0) {
-      if (logs == 'full') {
-        // eslint-disable-next-line no-console
-        console.table(
-          elementEnteties
-            .map((item) => {
-              return {
-                key: item.key,
-                integrationKey: item.integrationKey,
-                universal: !item.integrationKey,
-              }
-            })
-            .reduce((acc, item) => {
-              if (!acc) {
-                acc = {}
-              }
-              if (!acc[item.key]) {
-                acc[item.key] = {}
-              }
-              if (item.universal) {
-                acc[item.key].universal = true
-              }
-              if (item.integrationKey) {
-                if (!acc[item.key].integration) {
-                  acc[item.key].integration = item.integrationKey
-                } else {
-                  acc[item.key].integration += ` ${item.integrationKey}`
-                }
-              }
-              return acc
-            }, {}),
-        )
-        // eslint-disable-next-line no-console
-        console.groupEnd()
-      }
-    }
-    workspaceData[elementType] = elementEnteties
-  }
-  Logger.success('Remote workspace data retrieved successfully')
-  return workspaceData
-}
-
-function splitWorkspaceData(data: WorkspaceData) {
-  const universalElements: any = {}
-  const integrationSpecificElements: any = {}
-  for (const elementType of Object.keys(data)) {
-    universalElements[elementType] = []
-    integrationSpecificElements[elementType] = []
-
-    const isIntegrationSpecific = INTEGRATION_ELEMENTS[elementType]?.integrationSpecific
-
-    if (isIntegrationSpecific) {
-      for (const element of data[elementType]) {
-        if (element.integrationKey || element.integration || element.integrationId) {
-          integrationSpecificElements[elementType].push(element)
-        } else {
-          universalElements[elementType].push(element)
-        }
-      }
-    } else {
-      universalElements[elementType].push(...data[elementType])
-    }
-  }
-  return { universalElements, integrationSpecificElements }
-}
-function cleanUpForExport(elementType, element) {
-  element = baseExportCleanup(element)
-  return INTEGRATION_ELEMENTS[elementType].exportCleanup
-    ? INTEGRATION_ELEMENTS[elementType].exportCleanup(element)
-    : element
-}
-function hasParent(element) {
-  return Object.keys(element).some((key) => /universal.*Id/g.test(key) || /parentId/g.test(key))
-}
-
-function coloredLog(message, color) {
-  const colors = {
-    Reset: '\x1b[0m',
-    Bright: '\x1b[1m',
-    Dim: '\x1b[2m',
-    Underscore: '\x1b[4m',
-    Blink: '\x1b[5m',
-    Reverse: '\x1b[7m',
-    Hidden: '\x1b[8m',
-    Black: '\x1b[30m',
-    Red: '\x1b[31m',
-    Green: '\x1b[32m',
-    Yellow: '\x1b[33m',
-    Blue: '\x1b[34m',
-    Magenta: '\x1b[35m',
-    Cyan: '\x1b[36m',
-    White: '\x1b[37m',
-    Gray: '\x1b[90m',
-    BgBlack: '\x1b[40m',
-    BgRed: '\x1b[41m',
-    BgGreen: '\x1b[42m',
-    BgYellow: '\x1b[43m',
-    BgBlue: '\x1b[44m',
-    BgMagenta: '\x1b[45m',
-    BgCyan: '\x1b[46m',
-    BgWhite: '\x1b[47m',
-    BgGray: '\x1b[100m',
-  }
-  console.debug('\x1b[0m', `\x1b[${colors[color]}`, message, '\x1b[0m')
-}
-
-export { getWorkspaceData, splitWorkspaceData, hasParent, coloredLog }

package/src/mcp/server-status.ts

@@ -1,27 +0,0 @@
-type McpServerStatus = 'starting' | 'running' | 'error'
-
-let status: McpServerStatus = 'starting'
-let url = ''
-const listeners = new Set<(status: McpServerStatus) => void>()
-
-export function getMcpServerStatus(): McpServerStatus {
-  return status
-}
-
-export function setMcpServerStatus(newStatus: McpServerStatus): void {
-  status = newStatus
-  listeners.forEach((cb) => cb(status))
-}
-
-export function subscribeMcpServerStatus(cb: (status: McpServerStatus) => void): () => void {
-  listeners.add(cb)
-  return () => listeners.delete(cb)
-}
-
-export function getMcpServerUrl(): string {
-  return url
-}
-
-export function setMcpServerUrl(newUrl: string): void {
-  url = newUrl
-}

package/src/mcp/server.ts

@@ -1,36 +0,0 @@
-import { FastMCP } from 'fastmcp'
-
-import { setMcpServerStatus, setMcpServerUrl } from './server-status'
-import { getTestAccessTokenTool } from './tools/getTestAccessToken'
-import { getAgentVersion } from '../modules/config/project/getAgentVersion'
-
-/**
- * Starts the FastMCP server with HTTP streaming transport.
- * Exposes a simple 'hello' tool.
- */
-export async function startMcpServer(): Promise<void> {
-  setMcpServerStatus('starting')
-  const mcpServer = new FastMCP({
-    name: 'Membrane',
-    instructions: `Use this server for anything related to building software integrations.
-It provides tools for working with Membrane - a Universal Integration Layer for your product.
-Full documentation (fetch it when building integrations) is here: https://docs.integration.app/llms.txt`,
-    version: getAgentVersion(),
-  })
-
-  // Register tools
-  mcpServer.addTool(getTestAccessTokenTool())
-
-  try {
-    await mcpServer.start({
-      transportType: 'httpStream',
-      httpStream: {
-        port: 8001,
-      },
-    })
-    setMcpServerUrl('http://localhost:8001/mcp')
-    setMcpServerStatus('running')
-  } catch {
-    setMcpServerStatus('error')
-  }
-}

package/src/mcp/tools/getTestAccessToken.ts

@@ -1,32 +0,0 @@
-import jwt from 'jsonwebtoken'
-import { z } from 'zod'
-
-import { CONFIG_FILE_NAME, readProjectConfig } from '../../modules/config/project/readProjectConfig'
-
-export function getTestAccessTokenTool() {
-  return {
-    name: 'getTestAccessToken',
-    description:
-      'Returns a JWT access token for your test customer in Membrane. Use this whenever you want to test any integration functionality. The token is used as bearer token in any API requests to Membrane or for initializing its SDK.',
-    parameters: z.object({}),
-    async execute() {
-      const config = readProjectConfig()
-
-      if (!config.workspaceKey || !config.workspaceSecret) {
-        throw new Error(`workspaceKey or workspaceSecret not found in ${CONFIG_FILE_NAME}`)
-      }
-
-      // Generate JWT as per docs
-      const tokenData = {
-        id: config.testCustomerId || 'test-customer',
-      }
-      const options = {
-        issuer: config.workspaceKey,
-        expiresIn: 7200,
-        algorithm: 'HS512' as const,
-      }
-      const token = jwt.sign(tokenData, config.workspaceSecret, options)
-      return token
-    },
-  }
-}

package/src/modules/api/account-api-client.ts

@@ -1,89 +0,0 @@
-import { getPat } from '../config/system'
-
-const DEFAULT_API_BASE_URL = 'https://api.integration.app'
-
-export class AccountApiClient {
-  constructor(private readonly apiBaseUrl: string = DEFAULT_API_BASE_URL) {}
-
-  public async request<T>(path: string, options: RequestInit = {}): Promise<T> {
-    // Start with headers from options, or new Headers
-    const headers = options.headers
-      ? options.headers instanceof Headers
-        ? new Headers(options.headers)
-        : new Headers(options.headers as Record<string, string>)
-      : new Headers()
-
-    // Set Authorization if not already set
-    if (!headers.has('Authorization')) {
-      const pat = getPat()
-      if (!pat) {
-        throw new Error('Personal Access Token not found.')
-      }
-
-      headers.set('Authorization', `Bearer ${pat}`)
-    }
-
-    // Set Content-Type if body is present and not already set
-    if (options.body && !headers.has('Content-Type')) {
-      headers.set('Content-Type', 'application/json')
-    }
-
-    const response = await fetch(`${this.apiBaseUrl}${path}`, {
-      ...options,
-      headers,
-    })
-
-    if (!response.ok) {
-      const errorBody = await response.text()
-      throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorBody}`)
-    }
-
-    if (response.status === 204) {
-      return {} as T
-    }
-
-    const responseText = await response.text()
-
-    return JSON.parse(responseText)
-  }
-
-  public get<T>(path: string): Promise<T> {
-    return this.request<T>(path, { method: 'GET' })
-  }
-
-  public post<T>(path: string, body: unknown): Promise<T> {
-    return this.request<T>(path, {
-      method: 'POST',
-      body: JSON.stringify(body),
-    })
-  }
-
-  public put<T>(path: string, body: unknown): Promise<T> {
-    return this.request<T>(path, {
-      method: 'PUT',
-      body: JSON.stringify(body),
-    })
-  }
-
-  public patch<T>(path: string, body: unknown): Promise<T> {
-    return this.request<T>(path, {
-      method: 'PATCH',
-      body: JSON.stringify(body),
-    })
-  }
-
-  public delete<T>(path: string): Promise<T> {
-    return this.request<T>(path, { method: 'DELETE' })
-  }
-}
-
-export const apiClient = new AccountApiClient()
-
-// Legacy export for backward compatibility
-export const accountApiFetcher = (path: string) => apiClient.get(path)
-
-// New centralized fetcher that can be configured with project settings
-export const createAccountApiFetcher = (apiUri?: string) => {
-  const client = new AccountApiClient(apiUri || DEFAULT_API_BASE_URL)
-  return (path: string) => client.get(path)
-}

package/src/modules/api/index.ts

@@ -1,3 +0,0 @@
-export * from './account-api-client'
-export * from './membrane-api-client'
-export * from './workspace-api-client'

package/src/modules/api/membrane-api-client.ts

@@ -1,116 +0,0 @@
-import { IntegrationAppClient } from '@integration-app/sdk'
-import jwt from 'jsonwebtoken'
-
-import { readProjectConfig } from '../config/project/readProjectConfig'
-
-interface ClientConfig {
-  workspaceKey: string
-  workspaceSecret: string
-  apiUri?: string
-}
-
-class MembraneClient {
-  private client: IntegrationAppClient | null = null
-  private currentConfig: ClientConfig | null = null
-  private tokenExpiry: number = 0
-
-  /**
-   * Generates an access token for the workspace
-   */
-  private async generateAccessToken(key: string, secret: string): Promise<string> {
-    return jwt.sign(
-      {
-        name: 'Membrane Agent',
-        isAdmin: true,
-        exp: Math.floor(Date.now() / 1000) + 3600,
-        iss: key,
-      },
-      secret,
-      { algorithm: 'HS512' },
-    )
-  }
-
-  /**
-   * Checks if the current token is still valid
-   */
-  private isTokenValid(): boolean {
-    return Date.now() < this.tokenExpiry
-  }
-
-  /**
-   * Gets the current workspace configuration
-   */
-  private getCurrentConfig(cwd: string): ClientConfig | null {
-    const config = readProjectConfig(cwd)
-
-    if (!config?.workspaceKey || !config?.workspaceSecret) {
-      return null
-    }
-
-    return {
-      workspaceKey: config.workspaceKey,
-      workspaceSecret: config.workspaceSecret,
-      apiUri: config.apiUri,
-    }
-  }
-
-  /**
-   * Creates or updates the client with new configuration
-   */
-  private async createClient(config: ClientConfig): Promise<IntegrationAppClient> {
-    const token = await this.generateAccessToken(config.workspaceKey, config.workspaceSecret)
-
-    this.tokenExpiry = Date.now() + 3600000 // 1 hour from now
-    this.currentConfig = config
-
-    return new IntegrationAppClient({
-      token,
-      apiUri: config.apiUri,
-    })
-  }
-
-  /**
-   * Gets the IntegrationAppClient instance, creating or updating it as needed
-   */
-  async getClient(cwd: string): Promise<IntegrationAppClient> {
-    const config = this.getCurrentConfig(cwd)
-
-    if (!config) {
-      throw new Error('Unable to create IntegrationAppClient: No workspace configuration found.')
-    }
-
-    // Check if we need to create a new client or update existing one
-    const configChanged =
-      !this.currentConfig ||
-      this.currentConfig.workspaceKey !== config.workspaceKey ||
-      this.currentConfig.workspaceSecret !== config.workspaceSecret ||
-      this.currentConfig.apiUri !== config.apiUri
-
-    // Check if token is expired or will expire soon (within 5 minutes)
-    const tokenExpired = !this.isTokenValid() || this.tokenExpiry - Date.now() < 300000
-
-    if (!this.client || configChanged || tokenExpired) {
-      this.client = await this.createClient(config)
-    }
-    return this.client
-  }
-
-  /**
-   * Clears the current client (useful for testing or when config is invalid)
-   */
-  clearClient(): void {
-    this.client = null
-    this.currentConfig = null
-    this.tokenExpiry = 0
-  }
-
-  /**
-   * Gets the current configuration (for debugging)
-   */
-  getCurrentConfigInfo(): ClientConfig | null {
-    return this.currentConfig
-  }
-}
-
-// Export singleton instance
-export const membraneClient = new MembraneClient()

package/src/modules/api/workspace-api-client.ts

@@ -1,11 +0,0 @@
-import { membraneClient } from './membrane-api-client'
-
-export async function getWorkspaceId(cwd: string): Promise<string> {
-  const client = await membraneClient.getClient(cwd)
-  if (!client) {
-    throw new Error('No workspace configuration found')
-  }
-
-  const response = await client.get('org-workspace-id')
-  return response.id
-}

package/src/modules/config/cwd-context.tsx

@@ -1,11 +0,0 @@
-import React, { createContext, useContext } from 'react'
-
-const CwdContext = createContext<string>(process.cwd())
-
-export function CwdProvider({ cwd, children }: { cwd: string; children: React.ReactNode }) {
-  return <CwdContext.Provider value={cwd}>{children}</CwdContext.Provider>
-}
-
-export function useCwd(): string {
-  return useContext(CwdContext)
-}

package/src/modules/config/project/getAgentVersion.ts

@@ -1,16 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-export function getAgentVersion(): `${number}.${number}.${number}` {
-  try {
-    const pkgPath = path.join(__dirname, '../../../package.json')
-    const pkgRaw = fs.readFileSync(pkgPath, 'utf8')
-    const pkg = JSON.parse(pkgRaw)
-    if (typeof pkg.version === 'string' && /^\d+\.\d+\.\d+$/.test(pkg.version)) {
-      return pkg.version as `${number}.${number}.${number}`
-    }
-    return '0.0.0'
-  } catch {
-    return '0.0.0'
-  }
-}

package/src/modules/config/project/index.ts

@@ -1,8 +0,0 @@
-/**
- * Project Configuration Manager
- *
- * This module provides a configuration manager for handling membrane.config.yml file.
- * It includes a hook to access the config manager instance.
- */
-
-export * from './useProjectConfig'

package/src/modules/config/project/paths.ts

@@ -1,25 +0,0 @@
-import * as path from 'node:path'
-
-const MEMBRANE_DIR_NAME = 'membrane'
-
-export const IGNORED_FILES = [
-  '**/node_modules/**',
-  '**/.git/**',
-  '**/.DS_Store',
-  '**/Thumbs.db',
-  '**/*.tmp',
-  '**/*.swp',
-  '**/*.swo',
-  '**/*.log',
-  '**/*.lock',
-  '**/dist/**',
-  '**/build/**',
-  '**/.cache/**',
-  '**/.next/**',
-  '**/.vscode/**',
-  '**/.idea/**',
-]
-
-export function getMembraneDir(cwd: string): string {
-  return path.join(cwd, MEMBRANE_DIR_NAME)
-}

package/src/modules/config/project/readProjectConfig.ts

@@ -1,27 +0,0 @@
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-import YAML from 'js-yaml'
-
-import { configSchema, type ProjectConfig } from './useProjectConfig'
-
-export const CONFIG_FILE_NAME = 'membrane.config.yml'
-
-/**
- * Reads and parses membrane.config.yml from the given cwd (or process.cwd() by default).
- * Returns the validated ProjectConfig or null if not found/invalid.
- */
-export function readProjectConfig(cwd?: string): ProjectConfig | null {
-  const configPath = path.join(cwd ?? process.cwd(), CONFIG_FILE_NAME)
-  try {
-    const configFile = fs.readFileSync(configPath, 'utf8')
-    const parsedConfig = YAML.load(configFile)
-    const validation = configSchema.safeParse(parsedConfig)
-    if (validation.success) {
-      return validation.data
-    }
-    return null
-  } catch (_error) {
-    return null
-  }
-}