chore: import upstream snapshot with attribution

apps/sim/lib/resources/orchestration/index.ts

@@ -0,0 +1,5 @@
+export {
+  type PerformRestoreResourceParams,
+  performRestoreResource,
+  type RestorableResourceType,
+} from './restore-resource'

apps/sim/lib/resources/orchestration/restore-resource.ts

@@ -0,0 +1,179 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { generateId } from '@sim/utils/id'
+import type { MothershipResource } from '@/lib/copilot/resources/types'
+import type { ToolExecutionResult } from '@/lib/copilot/tool-executor/types'
+import {
+  getRestorableKnowledgeBase,
+  performRestoreKnowledgeBase,
+} from '@/lib/knowledge/orchestration'
+import { performRestoreTable } from '@/lib/table/orchestration'
+import { getTableById } from '@/lib/table/service'
+import { getWorkspaceFile } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
+import { performRestoreFolder, performRestoreWorkflow } from '@/lib/workflows/orchestration'
+import { getWorkflowById } from '@/lib/workflows/utils'
+import {
+  performRestoreWorkspaceFile,
+  performRestoreWorkspaceFileFolder,
+} from '@/lib/workspace-files/orchestration'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('RestoreResourceOrchestration')
+
+export type RestorableResourceType =
+  | 'workflow'
+  | 'table'
+  | 'file'
+  | 'knowledgebase'
+  | 'folder'
+  | 'file_folder'
+
+export interface PerformRestoreResourceParams {
+  type: RestorableResourceType
+  id: string
+  userId: string
+  workspaceId: string
+  requestId?: string
+}
+
+async function hasWriteAccess(
+  userId: string,
+  callerWorkspaceId: string,
+  resourceWorkspaceId: string | null | undefined
+): Promise<boolean> {
+  if (!resourceWorkspaceId || resourceWorkspaceId !== callerWorkspaceId) return false
+  const permission = await getUserEntityPermissions(userId, 'workspace', resourceWorkspaceId)
+  return permission === 'write' || permission === 'admin'
+}
+
+function success(
+  output: Record<string, unknown>,
+  resources?: MothershipResource[]
+): ToolExecutionResult {
+  return { success: true, output, resources }
+}
+
+export async function performRestoreResource(
+  params: PerformRestoreResourceParams
+): Promise<ToolExecutionResult> {
+  const { type, id, userId, workspaceId } = params
+  const requestId = params.requestId ?? generateId().slice(0, 8)
+
+  try {
+    switch (type) {
+      case 'workflow': {
+        const existing = await getWorkflowById(id, { includeArchived: true })
+        if (!existing || !(await hasWriteAccess(userId, workspaceId, existing.workspaceId))) {
+          return { success: false, error: 'Workflow not found' }
+        }
+
+        const result = await performRestoreWorkflow({ workflowId: id, userId, requestId })
+        if (!result.success || !result.workflow) {
+          return { success: false, error: result.error || 'Failed to restore workflow' }
+        }
+
+        logger.info('Workflow restored via restore_resource', { workflowId: id })
+        return success({ type, id, name: result.workflow.name }, [
+          { type: 'workflow', id, title: result.workflow.name || id },
+        ])
+      }
+
+      case 'table': {
+        const existing = await getTableById(id, { includeArchived: true })
+        if (!existing || !(await hasWriteAccess(userId, workspaceId, existing.workspaceId))) {
+          return { success: false, error: 'Table not found' }
+        }
+
+        const result = await performRestoreTable({ tableId: id, userId, requestId })
+        if (!result.success || !result.table) {
+          return { success: false, error: result.error || 'Failed to restore table' }
+        }
+
+        logger.info('Table restored via restore_resource', { tableId: id, name: result.table.name })
+        return success({ type, id, name: result.table.name }, [
+          { type: 'table', id, title: result.table.name },
+        ])
+      }
+
+      case 'file': {
+        if (!(await hasWriteAccess(userId, workspaceId, workspaceId))) {
+          return { success: false, error: 'File not found' }
+        }
+
+        const result = await performRestoreWorkspaceFile({ workspaceId, fileId: id, userId })
+        if (!result.success) {
+          return { success: false, error: result.error || 'Failed to restore file' }
+        }
+
+        const file = await getWorkspaceFile(workspaceId, id)
+        const fileName = file?.name || id
+        logger.info('File restored via restore_resource', { fileId: id, name: fileName })
+        return success({ type, id, name: fileName }, [{ type: 'file', id, title: fileName }])
+      }
+
+      case 'knowledgebase': {
+        const existing = await getRestorableKnowledgeBase(id)
+        if (!existing || !(await hasWriteAccess(userId, workspaceId, existing.workspaceId))) {
+          return { success: false, error: 'Knowledge base not found' }
+        }
+
+        const result = await performRestoreKnowledgeBase({
+          knowledgeBaseId: id,
+          userId,
+          requestId,
+        })
+        if (!result.success || !result.knowledgeBase) {
+          return { success: false, error: result.error || 'Failed to restore knowledge base' }
+        }
+
+        logger.info('Knowledge base restored via restore_resource', { knowledgeBaseId: id })
+        return success({ type, id, name: result.knowledgeBase.name }, [
+          { type: 'knowledgebase', id, title: result.knowledgeBase.name },
+        ])
+      }
+
+      case 'folder': {
+        if (!(await hasWriteAccess(userId, workspaceId, workspaceId))) {
+          return { success: false, error: 'Folder not found' }
+        }
+
+        const result = await performRestoreFolder({ folderId: id, workspaceId, userId })
+        if (!result.success) {
+          return { success: false, error: result.error || 'Failed to restore folder' }
+        }
+
+        logger.info('Folder restored via restore_resource', { folderId: id })
+        return success({ type, id, restoredItems: result.restoredItems })
+      }
+
+      case 'file_folder': {
+        if (!(await hasWriteAccess(userId, workspaceId, workspaceId))) {
+          return { success: false, error: 'File folder not found' }
+        }
+
+        const result = await performRestoreWorkspaceFileFolder({
+          workspaceId,
+          folderId: id,
+          userId,
+        })
+        if (!result.success || !result.folder || !result.restoredItems) {
+          return { success: false, error: result.error || 'Failed to restore file folder' }
+        }
+
+        logger.info('File folder restored via restore_resource', {
+          folderId: id,
+          restoredItems: result.restoredItems,
+        })
+        return success({
+          type,
+          id,
+          name: result.folder.name,
+          restoredItems: result.restoredItems,
+        })
+      }
+    }
+  } catch (error) {
+    logger.error('Failed to restore resource via restore_resource', { type, id, error })
+    return { success: false, error: toError(error).message }
+  }
+}