@undefineds.co/linx 0.3.20 → 0.3.22

package/dist/plugins/linx-symphony-codex/hooks.json

@@ -0,0 +1,60 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ./scripts/symphony-hook-events.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ./scripts/symphony-hook-events.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ./scripts/symphony-hook-events.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ./scripts/symphony-hook-events.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ./scripts/symphony-hook-events.mjs",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/dist/plugins/linx-symphony-codex/scripts/symphony-hook-events.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+function readStdinJson() {
+  const input = readFileSync(0, 'utf-8').trim()
+  if (!input) return {}
+  const parsed = JSON.parse(input)
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {}
+}
+
+function optionalString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function optionalNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function safeObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+}
+
+function sha256(value) {
+  return createHash('sha256').update(value).digest('hex')
+}
+
+function textDigest(value) {
+  if (typeof value !== 'string') return undefined
+  return {
+    length: value.length,
+    sha256: sha256(value),
+  }
+}
+
+function toolInputSummary(payload) {
+  const toolName = optionalString(payload.tool_name ?? payload.toolName)
+  const toolInput = safeObject(payload.tool_input ?? payload.toolInput)
+  if (toolName === 'Bash' && typeof toolInput.command === 'string') {
+    const command = toolInput.command
+    return {
+      kind: 'bash',
+      commandLength: command.length,
+      commandSha256: sha256(command),
+    }
+  }
+  if (Object.keys(toolInput).length > 0) {
+    return {
+      kind: 'structured',
+      keyCount: Object.keys(toolInput).length,
+      keys: Object.keys(toolInput).sort().slice(0, 20),
+    }
+  }
+  return undefined
+}
+
+function toolResponseSummary(payload) {
+  const response = safeObject(payload.tool_response ?? payload.toolResponse)
+  if (Object.keys(response).length === 0) return undefined
+  return {
+    exitCode: optionalNumber(response.exit_code ?? response.exitCode),
+    stdout: textDigest(response.stdout),
+    stderr: textDigest(response.stderr),
+  }
+}
+
+function resolveEventsPath(env) {
+  const explicit = optionalString(env.LINX_SYMPHONY_HOOK_EVENTS)
+  return explicit ? resolve(explicit) : undefined
+}
+
+function buildEvent(payload, env = process.env, now = new Date()) {
+  const eventName = optionalString(payload.hook_event_name ?? payload.hookEventName ?? payload.event) ?? 'unknown'
+  const sessionId = optionalString(payload.session_id ?? payload.sessionId)
+  const cwd = optionalString(payload.cwd) ?? optionalString(env.PWD)
+  const prompt = typeof payload.prompt === 'string' ? payload.prompt : undefined
+  return {
+    symphonyHookEvent: true,
+    source: 'codex-native-hook',
+    hookEventName: eventName,
+    createdAt: now.toISOString(),
+    ...(sessionId ? { sessionId } : {}),
+    ...(cwd ? { cwd } : {}),
+    ...(optionalString(payload.transcript_path ?? payload.transcriptPath) ? { transcriptPath: optionalString(payload.transcript_path ?? payload.transcriptPath) } : {}),
+    ...(optionalString(payload.tool_name ?? payload.toolName) ? { toolName: optionalString(payload.tool_name ?? payload.toolName) } : {}),
+    ...(optionalString(payload.tool_use_id ?? payload.toolUseId) ? { toolUseId: optionalString(payload.tool_use_id ?? payload.toolUseId) } : {}),
+    ...(prompt ? { prompt: textDigest(prompt) } : {}),
+    ...(toolInputSummary(payload) ? { toolInput: toolInputSummary(payload) } : {}),
+    ...(toolResponseSummary(payload) ? { toolResponse: toolResponseSummary(payload) } : {}),
+  }
+}
+
+function writeEvent(record, env = process.env) {
+  const eventsPath = resolveEventsPath(env)
+  if (!eventsPath) return { written: false, reason: 'not_configured' }
+  mkdirSync(dirname(eventsPath), { recursive: true })
+  appendFileSync(eventsPath, `${JSON.stringify(record)}\n`, 'utf-8')
+  return { written: true, eventsPath }
+}
+
+export function recordSymphonyCodexHookEvent(payload, options = {}) {
+  const env = options.env ?? process.env
+  const now = options.now ?? new Date()
+  const record = buildEvent(payload, env, now)
+  return {
+    record,
+    ...writeEvent(record, env),
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+  try {
+    recordSymphonyCodexHookEvent(readStdinJson())
+  } catch (error) {
+    process.stderr.write(`[linx-symphony-hook] ${error instanceof Error ? error.message : String(error)}\n`)
+  }
+}

package/dist/plugins/linx-symphony-codex/scripts/symphony-mcp.mjs

@@ -0,0 +1,335 @@
+import { createInterface } from 'node:readline';
+import { join, resolve } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { createSymphonyDeliveryUri, getSymphonyArchiveRelativePaths, normalizeSymphonyRuntimeDeliveryResult as normalizeSymphonyDeliveryResult, reconcileSymphonyThreadEvents, SYMPHONY_HOME_DIRNAME, } from '@linx/agent-runtime/symphony';
+const PROTOCOL_VERSION = '2025-03-26';
+const SERVER_INFO = {
+    name: 'linx-symphony-codex',
+    title: 'LinX Symphony',
+    version: '0.1.0',
+};
+export function createSymphonyCodexMcpServer(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const err = options.err ?? process.stderr;
+    const env = options.env ?? process.env;
+    async function handleMessage(message) {
+        if (typeof message.method !== 'string') {
+            return null;
+        }
+        const id = readJsonRpcId(message.id);
+        const method = message.method;
+        if (method === 'notifications/initialized' || method.startsWith('notifications/')) {
+            return null;
+        }
+        try {
+            if (method === 'initialize') {
+                return response(id, {
+                    protocolVersion: readProtocolVersion(message.params) ?? PROTOCOL_VERSION,
+                    capabilities: {
+                        tools: {
+                            listChanged: false,
+                        },
+                    },
+                    serverInfo: SERVER_INFO,
+                });
+            }
+            if (method === 'ping') {
+                return response(id, {});
+            }
+            if (method === 'tools/list') {
+                return response(id, {
+                    tools: buildToolDefinitions(),
+                });
+            }
+            if (method === 'tools/call') {
+                return response(id, await handleToolCall(readParamsObject(message.params), env));
+            }
+            return errorResponse(id, -32601, `Unknown MCP method: ${method}`);
+        }
+        catch (error) {
+            return errorResponse(id, -32000, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return {
+        handleMessage,
+        async run() {
+            const rl = createInterface({ input, crlfDelay: Infinity });
+            for await (const line of rl) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                        continue;
+                    const reply = await handleMessage(parsed);
+                    if (reply) {
+                        output.write(`${JSON.stringify(reply)}\n`);
+                    }
+                }
+                catch (error) {
+                    err.write(`[linx-symphony-codex-mcp] ${error instanceof Error ? error.message : String(error)}\n`);
+                }
+            }
+            return 0;
+        },
+    };
+}
+async function handleToolCall(params, env) {
+    const name = typeof params.name === 'string' ? params.name : '';
+    const args = readParamsObject(params.arguments);
+    if (name === 'delivery_status') {
+        const podRoot = resolvePodMirrorRoot(args, env);
+        return toolResult({
+            configured: true,
+            podRoot,
+            instructions: 'Call submit_delivery with the final worker report before ending this Codex session.',
+        });
+    }
+    if (name === 'validate_delivery') {
+        const normalized = normalizeDeliveryFromToolArgs(args);
+        return toolResult({
+            valid: true,
+            status: normalized.status,
+            exitCode: normalized.exitCode,
+            eventCount: normalized.events.length,
+            hasReport: Boolean(normalized.reportText),
+            autoModeSessionId: normalized.autoModeSessionId ?? null,
+        });
+    }
+    if (name === 'submit_delivery') {
+        const podRoot = resolvePodMirrorRoot(args, env);
+        const normalized = normalizeDeliveryFromToolArgs(args);
+        const submitted = writeDeliveryToPodMirror(args, normalized, podRoot);
+        return toolResult({
+            submitted: true,
+            podRoot,
+            ...submitted,
+            status: normalized.status,
+            exitCode: normalized.exitCode,
+            eventCount: normalized.events.length,
+            hasReport: Boolean(normalized.reportText),
+            autoModeSessionId: normalized.autoModeSessionId ?? null,
+        });
+    }
+    if (name === 'reconcile') {
+        return toolResult(reconcileSymphonyThreadEvents({
+            chat: readOptionalString(args.chat),
+            thread: readOptionalString(args.thread),
+            randomId: readOptionalString(args.randomId),
+            events: readThreadReconcileEvents(args, env),
+        }));
+    }
+    return toolResult({ error: `Unknown Symphony tool: ${name}` }, true);
+}
+function normalizeDeliveryFromToolArgs(args) {
+    const delivery = readDeliveryInput(args.delivery);
+    const candidate = normalizeSymphonyDeliveryResult(delivery ?? {
+        status: args.status,
+        exitCode: args.exitCode,
+        autoModeSessionId: args.autoModeSessionId,
+        events: args.events,
+        report: args.report,
+        reportText: args.reportText,
+    });
+    if (!candidate) {
+        throw new Error('Invalid Symphony Delivery. Provide a delivery object or fields with status/events/report.');
+    }
+    return candidate;
+}
+function writeDeliveryToPodMirror(args, normalized, podRoot) {
+    const deliveryUri = readOptionalString(args.deliveryUri)
+        ?? createSymphonyDeliveryUri({ randomId: readOptionalString(args.randomId) ?? normalized.autoModeSessionId });
+    const paths = getSymphonyArchiveRelativePaths(deliveryUri, 'delivery');
+    const deliveryDir = join(podRoot, SYMPHONY_HOME_DIRNAME, paths.dir);
+    const deliveryFile = join(podRoot, SYMPHONY_HOME_DIRNAME, paths.file);
+    const reportFile = normalized.reportText ? join(deliveryDir, 'report.md') : undefined;
+    const eventsFile = normalized.events.length > 0 ? join(deliveryDir, 'events.jsonl') : undefined;
+    mkdirSync(deliveryDir, { recursive: true });
+    writeFileSync(deliveryFile, `${JSON.stringify({
+        symphonyDelivery: true,
+        uri: deliveryUri,
+        status: normalized.status,
+        exitCode: normalized.exitCode,
+        ...(normalized.autoModeSessionId ? { autoModeSessionId: normalized.autoModeSessionId } : {}),
+        eventCount: normalized.events.length,
+        ...(reportFile ? { reportFile: relativePodMirrorPath(podRoot, reportFile) } : {}),
+        ...(eventsFile ? { eventsFile: relativePodMirrorPath(podRoot, eventsFile) } : {}),
+        submittedAt: new Date().toISOString(),
+    }, null, 2)}\n`, 'utf-8');
+    if (reportFile) {
+        writeFileSync(reportFile, `${normalized.reportText}\n`, 'utf-8');
+    }
+    if (eventsFile) {
+        writeFileSync(eventsFile, `${normalized.events.map((event) => JSON.stringify(event)).join('\n')}\n`, 'utf-8');
+    }
+    return {
+        deliveryUri,
+        deliveryFile,
+        ...(reportFile ? { reportFile } : {}),
+        ...(eventsFile ? { eventsFile } : {}),
+    };
+}
+function readDeliveryInput(value) {
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function resolvePodMirrorRoot(args, env) {
+    return resolve(readOptionalString(args.podRoot)
+        ?? readOptionalString(env.LINX_POD_MIRROR_ROOT)
+        ?? join(process.cwd(), '.pod'));
+}
+function relativePodMirrorPath(podRoot, path) {
+    return path.startsWith(`${podRoot}/`) ? path.slice(podRoot.length + 1) : path;
+}
+function buildToolDefinitions() {
+    return [
+        {
+            name: 'delivery_status',
+            title: 'Delivery Status',
+            description: 'Report the local Pod mirror root where Codex worker Deliveries will be written.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    podRoot: { type: 'string', description: 'Optional local Pod mirror root. Defaults to LINX_POD_MIRROR_ROOT or ./.pod.' },
+                },
+                additionalProperties: false,
+            },
+        },
+        {
+            name: 'validate_delivery',
+            title: 'Validate Delivery',
+            description: 'Validate a Symphony worker Delivery without writing it.',
+            inputSchema: deliveryInputSchema(),
+        },
+        {
+            name: 'submit_delivery',
+            title: 'Submit Delivery',
+            description: 'Write a Symphony worker Delivery into the local Pod mirror for later Pod sync.',
+            inputSchema: {
+                ...deliveryInputSchema(),
+                properties: {
+                    ...deliveryInputSchema().properties,
+                    podRoot: { type: 'string', description: 'Optional local Pod mirror root. Defaults to LINX_POD_MIRROR_ROOT or ./.pod.' },
+                    deliveryUri: { type: 'string', description: 'Optional stable Delivery URI.' },
+                    randomId: { type: 'string', description: 'Optional stable id seed when creating a Delivery URI.' },
+                },
+            },
+        },
+        {
+            name: 'reconcile',
+            title: 'Reconcile',
+            description: 'Run the storage-agnostic Symphony reconciler over Codex events. This is the Codex-side MCP runner; Pod writes stay in LinX/xpod adapters.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    chat: { type: 'string', description: 'Optional Chat URI or portable chat reference.' },
+                    thread: { type: 'string', description: 'Optional Thread URI or portable thread reference.' },
+                    randomId: { type: 'string', description: 'Optional stable id seed for deterministic reconciler ids.' },
+                    events: {
+                        type: 'array',
+                        description: 'Thread control events or redacted Codex hook events to reconcile.',
+                        items: { type: 'object', additionalProperties: true },
+                    },
+                    eventsPath: {
+                        type: 'string',
+                        description: 'Optional JSONL path containing redacted Codex hook events. Defaults to LINX_SYMPHONY_HOOK_EVENTS when set.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        },
+    ];
+}
+function deliveryInputSchema() {
+    return {
+        type: 'object',
+        properties: {
+            delivery: {
+                description: 'Full Symphony Delivery object or JSON string. Preferred when available.',
+                anyOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+            },
+            status: { type: 'string', enum: ['completed', 'failed', 'success', 'succeeded', 'ok', 'failure', 'error'] },
+            exitCode: { type: 'number' },
+            autoModeSessionId: { type: 'string' },
+            events: { type: 'array', items: { type: 'object', additionalProperties: true } },
+            report: { description: 'Structured final report.', type: 'object', additionalProperties: true },
+            reportText: { type: 'string' },
+        },
+        additionalProperties: false,
+    };
+}
+function toolResult(structuredContent, isError = false) {
+    const text = typeof structuredContent === 'string'
+        ? structuredContent
+        : JSON.stringify(structuredContent, null, 2);
+    return {
+        content: [{ type: 'text', text }],
+        structuredContent,
+        isError,
+    };
+}
+function readParamsObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function readThreadReconcileEvents(args, env) {
+    const inline = readRecordArray(args.events);
+    const eventsPath = readOptionalString(args.eventsPath) ?? readOptionalString(env.LINX_SYMPHONY_HOOK_EVENTS);
+    if (!eventsPath) {
+        return inline;
+    }
+    return [...readJsonlRecords(eventsPath), ...inline];
+}
+function readRecordArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function readJsonlRecords(path) {
+    const body = readFileSync(path, 'utf-8');
+    return body
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => JSON.parse(line))
+        .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item));
+}
+function readOptionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function readJsonRpcId(value) {
+    if (typeof value === 'string' || typeof value === 'number' || value === null) {
+        return value;
+    }
+    return null;
+}
+function readProtocolVersion(params) {
+    const object = readParamsObject(params);
+    return typeof object.protocolVersion === 'string' ? object.protocolVersion : undefined;
+}
+function response(id, result) {
+    return { jsonrpc: '2.0', id, result };
+}
+function errorResponse(id, code, message) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: { code, message },
+    };
+}
+if (process.argv[1] && resolve(process.argv[1]) === resolve(fileURLToPath(import.meta.url))) {
+    createSymphonyCodexMcpServer().run()
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((error) => {
+        process.stderr.write(`[linx-symphony-codex-mcp] ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=symphony-mcp.js.map