specrails-desktop 2.0.0

package/server/dist/codex-otel-bridge.js

@@ -0,0 +1,235 @@
+"use strict";
+// Synthetic OTEL bridge for codex (and any future provider whose CLI does not
+// honour `OTEL_EXPORTER_OTLP_*` environment variables natively).
+//
+// Lifecycle:
+//
+//   const bridge = createCodexOtelBridge({ jobId, projectId, desktopPort, model, threadId? })
+//   for each parsed AdapterEvent → bridge.consumeEvent(event)
+//   on child close → await bridge.finalize({ exitCode, stderr? })
+//
+// On finalize, the bridge composes one OTLP/JSON payload per signal (traces,
+// metrics, logs) and POSTs them to the in-process receiver at
+// http://127.0.0.1:<desktopPort>/otlp/v1/{traces,metrics,logs}. The receiver
+// already routes by resource attributes, enforces the 10 MB cap, gzips the
+// NDJSON, and updates `telemetry_blobs` — the bridge does not bypass any of
+// that.
+//
+// Spec: openspec/changes/add-multi-provider-support/specs/pipeline-telemetry/spec.md
+//   - "Synthetic OTEL bridge for providers without native OTEL env support"
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodexOtelBridge = createCodexOtelBridge;
+const crypto_1 = require("crypto");
+const LOGS_CAP_BYTES = 10 * 1024 * 1024; // 10 MB — mirrors telemetry-receiver cap
+// ─── OTLP shape helpers ───────────────────────────────────────────────────────
+function attr(key, value) {
+    return { key, value: { stringValue: value } };
+}
+function intAttr(key, value) {
+    return { key, value: { intValue: String(value) } };
+}
+function makeResource(opts, threadId) {
+    const attrs = [
+        attr('specrails.job_id', opts.jobId),
+        attr('specrails.project_id', opts.projectId),
+        attr('specrails.provider', 'codex'),
+        attr('service.name', 'specrails-desktop.codex-bridge'),
+    ];
+    if (opts.model)
+        attrs.push(attr('specrails.codex.model', opts.model));
+    if (opts.cliVersion)
+        attrs.push(attr('specrails.codex.cli_version', opts.cliVersion));
+    if (threadId)
+        attrs.push(attr('specrails.codex.thread_id', threadId));
+    return { attributes: attrs };
+}
+// ─── Bridge factory ───────────────────────────────────────────────────────────
+function createCodexOtelBridge(opts) {
+    const clock = opts.clock ?? { now: () => Date.now() };
+    const rb = opts.randomBytes ?? crypto_1.randomBytes;
+    const poster = opts.poster ?? defaultPoster;
+    const startedAtMs = clock.now();
+    const startedAtUnixNs = String(BigInt(startedAtMs) * 1000000n);
+    const traceId = rb(16).toString('hex');
+    const rootSpanId = rb(8).toString('hex');
+    let threadId;
+    let logsBytes = 0;
+    let truncated = false;
+    const logRecords = [];
+    const spanEvents = [];
+    let resultPayload = null;
+    function consumeEvent(event) {
+        const nowMs = clock.now();
+        const nowNs = String(BigInt(nowMs) * 1000000n);
+        switch (event.kind) {
+            case 'session-started':
+                threadId = event.sessionId;
+                break;
+            case 'tool-use': {
+                const tail = {
+                    timeUnixNano: nowNs,
+                    name: 'codex.tool_use',
+                    attributes: [
+                        attr('codex.tool.name', event.name),
+                        attr('codex.tool.input_preview', event.inputPreview),
+                    ],
+                };
+                spanEvents.push(tail);
+                break;
+            }
+            case 'text-delta': {
+                const recordSize = Buffer.byteLength(event.text, 'utf-8') + 64; // overhead estimate
+                if (logsBytes + recordSize > LOGS_CAP_BYTES) {
+                    if (!truncated) {
+                        truncated = true;
+                        logRecords.push({
+                            timeUnixNano: nowNs,
+                            body: { stringValue: '[specrails.codex-bridge] logs truncated (10 MB cap)' },
+                        });
+                    }
+                    break;
+                }
+                logsBytes += recordSize;
+                logRecords.push({ timeUnixNano: nowNs, body: { stringValue: event.text } });
+                break;
+            }
+            case 'result':
+                resultPayload = event.payload;
+                break;
+            case 'other':
+                // Ignore — these are progress markers, not actionable telemetry.
+                break;
+        }
+    }
+    async function finalize(input) {
+        const endedAtMs = clock.now();
+        const endedAtUnixNs = String(BigInt(endedAtMs) * 1000000n);
+        const resource = makeResource(opts, threadId);
+        const scopeKey = { name: 'specrails-desktop.codex-bridge' };
+        // ── Spans ──────────────────────────────────────────────────────────────
+        const usage = resultPayload?.usage ?? {};
+        const tokensIn = usage.input_tokens ?? 0;
+        const tokensOut = (usage.output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0);
+        const tokensCacheRead = usage.cached_input_tokens ?? 0;
+        const spanAttrs = [
+            intAttr('codex.tokens.input', tokensIn),
+            intAttr('codex.tokens.output', tokensOut),
+            intAttr('codex.tokens.cache_read', tokensCacheRead),
+            intAttr('codex.exit_code', input.exitCode ?? -1),
+        ];
+        if (opts.model)
+            spanAttrs.push(attr('codex.model', opts.model));
+        const tracesPayload = {
+            resourceSpans: [{
+                    resource,
+                    scopeSpans: [{
+                            scope: scopeKey,
+                            spans: [{
+                                    traceId,
+                                    spanId: rootSpanId,
+                                    name: 'specrails.codex.turn',
+                                    kind: 1, // INTERNAL
+                                    startTimeUnixNano: startedAtUnixNs,
+                                    endTimeUnixNano: endedAtUnixNs,
+                                    attributes: spanAttrs,
+                                    events: spanEvents,
+                                    status: {
+                                        code: input.exitCode === 0 ? 1 : 2, // OK=1, ERROR=2
+                                        message: input.exitCode === 0 ? '' : (input.stderr?.slice(-300) ?? ''),
+                                    },
+                                }],
+                        }],
+                }],
+        };
+        // ── Metrics ────────────────────────────────────────────────────────────
+        function tokenMetric(name, value) {
+            return {
+                name,
+                unit: 'tokens',
+                sum: {
+                    aggregationTemporality: 1, // DELTA
+                    isMonotonic: true,
+                    dataPoints: [{
+                            timeUnixNano: endedAtUnixNs,
+                            startTimeUnixNano: startedAtUnixNs,
+                            asInt: String(value),
+                        }],
+                },
+            };
+        }
+        const durationMs = endedAtMs - startedAtMs;
+        const metricsPayload = {
+            resourceMetrics: [{
+                    resource,
+                    scopeMetrics: [{
+                            scope: scopeKey,
+                            metrics: [
+                                tokenMetric('specrails.codex.tokens.input', tokensIn),
+                                tokenMetric('specrails.codex.tokens.output', tokensOut),
+                                tokenMetric('specrails.codex.tokens.cache_read', tokensCacheRead),
+                                {
+                                    name: 'specrails.codex.duration_ms',
+                                    unit: 'ms',
+                                    gauge: {
+                                        dataPoints: [{
+                                                timeUnixNano: endedAtUnixNs,
+                                                asInt: String(durationMs),
+                                            }],
+                                    },
+                                },
+                            ],
+                        }],
+                }],
+        };
+        // ── Logs ───────────────────────────────────────────────────────────────
+        const logsPayload = {
+            resourceLogs: [{
+                    resource,
+                    scopeLogs: [{
+                            scope: scopeKey,
+                            logRecords: logRecords.map((r) => ({
+                                timeUnixNano: r.timeUnixNano,
+                                severityNumber: 9, // INFO
+                                severityText: 'INFO',
+                                body: r.body,
+                            })),
+                        }],
+                }],
+        };
+        const url = (signal) => `http://127.0.0.1:${opts.desktopPort}/otlp/v1/${signal}`;
+        const results = await Promise.allSettled([
+            poster(url('traces'), JSON.stringify(tracesPayload)),
+            poster(url('metrics'), JSON.stringify(metricsPayload)),
+            poster(url('logs'), JSON.stringify(logsPayload)),
+        ]);
+        // Log POST failures but never throw — telemetry is best-effort.
+        for (const r of results) {
+            if (r.status === 'rejected') {
+                console.warn('[codex-otel-bridge] poster rejected:', r.reason);
+            }
+            else if (!r.value.ok) {
+                console.warn(`[codex-otel-bridge] poster non-ok status ${r.value.status}`);
+            }
+        }
+    }
+    return {
+        consumeEvent,
+        finalize,
+        _debugLogBytes: () => logsBytes,
+        _debugTruncated: () => truncated,
+    };
+}
+// ─── Default poster (uses globalThis.fetch) ─────────────────────────────────
+const defaultPoster = async (url, body) => {
+    try {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body,
+        });
+        return { ok: res.ok, status: res.status };
+    }
+    catch (err) {
+        return { ok: false, status: 0, body: err.message };
+    }
+};

