chore: import upstream snapshot with attribution

apps/sim/tools/sftp/delete.ts

@@ -0,0 +1,107 @@
+import type { SftpDeleteParams, SftpDeleteResult } from '@/tools/sftp/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const sftpDeleteTool: ToolConfig<SftpDeleteParams, SftpDeleteResult> = {
+  id: 'sftp_delete',
+  name: 'SFTP Delete',
+  description: 'Delete a file or directory on a remote SFTP server',
+  version: '1.0.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server port (default: 22)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP username',
+    },
+    password: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Password for authentication (if not using private key)',
+    },
+    privateKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Private key for authentication (OpenSSH format)',
+    },
+    passphrase: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Passphrase for encrypted private key',
+    },
+    remotePath: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Path to the file or directory to delete',
+    },
+    recursive: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Delete directories recursively',
+    },
+  },
+
+  request: {
+    url: '/api/tools/sftp/delete',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port) || 22,
+      username: params.username,
+      password: params.password,
+      privateKey: params.privateKey,
+      passphrase: params.passphrase,
+      remotePath: params.remotePath,
+      recursive: params.recursive || false,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: {
+          success: false,
+        },
+        error: data.error || 'SFTP delete failed',
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        success: true,
+        deletedPath: data.deletedPath,
+        message: data.message,
+      },
+    }
+  },
+
+  outputs: {
+    success: { type: 'boolean', description: 'Whether the deletion was successful' },
+    deletedPath: { type: 'string', description: 'Path that was deleted' },
+    message: { type: 'string', description: 'Operation status message' },
+  },
+}

apps/sim/tools/sftp/download.ts

@@ -0,0 +1,115 @@
+import type { SftpDownloadParams, SftpDownloadResult } from '@/tools/sftp/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const sftpDownloadTool: ToolConfig<SftpDownloadParams, SftpDownloadResult> = {
+  id: 'sftp_download',
+  name: 'SFTP Download',
+  description: 'Download a file from a remote SFTP server',
+  version: '1.0.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server port (default: 22)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP username',
+    },
+    password: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Password for authentication (if not using private key)',
+    },
+    privateKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Private key for authentication (OpenSSH format)',
+    },
+    passphrase: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Passphrase for encrypted private key',
+    },
+    remotePath: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Path to the file on the remote server',
+    },
+    encoding: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Output encoding: utf-8 for text, base64 for binary (default: utf-8)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/sftp/download',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port) || 22,
+      username: params.username,
+      password: params.password,
+      privateKey: params.privateKey,
+      passphrase: params.passphrase,
+      remotePath: params.remotePath,
+      encoding: params.encoding || 'utf-8',
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: {
+          success: false,
+        },
+        error: data.error || 'SFTP download failed',
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        success: true,
+        fileName: data.fileName,
+        file: data.file,
+        content: data.content,
+        size: data.size,
+        encoding: data.encoding,
+        message: data.message,
+      },
+    }
+  },
+
+  outputs: {
+    success: { type: 'boolean', description: 'Whether the download was successful' },
+    file: { type: 'file', description: 'Downloaded file stored in execution files' },
+    fileName: { type: 'string', description: 'Name of the downloaded file' },
+    content: { type: 'string', description: 'File content (text or base64 encoded)' },
+    size: { type: 'number', description: 'File size in bytes' },
+    encoding: { type: 'string', description: 'Content encoding (utf-8 or base64)' },
+    message: { type: 'string', description: 'Operation status message' },
+  },
+}

apps/sim/tools/sftp/index.ts

@@ -0,0 +1,5 @@
+export { sftpDeleteTool } from './delete'
+export { sftpDownloadTool } from './download'
+export { sftpListTool } from './list'
+export { sftpMkdirTool } from './mkdir'
+export { sftpUploadTool } from './upload'

apps/sim/tools/sftp/list.ts

