@loicngr/kobo 0.1.1

package/dist/server/services/dev-server-service.js

@@ -0,0 +1,298 @@
+import { execSync, spawn } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { getProjectSettings } from './settings-service.js';
+import { emitEphemeral } from './websocket-service.js';
+import { getWorkspace, updateDevServerStatus } from './workspace-service.js';
+// ── State ──────────────────────────────────────────────────────────────────────
+/** workspaceId -> spawned dev-server process */
+const trackedProcesses = new Map();
+// ── Pure helpers ───────────────────────────────────────────────────────────────
+/**
+ * Sanitize a branch name for use as a Docker instance name.
+ * Replace `/` and `_` with `-`, lowercase.
+ */
+export function sanitizeBranchName(branch) {
+    return branch.toLowerCase().replace(/[/_]/g, '-');
+}
+/**
+ * Parse a `.env` file content into key=value pairs.
+ * Skips empty lines and comments (#). Handles quotes.
+ */
+export function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Resolve the dev-server instance config for a given project + branch.
+ * Looks in `<projectPath>/.container/instances/` for `.env` files.
+ */
+export function resolveInstance(projectPath, workingBranch) {
+    const instancesDir = path.join(projectPath, '.container', 'instances');
+    if (!existsSync(instancesDir))
+        return null;
+    const sanitized = sanitizeBranchName(workingBranch);
+    const files = readdirSync(instancesDir).filter((f) => f.endsWith('.env'));
+    for (const file of files) {
+        const content = readFileSync(path.join(instancesDir, file), 'utf-8');
+        const parsed = parseEnvFile(content);
+        if (parsed.INSTANCE_NAME && parsed.INSTANCE_NAME.toLowerCase() === sanitized) {
+            return {
+                instanceName: parsed.INSTANCE_NAME,
+                projectName: parsed.PROJECT_NAME ?? '',
+                httpPort: parsed.HTTP_PORT ?? '',
+            };
+        }
+    }
+    return null;
+}
+// ── Docker helpers ─────────────────────────────────────────────────────────────
+/**
+ * List all running Docker container names.
+ * Note: uses execSync with shell because docker ps --format requires
+ * Go template syntax with `{{}}`. Input is a static string, no injection risk.
+ */
+export function listRunningContainers() {
+    try {
+        const output = execSync('docker ps --format "{{.Names}}"', {
+            encoding: 'utf-8',
+            timeout: 10000,
+        });
+        return output
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Status ─────────────────────────────────────────────────────────────────────
+/**
+ * Get the dev-server status for a given project + branch.
+ */
+export function getStatus(projectPath, workingBranch) {
+    const config = resolveInstance(projectPath, workingBranch);
+    if (!config) {
+        return {
+            status: 'unknown',
+            instanceName: '',
+            projectName: '',
+            httpPort: '',
+            url: '',
+            containers: [],
+        };
+    }
+    const running = listRunningContainers();
+    const matching = running.filter((name) => name.toLowerCase().includes(config.projectName.toLowerCase()));
+    if (matching.length > 0) {
+        return {
+            status: 'running',
+            instanceName: config.instanceName,
+            projectName: config.projectName,
+            httpPort: config.httpPort,
+            url: `http://localhost:${config.httpPort}`,
+            containers: matching,
+        };
+    }
+    return {
+        status: 'stopped',
+        instanceName: config.instanceName,
+        projectName: config.projectName,
+        httpPort: config.httpPort,
+        url: '',
+        containers: [],
+    };
+}
+// ── Start ──────────────────────────────────────────────────────────────────────
+/**
+ * Start the dev-server for a workspace.
+ */
+export function startDevServer(workspaceId) {
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    const settings = getProjectSettings(workspace.projectPath);
+    if (!settings?.devServer.startCommand) {
+        throw new Error('No dev-server start command configured');
+    }
+    const instanceName = sanitizeBranchName(workspace.workingBranch);
+    // Execute as bash script (supports multi-line scripts)
+    const proc = spawn('bash', ['-c', settings.devServer.startCommand], {
+        cwd: workspace.projectPath,
+        env: {
+            ...process.env,
+            INSTANCE: instanceName,
+            DEV_DOCKER_NO_FOLLOW: '1',
+        },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
+    });
+    trackedProcesses.set(workspaceId, proc);
+    // Log stdout/stderr for debugging
+    proc.stdout?.on('data', (data) => {
+        console.log(`[dev-server:${instanceName}] ${data.toString().trim()}`);
+    });
+    proc.stderr?.on('data', (data) => {
+        console.error(`[dev-server:${instanceName}] ${data.toString().trim()}`);
+    });
+    proc.on('exit', (code) => {
+        trackedProcesses.delete(workspaceId);
+        const currentStatus = getStatus(workspace.projectPath, workspace.workingBranch);
+        updateDevServerStatus(workspaceId, currentStatus.status);
+        emitEphemeral(workspaceId, 'devserver:status', currentStatus);
+        if (code !== 0) {
+            console.error(`[dev-server] Process exited with code ${code} for workspace ${workspaceId}`);
+        }
+    });
+    proc.on('error', (err) => {
+        trackedProcesses.delete(workspaceId);
+        updateDevServerStatus(workspaceId, 'error');
+        console.error(`[dev-server] Process error for workspace ${workspaceId}:`, err);
+        emitEphemeral(workspaceId, 'devserver:status', {
+            status: 'error',
+            instanceName,
+            projectName: '',
+            httpPort: '',
+            url: '',
+            containers: [],
+            error: err.message,
+        });
+    });
+    const status = {
+        status: 'starting',
+        instanceName,
+        projectName: '',
+        httpPort: '',
+        url: '',
+        containers: [],
+    };
+    updateDevServerStatus(workspaceId, 'starting');
+    emitEphemeral(workspaceId, 'devserver:status', status);
+    return status;
+}
+// ── Stop ───────────────────────────────────────────────────────────────────────
+/**
+ * Stop the dev-server for a workspace.
+ */
+export function stopDevServer(workspaceId) {
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace) {
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    }
+    const config = resolveInstance(workspace.projectPath, workspace.workingBranch);
+    const instanceName = config?.instanceName ?? sanitizeBranchName(workspace.workingBranch);
+    // Kill tracked process first (covers Node servers and any spawned process)
+    const tracked = trackedProcesses.get(workspaceId);
+    if (tracked) {
+        try {
+            if (tracked.pid) {
+                process.kill(-tracked.pid, 'SIGTERM');
+            }
+            else {
+                tracked.kill('SIGTERM');
+            }
+        }
+        catch (err) {
+            console.error('[dev-server] Failed to kill tracked process:', err instanceof Error ? err.message : err);
+        }
+        trackedProcesses.delete(workspaceId);
+    }
+    const settings = getProjectSettings(workspace.projectPath);
+    if (settings?.devServer.stopCommand) {
+        // Custom stop script — run synchronously with instance context in env
+        try {
+            execSync(settings.devServer.stopCommand, {
+                cwd: workspace.projectPath,
+                env: {
+                    ...process.env,
+                    INSTANCE: instanceName,
+                    PROJECT_NAME: config?.projectName ?? '',
+                },
+                encoding: 'utf-8',
+                timeout: 30000,
+                shell: 'bash',
+            });
+        }
+        catch (err) {
+            console.error(`[dev-server] Stop command failed:`, err instanceof Error ? err.message : err);
+        }
+    }
+    // Always try docker compose down with project name if we have one
+    // (handles cases where custom stop command doesn't use -p flag)
+    if (config?.projectName) {
+        try {
+            execSync(`docker compose -p "${config.projectName}" down`, {
+                cwd: workspace.projectPath,
+                encoding: 'utf-8',
+                timeout: 30000,
+            });
+        }
+        catch {
+            // May already be stopped by the custom command — ignore
+        }
+    }
+    const status = {
+        status: 'stopped',
+        instanceName,
+        projectName: config?.projectName ?? '',
+        httpPort: config?.httpPort ?? '',
+        url: '',
+        containers: [],
+    };
+    updateDevServerStatus(workspaceId, 'stopped');
+    emitEphemeral(workspaceId, 'devserver:status', status);
+    return status;
+}
+// ── Logs ───────────────────────────────────────────────────────────────────────
+/**
+ * Get logs from running dev-server containers for a workspace.
+ * Note: uses execSync for `docker logs` — container names come from
+ * `docker ps` output (not user input), so no injection risk.
+ */
+export function getDevServerLogs(workspaceId, tail = 200) {
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace) {
+        return 'Workspace not found';
+    }
+    const config = resolveInstance(workspace.projectPath, workspace.workingBranch);
+    if (!config) {
+        return 'No dev-server instance found';
+    }
+    const running = listRunningContainers();
+    const matching = running.filter((name) => name.toLowerCase().includes(config.projectName.toLowerCase()));
+    if (matching.length === 0) {
+        return 'No running containers found';
+    }
+    const outputs = [];
+    for (const container of matching) {
+        try {
+            const logs = execSync(`docker logs --tail ${tail} ${container}`, {
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            outputs.push(`=== ${container} ===\n${logs}`);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            outputs.push(`=== ${container} ===\n[Error fetching logs: ${message}]`);
+        }
+    }
+    return outputs.join('\n\n');
+}

package/dist/server/services/notion-service.js

@@ -0,0 +1,369 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+// Gherkin keywords (French and English)
+const GHERKIN_PATTERN = /^(Scénario|Étant donné|Quand|Alors|Scenario|Given|When|Then|Feature|Fonctionnalité|And|Et|But|Mais)/i;
+// C2: rpcIdCounter encapsulated in a closure to avoid module-level mutable state
+const nextRpcId = (() => {
+    let counter = 1;
+    return () => counter++;
+})();
+/**
+ * Parse a Notion URL and extract the page_id in UUID format (with dashes).
+ * Handles:
+ *   https://www.notion.so/workspace/Title-<32hexChars>
+ *   https://www.notion.so/workspace/<32hexChars>
+ *   https://www.notion.so/<32hexChars>
+ */
+export function parseNotionUrl(url) {
+    // Strip query string and fragment
+    const cleanUrl = url.split('?')[0].split('#')[0];
+    // The page ID is always the last 32 hex characters (no dashes) at the end of the path
+    const match = cleanUrl.match(/([0-9a-f]{32})$/i);
+    if (!match) {
+        // Try to find a UUID with dashes
+        const uuidMatch = cleanUrl.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+        if (uuidMatch) {
+            return uuidMatch[1];
+        }
+        throw new Error(`Could not extract page ID from Notion URL: ${url}`);
+    }
+    const raw = match[1];
+    // Convert 32 hex chars to UUID format: 8-4-4-4-12
+    return `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`;
+}
+/**
+ * Send a JSON-RPC request to the MCP process and read the response.
+ * M4: parameter renamed from `process` to `mcpProcess` to avoid shadowing global `process`.
+ * C1: 30s timeout added to prevent hanging indefinitely.
+ */
+export async function callMcpTool(mcpProcess, toolName, args) {
+    const id = nextRpcId();
+    const request = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method: 'tools/call',
+        params: {
+            name: toolName,
+            arguments: args,
+        },
+    });
+    return new Promise((resolve, reject) => {
+        if (!mcpProcess.stdin || !mcpProcess.stdout) {
+            reject(new Error('MCP process stdin/stdout not available'));
+            return;
+        }
+        let buffer = '';
+        // C1: 30s timeout
+        const timeout = setTimeout(() => {
+            mcpProcess.stdout?.removeListener('data', onData);
+            mcpProcess.stdout?.removeListener('error', onError);
+            reject(new Error(`callMcpTool('${toolName}') timed out after 30s`));
+        }, 30_000);
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            // Try to parse complete JSON lines
+            const lines = buffer.split('\n');
+            // Keep the last (potentially incomplete) line in the buffer
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (parsed.id === id) {
+                        clearTimeout(timeout);
+                        mcpProcess.stdout?.removeListener('data', onData);
+                        mcpProcess.stdout?.removeListener('error', onError);
+                        if (parsed.error) {
+                            reject(new Error(`MCP tool '${toolName}' error: ${parsed.error.message} (code: ${parsed.error.code})`));
+                        }
+                        else {
+                            resolve(parsed.result);
+                        }
+                    }
+                }
+                catch {
+                    // Ignore JSON parse errors for partial lines
+                }
+            }
+        };
+        const onError = (err) => {
+            clearTimeout(timeout);
+            mcpProcess.stdout?.removeListener('data', onData);
+            reject(err);
+        };
+        mcpProcess.stdout.on('data', onData);
+        mcpProcess.stdout.once('error', onError);
+        mcpProcess.stdin.write(`${request}\n`);
+    });
+}
+/**
+ * Read the Notion token from Claude Code's config file as a fallback.
+ */
+function readNotionTokenFromClaudeConfig() {
+    try {
+        const homedir = process.env.HOME ?? process.env.USERPROFILE ?? '';
+        const configPath = `${homedir}/.claude.json`;
+        const raw = readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(raw);
+        const mcpServers = config.mcpServers;
+        const notionServer = mcpServers?.notion;
+        return notionServer?.env?.NOTION_TOKEN ?? notionServer?.env?.NOTION_API_TOKEN ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function spawnMcpProcess() {
+    const notionToken = process.env.NOTION_API_TOKEN ?? process.env.NOTION_TOKEN ?? readNotionTokenFromClaudeConfig();
+    const mcpCommand = process.env.NOTION_MCP_COMMAND ?? 'npx';
+    const mcpArgs = process.env.NOTION_MCP_ARGS
+        ? process.env.NOTION_MCP_ARGS.split(' ')
+        : ['-y', '@notionhq/notion-mcp-server'];
+    const mcpProcess = spawn(mcpCommand, mcpArgs, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            OPENAPI_MCP_HEADERS: JSON.stringify({
+                Authorization: `Bearer ${notionToken}`,
+                'Notion-Version': '2022-06-28',
+            }),
+        },
+    });
+    mcpProcess.stderr?.on('data', (data) => {
+        // Silently consume stderr to avoid cluttering logs
+        const text = data.toString();
+        if (process.env.DEBUG_NOTION_MCP) {
+            console.error('[notion-mcp stderr]', text);
+        }
+    });
+    return mcpProcess;
+}
+/**
+ * Initialize the MCP server by sending an initialize request.
+ * I1: notifications/initialized is sent after receiving the initialize response.
+ * I4: onData listener is removed in the reject path.
+ * C1: 10s timeout added.
+ */
+async function initializeMcp(mcpProcess) {
+    const id = nextRpcId();
+    const request = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method: 'initialize',
+        params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'kobo', version: '0.1.0' },
+        },
+    });
+    await new Promise((resolve, reject) => {
+        if (!mcpProcess.stdin || !mcpProcess.stdout) {
+            reject(new Error('MCP process not ready'));
+            return;
+        }
+        let buffer = '';
+        // C1: 10s timeout for initialization
+        const timeout = setTimeout(() => {
+            mcpProcess.stdout?.removeListener('data', onData);
+            reject(new Error('initializeMcp timed out after 10s'));
+        }, 10_000);
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (parsed.id === id) {
+                        clearTimeout(timeout);
+                        mcpProcess.stdout?.removeListener('data', onData);
+                        // I1: Send notifications/initialized AFTER receiving the initialize response
+                        const initialized = JSON.stringify({
+                            jsonrpc: '2.0',
+                            method: 'notifications/initialized',
+                        });
+                        mcpProcess.stdin?.write(`${initialized}\n`);
+                        resolve();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        };
+        // I4: onError handler to clean up listener on error
+        const onError = (err) => {
+            clearTimeout(timeout);
+            mcpProcess.stdout?.removeListener('data', onData);
+            reject(err);
+        };
+        mcpProcess.stdout.on('data', onData);
+        mcpProcess.stdout.once('error', onError);
+        mcpProcess.stdin.write(`${request}\n`);
+    });
+}
+/**
+ * Unwrap MCP tool response.
+ * MCP returns { content: [{ type: "text", text: "..." }] }
+ * where text is a JSON-stringified API response.
+ */
+function unwrapMcpResult(result) {
+    if (result && typeof result === 'object') {
+        const obj = result;
+        if (Array.isArray(obj.content)) {
+            const first = obj.content[0];
+            if (first?.type === 'text' && first.text) {
+                try {
+                    return JSON.parse(first.text);
+                }
+                catch {
+                    return first.text;
+                }
+            }
+        }
+    }
+    return result;
+}
+function extractTextFromRichText(richText) {
+    if (!Array.isArray(richText))
+        return '';
+    return richText
+        .map((rt) => {
+        if (rt && typeof rt === 'object' && 'plain_text' in rt) {
+            return rt.plain_text;
+        }
+        return '';
+    })
+        .join('');
+}
+export function parseBlocks(blocks) {
+    const todos = [];
+    const gherkinFeatures = [];
+    let goal = '';
+    let insideObjectif = false;
+    let currentGherkinBlock = [];
+    for (const block of blocks) {
+        const blockType = block.type;
+        if (blockType === 'heading_1' || blockType === 'heading_2' || blockType === 'heading_3') {
+            // Flush current gherkin block
+            if (currentGherkinBlock.length > 0) {
+                gherkinFeatures.push(currentGherkinBlock.join('\n'));
+                currentGherkinBlock = [];
+            }
+            const headingData = block[blockType];
+            const headingText = extractTextFromRichText(headingData?.rich_text ?? [])
+                .toLowerCase()
+                .trim();
+            insideObjectif = headingText === 'objectif' || headingText === 'goal';
+            continue;
+        }
+        if (blockType === 'to_do') {
+            insideObjectif = false;
+            const todoData = block.to_do;
+            const title = extractTextFromRichText(todoData?.rich_text ?? []);
+            const checked = todoData?.checked ?? false;
+            todos.push({ title, checked });
+            continue;
+        }
+        if (blockType === 'paragraph' || blockType === 'bulleted_list_item' || blockType === 'numbered_list_item') {
+            const data = block[blockType];
+            const text = extractTextFromRichText(data?.rich_text ?? []);
+            if (insideObjectif && blockType === 'paragraph') {
+                goal = goal ? `${goal}\n${text}` : text;
+                continue;
+            }
+            // Check if this is a Gherkin line
+            if (GHERKIN_PATTERN.test(text.trim())) {
+                currentGherkinBlock.push(text);
+            }
+            else if (currentGherkinBlock.length > 0) {
+                // Part of an ongoing gherkin block (continuation lines)
+                currentGherkinBlock.push(text);
+            }
+            continue;
+        }
+        if (blockType === 'code') {
+            const codeData = block.code;
+            const codeText = extractTextFromRichText(codeData?.rich_text ?? []);
+            // Check if the code block contains Gherkin
+            if (GHERKIN_PATTERN.test(codeText.trim())) {
+                if (currentGherkinBlock.length > 0) {
+                    gherkinFeatures.push(currentGherkinBlock.join('\n'));
+                    currentGherkinBlock = [];
+                }
+                gherkinFeatures.push(codeText);
+            }
+            insideObjectif = false;
+            continue;
+        }
+        // Any other block type resets objectif context
+        if (blockType !== 'paragraph') {
+            insideObjectif = false;
+        }
+    }
+    // Flush remaining gherkin block
+    if (currentGherkinBlock.length > 0) {
+        gherkinFeatures.push(currentGherkinBlock.join('\n'));
+    }
+    return { goal, todos, gherkinFeatures };
+}
+/**
+ * Extract content from a Notion page via MCP.
+ */
+export async function extractNotionPage(notionUrl) {
+    const pageId = parseNotionUrl(notionUrl);
+    const mcpProcess = spawnMcpProcess();
+    // Give the process a moment to start
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => resolve(), 1000);
+        mcpProcess.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`Failed to start MCP Notion server: ${err.message}`));
+        });
+    });
+    try {
+        // Initialize the MCP server
+        await initializeMcp(mcpProcess);
+        // Retrieve the page metadata (title)
+        const pageRaw = await callMcpTool(mcpProcess, 'API-retrieve-a-page', { page_id: pageId });
+        const pageResult = unwrapMcpResult(pageRaw);
+        let title = '';
+        if (pageResult && typeof pageResult === 'object') {
+            const result = pageResult;
+            const properties = result.properties;
+            if (properties) {
+                for (const prop of Object.values(properties)) {
+                    const propObj = prop;
+                    if (propObj.type === 'title' && Array.isArray(propObj.title)) {
+                        title = extractTextFromRichText(propObj.title);
+                        break;
+                    }
+                }
+            }
+        }
+        // Retrieve the page blocks (content)
+        const blocksRaw = await callMcpTool(mcpProcess, 'API-get-block-children', {
+            block_id: pageId,
+        });
+        const blocksResult = unwrapMcpResult(blocksRaw);
+        let blocks = [];
+        if (blocksResult && typeof blocksResult === 'object') {
+            const result = blocksResult;
+            if (Array.isArray(result.results)) {
+                blocks = result.results;
+            }
+        }
+        const { goal, todos, gherkinFeatures } = parseBlocks(blocks);
+        return { title, goal, todos, gherkinFeatures };
+    }
+    finally {
+        // Ensure the MCP process is terminated
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}