package/server/dist/command-resolver.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCommand = resolveCommand;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Locate the app repository root (the directory containing .claude/commands/).
+ * Works in both dev mode (tsx: __dirname = <repo>/server/) and
+ * compiled mode (tsc: __dirname = <repo>/server/dist/).
+ */
+function findDesktopRoot() {
+    let dir = (0, path_1.resolve)(__dirname, '..');
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, '.claude', 'commands')))
+        return dir;
+    dir = (0, path_1.resolve)(__dirname, '../..');
+    if ((0, fs_1.existsSync)((0, path_1.join)(dir, '.claude', 'commands')))
+        return dir;
+    return null;
+}
+const DESKTOP_ROOT = findDesktopRoot();
+function builtInCommand(commandPath, commandArgs) {
+    if (commandPath !== 'specrails:explore-spec')
+        return null;
+    return `You are a senior product engineer helping the user shape one backlog spec inside Specrails' Explore Spec experience.
+
+Do not use any local skill, slash-command workflow, or repository-change workflow. Stay inside this chat and shape the draft ticket only. Do not inspect active change folders unless the user explicitly asks about them, and do not create or modify files. The app commits the final ticket only when the user clicks Create Spec.
+
+Your job is to maintain a live draft. After every assistant turn that changes draft state, end your message with a fenced \`spec-draft\` JSON block. The visible prose should match the user's language. Draft fields must be written in English.
+
+Use this draft schema. Omit fields you do not want to update:
+
+\`\`\`spec-draft
+{
+  "title": "Concise, action-oriented title",
+  "description": "## Problem Statement\\n2-3 sentences.\\n\\n## Proposed Solution\\n3-5 sentences.\\n\\n## Out of Scope\\n- bullet\\n\\n## Technical Considerations\\n- bullet\\n\\n## Estimated Complexity\\nMedium - one sentence justification.",
+  "labels": ["short-label"],
+  "priority": "low | medium | high | critical",
+  "acceptanceCriteria": ["Short, testable criterion"],
+  "chips": ["Up to 3 short replies"],
+  "ready": false
+}
+\`\`\`
+
+Rules:
+- Ask only the clarifying questions genuinely needed to make the spec concrete.
+- Keep visible replies brief.
+- Set \`ready: true\` only when the draft has a title, description, acceptance criteria, and no outstanding clarifying question.
+- Never call \`/specrails:propose-spec\`, \`/specrails:implement\`, or any slash command with side effects.
+
+The user's idea follows below. Begin the Explore Spec conversation.
+
+---
+
+${commandArgs}`.trim();
+}
+/**
+ * Try to find a command/skill .md file for the given command path parts
+ * within the given base directory. Returns the resolved path or null.
+ */
+function findCommandFile(baseDir, parts) {
+    const filePath = (0, path_1.join)(baseDir, '.claude', 'commands', ...parts) + '.md';
+    if ((0, fs_1.existsSync)(filePath))
+        return filePath;
+    const skillPath = (0, path_1.join)(baseDir, '.claude', 'skills', ...parts) + '.md';
+    if ((0, fs_1.existsSync)(skillPath))
+        return skillPath;
+    return null;
+}
+/**
+ * Resolves a slash command string to its full prompt content.
+ * Reads the command file from .claude/commands/ or .claude/skills/,
+ * strips YAML frontmatter, and substitutes $ARGUMENTS.
+ *
+ * Searches the project directory first, then falls back to the app's
+ * own .claude/commands/ directory (for app-namespaced commands like
+ * /specrails:implement that aren't installed in the target project).
+ *
+ * Falls back to returning the command string as-is if the file is not found.
+ */
+function resolveCommand(command, cwd) {
+    const match = command.match(/^\/([^\s]+)\s*(.*)$/s);
+    if (!match)
+        return command;
+    const commandPath = match[1];
+    const commandArgs = match[2].trim();
+    const parts = commandPath.split(':');
+    const builtIn = builtInCommand(commandPath, commandArgs);
+    if (builtIn)
+        return builtIn;
+    // 1. Check the project directory
+    let resolvedPath = findCommandFile(cwd, parts);
+    // 2. Fallback: check the app's own directory
+    if (!resolvedPath && DESKTOP_ROOT && (0, path_1.resolve)(cwd) !== (0, path_1.resolve)(DESKTOP_ROOT)) {
+        resolvedPath = findCommandFile(DESKTOP_ROOT, parts);
+    }
+    if (!resolvedPath)
+        return command;
+    let content = (0, fs_1.readFileSync)(resolvedPath, 'utf-8');
+    content = content.replace(/^---[\s\S]*?---\s*/, '');
+    content = content.replace(/\$ARGUMENTS/g, commandArgs);
+    return content.trim();
+}

