@membranehq/cli 0.1.1

package/src/modules/config/project/useProjectConfig.tsx

@@ -0,0 +1,103 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import { createContext, useCallback, useContext, useEffect, useState } from 'react'
+import type { PropsWithChildren } from 'react'
+import YAML from 'js-yaml'
+import { z } from 'zod'
+
+import { useCwd } from '../cwd-context'
+import { readProjectConfig } from './readProjectConfig'
+
+const CONFIG_FILE_NAME = 'membrane.config.yml'
+
+export const configSchema = z.object({
+  workspaceKey: z.string().optional(),
+  workspaceSecret: z.string().optional(),
+  apiUri: z.string().optional(),
+  testCustomerId: z.string().optional(),
+  anthropicApiKey: z.string().optional(),
+})
+
+export type ProjectConfig = z.infer<typeof configSchema>
+
+export const commandSchema = z.enum(['pull'])
+export type Command = z.infer<typeof commandSchema>
+
+interface IProjectConfigContext {
+  readonly config: ProjectConfig | null
+  readonly isLoading: boolean
+  readonly updateConfig: (newConfig: Partial<ProjectConfig>) => boolean
+  readonly validateConfig: () => boolean
+}
+
+const ProjectConfigContext = createContext<IProjectConfigContext | undefined>(undefined)
+
+export function ProjectConfigProvider({ children }: PropsWithChildren) {
+  const cwd = useCwd()
+  const [config, setConfig] = useState<ProjectConfig | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+
+  useEffect(() => {
+    const config = readProjectConfig(cwd)
+    setConfig(config)
+    setIsLoading(false)
+  }, [cwd])
+
+  const updateConfig = useCallback(
+    (newConfig: Partial<ProjectConfig>): boolean => {
+      const configPath = path.join(cwd, CONFIG_FILE_NAME)
+      const currentConfig = readProjectConfig(cwd) ?? {}
+      const newConfigData = {
+        ...currentConfig,
+        ...newConfig,
+      }
+
+      const validationResult = configSchema.safeParse(newConfigData)
+      if (!validationResult.success) {
+        return false
+      }
+
+      fs.writeFileSync(configPath, YAML.dump(validationResult.data))
+      setConfig(validationResult.data)
+      return true
+    },
+    [cwd],
+  )
+
+  const validateConfig = useCallback((): boolean => {
+    return !!(config?.workspaceKey && config?.workspaceSecret)
+  }, [config])
+
+  const value: IProjectConfigContext = {
+    config,
+    isLoading,
+    updateConfig,
+    validateConfig,
+  }
+
+  return <ProjectConfigContext.Provider value={value}>{children}</ProjectConfigContext.Provider>
+}
+
+export function useProjectConfig(): IProjectConfigContext {
+  const context = useContext(ProjectConfigContext)
+  if (context === undefined) {
+    throw new Error('useProjectConfig must be used within a ProjectConfigProvider')
+  }
+  return context
+}
+
+export function clearWorkspaceConfig(): void {
+  const cwd = process.cwd()
+  const configPath = path.join(cwd, CONFIG_FILE_NAME)
+  const currentConfig = readProjectConfig(cwd) ?? {}
+  const newConfigData = {
+    ...currentConfig,
+    workspaceKey: undefined,
+    workspaceSecret: undefined,
+  }
+  // Remove keys if present
+  delete newConfigData.workspaceKey
+  delete newConfigData.workspaceSecret
+  fs.writeFileSync(configPath, YAML.dump(newConfigData))
+}

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

@@ -0,0 +1,35 @@
+import os from 'os'
+import path from 'path'
+
+import Conf from 'conf'
+
+const schema = {
+  pat: {
+    type: 'string',
+  },
+  workspace: {
+    type: 'object',
+  },
+}
+
+const config = new Conf({
+  schema,
+  configName: 'config',
+  cwd: path.join(os.homedir(), '.membrane'),
+})
+
+export const setPat = (token: string): void => {
+  config.set('pat', token)
+}
+
+export const getPat = (): string | undefined => {
+  return config.get('pat') as string | undefined
+}
+
+export const hasPat = (): boolean => {
+  return !!config.get('pat')
+}
+
+export const clearPat = (): void => {
+  config.delete('pat')
+}

package/src/modules/file-watcher/index.ts

