How to Integrate Replit with Box

1import os
2import base64
3import json
4
5# Option A: Individual secrets
6BOX_CONFIG = {
7    "boxAppSettings": {
8        "clientID": os.environ["BOX_CLIENT_ID"],
9        "clientSecret": os.environ["BOX_CLIENT_SECRET"],
10        "appAuth": {
11            "publicKeyID": os.environ["BOX_JWT_KEY_ID"],
12            "privateKey": os.environ["BOX_PRIVATE_KEY"].replace("\\n", "\n"),
13            "passphrase": os.environ["BOX_PASSPHRASE"]
14        }
15    },
16    "enterpriseID": os.environ["BOX_ENTERPRISE_ID"]
17}
18
19# Option B: Base64-encoded full JSON config (simpler)
20# config_b64 = os.environ["BOX_CONFIG_JSON"]
21# BOX_CONFIG = json.loads(base64.b64decode(config_b64).decode())
22
23print("Box config loaded:", BOX_CONFIG["boxAppSettings"]["clientID"])

1import os
2import json
3from boxsdk import JWTAuth, Client
4
5# Load Box configuration from Replit Secrets
6box_config = {
7    "boxAppSettings": {
8        "clientID": os.environ["BOX_CLIENT_ID"],
9        "clientSecret": os.environ["BOX_CLIENT_SECRET"],
10        "appAuth": {
11            "publicKeyID": os.environ["BOX_JWT_KEY_ID"],
12            "privateKey": os.environ["BOX_PRIVATE_KEY"].replace("\\n", "\n"),
13            "passphrase": os.environ["BOX_PASSPHRASE"]
14        }
15    },
16    "enterpriseID": os.environ["BOX_ENTERPRISE_ID"]
17}
18
19# Authenticate using JWT service account
20auth = JWTAuth.from_settings_dictionary(box_config)
21client = Client(auth)
22
23def list_folder(folder_id: str = '0') -> list:
24    """List contents of a Box folder. Root folder ID is '0'."""
25    folder = client.folder(folder_id).get()
26    items = []
27    for item in client.folder(folder_id).get_items():
28        items.append({
29            'id': item.id,
30            'name': item.name,
31            'type': item.type,  # 'file' or 'folder'
32        })
33    return items
34
35def upload_file(folder_id: str, file_path: str, file_name: str = None) -> dict:
36    """Upload a local file to a Box folder."""
37    name = file_name or os.path.basename(file_path)
38    with open(file_path, 'rb') as f:
39        uploaded = client.folder(folder_id).upload_stream(f, name)
40    return {'id': uploaded.id, 'name': uploaded.name}
41
42def download_file(file_id: str, local_path: str) -> str:
43    """Download a Box file to a local path."""
44    with open(local_path, 'wb') as f:
45        client.file(file_id).download_to(f)
46    return local_path
47
48def create_folder(parent_folder_id: str, folder_name: str) -> dict:
49    """Create a new subfolder inside a Box folder."""
50    folder = client.folder(parent_folder_id).create_subfolder(folder_name)
51    return {'id': folder.id, 'name': folder.name}
52
53def search_files(query: str, limit: int = 20) -> list:
54    """Search Box content by name or text."""
55    results = client.search().query(query, limit=limit)
56    return [{'id': item.id, 'name': item.name, 'type': item.type} for item in results]
57
58def create_shared_link(file_id: str, access: str = 'open') -> str:
59    """Create a shared link for a Box file. access: 'open', 'company', or 'collaborators'."""
60    file_obj = client.file(file_id).update_info(data={
61        'shared_link': {'access': access}
62    })
63    return file_obj.shared_link['url']
64
65if __name__ == '__main__':
66    # List root folder
67    print('Root folder contents:')
68    items = list_folder('0')
69    for item in items[:5]:
70        print(f"  [{item['type']}] {item['name']} (ID: {item['id']})")
71
72    # Search for files
73    results = search_files('quarterly report')
74    print(f"\nSearch results: {len(results)} files found")

