Function execute

apps/sim/lib/copilot/tools/server/files/workspace-file.ts:255–662

(
    params: WorkspaceFileArgs,
    context?: ServerToolContext
  )

export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, WorkspaceFileResult> = {
  name: WorkspaceFile.id,
  async execute(
    params: WorkspaceFileArgs,
    context?: ServerToolContext
  ): Promise<WorkspaceFileResult> {
    const withMessageId = (message: string) =>
      context?.messageId ? `${message} [messageId:${context.messageId}]` : message

    if (!context?.userId) {
      logger.error('Unauthorized attempt to access workspace files')
      throw new Error('Authentication required')
    }

    const raw = params as Record<string, unknown>
    const nested = raw.args as Record<string, unknown> | undefined
    const normalized: WorkspaceFileArgs =
      params.operation && params.target
        ? params
        : nested && typeof nested === 'object'
          ? {
              operation: (nested.operation ?? raw.operation) as WorkspaceFileOperation,
              target: (nested.target ?? raw.target) as WorkspaceFileTarget | undefined,
              title: (nested.title ?? raw.title) as string | undefined,
              content: (nested.content ?? raw.content) as string | undefined,
              contentType: (nested.contentType ?? raw.contentType) as string | undefined,
              newName: (nested.newName ?? raw.newName) as string | undefined,
              edit: (nested.edit ?? raw.edit) as WorkspaceFileEdit | undefined,
            }
          : params
    const { operation } = normalized
    const workspaceId = context.workspaceId

    const resolveExistingTarget = async (
      target: WorkspaceFileTarget | undefined,
      operationName: string
    ): Promise<{ fileRecord?: WorkspaceFileRecord; vfsPath?: string; error?: string }> => {
      if (!target || (target.kind !== 'path' && target.kind !== 'file_id')) {
        return { error: `${operationName} requires target.kind=path with target.path` }
      }
      let fileRecord: WorkspaceFileRecord | null = null
      let vfsPath: string | undefined
      if (target.kind === 'path') {
        const alias = await resolveWorkflowAliasForWorkspace({
          workspaceId: workspaceId!,
          path: target.path,
        })
        if (!alias && isPlanAliasPath(target.path)) {
          return { error: `Unsupported plan alias path or missing workflow: ${target.path}` }
        }
        if (alias) {
          if (alias.kind === 'plans_dir') {
            return { error: `Plan alias directory is not a file: ${target.path}` }
          }
          fileRecord = await resolveWorkspaceFileReference(workspaceId!, alias.backingPath)
          if (!fileRecord && alias.kind === 'changelog') {
            await ensureWorkflowAliasBacking({
              workspaceId: workspaceId!,
              userId: context.userId,
              workflowId: alias.workflowId,