@@ -0,0 +1,166 @@
+import * as crypto from 'node:crypto'
+import { EventEmitter } from 'node:events'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import chokidar from 'chokidar'
+import yaml from 'yaml'
+
+import { FileChangeEventType, FileChangeEvent, FileChangeEventMap } from './types'
+import { getMembraneDir, IGNORED_FILES } from '../config/project/paths'
+
+import type { FSWatcher } from 'chokidar'
+
+type WatchOptions = Parameters<typeof chokidar.watch>[1]
+
+const DEFAULT_WATCHER_CONFIG: WatchOptions = {
+  ignored: IGNORED_FILES,
+  persistent: true,
+  ignoreInitial: true,
+  followSymlinks: false,
+  depth: 10,
+  awaitWriteFinish: {
+    stabilityThreshold: 500,
+    pollInterval: 100,
+  },
+  ignorePermissionErrors: true,
+  atomic: true,
+  usePolling: false,
+  alwaysStat: false,
+  interval: 1000,
+  binaryInterval: 300,
+}
+
+export class FileWatcher extends EventEmitter<FileChangeEventMap> {
+  private isWatching = false
+  private watcher?: FSWatcher
+  private readonly membraneDir: string
+  private readonly contentCache: Record<string, string> = {}
+
+  constructor(private readonly options: { cwd: string }) {
+    super()
+    this.membraneDir = getMembraneDir(options.cwd)
+  }
+
+  /**
+   * Starts the file watcher
+   */
+  async start(): Promise<void> {
+    if (this.isWatching) {
+      return
+    }
+    if (!fs.existsSync(this.membraneDir)) {
+      fs.mkdirSync(this.membraneDir, { recursive: true })
+    }
+
+    this.watcher = chokidar.watch(this.membraneDir, DEFAULT_WATCHER_CONFIG)
+    this.watcher
+      .on('add', (filePath) => this.handleFileSystemEvent('added', filePath))
+      .on('change', (filePath) => this.handleFileSystemEvent('changed', filePath))
+      .on('unlink', (filePath) => this.handleFileSystemEvent('deleted', filePath))
+      .on('ready', () => (this.isWatching = true))
+  }
+
+  /**
+   * Stops the file watcher
+   */
+  async stop(): Promise<void> {
+    if (!this.isWatching || !this.watcher) {
+      return
+    }
+
+    await this.watcher.close()
+    this.isWatching = false
+    this.watcher = undefined
+    this.clearCache()
+    this.emit('stopped')
+  }
+
+  getCwd(): string {
+    return this.options.cwd
+  }
+
+  /**
+   * Handles file system events and only emits when content actually changes
+   */
+  private handleFileSystemEvent(eventType: FileChangeEventType, filePath: string): void {
+    const relativePath = path.relative(this.membraneDir, filePath)
+
+    if (eventType === 'deleted') {
+      this.removeFromCache(relativePath)
+      const event: FileChangeEvent = {
+        filePath,
+        relativePath,
+        data: undefined,
+      }
+      this.emit(eventType, event)
+      return
+    }
+
+    const fileContent = this.readFileContent(filePath)
+
+    const hasContentChanged = this.hasContentChanged(relativePath, fileContent, eventType)
+    if (!hasContentChanged) {
+      return
+    }
+
+    const event = this.processFileEvent(filePath, fileContent)
+    this.updateCache(relativePath, fileContent)
+    this.emit(eventType, event)
+  }
+
+  private readFileContent(filePath: string): string {
+    return fs.readFileSync(filePath, 'utf8')
+  }
+
+  private processFileEvent(filePath: string, fileContent: string): FileChangeEvent | null {
+    const relativePath = path.relative(this.membraneDir, filePath)
+
+    let data: any
+    try {
+      data = fileContent ? yaml.parse(fileContent) : undefined
+    } catch (_error) {
+      data = undefined
+    }
+
+    return { filePath, relativePath, data }
+  }
+
+  private hasContentChanged(relativePath: string, fileContent: string, eventType: FileChangeEventType): boolean {
+    if (eventType === 'added') {
+      return true
+    }
+
+    if (!fileContent) {
+      return this.contentCache[relativePath] !== undefined
+    }
+
+    const contentHash = this.getContentHash(fileContent)
+    const cachedHash = this.contentCache[relativePath]
+
+    return cachedHash !== contentHash
+  }
+
+  private getContentHash(fileContent: string): string {
+    return crypto.createHash('sha256').update(fileContent).digest('hex')
+  }
+
+  private updateCache(relativePath: string, fileContent: string | null): void {
+    if (!fileContent) {
+      delete this.contentCache[relativePath]
+      return
+    }
+
+    this.contentCache[relativePath] = this.getContentHash(fileContent)
+  }
+
+  private removeFromCache(relativePath: string): void {
+    delete this.contentCache[relativePath]
+  }
+
+  private clearCache(): void {
+    Object.keys(this.contentCache).forEach((key) => {
+      delete this.contentCache[key]
+    })
+  }
+}

