@henrikogard/auroradocs-mcp 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * AuroraDocs MCP Server
+ *
+ * Exposes AuroraDocs workspace data to Claude Desktop and other MCP clients.
+ * Uses the MCP stdio transport — add it to claude_desktop_config.json.
+ *
+ * SECURITY:
+ *   - On startup the server verifies the authenticated user is a member
+ *     of AURORA_WORKSPACE_ID. All queries are scoped to that workspace.
+ *   - Object reads/writes verify workspace ownership before proceeding.
+ *   - No cross-workspace or cross-user data leakage is possible.
+ *
+ * Environment variables:
+ *   AURORA_WORKSPACE_ID  Workspace ID to expose
+ *   AURORA_API_URL       AuroraCloud API URL, e.g. http://127.0.0.1:3000
+ *   AURORA_API_TOKEN     AuroraCloud bearer token (recommended: workspace MCP token `aur_mcp_...`)
+ *   AURORA_API_EMAIL     AuroraCloud user email (legacy/dev fallback)
+ *   AURORA_API_PASSWORD  AuroraCloud user password (legacy/dev fallback)
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { authenticate } from './auroraClient.js';
+import { executeToolCall, formatToolResult } from './tools.js';
+import { getToolDefinitions } from './toolCatalog.js';
+import { SERVER_VERSION } from './version.js';
+// ── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const workspaceId = process.env['AURORA_WORKSPACE_ID'];
+    if (!workspaceId) {
+        process.stderr.write('Error: AURORA_WORKSPACE_ID environment variable is required\n');
+        process.exit(1);
+    }
+    try {
+        await authenticate();
+    }
+    catch (err) {
+        process.stderr.write(`Authentication failed: ${err instanceof Error ? err.message : err}\n`);
+        process.exit(1);
+    }
+    const server = new Server({ name: 'auroradocs-mcp', version: SERVER_VERSION }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: getToolDefinitions(),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const result = await executeToolCall(name, (args ?? {}), workspaceId);
+        const text = formatToolResult(result);
+        return {
+            content: [{ type: 'text', text }],
+            isError: result.type === 'error',
+        };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write(`AuroraDocs MCP server running (workspace: ${workspaceId})\n`);
+}
+main().catch((err) => {
+    process.stderr.write(`Fatal: ${err}\n`);
+    process.exit(1);
+});

package/dist/planningTools.d.ts

@@ -0,0 +1,76 @@
+export type McpPlanningTask = {
+    id: string;
+    title: string | null;
+    status: string | null;
+    due_date: string | null;
+    updated_at: string | null;
+    labels: string[];
+};
+export type BuildWeekPlanInput = {
+    anchorDate: string;
+    includeUnscheduled: boolean;
+    unscheduledLimit: number;
+};
+export type McpWeekPlanTask = McpPlanningTask & {
+    timeBlock: {
+        isTimeBlock: boolean;
+        durationMinutes: number | null;
+    };
+};
+export type McpWeekPlan = {
+    type: 'week_plan';
+    range: {
+        start: string;
+        end: string;
+    };
+    days: Array<{
+        date: string;
+        tasks: McpWeekPlanTask[];
+    }>;
+    unscheduled: McpWeekPlanTask[];
+};
+export type McpCanvasObject = {
+    id: string;
+    title: string | null;
+    type: string;
+};
+export type McpCanvasCard = {
+    id: string;
+    type: string;
+    x: number | null;
+    y: number | null;
+    width: number | null;
+    height: number | null;
+    text: string | null;
+    color: string | null;
+    objectId: string | null;
+    objectTitle: string | null;
+};
+export type McpCanvasEdge = {
+    id: string;
+    fromCard: string | null;
+    toCard: string | null;
+    fromSide: string | null;
+    toSide: string | null;
+    label: string | null;
+    color: string | null;
+    style: string | null;
+    arrow: string | null;
+    arrowMode: string | null;
+    strokeWidth: number | null;
+};
+export type McpCanvasReadResult = {
+    type: 'canvas';
+    canvas: {
+        id: string;
+        title: string | null;
+    };
+    cards: McpCanvasCard[];
+    edges: McpCanvasEdge[];
+    frames: Array<Record<string, unknown>>;
+    warnings: string[];
+};
+export declare function buildWeekPlan(tasks: McpPlanningTask[], input: BuildWeekPlanInput): McpWeekPlan;
+export declare function normalizeCanvasContent(object: McpCanvasObject, contentJson: unknown, options?: {
+    includeText?: boolean;
+}): McpCanvasReadResult;

