modular-studio 1.0.6 → 1.1.0

package/dist-server/server/routes/connectors/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../../../server/routes/connectors/github.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,QAAA,MAAM,MAAM,4CAAW,CAAC;AAqMxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/connectors/github.js

@@ -0,0 +1,195 @@
+/**
+ * GitHub Connector — Issues + PRs
+ * Issues #90, #99
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, fetchPaginated, connectorError, getApiKey, formatTimestamp } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const GH_API = 'https://api.github.com';
+function ghHeaders(token) {
+    return {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing apiKey' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${GH_API}/user`, { headers: ghHeaders(apiKey) });
+        if (!resp.ok) {
+            res.status(401).json({ status: 'error', error: 'Invalid GitHub token' });
+            return;
+        }
+        const user = await resp.json();
+        sessionKeys.set('github', apiKey);
+        res.json({ status: 'ok', data: { user: user.name ?? user.login } });
+    }
+    catch (err) {
+        connectorError(res, 'GitHub', err);
+    }
+});
+// ── Fetch Issues ──
+router.post('/issues', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('github', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No GitHub token. Test connection first.' });
+        return;
+    }
+    const repo = body.repo;
+    const state = body.state ?? 'open';
+    const labels = body.labels;
+    if (!repo || !repo.includes('/')) {
+        res.status(400).json({ status: 'error', error: 'repo must be owner/name format' });
+        return;
+    }
+    try {
+        const items = await fetchPaginated({
+            maxPages: 5,
+            maxItems: 200,
+            fetchPage: async (cursor) => {
+                const params = new URLSearchParams({ state, per_page: '100', sort: 'updated', direction: 'desc' });
+                if (labels?.length)
+                    params.set('labels', labels.join(','));
+                if (cursor)
+                    params.set('page', cursor);
+                const resp = await rateLimitedFetch(`${GH_API}/repos/${repo}/issues?${params}`, { headers: ghHeaders(token) });
+                if (!resp.ok)
+                    throw new Error(`GitHub API ${resp.status}`);
+                const data = await resp.json();
+                // Filter out pull requests (GitHub API returns PRs as issues)
+                const issues = data.filter((d) => !d.pull_request);
+                // Check for next page via Link header
+                const link = resp.headers.get('Link') ?? '';
+                const nextMatch = link.match(/page=(\d+)>; rel="next"/);
+                const nextCursor = nextMatch ? nextMatch[1] : undefined;
+                return {
+                    items: issues.map((issue) => ({
+                        number: issue.number,
+                        title: issue.title,
+                        body: issue.body ?? '',
+                        state: issue.state,
+                        labels: (issue.labels ?? []).map((l) => l.name),
+                        assignee: issue.assignee?.login ?? 'unassigned',
+                        author: issue.user?.login ?? '',
+                        createdAt: issue.created_at,
+                        updatedAt: issue.updated_at,
+                        comments: issue.comments ?? 0,
+                        url: issue.html_url,
+                    })),
+                    nextCursor,
+                };
+            },
+        });
+        // Convert to markdown
+        const markdown = items.map((issue) => `## #${issue.number}: ${issue.title}\n` +
+            `**Status:** ${issue.state} · **Assignee:** ${issue.assignee} · **Author:** ${issue.author}\n` +
+            `**Labels:** ${issue.labels.join(', ') || 'none'} · **Comments:** ${issue.comments}\n` +
+            `**Created:** ${formatTimestamp(issue.createdAt)} · **Updated:** ${formatTimestamp(issue.updatedAt)}\n\n` +
+            `${issue.body}\n`).join('\n---\n\n');
+        res.json({
+            status: 'ok',
+            data: {
+                items,
+                markdown,
+                count: items.length,
+                tokens: Math.ceil(markdown.length / 4),
+            },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'GitHub', err);
+    }
+});
+// ── Fetch PRs (#99) ──
+router.post('/pulls', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('github', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No GitHub token.' });
+        return;
+    }
+    const repo = body.repo;
+    const state = body.state ?? 'open';
+    if (!repo?.includes('/')) {
+        res.status(400).json({ status: 'error', error: 'repo must be owner/name format' });
+        return;
+    }
+    try {
+        const params = new URLSearchParams({ state, per_page: '50', sort: 'updated', direction: 'desc' });
+        const resp = await rateLimitedFetch(`${GH_API}/repos/${repo}/pulls?${params}`, { headers: ghHeaders(token) });
+        if (!resp.ok)
+            throw new Error(`GitHub API ${resp.status}`);
+        const prs = await resp.json();
+        const items = prs.map((pr) => ({
+            number: pr.number,
+            title: pr.title,
+            body: pr.body ?? '',
+            state: pr.state,
+            author: pr.user?.login ?? '',
+            draft: pr.draft ?? false,
+            additions: pr.additions ?? 0,
+            deletions: pr.deletions ?? 0,
+            changedFiles: pr.changed_files ?? 0,
+            createdAt: pr.created_at,
+            updatedAt: pr.updated_at,
+            mergedAt: pr.merged_at,
+            url: pr.html_url,
+        }));
+        const markdown = items.map((pr) => `## PR #${pr.number}: ${pr.title}${pr.draft ? ' [DRAFT]' : ''}\n` +
+            `**Status:** ${pr.mergedAt ? 'merged' : pr.state} · **Author:** ${pr.author}\n` +
+            `**Changes:** +${pr.additions} -${pr.deletions} in ${pr.changedFiles} files\n` +
+            `**Created:** ${formatTimestamp(pr.createdAt)}${pr.mergedAt ? ` · **Merged:** ${formatTimestamp(pr.mergedAt)}` : ''}\n\n` +
+            `${pr.body}\n`).join('\n---\n\n');
+        res.json({
+            status: 'ok',
+            data: { items, markdown, count: items.length, tokens: Math.ceil(markdown.length / 4) },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'GitHub', err);
+    }
+});
+// ── Search ──
+router.post('/search', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('github', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No GitHub token.' });
+        return;
+    }
+    const query = body.query;
+    const repo = body.repo;
+    if (!query) {
+        res.status(400).json({ status: 'error', error: 'query required' });
+        return;
+    }
+    try {
+        const q = repo ? `${query}+repo:${repo}` : query;
+        const resp = await rateLimitedFetch(`${GH_API}/search/issues?q=${encodeURIComponent(q)}&per_page=20`, { headers: ghHeaders(token) });
+        if (!resp.ok)
+            throw new Error(`GitHub search ${resp.status}`);
+        const data = await resp.json();
+        res.json({
+            status: 'ok',
+            data: data.items.map((i) => ({
+                number: i.number,
+                title: i.title,
+                type: i.pull_request ? 'pr' : 'issue',
+                state: i.state,
+                repo: i.repository_url?.split('/').slice(-2).join('/'),
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'GitHub', err);
+    }
+});
+export default router;

package/dist-server/server/routes/connectors/gmail.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Gmail Connector — Messages via search
+ * Issue #100
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=gmail.d.ts.map

package/dist-server/server/routes/connectors/gmail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gmail.d.ts","sourceRoot":"","sources":["../../../../server/routes/connectors/gmail.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,QAAA,MAAM,MAAM,4CAAW,CAAC;AAmIxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/connectors/gmail.js

@@ -0,0 +1,115 @@
+/**
+ * Gmail Connector — Messages via search
+ * Issue #100
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, connectorError, getApiKey } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const GMAIL_API = 'https://gmail.googleapis.com/gmail/v1/users/me';
+function gHeaders(token) {
+    return { Authorization: `Bearer ${token}` };
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing OAuth token' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${GMAIL_API}/profile`, { headers: gHeaders(apiKey) });
+        if (!resp.ok) {
+            res.status(401).json({ status: 'error', error: 'Invalid Gmail token' });
+            return;
+        }
+        const data = await resp.json();
+        sessionKeys.set('gmail', apiKey);
+        res.json({ status: 'ok', data: { email: data.emailAddress } });
+    }
+    catch (err) {
+        connectorError(res, 'Gmail', err);
+    }
+});
+// ── Fetch Messages ──
+router.post('/fetch', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('gmail', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Gmail token.' });
+        return;
+    }
+    const query = body.query ?? 'in:inbox';
+    const maxResults = Math.min(body.maxResults ?? 20, 50);
+    try {
+        // List message IDs
+        const listResp = await rateLimitedFetch(`${GMAIL_API}/messages?q=${encodeURIComponent(query)}&maxResults=${maxResults}`, { headers: gHeaders(token) });
+        if (!listResp.ok)
+            throw new Error(`Gmail list ${listResp.status}`);
+        const listData = await listResp.json();
+        const messageIds = (listData.messages ?? []).map(m => m.id);
+        const items = [];
+        // Fetch each message (batch would be better but simpler this way)
+        for (const msgId of messageIds.slice(0, 20)) {
+            try {
+                const msgResp = await rateLimitedFetch(`${GMAIL_API}/messages/${msgId}?format=full`, { headers: gHeaders(token) });
+                if (!msgResp.ok)
+                    continue;
+                const msg = await msgResp.json();
+                const headers = msg.payload?.headers ?? [];
+                const getHeader = (name) => headers.find(h => h.name.toLowerCase() === name.toLowerCase())?.value ?? '';
+                items.push({
+                    id: msgId,
+                    subject: getHeader('Subject'),
+                    from: getHeader('From'),
+                    date: getHeader('Date'),
+                    snippet: msg.snippet ?? '',
+                    body: extractGmailBody(msg.payload),
+                });
+            }
+            catch { /* skip */ }
+        }
+        const markdown = items.map(m => `## ${m.subject}\n` +
+            `**From:** ${m.from}\n` +
+            `**Date:** ${m.date}\n\n` +
+            `${m.body}\n`).join('\n---\n\n');
+        res.json({
+            status: 'ok',
+            data: { items, markdown, count: items.length, tokens: Math.ceil(markdown.length / 4) },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Gmail', err);
+    }
+});
+function extractGmailBody(payload) {
+    if (!payload)
+        return '';
+    // Try to find text/plain first, then text/html
+    const plain = findPart(payload, 'text/plain');
+    if (plain?.body?.data) {
+        return Buffer.from(plain.body.data, 'base64url').toString('utf-8');
+    }
+    const html = findPart(payload, 'text/html');
+    if (html?.body?.data) {
+        const raw = Buffer.from(html.body.data, 'base64url').toString('utf-8');
+        // Simple HTML strip (shared htmlToMarkdown is overkill for email)
+        return raw.replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
+    }
+    // Direct body
+    if (payload.body?.data) {
+        return Buffer.from(payload.body.data, 'base64url').toString('utf-8');
+    }
+    return '';
+}
+function findPart(part, mimeType) {
+    if (part.mimeType === mimeType)
+        return part;
+    for (const child of part.parts ?? []) {
+        const found = findPart(child, mimeType);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+export default router;

package/dist-server/server/routes/connectors/google-docs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Google Docs Connector
+ * Issue #91
+ *
+ * Requires OAuth token (from Google Drive OAuth flow in connectors.ts).
+ * Fetches document structural elements and converts to markdown.
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=google-docs.d.ts.map

package/dist-server/server/routes/connectors/google-docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-docs.d.ts","sourceRoot":"","sources":["../../../../server/routes/connectors/google-docs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,QAAA,MAAM,MAAM,4CAAW,CAAC;AA8LxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/connectors/google-docs.js

@@ -0,0 +1,165 @@
+/**
+ * Google Docs Connector
+ * Issue #91
+ *
+ * Requires OAuth token (from Google Drive OAuth flow in connectors.ts).
+ * Fetches document structural elements and converts to markdown.
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, connectorError, getApiKey } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const DOCS_API = 'https://docs.googleapis.com/v1/documents';
+const DRIVE_API = 'https://www.googleapis.com/drive/v3';
+function gHeaders(token) {
+    return { Authorization: `Bearer ${token}` };
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing OAuth token' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${DRIVE_API}/about?fields=user(displayName,emailAddress)`, { headers: gHeaders(apiKey) });
+        if (!resp.ok) {
+            res.status(401).json({ status: 'error', error: 'Invalid Google token' });
+            return;
+        }
+        const data = await resp.json();
+        sessionKeys.set('google-docs', apiKey);
+        res.json({ status: 'ok', data: { user: data.user.displayName, email: data.user.emailAddress } });
+    }
+    catch (err) {
+        connectorError(res, 'Google Docs', err);
+    }
+});
+// ── Fetch Document(s) ──
+router.post('/fetch', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('google-docs', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Google token.' });
+        return;
+    }
+    const documentIds = body.documentIds ?? [];
+    const folderId = body.folderId;
+    try {
+        let docIds = [...documentIds];
+        // If folderId provided, list docs in folder
+        if (folderId) {
+            const resp = await rateLimitedFetch(`${DRIVE_API}/files?q='${folderId}'+in+parents+and+mimeType='application/vnd.google-apps.document'&fields=files(id,name)&pageSize=50`, { headers: gHeaders(token) });
+            if (resp.ok) {
+                const data = await resp.json();
+                docIds.push(...data.files.map(f => f.id));
+            }
+        }
+        if (docIds.length === 0) {
+            // List recent docs
+            const resp = await rateLimitedFetch(`${DRIVE_API}/files?q=mimeType='application/vnd.google-apps.document'&fields=files(id,name)&orderBy=modifiedTime+desc&pageSize=20`, { headers: gHeaders(token) });
+            if (resp.ok) {
+                const data = await resp.json();
+                docIds = data.files.map(f => f.id);
+            }
+        }
+        const items = [];
+        for (const docId of docIds.slice(0, 20)) {
+            try {
+                const resp = await rateLimitedFetch(`${DOCS_API}/${docId}`, { headers: gHeaders(token) });
+                if (!resp.ok)
+                    continue;
+                const doc = await resp.json();
+                const markdown = googleDocToMarkdown(doc);
+                items.push({
+                    id: docId,
+                    title: doc.title ?? docId,
+                    markdown,
+                    tokens: Math.ceil(markdown.length / 4),
+                });
+            }
+            catch { /* skip individual doc errors */ }
+        }
+        const fullMarkdown = items.map(i => `# ${i.title}\n\n${i.markdown}`).join('\n\n---\n\n');
+        res.json({
+            status: 'ok',
+            data: { items, markdown: fullMarkdown, count: items.length, tokens: Math.ceil(fullMarkdown.length / 4) },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Google Docs', err);
+    }
+});
+// ── Search ──
+router.post('/search', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('google-docs', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Google token.' });
+        return;
+    }
+    const query = body.query ?? '';
+    try {
+        const q = query
+            ? `mimeType='application/vnd.google-apps.document' and fullText contains '${query.replace(/'/g, "\\'")}'`
+            : `mimeType='application/vnd.google-apps.document'`;
+        const resp = await rateLimitedFetch(`${DRIVE_API}/files?q=${encodeURIComponent(q)}&fields=files(id,name,modifiedTime)&orderBy=modifiedTime+desc&pageSize=20`, { headers: gHeaders(token) });
+        if (!resp.ok)
+            throw new Error(`Drive search ${resp.status}`);
+        const data = await resp.json();
+        res.json({ status: 'ok', data: data.files });
+    }
+    catch (err) {
+        connectorError(res, 'Google Docs', err);
+    }
+});
+function googleDocToMarkdown(doc) {
+    const elements = doc.body?.content ?? [];
+    const lines = [];
+    for (const el of elements) {
+        if (el.paragraph) {
+            const style = el.paragraph.paragraphStyle?.namedStyleType ?? '';
+            const text = (el.paragraph.elements ?? []).map(e => {
+                if (!e.textRun?.content)
+                    return '';
+                let t = e.textRun.content;
+                const ts = e.textRun.textStyle;
+                if (ts?.bold)
+                    t = `**${t.trim()}** `;
+                if (ts?.italic)
+                    t = `*${t.trim()}* `;
+                if (ts?.link?.url)
+                    t = `[${t.trim()}](${ts.link.url}) `;
+                return t;
+            }).join('').trimEnd();
+            if (!text || text === '\n')
+                continue;
+            if (style === 'HEADING_1')
+                lines.push(`# ${text}`);
+            else if (style === 'HEADING_2')
+                lines.push(`## ${text}`);
+            else if (style === 'HEADING_3')
+                lines.push(`### ${text}`);
+            else if (style === 'HEADING_4')
+                lines.push(`#### ${text}`);
+            else
+                lines.push(text);
+        }
+        if (el.table) {
+            const rows = (el.table.tableRows ?? []).map(row => (row.tableCells ?? []).map(cell => {
+                return (cell.content ?? [])
+                    .map(c => (c.paragraph?.elements ?? []).map(e => e.textRun?.content ?? '').join(''))
+                    .join(' ').trim();
+            }));
+            if (rows.length > 0) {
+                lines.push('| ' + rows[0].join(' | ') + ' |');
+                lines.push('| ' + rows[0].map(() => '---').join(' | ') + ' |');
+                for (const row of rows.slice(1)) {
+                    lines.push('| ' + row.join(' | ') + ' |');
+                }
+            }
+        }
+    }
+    return lines.join('\n');
+}
+export default router;