package/src/modules/file-watcher/types.ts

@@ -0,0 +1,14 @@
+export interface FileChangeEvent {
+  filePath: string
+  relativePath: string
+  data?: any
+}
+
+export type FileChangeEventMap = {
+  added: [FileChangeEvent]
+  changed: [FileChangeEvent]
+  deleted: [FileChangeEvent]
+  stopped: []
+}
+
+export type FileChangeEventType = keyof FileChangeEventMap

package/src/modules/setup/steps.ts

@@ -0,0 +1,9 @@
+export enum Step {
+  Authenticate,
+  ConnectWorkspace,
+}
+
+export const STEP_LABELS: Record<Step, string> = {
+  [Step.Authenticate]: 'Authenticate in Membrane',
+  [Step.ConnectWorkspace]: 'Connect a Membrane Workspace',
+}

package/src/modules/setup/useSetup.ts

@@ -0,0 +1,16 @@
+import { useProjectConfig } from '../config/project'
+import { hasPat } from '../config/system'
+
+export const useSetup = () => {
+  const { config } = useProjectConfig()
+
+  const isAuthenticated = hasPat()
+  const workspaceIsConfigured = !!(config?.workspaceKey && config?.workspaceSecret)
+  const isSetupComplete = isAuthenticated && workspaceIsConfigured
+
+  return {
+    isAuthenticated,
+    workspaceIsConfigured,
+    isSetupComplete,
+  }
+}

package/src/modules/status/useStatus.ts

@@ -0,0 +1,16 @@
+import { useCwd } from '../config/cwd-context'
+import { useProjectConfig } from '../config/project'
+import { useSetup } from '../setup/useSetup'
+
+export const useStatus = () => {
+  const { isSetupComplete } = useSetup()
+  const { config } = useProjectConfig()
+  const cwd = useCwd()
+
+  return {
+    isSetupComplete,
+    workspaceKey: config?.workspaceKey,
+    config,
+    cwd,
+  }
+}

package/src/modules/workspace-element-service/constants.ts

@@ -0,0 +1,121 @@
+import { WorkspaceElementType } from '@integration-app/sdk'
+
+export interface ElementConfig {
+  element: string
+  elements: string
+  exportable?: boolean
+  integrationSpecific?: boolean
+}
+
+export const INTEGRATION_ELEMENTS: Record<WorkspaceElementType, ElementConfig> = {
+  [WorkspaceElementType.Integration]: {
+    element: 'integration',
+    elements: 'integrations',
+    exportable: false,
+  },
+  [WorkspaceElementType.Connector]: {
+    element: 'connector',
+    elements: 'connectors',
+    exportable: false,
+  },
+  [WorkspaceElementType.Action]: {
+    element: 'action',
+    elements: 'actions',
+    integrationSpecific: true,
+  },
+  [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,
+  },
+  [WorkspaceElementType.Flow]: {
+    element: 'flow',
+    elements: 'flows',
+    integrationSpecific: true,
+  },
+  [WorkspaceElementType.Customer]: {
+    element: 'customer',
+    elements: 'customers',
+  },
+  [WorkspaceElementType.FlowInstance]: {
+    element: 'flowInstance',
+    elements: 'flowInstances',
+  },
+  [WorkspaceElementType.FlowRun]: {
+    element: 'flowRun',
+    elements: 'flowRuns',
+  },
+  [WorkspaceElementType.Scenario]: {
+    element: 'scenario',
+    elements: 'scenarios',
+  },
+  [WorkspaceElementType.ActionInstance]: {
+    element: 'actionInstance',
+    elements: 'actionInstances',
+  },
+  [WorkspaceElementType.Connection]: {
+    element: 'connection',
+    elements: 'connections',
+  },
+  [WorkspaceElementType.FieldMappingInstance]: {
+    element: 'fieldMappingInstance',
+    elements: 'fieldMappingInstances',
+  },
+  [WorkspaceElementType.DataSourceInstance]: {
+    element: 'dataSourceInstance',
+    elements: 'dataSourceInstances',
+  },
+  [WorkspaceElementType.DataLinkTableInstance]: {
+    element: 'dataLinkTableInstance',
+    elements: 'dataLinkTableInstances',
+  },
+  [WorkspaceElementType.AppEventSubscription]: {
+    element: 'appEventSubscription',
+    elements: 'appEventSubscriptions',
+  },
+  [WorkspaceElementType.AppDataSchemaInstance]: {
+    element: 'appDataSchemaInstance',
+    elements: 'appDataSchemaInstances',
+  },
+  [WorkspaceElementType.ExternalEventSubscription]: {
+    element: 'externalEventSubscription',
+    elements: 'externalEventSubscriptions',
+  },
+  [WorkspaceElementType.ExternalEventLogRecord]: {
+    element: 'externalEventLogRecord',
+    elements: 'externalEventLogRecords',
+  },
+  [WorkspaceElementType.ExternalEventPull]: {
+    element: 'externalEventPull',
+    elements: 'externalEventPulls',
+  },
+  [WorkspaceElementType.DataCollection]: {
+    element: 'dataCollection',
+    elements: 'dataCollections',
+  },
+  [WorkspaceElementType.Screen]: {
+    element: 'screen',
+    elements: 'screens',
+  },
+  [WorkspaceElementType.ActionRunLogRecord]: {
+    element: 'actionRunLogRecord',
+    elements: 'actionRunLogRecords',
+  },
+}