1const express = require('express');
2const fileUpload = require('express-fileupload');
3const BoxSDK = require('box-node-sdk');
4
5const app = express();
6app.use(express.json());
7app.use(fileUpload({ limits: { fileSize: 50 * 1024 * 1024 } })); // 50MB limit
8
9// Initialize Box SDK with JWT service account
10const sdk = new BoxSDK({
11  clientID: process.env.BOX_CLIENT_ID,
12  clientSecret: process.env.BOX_CLIENT_SECRET,
13  appAuth: {
14    keyID: process.env.BOX_JWT_KEY_ID,
15    privateKey: (process.env.BOX_PRIVATE_KEY || '').replace(/\\n/g, '\n'),
16    passphrase: process.env.BOX_PASSPHRASE
17  }
18});
19
20// Create app enterprise client (service account)
21const client = sdk.getAppAuthClient('enterprise', process.env.BOX_ENTERPRISE_ID);
22
23// GET /folders/:id — list folder contents
24app.get('/folders/:id', async (req, res) => {
25  try {
26    const folderId = req.params.id || '0';
27    const items = await client.folders.getItems(folderId, { fields: 'id,name,type,size' });
28    res.json(items.entries);
29  } catch (err) {
30    console.error('Box error:', err.message);
31    res.status(500).json({ error: err.message });
32  }
33});
34
35// POST /folders/:id/upload — upload file to folder
36app.post('/folders/:id/upload', async (req, res) => {
37  if (!req.files || !req.files.file) {
38    return res.status(400).json({ error: 'No file uploaded' });
39  }
40  const file = req.files.file;
41  try {
42    const uploaded = await client.files.uploadFile(
43      req.params.id,
44      file.name,
45      file.data
46    );
47    res.json({ id: uploaded.entries[0].id, name: uploaded.entries[0].name });
48  } catch (err) {
49    res.status(500).json({ error: err.message });
50  }
51});
52
53// GET /files/:id/download — download file
54app.get('/files/:id/download', async (req, res) => {
55  try {
56    const stream = await client.files.getReadStream(req.params.id);
57    stream.pipe(res);
58  } catch (err) {
59    res.status(500).json({ error: err.message });
60  }
61});
62
63// GET /search — search Box content
64app.get('/search', async (req, res) => {
65  const { q } = req.query;
66  if (!q) return res.status(400).json({ error: 'Query parameter q is required' });
67  try {
68    const results = await client.search.query(q, { limit: 20 });
69    res.json(results.entries.map(item => ({ id: item.id, name: item.name, type: item.type })));
70  } catch (err) {
71    res.status(500).json({ error: err.message });
72  }
73});
74
75app.listen(3000, '0.0.0.0', () => {
76  console.log('Box API server running on port 3000');
77});

1import os
2import hmac
3import hashlib
4from flask import Flask, request, jsonify
5from boxsdk import JWTAuth, Client
6
7app = Flask(__name__)
8
9WEBHOOK_KEY = os.environ.get('BOX_WEBHOOK_KEY', '')
10
11# Initialize Box client (same as above)
12box_config = {
13    "boxAppSettings": {
14        "clientID": os.environ["BOX_CLIENT_ID"],
15        "clientSecret": os.environ["BOX_CLIENT_SECRET"],
16        "appAuth": {
17            "publicKeyID": os.environ["BOX_JWT_KEY_ID"],
18            "privateKey": os.environ["BOX_PRIVATE_KEY"].replace("\\n", "\n"),
19            "passphrase": os.environ["BOX_PASSPHRASE"]
20        }
21    },
22    "enterpriseID": os.environ["BOX_ENTERPRISE_ID"]
23}
24auth = JWTAuth.from_settings_dictionary(box_config)
25box_client = Client(auth)
26
27def verify_box_signature(body: bytes, primary_sig: str, secondary_sig: str, delivery_ts: str) -> bool:
28    """Verify Box webhook signature for security."""
29    if not WEBHOOK_KEY:
30        return True  # Skip verification if no key configured
31    message = body + delivery_ts.encode()
32    expected = hmac.new(WEBHOOK_KEY.encode(), message, hashlib.sha256).digest()
33    import base64
34    expected_b64 = base64.b64encode(expected).decode()
35    return primary_sig == expected_b64 or secondary_sig == expected_b64
36
37@app.route('/box/webhook', methods=['POST'])
38def box_webhook():
39    primary_sig = request.headers.get('Box-Signature-Primary', '')
40    secondary_sig = request.headers.get('Box-Signature-Secondary', '')
41    delivery_ts = request.headers.get('Box-Delivery-Timestamp', '')
42
43    if not verify_box_signature(request.data, primary_sig, secondary_sig, delivery_ts):
44        return jsonify({'error': 'Invalid signature'}), 401
45
46    payload = request.json
47    event_type = payload.get('trigger')  # e.g., 'FILE.UPLOADED'
48    source = payload.get('source', {})
49    file_name = source.get('name', '')
50    file_id = source.get('id', '')
51
52    print(f"Box webhook: {event_type} on file '{file_name}' (ID: {file_id})")
53
54    if event_type == 'FILE.UPLOADED':
55        # File was uploaded — trigger processing workflow
56        print(f"New file uploaded to Box: {file_name}")
57    elif event_type == 'FILE.MOVED':
58        print(f"File {file_name} was moved")
59
60    return jsonify({'received': True}), 200
61
62if __name__ == '__main__':
63    app.run(host='0.0.0.0', port=3000)