package/dist-server/server/routes/connectors/google-drive.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Google Drive Connector — Files + Content
+ * Issue #101
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=google-drive.d.ts.map

package/dist-server/server/routes/connectors/google-drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-drive.d.ts","sourceRoot":"","sources":["../../../../server/routes/connectors/google-drive.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,QAAA,MAAM,MAAM,4CAAW,CAAC;AAuLxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/connectors/google-drive.js

@@ -0,0 +1,163 @@
+/**
+ * Google Drive Connector — Files + Content
+ * Issue #101
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, connectorError, getApiKey } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const DRIVE_API = 'https://www.googleapis.com/drive/v3';
+function gHeaders(token) {
+    return { Authorization: `Bearer ${token}` };
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing OAuth token' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${DRIVE_API}/about?fields=user(displayName,emailAddress)`, { headers: gHeaders(apiKey) });
+        if (!resp.ok) {
+            res.status(401).json({ status: 'error', error: 'Invalid Google token' });
+            return;
+        }
+        const data = await resp.json();
+        sessionKeys.set('google-drive', apiKey);
+        res.json({ status: 'ok', data: { user: data.user.displayName, email: data.user.emailAddress } });
+    }
+    catch (err) {
+        connectorError(res, 'Google Drive', err);
+    }
+});
+// ── List Files ──
+router.post('/list', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('google-drive', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Google token.' });
+        return;
+    }
+    const folderId = body.folderId;
+    const query = body.query;
+    const mimeType = body.mimeType;
+    try {
+        const qParts = [];
+        if (folderId)
+            qParts.push(`'${folderId}' in parents`);
+        if (mimeType)
+            qParts.push(`mimeType='${mimeType}'`);
+        if (query)
+            qParts.push(`fullText contains '${query.replace(/'/g, "\\'")}'`);
+        qParts.push('trashed=false');
+        const resp = await rateLimitedFetch(`${DRIVE_API}/files?q=${encodeURIComponent(qParts.join(' and '))}&fields=files(id,name,mimeType,size,modifiedTime,parents)&orderBy=modifiedTime+desc&pageSize=50`, { headers: gHeaders(token) });
+        if (!resp.ok)
+            throw new Error(`Drive list ${resp.status}`);
+        const data = await resp.json();
+        res.json({
+            status: 'ok',
+            data: data.files.map(f => ({
+                id: f.id,
+                name: f.name,
+                mimeType: f.mimeType,
+                size: f.size,
+                modifiedTime: f.modifiedTime,
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Google Drive', err);
+    }
+});
+// ── Fetch File Content ──
+router.post('/fetch', async (req, res) => {
+    const body = req.body;
+    const token = getApiKey('google-drive', body, sessionKeys);
+    if (!token) {
+        res.status(401).json({ status: 'error', error: 'No Google token.' });
+        return;
+    }
+    const fileIds = body.fileIds ?? [];
+    const folderId = body.folderId;
+    try {
+        let targetIds = [...fileIds];
+        // List folder contents if folderId provided
+        if (folderId && targetIds.length === 0) {
+            const resp = await rateLimitedFetch(`${DRIVE_API}/files?q='${folderId}'+in+parents+and+trashed=false&fields=files(id,name,mimeType)&pageSize=50`, { headers: gHeaders(token) });
+            if (resp.ok) {
+                const data = await resp.json();
+                targetIds = data.files
+                    .filter(f => isContentFetchable(f.mimeType))
+                    .map(f => f.id);
+            }
+        }
+        const items = [];
+        for (const fid of targetIds.slice(0, 20)) {
+            try {
+                // Get metadata first
+                const metaResp = await rateLimitedFetch(`${DRIVE_API}/files/${fid}?fields=id,name,mimeType`, { headers: gHeaders(token) });
+                if (!metaResp.ok)
+                    continue;
+                const meta = await metaResp.json();
+                let content = '';
+                if (meta.mimeType === 'application/vnd.google-apps.document') {
+                    // Export Google Doc as plain text
+                    const exportResp = await rateLimitedFetch(`${DRIVE_API}/files/${fid}/export?mimeType=text/plain`, { headers: gHeaders(token) });
+                    if (exportResp.ok)
+                        content = await exportResp.text();
+                }
+                else if (meta.mimeType === 'application/vnd.google-apps.spreadsheet') {
+                    // Export spreadsheet as CSV
+                    const exportResp = await rateLimitedFetch(`${DRIVE_API}/files/${fid}/export?mimeType=text/csv`, { headers: gHeaders(token) });
+                    if (exportResp.ok) {
+                        const csv = await exportResp.text();
+                        content = csvToMarkdownTable(csv);
+                    }
+                }
+                else if (meta.mimeType?.startsWith('text/') || meta.mimeType === 'application/json') {
+                    // Download text files directly
+                    const dlResp = await rateLimitedFetch(`${DRIVE_API}/files/${fid}?alt=media`, { headers: gHeaders(token) });
+                    if (dlResp.ok)
+                        content = (await dlResp.text()).slice(0, 100000); // Cap at 100K chars
+                }
+                else {
+                    // Non-text files: metadata only
+                    content = `[Binary file: ${meta.name} (${meta.mimeType})]`;
+                }
+                items.push({
+                    id: fid,
+                    name: meta.name,
+                    mimeType: meta.mimeType,
+                    content,
+                    tokens: Math.ceil(content.length / 4),
+                });
+            }
+            catch { /* skip individual file errors */ }
+        }
+        const markdown = items.map(i => `# ${i.name}\n\n${i.content}`).join('\n\n---\n\n');
+        res.json({
+            status: 'ok',
+            data: { items, markdown, count: items.length, tokens: Math.ceil(markdown.length / 4) },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Google Drive', err);
+    }
+});
+function isContentFetchable(mimeType) {
+    return (mimeType.startsWith('text/') ||
+        mimeType === 'application/json' ||
+        mimeType === 'application/vnd.google-apps.document' ||
+        mimeType === 'application/vnd.google-apps.spreadsheet');
+}
+function csvToMarkdownTable(csv) {
+    const rows = csv.split('\n').map(r => r.split(',').map(c => c.replace(/^"|"$/g, '').trim()));
+    if (rows.length === 0)
+        return '';
+    const headers = rows[0];
+    const dataRows = rows.slice(1).filter(r => r.some(c => c));
+    return `| ${headers.join(' | ')} |\n| ${headers.map(() => '---').join(' | ')} |\n` +
+        dataRows.map(r => `| ${r.join(' | ')} |`).join('\n');
+}
+export default router;