package/src/modules/workspace-element-service/getTypeAndKeyFromPath.ts

@@ -0,0 +1,69 @@
+import * as path from 'node:path'
+
+import { WorkspaceElementSpecs, WorkspaceElementType } from '@integration-app/sdk'
+
+export interface WorkspaceElementKeyReference {
+  readonly type: WorkspaceElementType
+  readonly key: string
+}
+
+export function getTypeAndKeyFromPath(relativePath: string): WorkspaceElementKeyReference | undefined {
+  // NOTE: skip connector files for now
+  if (isConnectorFile(relativePath)) {
+    return undefined
+  }
+
+  if (isWorkspaceElementFile(relativePath)) {
+    return extractWorkspaceElementKeyReference(relativePath)
+  }
+  return undefined
+}
+
+function extractWorkspaceElementKeyReference(relativePath: string): WorkspaceElementKeyReference | undefined {
+  const elementTypes = Object.values(WorkspaceElementSpecs).map((spec) => spec.apiPath)
+
+  // <element-type>/<element-key>/spec.yml or .yaml
+  const universalElementPattern = new RegExp(
+    `^(?<elementTypePlural>${elementTypes.join('|')})\/(?<elementKey>[^\/]+)\/spec\.y[a]*ml$`,
+  )
+  const universalMatch = relativePath.match(universalElementPattern)
+  if (universalMatch && universalMatch.groups) {
+    const { elementTypePlural, elementKey } = universalMatch.groups
+    const type = getWorkspaceElementTypeFromFolderName(elementTypePlural)
+    if (type) {
+      return { key: elementKey, type }
+    }
+  }
+
+  // integrations/<integration-key>/<element-type>/<element-key>/spec.yml or .yaml
+  const integratedElementPattern = new RegExp(
+    `^integrations\/(?<integrationKey>[^\/]+)\/(?<elementTypePlural>${elementTypes.join('|')})\/(?<elementKey>[^\/]+)\/spec\.y[a]*ml$`,
+  )
+  const integratedMatch = relativePath.match(integratedElementPattern)
+  if (integratedMatch && integratedMatch.groups) {
+    const { elementTypePlural, elementKey } = integratedMatch.groups
+    const type = getWorkspaceElementTypeFromFolderName(elementTypePlural)
+    if (type) {
+      return { key: elementKey, type }
+    }
+  }
+
+  return undefined
+}
+
+function isWorkspaceElementFile(relativePath: string): boolean {
+  return relativePath.endsWith('.yml') || relativePath.endsWith('.yaml')
+}
+
+function isConnectorFile(relativePath: string): boolean {
+  const [rootDir] = relativePath.split(path.sep)
+  return rootDir === WorkspaceElementSpecs[WorkspaceElementType.Connector].apiPath
+}
+
+function getWorkspaceElementTypeFromFolderName(folderName: string): WorkspaceElementType | undefined {
+  return Object.values(WorkspaceElementType).find((type) => getWorkspaceElementTypeFolderName(type) === folderName)
+}
+
+function getWorkspaceElementTypeFolderName(type: WorkspaceElementType): string {
+  return WorkspaceElementSpecs[type].apiPath
+}