@@ -0,0 +1,114 @@
+import type { SftpListParams, SftpListResult } from '@/tools/sftp/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const sftpListTool: ToolConfig<SftpListParams, SftpListResult> = {
+  id: 'sftp_list',
+  name: 'SFTP List Directory',
+  description: 'List files and directories on a remote SFTP server',
+  version: '1.0.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server port (default: 22)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP username',
+    },
+    password: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Password for authentication (if not using private key)',
+    },
+    privateKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Private key for authentication (OpenSSH format)',
+    },
+    passphrase: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Passphrase for encrypted private key',
+    },
+    remotePath: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Directory path on the remote server',
+    },
+    detailed: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Include detailed file information (size, permissions, modified date)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/sftp/list',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port) || 22,
+      username: params.username,
+      password: params.password,
+      privateKey: params.privateKey,
+      passphrase: params.passphrase,
+      remotePath: params.remotePath,
+      detailed: params.detailed || false,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: {
+          success: false,
+        },
+        error: data.error || 'SFTP list failed',
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        success: true,
+        path: data.path,
+        entries: data.entries,
+        count: data.count,
+        message: data.message,
+      },
+    }
+  },
+
+  outputs: {
+    success: { type: 'boolean', description: 'Whether the operation was successful' },
+    path: { type: 'string', description: 'Directory path that was listed' },
+    entries: {
+      type: 'json',
+      description: 'Array of directory entries with name, type, size, permissions, modifiedAt',
+    },
+    count: { type: 'number', description: 'Number of entries in the directory' },
+    message: { type: 'string', description: 'Operation status message' },
+  },
+}

apps/sim/tools/sftp/mkdir.ts

@@ -0,0 +1,107 @@
+import type { SftpMkdirParams, SftpMkdirResult } from '@/tools/sftp/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const sftpMkdirTool: ToolConfig<SftpMkdirParams, SftpMkdirResult> = {
+  id: 'sftp_mkdir',
+  name: 'SFTP Create Directory',
+  description: 'Create a directory on a remote SFTP server',
+  version: '1.0.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server port (default: 22)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP username',
+    },
+    password: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Password for authentication (if not using private key)',
+    },
+    privateKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Private key for authentication (OpenSSH format)',
+    },
+    passphrase: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Passphrase for encrypted private key',
+    },
+    remotePath: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Path for the new directory',
+    },
+    recursive: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Create parent directories if they do not exist',
+    },
+  },
+
+  request: {
+    url: '/api/tools/sftp/mkdir',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port) || 22,
+      username: params.username,
+      password: params.password,
+      privateKey: params.privateKey,
+      passphrase: params.passphrase,
+      remotePath: params.remotePath,
+      recursive: params.recursive || false,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: {
+          success: false,
+        },
+        error: data.error || 'SFTP mkdir failed',
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        success: true,
+        createdPath: data.createdPath,
+        message: data.message,
+      },
+    }
+  },
+
+  outputs: {
+    success: { type: 'boolean', description: 'Whether the directory was created successfully' },
+    createdPath: { type: 'string', description: 'Path of the created directory' },
+    message: { type: 'string', description: 'Operation status message' },
+  },
+}

apps/sim/tools/sftp/types.ts

