modular-studio 1.0.6 → 1.1.0

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

@@ -0,0 +1,201 @@
+/**
+ * Notion Connector (v2) — delegates to the main connectors.ts Notion endpoints.
+ *
+ * The full Notion implementation (test, fetch, search, OAuth) lives in
+ * server/routes/connectors.ts. This v2 route file re-exports the same
+ * functionality so the frontend can access it via /api/connectors/v2/notion/*.
+ */
+import { Router } from 'express';
+import { connectorError, getApiKey } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+const NOTION_API = 'https://api.notion.com/v1';
+function notionHeaders(key) {
+    return {
+        Authorization: `Bearer ${key}`,
+        'Notion-Version': '2022-06-28',
+        'Content-Type': 'application/json',
+    };
+}
+// ── 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 fetch(`${NOTION_API}/users/me`, { headers: notionHeaders(apiKey) });
+        if (resp.status === 401) {
+            res.status(401).json({ status: 'error', error: 'Invalid Notion API key. Create one at notion.so/my-integrations' });
+            return;
+        }
+        if (!resp.ok) {
+            res.status(resp.status).json({ status: 'error', error: `Notion API error: ${resp.status}` });
+            return;
+        }
+        const user = await resp.json();
+        sessionKeys.set('notion', apiKey);
+        res.json({ status: 'ok', data: { user: user.name ?? user.id } });
+    }
+    catch (err) {
+        connectorError(res, 'Notion', err);
+    }
+});
+// ── Search ──
+router.post('/search', async (req, res) => {
+    const apiKey = getApiKey('notion', req.body, sessionKeys);
+    if (!apiKey) {
+        res.status(401).json({ status: 'error', error: 'No API key. Test connection first.' });
+        return;
+    }
+    const { query } = req.body;
+    try {
+        const resp = await fetch(`${NOTION_API}/search`, {
+            method: 'POST',
+            headers: notionHeaders(apiKey),
+            body: JSON.stringify(query ? { query, page_size: 20 } : { page_size: 20 }),
+        });
+        if (!resp.ok) {
+            res.status(resp.status).json({ status: 'error', error: `Notion search failed: ${resp.status}` });
+            return;
+        }
+        const data = await resp.json();
+        const results = data.results.map(r => {
+            let title = r.id;
+            if (r.object === 'database' && r.title?.[0]) {
+                title = r.title[0].plain_text;
+            }
+            else if (r.properties) {
+                const titleProp = Object.values(r.properties).find((p) => p.type === 'title');
+                title = titleProp?.title?.[0]?.plain_text ?? r.id;
+            }
+            return { id: r.id, title, type: r.object };
+        });
+        res.json({ status: 'ok', data: results });
+    }
+    catch (err) {
+        connectorError(res, 'Notion', err);
+    }
+});
+// ── Fetch page content ──
+router.post('/fetch', async (req, res) => {
+    const apiKey = getApiKey('notion', req.body, sessionKeys);
+    if (!apiKey) {
+        res.status(401).json({ status: 'error', error: 'No API key. Test connection first.' });
+        return;
+    }
+    const { pageIds, databaseIds } = req.body;
+    try {
+        const items = [];
+        for (const pageId of pageIds ?? []) {
+            const page = await fetchNotionPage(pageId, apiKey);
+            if (page)
+                items.push(page);
+        }
+        for (const dbId of databaseIds ?? []) {
+            const rows = await queryNotionDatabase(dbId, apiKey);
+            items.push(...rows);
+        }
+        // If nothing specified, search recent pages
+        if (!pageIds?.length && !databaseIds?.length) {
+            const resp = await fetch(`${NOTION_API}/search`, {
+                method: 'POST',
+                headers: notionHeaders(apiKey),
+                body: JSON.stringify({ sort: { direction: 'descending', timestamp: 'last_edited_time' }, page_size: 10 }),
+            });
+            if (resp.ok) {
+                const data = await resp.json();
+                for (const r of data.results) {
+                    if (r.object === 'page') {
+                        const page = await fetchNotionPage(r.id, apiKey);
+                        if (page)
+                            items.push(page);
+                    }
+                }
+            }
+        }
+        res.json({ status: 'ok', data: items });
+    }
+    catch (err) {
+        connectorError(res, 'Notion', err);
+    }
+});
+// ── Helpers ──
+async function fetchNotionPage(pageId, apiKey) {
+    const pageResp = await fetch(`${NOTION_API}/pages/${pageId}`, { headers: notionHeaders(apiKey) });
+    if (!pageResp.ok)
+        return null;
+    const page = await pageResp.json();
+    // Get title
+    const titleProp = Object.values(page.properties).find((p) => p.type === 'title');
+    const title = titleProp?.title?.[0]?.plain_text ?? page.id;
+    // Get blocks
+    const blocks = await fetchAllBlocks(pageId, apiKey);
+    const content = blocksToMarkdown(blocks);
+    return { id: pageId, title, content, tokens: Math.ceil(content.length / 4) };
+}
+async function queryNotionDatabase(dbId, apiKey) {
+    const items = [];
+    let cursor;
+    do {
+        const body = JSON.stringify(cursor ? { start_cursor: cursor } : {});
+        const resp = await fetch(`${NOTION_API}/databases/${dbId}/query`, {
+            method: 'POST', headers: notionHeaders(apiKey), body,
+        });
+        if (!resp.ok)
+            break;
+        const data = await resp.json();
+        for (const row of data.results) {
+            const titleProp = Object.values(row.properties).find((p) => p.type === 'title');
+            const title = titleProp?.title?.[0]?.plain_text ?? row.id;
+            items.push({ id: row.id, title, content: `# ${title}`, tokens: Math.ceil(title.length / 4) + 10 });
+        }
+        cursor = data.has_more && data.next_cursor ? data.next_cursor : undefined;
+    } while (cursor);
+    return items;
+}
+async function fetchAllBlocks(pageId, apiKey) {
+    const blocks = [];
+    let cursor;
+    do {
+        const qs = cursor ? `?start_cursor=${encodeURIComponent(cursor)}` : '';
+        const resp = await fetch(`${NOTION_API}/blocks/${pageId}/children${qs}`, { headers: notionHeaders(apiKey) });
+        if (!resp.ok)
+            break;
+        const data = await resp.json();
+        blocks.push(...data.results);
+        cursor = data.has_more && data.next_cursor ? data.next_cursor : undefined;
+    } while (cursor);
+    return blocks;
+}
+function blocksToMarkdown(blocks) {
+    const lines = [];
+    for (const b of blocks) {
+        const content = b[b.type];
+        if (!content || typeof content !== 'object')
+            continue;
+        const rt = content.rich_text;
+        if (!Array.isArray(rt))
+            continue;
+        const text = rt.map((r) => r.plain_text ?? '').join('');
+        if (!text)
+            continue;
+        if (b.type === 'heading_1')
+            lines.push(`# ${text}`);
+        else if (b.type === 'heading_2')
+            lines.push(`## ${text}`);
+        else if (b.type === 'heading_3')
+            lines.push(`### ${text}`);
+        else if (b.type === 'bulleted_list_item')
+            lines.push(`- ${text}`);
+        else if (b.type === 'numbered_list_item')
+            lines.push(`1. ${text}`);
+        else if (b.type === 'code')
+            lines.push(`\`\`\`\n${text}\n\`\`\``);
+        else
+            lines.push(text);
+    }
+    return lines.join('\n');
+}
+export default router;

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