package/dist/planningTools.js

@@ -0,0 +1,159 @@
+export function buildWeekPlan(tasks, input) {
+    const days = getWeekPlanningDays(input.anchorDate);
+    const buckets = getWeekPlanningTaskBuckets(tasks, days);
+    return {
+        type: 'week_plan',
+        range: getWeekPlanningRange(input.anchorDate),
+        days: days.map((date) => ({
+            date,
+            tasks: (buckets[date] ?? []).map(toWeekPlanTask),
+        })),
+        unscheduled: input.includeUnscheduled
+            ? getUnscheduledWeekPlanningTasks(tasks).slice(0, clampLimit(input.unscheduledLimit)).map(toWeekPlanTask)
+            : [],
+    };
+}
+export function normalizeCanvasContent(object, contentJson, options = {}) {
+    const includeText = options.includeText !== false;
+    const content = isRecord(contentJson) ? contentJson : {};
+    const cardsRaw = Array.isArray(content['cards']) ? content['cards'] : [];
+    const edgesRaw = Array.isArray(content['edges']) ? content['edges'] : [];
+    const framesRaw = Array.isArray(content['frames']) ? content['frames'] : [];
+    const warnings = [];
+    if (!Array.isArray(content['cards']))
+        warnings.push('Canvas content did not include a cards array.');
+    if (!Array.isArray(content['edges']))
+        warnings.push('Canvas content did not include an edges array.');
+    return {
+        type: 'canvas',
+        canvas: { id: object.id, title: object.title },
+        cards: cardsRaw.filter(isRecord).map((card) => ({
+            id: readString(card['id']) ?? '(missing-id)',
+            type: readString(card['type']) ?? 'unknown',
+            x: readNumber(card['x']),
+            y: readNumber(card['y']),
+            width: readNumber(card['w']),
+            height: readNumber(card['h']),
+            text: includeText ? readString(card['text']) : null,
+            color: readString(card['color']),
+            objectId: readString(card['objectId']),
+            objectTitle: readString(card['objectTitle']),
+        })),
+        edges: edgesRaw.filter(isRecord).map((edge) => ({
+            id: readString(edge['id']) ?? '(missing-id)',
+            fromCard: readString(edge['fromCard']),
+            toCard: readString(edge['toCard']),
+            fromSide: readString(edge['fromSide']),
+            toSide: readString(edge['toSide']),
+            label: readString(edge['label']),
+            color: readString(edge['color']),
+            style: readString(edge['style']),
+            arrow: readString(edge['arrow']),
+            arrowMode: readString(edge['arrowMode']),
+            strokeWidth: readNumber(edge['strokeWidth']),
+        })),
+        frames: framesRaw.filter(isRecord),
+        warnings,
+    };
+}
+function toWeekPlanTask(task) {
+    return {
+        ...task,
+        timeBlock: parseWeekPlanningTimeBlock(task),
+    };
+}
+function clampLimit(value) {
+    return Math.max(0, Math.min(50, Number.isFinite(value) ? Math.round(value) : 12));
+}
+function getWeekPlanningRange(anchorDateKey) {
+    const start = getWeekPlanningStart(anchorDateKey);
+    return {
+        start,
+        end: addDaysToDateKey(start, 6),
+    };
+}
+function getWeekPlanningDays(anchorDateKey) {
+    const start = getWeekPlanningStart(anchorDateKey);
+    return Array.from({ length: 7 }, (_, index) => addDaysToDateKey(start, index));
+}
+function getWeekPlanningStart(anchorDateKey) {
+    const day = parseDateKey(anchorDateKey).getDay();
+    const offsetToMonday = day === 0 ? -6 : 1 - day;
+    return addDaysToDateKey(anchorDateKey, offsetToMonday);
+}
+function getWeekPlanningTaskBuckets(tasks, days) {
+    const daySet = new Set(days);
+    const buckets = Object.fromEntries(days.map((day) => [day, []]));
+    for (const task of tasks) {
+        if (isDoneTask(task))
+            continue;
+        const day = task.due_date?.slice(0, 10);
+        if (!day || !daySet.has(day))
+            continue;
+        buckets[day].push(task);
+    }
+    for (const day of days) {
+        buckets[day].sort(compareWeekPlanningTasks);
+    }
+    return buckets;
+}
+function getUnscheduledWeekPlanningTasks(tasks) {
+    return tasks
+        .filter((task) => !isDoneTask(task) && !task.due_date)
+        .sort(compareWeekPlanningTasks);
+}
+function parseWeekPlanningTimeBlock(task) {
+    const labels = task.labels ?? [];
+    if (!labels.includes('time-block'))
+        return { isTimeBlock: false, durationMinutes: null };
+    const durationLabel = labels.find((label) => /^duration:\d+m$/.test(label));
+    const durationMinutes = durationLabel ? Number(durationLabel.match(/^duration:(\d+)m$/)?.[1] ?? '') : NaN;
+    return {
+        isTimeBlock: true,
+        durationMinutes: Number.isFinite(durationMinutes) && durationMinutes > 0 ? durationMinutes : null,
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function addDaysToDateKey(dateKey, days) {
+    const date = parseDateKey(dateKey);
+    date.setDate(date.getDate() + days);
+    return formatDateKey(date);
+}
+function parseDateKey(dateKey) {
+    const [year, month, day] = dateKey.split('-').map((part) => Number(part));
+    return new Date(year, month - 1, day);
+}
+function formatDateKey(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function isDoneTask(task) {
+    return task.status === 'Done';
+}
+function compareWeekPlanningTasks(a, b) {
+    const aTime = taskTime(a.due_date);
+    const bTime = taskTime(b.due_date);
+    if (aTime && bTime && aTime !== bTime)
+        return aTime.localeCompare(bTime);
+    if (aTime && !bTime)
+        return -1;
+    if (!aTime && bTime)
+        return 1;
+    const aTitle = a.title?.trim() || a.id;
+    const bTitle = b.title?.trim() || b.id;
+    return aTitle.localeCompare(bTitle);
+}
+function taskTime(dueDate) {
+    const match = dueDate?.match(/^\d{4}-\d{2}-\d{2}T(\d{2}:\d{2})/);
+    return match?.[1] ?? null;
+}

package/dist/toolCatalog.d.ts

@@ -0,0 +1,39 @@
+export type McpToolDefinition = {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+};
+export type McpCoveragePriority = 'high' | 'medium' | 'low';
+export type McpCoverageStatus = 'covered' | 'partial' | 'gap';
+export type McpToolEffect = 'read' | 'write';
+export type McpToolCoverageAudit = {
+    generatedAt: string;
+    areas: Array<{
+        id: string;
+        label: string;
+        status: McpCoverageStatus;
+        implementedTools: string[];
+        missingTools: Array<{
+            name: string;
+            priority: McpCoveragePriority;
+            reason: string;
+        }>;
+    }>;
+};
+export type McpWorkflowRecipe = {
+    id: string;
+    title: string;
+    goal: string;
+    requiredScopes: string[];
+    toolSteps: string[];
+    prompt: string;
+};
+export declare function getToolDefinitions(): McpToolDefinition[];
+export declare function getToolEffect(name: string): McpToolEffect | undefined;
+export declare function getToolEffects(): Readonly<Record<string, McpToolEffect>>;
+export declare function getMcpToolCoverageAudit(): McpToolCoverageAudit;
+export declare function getMcpWorkflowRecipes(): McpWorkflowRecipe[];