@@ -0,0 +1,101 @@
+import type { UserFile } from '@/executor/types'
+import type { ToolFileData, ToolResponse } from '@/tools/types'
+
+interface SftpConnectionConfig {
+  host: string
+  port: number
+  username: string
+  password?: string
+  privateKey?: string
+  passphrase?: string
+}
+
+// Upload file params
+export interface SftpUploadParams extends SftpConnectionConfig {
+  remotePath: string
+  files?: UserFile[]
+  fileContent?: string // Direct content for text files
+  fileName?: string // File name when using direct content
+  overwrite?: boolean
+  permissions?: string
+}
+
+export interface SftpUploadResult extends ToolResponse {
+  output: {
+    success: boolean
+    uploadedFiles?: Array<{
+      name: string
+      remotePath: string
+      size: number
+    }>
+    message?: string
+  }
+}
+
+// Download file params
+export interface SftpDownloadParams extends SftpConnectionConfig {
+  remotePath: string
+  encoding?: 'utf-8' | 'base64'
+}
+
+export interface SftpDownloadResult extends ToolResponse {
+  output: {
+    success: boolean
+    fileName?: string
+    file?: ToolFileData
+    content?: string
+    size?: number
+    encoding?: string
+    message?: string
+  }
+}
+
+// List directory params
+export interface SftpListParams extends SftpConnectionConfig {
+  remotePath: string
+  detailed?: boolean
+}
+
+export interface SftpListResult extends ToolResponse {
+  output: {
+    success: boolean
+    path?: string
+    entries?: Array<{
+      name: string
+      type: 'file' | 'directory' | 'symlink' | 'other'
+      size?: number
+      permissions?: string
+      modifiedAt?: string
+    }>
+    count?: number
+    message?: string
+  }
+}
+
+// Delete file params
+export interface SftpDeleteParams extends SftpConnectionConfig {
+  remotePath: string
+  recursive?: boolean
+}
+
+export interface SftpDeleteResult extends ToolResponse {
+  output: {
+    success: boolean
+    deletedPath?: string
+    message?: string
+  }
+}
+
+// Mkdir params
+export interface SftpMkdirParams extends SftpConnectionConfig {
+  remotePath: string
+  recursive?: boolean
+}
+
+export interface SftpMkdirResult extends ToolResponse {
+  output: {
+    success: boolean
+    createdPath?: string
+    message?: string
+  }
+}

apps/sim/tools/sftp/upload.ts

@@ -0,0 +1,138 @@
+import type { SftpUploadParams, SftpUploadResult } from '@/tools/sftp/types'
+import type { ToolConfig } from '@/tools/types'
+
+export const sftpUploadTool: ToolConfig<SftpUploadParams, SftpUploadResult> = {
+  id: 'sftp_upload',
+  name: 'SFTP Upload',
+  description: 'Upload files to a remote SFTP server',
+  version: '1.0.0',
+
+  params: {
+    host: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server hostname or IP address',
+    },
+    port: {
+      type: 'number',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP server port (default: 22)',
+    },
+    username: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'SFTP username',
+    },
+    password: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Password for authentication (if not using private key)',
+    },
+    privateKey: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Private key for authentication (OpenSSH format)',
+    },
+    passphrase: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'Passphrase for encrypted private key',
+    },
+    remotePath: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'Destination directory on the remote server',
+    },
+    files: {
+      type: 'file[]',
+      required: false,
+      visibility: 'user-only',
+      description: 'Files to upload',
+    },
+    fileContent: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Direct file content to upload (for text files)',
+    },
+    fileName: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'File name when using direct content',
+    },
+    overwrite: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-only',
+      description: 'Whether to overwrite existing files (default: true)',
+    },
+    permissions: {
+      type: 'string',
+      required: false,
+      visibility: 'user-only',
+      description: 'File permissions (e.g., 0644)',
+    },
+  },
+
+  request: {
+    url: '/api/tools/sftp/upload',
+    method: 'POST',
+    headers: () => ({
+      'Content-Type': 'application/json',
+    }),
+    body: (params) => ({
+      host: params.host,
+      port: Number(params.port) || 22,
+      username: params.username,
+      password: params.password,
+      privateKey: params.privateKey,
+      passphrase: params.passphrase,
+      remotePath: params.remotePath,
+      files: params.files,
+      fileContent: params.fileContent,
+      fileName: params.fileName,
+      overwrite: params.overwrite !== false,
+      permissions: params.permissions,
+    }),
+  },
+
+  transformResponse: async (response: Response) => {
+    const data = await response.json()
+
+    if (!response.ok) {
+      return {
+        success: false,
+        output: {
+          success: false,
+        },
+        error: data.error || 'SFTP upload failed',
+      }
+    }
+
+    return {
+      success: true,
+      output: {
+        success: true,
+        uploadedFiles: data.uploadedFiles,
+        message: data.message,
+      },
+    }
+  },
+
+  outputs: {
+    success: { type: 'boolean', description: 'Whether the upload was successful' },
+    uploadedFiles: {
+      type: 'json',
+      description: 'Array of uploaded file details (name, remotePath, size)',
+    },
+    message: { type: 'string', description: 'Operation status message' },
+  },
+}