transfer_files_from_integration

Instructions

Implementation Reference

• src/api/integrations.ts:90-98 (schema)

  Zod schema definition for TransferFilesFromIntegration input validation. Defines fields: integrationId, files (array of TransferFileSchema), packageName, packageDescription, recipients, notifyEmail, accessLimit.

  const TransferFilesFromIntegrationSchema = z.object({
    integrationId: z.string().describe("ID of the cloud or storage gateway integration"),
    files: z.array(TransferFileSchema).min(1).describe("Array of files/directories to transfer from the integration"),
    packageName: z.string().describe("Name for the new package"),
    packageDescription: z.string().optional().describe("Description for the package"),
    recipients: z.array(z.email()).optional().describe("Email addresses to send package to"),
    notifyEmail: z.email().optional().describe("Email to notify on transfer completion"),
    accessLimit: z.number().optional().describe("Download access limit (default: 5)"),
  });

• src/api/integrations.ts:104-212 (handler)

  Main handler function transferFilesFromIntegration. Steps: (1) Gets integration provider details, (2) Creates a new package via MASV API, (3) Initiates a cloud-to-MASV transfer with the selected files, (4) Formats a human-readable response summarizing the transfer result.

  async function transferFilesFromIntegration({
    integrationId,
    files,
    packageName,
    packageDescription = "",
    recipients = [],
    notifyEmail,
    accessLimit = 5,
  }: TransferFilesFromIntegrationParams) {
    // Step 1: Get integration details to extract provider
    const integration = await getIntegration(integrationId);
    const provider = integration.provider;
  
    // Step 2: Create package
    const createPackageUrl = new URL(
      `${MASV_BASE_URL}/v1/teams/${MASV_TEAM_ID}/packages`,
    );
  
    const createPackageBody = {
      name: packageName,
      description: packageDescription,
      recipients: recipients,
      access_limit: accessLimit,
    };
  
    const createPackageHeaders = {
      "content-type": "application/json",
      "x-api-key": MASV_API_KEY,
    };
  
    const createPackageResponse = await fetch(createPackageUrl.toString(), {
      method: "POST",
      headers: createPackageHeaders,
      body: JSON.stringify(createPackageBody),
    });
  
    const packageData = await createPackageResponse.json();
  
    if (!createPackageResponse.ok) {
      throw new Error(`Failed to create package: ${JSON.stringify(packageData)}`);
    }
  
    const packageId = packageData.id;
    const packageToken = packageData.access_token;
  
    // Step 3: Initiate transfer
    const transferUrl = new URL(
      `${MASV_BASE_URL}/v1/packages/${packageId}/transfer`,
    );
  
    const transferBody = {
      cloud_connection_id: integrationId,
      direction: "cloud_to_masv",
      provider: provider,
      files: files,
      ...(notifyEmail && { notify_email: notifyEmail }),
    };
  
    const transferHeaders = {
      "content-type": "application/json",
      "x-package-token": packageToken,
    };
  
    const transferResponse = await fetch(transferUrl.toString(), {
      method: "POST",
      headers: transferHeaders,
      body: JSON.stringify(transferBody),
    });
  
    const transferData = await transferResponse.json();
  
    if (!transferResponse.ok) {
      throw new Error(`Failed to initiate transfer: ${JSON.stringify(transferData)}`);
    }
  
    // Step 4: Format response for LLM
    const fileCount = files.length;
  
    const fileList = files.slice(0, 10).map(file => {
      if (file.kind === "directory") {
        return `[DIR] ${file.name}/`;
      } else {
        return `[FILE] ${file.name}`;
      }
    });
  
    if (files.length > 10) {
      fileList.push(`... and ${files.length - 10} more items`);
    }
  
    const response = [
      "Transfer initiated successfully!",
      "",
      `Package: ${packageName}`,
      `Package ID: ${packageId}`,
      `Transfer ID: ${transferData.id}`,
      `Status: ${transferData.state}`,
      "",
      `Files being transferred (${fileCount} items):`,
      ...fileList,
      "",
      "Track progress:",
      `- Use get_activities tool with package_id: ${packageId}`,
      `- Use get_package tool with package_id: ${packageId}`,
      "- Or track progress in MASV web application",
    ].join("\n");
  
    return response;
  }

• src/index.ts:298-314 (registration)

  Registers the 'transfer_files_from_integration' tool on the MCP server with description, schema reference, and handler that calls transferFilesFromIntegration and returns success/error.

  server.registerTool(
    "transfer_files_from_integration",
    {
      description:
        "Transfer files from a cloud integration (AWS S3, Azure, Dropbox, etc.) or MASV Storage Gateway to MASV. Creates a new package and initiates the transfer. Use list_files_on_integration first to get file information including IDs.",
      inputSchema: TransferFilesFromIntegrationSchema.shape,
    },
    async (args) => {
      try {
        const data = await transferFilesFromIntegration(args);
  
        return mcpOk(data);
      } catch (error) {
        return mcpError(error);
      }
    },
  );

• src/api/integrations.ts:84-88 (helper)

  TransferFileSchema - a supporting schema for individual file/directory objects used within the files array parameter.

  const TransferFileSchema = z.object({
    id: z.string().describe("File ID, for Storage Gateway it is full file path (path + filename)"),
    name: z.string().describe("File or directory name"),
    kind: z.enum(["file", "directory"]).describe("Type of item: file or directory"),
  });

• src/api/integrations.ts:100-102 (helper)

  TypeScript type inferred from the TransferFilesFromIntegrationSchema for type safety.

  type TransferFilesFromIntegrationParams = z.infer<
    typeof TransferFilesFromIntegrationSchema
  >;