@@ -0,0 +1,10 @@
+/**
+ * Plane Connector — Work Items (Issues), Projects, Cycles, Modules
+ *
+ * Plane is an open-source project management tool (alternative to Jira/Linear).
+ * API: REST, auth via X-API-Key header.
+ * Docs: https://developers.plane.so/api-reference
+ */
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=plane.d.ts.map

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

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

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

@@ -0,0 +1,189 @@
+/**
+ * Plane Connector — Work Items (Issues), Projects, Cycles, Modules
+ *
+ * Plane is an open-source project management tool (alternative to Jira/Linear).
+ * API: REST, auth via X-API-Key header.
+ * Docs: https://developers.plane.so/api-reference
+ */
+import { Router } from 'express';
+import { rateLimitedFetch, fetchPaginated, connectorError, formatTimestamp } from './shared.js';
+const router = Router();
+const sessionKeys = new Map();
+// Default to Plane Cloud; self-hosted users override via `baseUrl` param
+const DEFAULT_BASE = 'https://api.plane.so';
+function planeHeaders(token) {
+    return { 'X-API-Key': token, 'Content-Type': 'application/json' };
+}
+function getBase(body) {
+    return (body.baseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+}
+// ── Test ──
+router.post('/test', async (req, res) => {
+    const { apiKey, baseUrl } = req.body;
+    if (!apiKey) {
+        res.status(400).json({ status: 'error', error: 'Missing API key (Personal Access Token from Profile Settings)' });
+        return;
+    }
+    const base = (baseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+    try {
+        // List workspaces to validate token
+        const resp = await rateLimitedFetch(`${base}/api/v1/workspaces/`, { headers: planeHeaders(apiKey) });
+        if (!resp.ok) {
+            res.status(401).json({ status: 'error', error: `Invalid Plane token (${resp.status})` });
+            return;
+        }
+        const data = await resp.json();
+        sessionKeys.set('plane', JSON.stringify({ apiKey, baseUrl: base }));
+        res.json({
+            status: 'ok',
+            data: {
+                workspaces: (data.results ?? data).slice(0, 10).map((w) => ({ slug: w.slug, name: w.name })),
+            },
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Plane', err);
+    }
+});
+// ── List Projects ──
+router.post('/projects', async (req, res) => {
+    const body = req.body;
+    const creds = getPlaneCreds(body);
+    if (!creds) {
+        res.status(401).json({ status: 'error', error: 'No Plane credentials. Test connection first.' });
+        return;
+    }
+    const workspace = body.workspace;
+    if (!workspace) {
+        res.status(400).json({ status: 'error', error: 'workspace slug required' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${creds.baseUrl}/api/v1/workspaces/${workspace}/projects/`, { headers: planeHeaders(creds.apiKey) });
+        if (!resp.ok)
+            throw new Error(`Plane API ${resp.status}`);
+        const data = await resp.json();
+        res.json({
+            status: 'ok',
+            data: (data.results ?? data).map((p) => ({
+                id: p.id,
+                name: p.name,
+                identifier: p.identifier,
+                description: p.description ?? '',
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Plane', err);
+    }
+});
+// ── Fetch Work Items (Issues) ──
+router.post('/fetch', async (req, res) => {
+    const body = req.body;
+    const creds = getPlaneCreds(body);
+    if (!creds) {
+        res.status(401).json({ status: 'error', error: 'No Plane credentials.' });
+        return;
+    }
+    const workspace = body.workspace;
+    const projectId = body.projectId;
+    if (!workspace || !projectId) {
+        res.status(400).json({ status: 'error', error: 'workspace and projectId required' });
+        return;
+    }
+    try {
+        const items = await fetchPaginated({
+            maxPages: 5,
+            maxItems: 200,
+            fetchPage: async (cursor) => {
+                const params = new URLSearchParams();
+                if (cursor)
+                    params.set('cursor', cursor);
+                const resp = await rateLimitedFetch(`${creds.baseUrl}/api/v1/workspaces/${workspace}/projects/${projectId}/work-items/?${params}`, { headers: planeHeaders(creds.apiKey) });
+                if (!resp.ok)
+                    throw new Error(`Plane API ${resp.status}`);
+                const data = await resp.json();
+                return {
+                    items: (data.results ?? data).map((issue) => ({
+                        id: issue.id,
+                        sequence_id: issue.sequence_id,
+                        name: issue.name ?? issue.title ?? '',
+                        description_html: issue.description_html ?? '',
+                        description: issue.description_stripped ?? issue.description ?? '',
+                        state: issue.state_detail?.name ?? issue.state ?? '',
+                        priority: issue.priority ?? 'none',
+                        assignees: (issue.assignee_details ?? issue.assignees ?? []).map((a) => typeof a === 'string' ? a : (a.display_name ?? a.email ?? a.id)),
+                        labels: (issue.label_details ?? issue.labels ?? []).map((l) => typeof l === 'string' ? l : (l.name ?? l.id)),
+                        created_at: issue.created_at,
+                        updated_at: issue.updated_at,
+                    })),
+                    nextCursor: data.next_page_results ? data.next_cursor : undefined,
+                };
+            },
+        });
+        const markdown = items.map((issue) => `## ${issue.sequence_id ? `#${issue.sequence_id}: ` : ''}${issue.name}\n` +
+            `**Status:** ${issue.state} · **Priority:** ${issue.priority}\n` +
+            `**Assignees:** ${issue.assignees.join(', ') || 'unassigned'}\n` +
+            `**Labels:** ${issue.labels.join(', ') || 'none'}\n` +
+            `**Created:** ${formatTimestamp(issue.created_at)} · **Updated:** ${formatTimestamp(issue.updated_at)}\n\n` +
+            `${issue.description}\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, 'Plane', err);
+    }
+});
+// ── Fetch Cycles ──
+router.post('/cycles', async (req, res) => {
+    const body = req.body;
+    const creds = getPlaneCreds(body);
+    if (!creds) {
+        res.status(401).json({ status: 'error', error: 'No Plane credentials.' });
+        return;
+    }
+    const workspace = body.workspace;
+    const projectId = body.projectId;
+    if (!workspace || !projectId) {
+        res.status(400).json({ status: 'error', error: 'workspace and projectId required' });
+        return;
+    }
+    try {
+        const resp = await rateLimitedFetch(`${creds.baseUrl}/api/v1/workspaces/${workspace}/projects/${projectId}/cycles/`, { headers: planeHeaders(creds.apiKey) });
+        if (!resp.ok)
+            throw new Error(`Plane API ${resp.status}`);
+        const data = await resp.json();
+        res.json({
+            status: 'ok',
+            data: (data.results ?? data).map((c) => ({
+                id: c.id,
+                name: c.name,
+                start_date: c.start_date,
+                end_date: c.end_date,
+                status: c.status,
+                total_issues: c.total_issues ?? 0,
+                completed_issues: c.completed_issues ?? 0,
+            })),
+        });
+    }
+    catch (err) {
+        connectorError(res, 'Plane', err);
+    }
+});
+function getPlaneCreds(body) {
+    const stored = sessionKeys.get('plane');
+    if (stored) {
+        const parsed = JSON.parse(stored);
+        return {
+            apiKey: body.apiKey ?? parsed.apiKey,
+            baseUrl: getBase(body) !== DEFAULT_BASE ? getBase(body) : parsed.baseUrl,
+        };
+    }
+    if (body.apiKey) {
+        return { apiKey: body.apiKey, baseUrl: getBase(body) };
+    }
+    return null;
+}
+export default router;

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

@@ -0,0 +1,25 @@
+/**
+ * Connector Shared Utilities
+ *
+ * Pagination, rate limiting, HTML→markdown, error handling, markdown tables.
+ */
+export declare function rateLimitedFetch(url: string, options?: RequestInit, maxRetries?: number): Promise<globalThis.Response>;
+export interface PaginationConfig<T> {
+    fetchPage: (cursor?: string) => Promise<{
+        items: T[];
+        nextCursor?: string;
+    }>;
+    maxPages?: number;
+    maxItems?: number;
+}
+export declare function fetchPaginated<T>(config: PaginationConfig<T>): Promise<T[]>;
+export declare function htmlToMarkdown(html: string): string;
+export declare function toMarkdownTable(headers: string[], rows: string[][]): string;
+export declare function connectorError(res: any, service: string, error: unknown): void;
+export declare function getApiKey(service: string, body: Record<string, unknown>, sessionKeys: Map<string, string>): string | null;
+/**
+ * Persist an API key after successful test — survives server restarts.
+ */
+export declare function persistApiKey(service: string, apiKey: string): void;
+export declare function formatTimestamp(ts: string | number): string;
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../server/routes/connectors/shared.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkBH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,WAAgB,EACzB,UAAU,SAAc,GACvB,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CA0C9B;AAID,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAiBjF;AAID,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqEnD;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAa3E;AAID,wBAAgB,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAiB9E;AAID,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,IAAI,CAUzH;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAMnE;AAID,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAO3D"}

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

@@ -0,0 +1,202 @@
+/**
+ * Connector Shared Utilities
+ *
+ * Pagination, rate limiting, HTML→markdown, error handling, markdown tables.
+ */
+// ── Rate-Limited Fetch ────────────────────────────────────────────────────────
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/** Compute exponential backoff with ±25% jitter to avoid thundering herd. */
+function backoffMs(attempt, baseMs) {
+    const exp = baseMs * Math.pow(2, attempt);
+    const jitter = exp * 0.25 * (Math.random() * 2 - 1); // ±25%
+    return Math.min(Math.round(exp + jitter), 30_000);
+}
+export async function rateLimitedFetch(url, options = {}, maxRetries = MAX_RETRIES) {
+    let lastError = null;
+    let rateLimitHits = 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            const resp = await fetch(url, options);
+            if (resp.status === 429) {
+                rateLimitHits++;
+                if (attempt === maxRetries) {
+                    throw new Error(`Rate limit (429) exceeded after ${maxRetries + 1} attempts. ` +
+                        `Wait before retrying or check your API quota.`);
+                }
+                const retryAfter = resp.headers.get('Retry-After');
+                const delayMs = retryAfter
+                    ? parseInt(retryAfter, 10) * 1000
+                    : backoffMs(attempt, BASE_DELAY_MS);
+                await sleep(Math.min(delayMs, 30_000));
+                continue;
+            }
+            return resp;
+        }
+        catch (err) {
+            // Re-throw rate-limit errors immediately — no more retries
+            if (err instanceof Error && err.message.startsWith('Rate limit (429)'))
+                throw err;
+            lastError = err instanceof Error ? err : new Error(String(err));
+            if (attempt < maxRetries) {
+                await sleep(backoffMs(attempt, BASE_DELAY_MS));
+            }
+        }
+    }
+    if (rateLimitHits > 0) {
+        throw new Error(`Rate limit (429) exceeded after ${maxRetries + 1} attempts. ` +
+            `Wait before retrying or check your API quota.`);
+    }
+    throw lastError ?? new Error('Fetch failed after retries');
+}
+export async function fetchPaginated(config) {
+    const { fetchPage, maxPages = 10, maxItems = 1000 } = config;
+    const allItems = [];
+    let cursor;
+    let page = 0;
+    do {
+        const { items, nextCursor } = await fetchPage(cursor);
+        allItems.push(...items);
+        cursor = nextCursor;
+        page++;
+        if (allItems.length >= maxItems)
+            break;
+        if (page >= maxPages)
+            break;
+    } while (cursor);
+    return allItems.slice(0, maxItems);
+}
+// ── HTML → Markdown ───────────────────────────────────────────────────────────
+export function htmlToMarkdown(html) {
+    if (!html)
+        return '';
+    let md = html;
+    // Remove scripts, styles, comments
+    md = md.replace(/<script[\s\S]*?<\/script>/gi, '');
+    md = md.replace(/<style[\s\S]*?<\/style>/gi, '');
+    md = md.replace(/<!--[\s\S]*?-->/g, '');
+    // Headings
+    md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '\n# $1\n');
+    md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n## $1\n');
+    md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '\n### $1\n');
+    md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '\n#### $1\n');
+    md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '\n##### $1\n');
+    md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '\n###### $1\n');
+    // Bold, italic
+    md = md.replace(/<(strong|b)>([\s\S]*?)<\/\1>/gi, '**$2**');
+    md = md.replace(/<(em|i)>([\s\S]*?)<\/\1>/gi, '*$2*');
+    // Links
+    md = md.replace(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+    // Images
+    md = md.replace(/<img[^>]+src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
+    md = md.replace(/<img[^>]+src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
+    // Code blocks
+    md = md.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, '\n```\n$1\n```\n');
+    md = md.replace(/<code>([\s\S]*?)<\/code>/gi, '`$1`');
+    // Lists
+    md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n');
+    md = md.replace(/<\/?[ou]l[^>]*>/gi, '\n');
+    // Paragraphs, line breaks
+    md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '\n$1\n');
+    md = md.replace(/<br\s*\/?>/gi, '\n');
+    md = md.replace(/<hr\s*\/?>/gi, '\n---\n');
+    // Tables
+    md = md.replace(/<table[\s\S]*?<\/table>/gi, (table) => {
+        const rows = [];
+        const rowMatches = table.match(/<tr[\s\S]*?<\/tr>/gi) ?? [];
+        for (const row of rowMatches) {
+            const cells = (row.match(/<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi) ?? [])
+                .map(c => c.replace(/<[^>]+>/g, '').trim());
+            rows.push(cells);
+        }
+        if (rows.length === 0)
+            return '';
+        return toMarkdownTable(rows[0], rows.slice(1));
+    });
+    // Strip remaining HTML tags
+    md = md.replace(/<[^>]+>/g, '');
+    // Decode HTML entities
+    md = md.replace(/&amp;/g, '&');
+    md = md.replace(/&lt;/g, '<');
+    md = md.replace(/&gt;/g, '>');
+    md = md.replace(/&quot;/g, '"');
+    md = md.replace(/&#39;/g, "'");
+    md = md.replace(/&nbsp;/g, ' ');
+    // Clean up whitespace
+    md = md.replace(/\n{3,}/g, '\n\n');
+    return md.trim();
+}
+// ── Markdown Table ────────────────────────────────────────────────────────────
+export function toMarkdownTable(headers, rows) {
+    if (headers.length === 0)
+        return '';
+    const lines = [];
+    lines.push('| ' + headers.join(' | ') + ' |');
+    lines.push('| ' + headers.map(() => '---').join(' | ') + ' |');
+    for (const row of rows) {
+        // Pad row to match header length
+        const padded = [...row];
+        while (padded.length < headers.length)
+            padded.push('');
+        lines.push('| ' + padded.slice(0, headers.length).join(' | ') + ' |');
+    }
+    return lines.join('\n');
+}
+// ── Error Handling ────────────────────────────────────────────────────────────
+export function connectorError(res, service, error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes('401') || msg.includes('Unauthorized') || msg.includes('Invalid')) {
+        res.status(401).json({ status: 'error', error: `${service}: Authentication failed. Check your API key.` });
+        return;
+    }
+    if (msg.includes('403') || msg.includes('Forbidden')) {
+        res.status(403).json({ status: 'error', error: `${service}: Permission denied. Check API key scopes.` });
+        return;
+    }
+    if (msg.includes('429') || msg.includes('Rate')) {
+        res.status(429).json({ status: 'error', error: `${service}: Rate limit hit. Try again in a minute.` });
+        return;
+    }
+    res.status(500).json({ status: 'error', error: `${service}: ${msg}` });
+}
+// ── Auth Helper ───────────────────────────────────────────────────────────────
+export function getApiKey(service, body, sessionKeys) {
+    if (typeof body.apiKey === 'string' && body.apiKey)
+        return body.apiKey;
+    const session = sessionKeys.get(service);
+    if (session)
+        return session;
+    // Fallback: persistent credential store (survives restarts)
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require('../services/credentialStore.js');
+        return mod.getCredential(service);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Persist an API key after successful test — survives server restarts.
+ */
+export function persistApiKey(service, apiKey) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require('../services/credentialStore.js');
+        mod.setCredential(service, apiKey);
+    }
+    catch { /* credential store not available */ }
+}
+// ── Timestamp Formatting ──────────────────────────────────────────────────────
+export function formatTimestamp(ts) {
+    try {
+        const d = new Date(ts);
+        return d.toISOString().replace('T', ' ').slice(0, 16);
+    }
+    catch {
+        return String(ts);
+    }
+}

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

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

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

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