package/server/dist/config.js

@@ -0,0 +1,306 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__resetTrackerDetectionCacheForTest = __resetTrackerDetectionCacheForTest;
+exports.getConfig = getConfig;
+exports.fetchIssues = fetchIssues;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+function runCommand(cmd, cwd) {
+    try {
+        return (0, child_process_1.execSync)(cmd, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, cwd }).toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Run a command with an explicit argv array via `execFileSync` — NO shell (H-12).
+ *
+ * `runCommand` routes through `/bin/sh -c`, so any shell metacharacter in an
+ * interpolated value is a command-injection sink. `fetchIssues` builds its
+ * arguments from HTTP query params (`search`/`label`) and the git remote, so it
+ * MUST use this argv form: each argument is passed literally to the program and
+ * the shell never sees it. `runCommand` is retained only for fixed, constant
+ * detection commands (`which gh`, `gh auth status`, `git remote get-url origin`)
+ * that carry no user input.
+ */
+function runCommandArgs(file, args, cwd) {
+    try {
+        return (0, child_process_1.execFileSync)(file, args, { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, cwd }).toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+function detectGithub() {
+    const ghPath = runCommand('which gh');
+    if (!ghPath)
+        return { available: false, authenticated: false };
+    const authOutput = runCommand('gh auth status');
+    const authenticated = authOutput !== null;
+    return { available: true, authenticated };
+}
+function detectJira() {
+    const jiraPath = runCommand('which jira');
+    if (!jiraPath)
+        return { available: false, authenticated: false };
+    // jira CLI availability means it is configured (auth is implicit via jira config)
+    return { available: true, authenticated: true };
+}
+// H19: `which gh` + `gh auth status` (a network round-trip, 0.3-2s) + `which
+// jira` are project-independent but ran synchronously on every getConfig()
+// call — once per project in the startup loadAll() and again on each
+// GET /config | GET /issues — blocking the single event loop app-wide.
+// Memoize with a short TTL (same pattern as setup-prerequisites.ts) so startup
+// probes once and hot request paths reuse the cached result; auth/install
+// changes surface after at most TTL.
+let _trackerCache = null;
+const TRACKER_CACHE_TTL_MS = 60_000;
+function detectTrackers() {
+    const now = Date.now();
+    if (_trackerCache && now - _trackerCache.at < TRACKER_CACHE_TTL_MS) {
+        return _trackerCache;
+    }
+    _trackerCache = { at: now, github: detectGithub(), jira: detectJira() };
+    return _trackerCache;
+}
+/** Test-only: clear the tracker-detection memo so each test re-probes. */
+function __resetTrackerDetectionCacheForTest() {
+    _trackerCache = null;
+}
+function getGitRepoName(projectRoot) {
+    const output = runCommand('git remote get-url origin', projectRoot);
+    if (!output)
+        return null;
+    // Parse both HTTPS and SSH remote URLs
+    // https://github.com/owner/repo.git → owner/repo
+    // git@github.com:owner/repo.git → owner/repo
+    const httpsMatch = output.match(/github\.com\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch)
+        return httpsMatch[1];
+    const sshMatch = output.match(/github\.com:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch)
+        return sshMatch[1];
+    return null;
+}
+function parseFrontmatter(content) {
+    const result = { scalars: {}, phases: [] };
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return result;
+    const lines = match[1].split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) {
+            i++;
+            continue;
+        }
+        const key = line.slice(0, colonIdx).trim();
+        const rawValue = line.slice(colonIdx + 1).trim();
+        if (!key) {
+            i++;
+            continue;
+        }
+        // Array field: value is empty, subsequent lines start with "  - "
+        if (rawValue === '' && i + 1 < lines.length && lines[i + 1].startsWith('  - ')) {
+            i++;
+            if (key === 'phases') {
+                const items = [];
+                let current = null;
+                while (i < lines.length) {
+                    const aLine = lines[i];
+                    if (aLine.startsWith('  - ')) {
+                        // New array item — flush current
+                        if (current)
+                            items.push(current);
+                        current = {};
+                        // Parse the inline key: value after "  - "
+                        const rest = aLine.slice(4);
+                        const aColon = rest.indexOf(':');
+                        if (aColon !== -1) {
+                            const aKey = rest.slice(0, aColon).trim();
+                            const aVal = rest.slice(aColon + 1).trim().replace(/^["']|["']$/g, '');
+                            current[aKey] = aVal;
+                        }
+                        i++;
+                    }
+                    else if (aLine.startsWith('    ') && !aLine.startsWith('    - ')) {
+                        // Continuation key: value for current item
+                        if (current) {
+                            const aColon = aLine.indexOf(':');
+                            if (aColon !== -1) {
+                                const aKey = aLine.slice(0, aColon).trim();
+                                const aVal = aLine.slice(aColon + 1).trim().replace(/^["']|["']$/g, '');
+                                current[aKey] = aVal;
+                            }
+                        }
+                        i++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (current)
+                    items.push(current);
+                result.phases = items.filter((item) => typeof item.key === 'string' &&
+                    typeof item.label === 'string' &&
+                    typeof item.description === 'string');
+            }
+            else {
+                // Skip unknown array fields
+                while (i < lines.length && (lines[i].startsWith('  - ') || lines[i].startsWith('    '))) {
+                    i++;
+                }
+            }
+        }
+        else {
+            result.scalars[key] = rawValue.replace(/^["']|["']$/g, '');
+            i++;
+        }
+    }
+    return result;
+}
+function slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+function scanCommands(commandsDir) {
+    if (!fs_1.default.existsSync(commandsDir))
+        return [];
+    let files;
+    try {
+        files = fs_1.default.readdirSync(commandsDir).filter((f) => f.endsWith('.md'));
+    }
+    catch {
+        return [];
+    }
+    return files.map((file) => {
+        const slug = file.replace(/\.md$/, '');
+        let name = slug;
+        let description = '';
+        let phases = [];
+        try {
+            const content = fs_1.default.readFileSync(path_1.default.join(commandsDir, file), 'utf-8');
+            const fm = parseFrontmatter(content);
+            if (fm.scalars.name)
+                name = fm.scalars.name;
+            if (fm.scalars.description)
+                description = fm.scalars.description;
+            phases = fm.phases;
+        }
+        catch {
+            // Use filename-derived name if frontmatter parsing fails
+        }
+        return {
+            id: slug,
+            name,
+            description,
+            slug,
+            phases,
+        };
+    });
+}
+function loadPersistedConfig(db) {
+    try {
+        const activeRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.active_tracker'`).get();
+        const labelRow = db.prepare(`SELECT value FROM queue_state WHERE key = 'config.label_filter'`).get();
+        return {
+            active: activeRow?.value ?? null,
+            labelFilter: labelRow?.value ?? '',
+        };
+    }
+    catch {
+        return { active: null, labelFilter: '' };
+    }
+}
+function getConfig(cwd, db, projectName) {
+    // Resolve project root. Super mode passes project.path directly, which has a
+    // `.claude` directory at its root; the walk-up fallback covers callers that
+    // pass a manager-relative cwd.
+    let projectRoot;
+    if (fs_1.default.existsSync(path_1.default.join(cwd, '.claude'))) {
+        projectRoot = cwd;
+    }
+    else {
+        projectRoot = path_1.default.resolve(cwd, '../..');
+    }
+    const commandsDir = path_1.default.join(projectRoot, '.claude', 'commands', 'sr');
+    const commands = scanCommands(commandsDir);
+    const { github, jira } = detectTrackers();
+    const repo = getGitRepoName(projectRoot);
+    const persisted = db ? loadPersistedConfig(db) : { active: null, labelFilter: '' };
+    // Auto-detect active tracker if not persisted
+    let active = persisted.active;
+    if (!active) {
+        if (github.authenticated)
+            active = 'github';
+        else if (jira.authenticated)
+            active = 'jira';
+    }
+    return {
+        project: {
+            name: projectName ?? path_1.default.basename(projectRoot),
+            repo: repo,
+        },
+        issueTracker: {
+            github,
+            jira,
+            active,
+            labelFilter: persisted.labelFilter,
+        },
+        commands,
+    };
+}
+function fetchIssues(tracker, opts) {
+    if (tracker === 'github') {
+        const args = ['issue', 'list', '--json', 'number,title,labels,body,url', '--limit', '50'];
+        if (opts.repo)
+            args.push('--repo', opts.repo);
+        if (opts.label)
+            args.push('--label', opts.label);
+        if (opts.search)
+            args.push('--search', opts.search);
+        const output = runCommandArgs('gh', args, opts.cwd);
+        if (!output)
+            return [];
+        try {
+            const raw = JSON.parse(output);
+            return raw.map((item) => ({
+                number: item.number,
+                title: item.title,
+                labels: item.labels.map((l) => l.name),
+                body: item.body ?? '',
+                url: item.url,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    if (tracker === 'jira') {
+        const jql = opts.search ? `summary ~ "${opts.search}"` : '';
+        const args = ['issue', 'list', '--plain', '--columns', 'KEY,SUMMARY,LABELS,STATUS'];
+        if (jql)
+            args.push('--jql', jql);
+        const output = runCommandArgs('jira', args);
+        if (!output)
+            return [];
+        // Parse plain text output: KEY  SUMMARY  LABELS  STATUS
+        const lines = output.split('\n').filter(Boolean);
+        return lines.slice(1).map((line, idx) => {
+            const parts = line.split('\t');
+            return {
+                number: idx + 1,
+                title: parts[1]?.trim() ?? line,
+                labels: parts[2] ? parts[2].split(',').map((l) => l.trim()) : [],
+                body: '',
+            };
+        });
+    }
+    return [];
+}