How to Integrate Replit with Dropbox

1import os
2import dropbox
3from dropbox.exceptions import ApiError, AuthError
4from dropbox.files import WriteMode
5
6# Initialize client using token from Replit Secrets
7ACCESS_TOKEN = os.environ["DROPBOX_ACCESS_TOKEN"]
8
9try:
10    dbx = dropbox.Dropbox(ACCESS_TOKEN)
11    # Verify token is valid
12    account = dbx.users_get_current_account()
13    print(f"Connected to Dropbox as: {account.name.display_name}")
14except AuthError as e:
15    print(f"Authentication failed: {e}")
16    raise
17
18def upload_file(local_path: str, dropbox_path: str) -> str:
19    """Upload a local file to Dropbox. Returns the file path on Dropbox."""
20    with open(local_path, "rb") as f:
21        file_data = f.read()
22    try:
23        result = dbx.files_upload(
24            file_data,
25            dropbox_path,
26            mode=WriteMode.overwrite,
27            mute=True  # Don't trigger desktop notifications
28        )
29        print(f"Uploaded {local_path} to {result.path_display}")
30        return result.path_display
31    except ApiError as e:
32        print(f"Upload failed: {e}")
33        raise
34
35def download_file(dropbox_path: str, local_path: str) -> None:
36    """Download a file from Dropbox to a local path."""
37    try:
38        metadata, response = dbx.files_download(dropbox_path)
39        with open(local_path, "wb") as f:
40            f.write(response.content)
41        print(f"Downloaded {dropbox_path} ({metadata.size} bytes)")
42    except ApiError as e:
43        print(f"Download failed: {e}")
44        raise
45
46def list_folder(dropbox_path: str) -> list:
47    """List files in a Dropbox folder."""
48    try:
49        result = dbx.files_list_folder(dropbox_path)
50        entries = []
51        while True:
52            for entry in result.entries:
53                entries.append({
54                    "name": entry.name,
55                    "path": entry.path_display,
56                    "type": "folder" if isinstance(entry, dropbox.files.FolderMetadata) else "file"
57                })
58            if not result.has_more:
59                break
60            result = dbx.files_list_folder_continue(result.cursor)
61        return entries
62    except ApiError as e:
63        print(f"List folder failed: {e}")
64        raise
65
66def create_shared_link(dropbox_path: str) -> str:
67    """Create a public shared link for a file."""
68    try:
69        link_metadata = dbx.sharing_create_shared_link_with_settings(dropbox_path)
70        return link_metadata.url
71    except ApiError as e:
72        # Link may already exist — retrieve existing link
73        links = dbx.sharing_list_shared_links(path=dropbox_path)
74        if links.links:
75            return links.links[0].url
76        raise
77
78# Example usage
79if __name__ == "__main__":
80    upload_file("report.csv", "/reports/report.csv")
81    entries = list_folder("/reports")
82    for entry in entries:
83        print(f"{entry['type']}: {entry['name']}")
84    url = create_shared_link("/reports/report.csv")
85    print(f"Share link: {url}")

1const express = require('express');
2const { Dropbox } = require('dropbox');
3const fetch = require('node-fetch');
4const fs = require('fs');
5const path = require('path');
6
7const app = express();
8app.use(express.json());
9
10// Initialize Dropbox client using token from Replit Secrets
11const dbx = new Dropbox({
12  accessToken: process.env.DROPBOX_ACCESS_TOKEN,
13  fetch: fetch  // Required for Node.js < 18
14});
15
16// Verify connection on startup
17dbx.usersGetCurrentAccount()
18  .then(response => console.log(`Connected to Dropbox as: ${response.result.name.display_name}`))
19  .catch(err => console.error('Dropbox auth failed:', err));
20
21// Upload a file to Dropbox
22app.post('/upload', async (req, res) => {
23  const { localPath, dropboxPath } = req.body;
24  if (!localPath || !dropboxPath) {
25    return res.status(400).json({ error: 'localPath and dropboxPath are required' });
26  }
27  try {
28    const fileContent = fs.readFileSync(localPath);
29    const response = await dbx.filesUpload({
30      path: dropboxPath,
31      contents: fileContent,
32      mode: { '.tag': 'overwrite' },
33      mute: true
34    });
35    res.json({ success: true, path: response.result.path_display });
36  } catch (err) {
37    console.error('Upload error:', err);
38    res.status(500).json({ error: err.message });
39  }
40});
41
42// List folder contents
43app.get('/files', async (req, res) => {
44  const folderPath = req.query.path || '';
45  try {
46    const response = await dbx.filesListFolder({ path: folderPath });
47    const entries = response.result.entries.map(entry => ({
48      name: entry.name,
49      path: entry.path_display,
50      type: entry['.tag']
51    }));
52    res.json({ entries });
53  } catch (err) {
54    console.error('List error:', err);
55    res.status(500).json({ error: err.message });
56  }
57});
58
59// Create a shared link
60app.post('/share', async (req, res) => {
61  const { dropboxPath } = req.body;
62  if (!dropboxPath) {
63    return res.status(400).json({ error: 'dropboxPath is required' });
64  }
65  try {
66    const response = await dbx.sharingCreateSharedLinkWithSettings({
67      path: dropboxPath
68    });
69    res.json({ url: response.result.url });
70  } catch (err) {
71    // If link already exists, retrieve it
72    if (err.status === 409) {
73      const existing = await dbx.sharingListSharedLinks({ path: dropboxPath });
74      if (existing.result.links.length > 0) {
75        return res.json({ url: existing.result.links[0].url });
76      }
77    }
78    console.error('Share error:', err);
79    res.status(500).json({ error: err.message });
80  }
81});
82
83app.listen(3000, '0.0.0.0', () => {
84  console.log('Dropbox integration server running on port 3000');
85});