alchemylab 1.0.3 → 1.0.5

package/dist/plugins/hooks/lib/condition-evaluator.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Hook Condition Evaluator
+ *
+ * Evaluates hook conditions against event variables to determine
+ * if a hook should be triggered.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateSingleCondition = evaluateSingleCondition;
+exports.evaluatePathsCondition = evaluatePathsCondition;
+exports.evaluateCondition = evaluateCondition;
+/**
+ * Simple glob-to-regex converter for pattern matching
+ * Handles common glob patterns without external dependencies
+ */
+// Cache compiled glob→regex patterns to avoid recompilation on every condition check
+const _globCache = new Map();
+function globToRegex(pattern) {
+    const cached = _globCache.get(pattern);
+    if (cached)
+        return cached;
+    let regex = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '{{GLOBSTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.')
+        .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+    const compiled = new RegExp(`^${regex}$`);
+    // Cap cache to prevent unbounded growth
+    if (_globCache.size > 500)
+        _globCache.clear();
+    _globCache.set(pattern, compiled);
+    return compiled;
+}
+/**
+ * Check if a string matches a glob pattern
+ */
+function isMatch(str, pattern) {
+    try {
+        return globToRegex(pattern).test(str);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Evaluate a single condition against the field value
+ */
+function evaluateSingleCondition(fieldValue, operator, value) {
+    switch (operator) {
+        case 'matches':
+            return isMatch(fieldValue, value);
+        case 'not_matches':
+            return !isMatch(fieldValue, value);
+        case 'contains':
+            return fieldValue.includes(value);
+        case 'not_contains':
+            return !fieldValue.includes(value);
+        case 'equals':
+            return fieldValue === value;
+        case 'not_equals':
+            return fieldValue !== value;
+        default:
+            return true;
+    }
+}
+/**
+ * Evaluate a condition against a paths array (comma-separated)
+ * For 'matches'/'contains' - returns true if ANY path matches
+ * For 'not_matches'/'not_contains' - returns true if ALL paths don't match
+ */
+function evaluatePathsCondition(paths, operator, value) {
+    switch (operator) {
+        case 'matches':
+            return paths.some(p => isMatch(p, value));
+        case 'not_matches':
+            return paths.every(p => !isMatch(p, value));
+        case 'contains':
+            return paths.some(p => p.includes(value));
+        case 'not_contains':
+            return paths.every(p => !p.includes(value));
+        case 'equals':
+            return paths.some(p => p === value);
+        case 'not_equals':
+            return paths.every(p => p !== value);
+        default:
+            return true;
+    }
+}
+/**
+ * Evaluate hook conditions against current variables
+ * Returns true if hook should be triggered, false to skip
+ */
+function evaluateCondition(condition, variables) {
+    // No conditions or empty conditions = always match
+    if (!condition || !condition.conditions || condition.conditions.length === 0) {
+        return true;
+    }
+    const results = condition.conditions.map((c) => {
+        const fieldValue = variables[c.field] || '';
+        // For 'paths' field, check if any path matches
+        if (c.field === 'paths' && fieldValue.includes(', ')) {
+            const paths = fieldValue.split(', ');
+            return evaluatePathsCondition(paths, c.operator, c.value);
+        }
+        // Single value evaluation
+        return evaluateSingleCondition(fieldValue, c.operator, c.value);
+    });
+    // Combine results based on logic (default: AND)
+    return condition.logic === 'OR'
+        ? results.some((r) => r)
+        : results.every((r) => r);
+}
+//# sourceMappingURL=condition-evaluator.js.map

package/dist/plugins/hooks/lib/dedup-utils.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Deduplication Utilities
+ *
+ * Functions to prevent duplicate hook triggers when OpenCode fires
+ * the same event multiple times in quick succession.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolCallHash = createToolCallHash;
+exports.isDuplicateToolCall = isDuplicateToolCall;
+exports.clearRecentCalls = clearRecentCalls;
+exports.getRecentCallsCount = getRecentCallsCount;
+exports.hasProcessedMessage = hasProcessedMessage;
+exports.markMessageProcessed = markMessageProcessed;
+exports.tryMarkMessageProcessed = tryMarkMessageProcessed;
+exports.clearProcessedMessages = clearProcessedMessages;
+// Track recent tool calls with timestamps
+const recentCalls = new Map();
+// Default window for considering calls as duplicates (2 seconds)
+const DEFAULT_DEDUP_WINDOW = 2000;
+/**
+ * Create a hash for a tool call based on tool name and output/input
+ * Used to identify potentially duplicate calls
+ *
+ * @param toolName - The name of the tool being called
+ * @param text - The output or input text to include in hash (truncated to 100 chars)
+ * @returns A string hash identifying this specific call
+ */
+function createToolCallHash(toolName, text) {
+    // Simple hash using tool name + first 100 chars of text
+    return `${toolName}:${text?.substring(0, 100) || ''}`;
+}
+/**
+ * Check if a tool call is a duplicate of a recent call
+ * Also cleans up old entries from the tracking map
+ *
+ * @param hash - The hash created by createToolCallHash
+ * @param now - Current timestamp (allows injection for testing)
+ * @param dedupWindow - Time window in ms to consider calls as duplicates (default: 2000ms)
+ * @returns true if this appears to be a duplicate call, false otherwise
+ */
+function isDuplicateToolCall(hash, now = Date.now(), dedupWindow = DEFAULT_DEDUP_WINDOW) {
+    const lastTime = recentCalls.get(hash);
+    if (lastTime && (now - lastTime) < dedupWindow) {
+        return true;
+    }
+    // Clean up old entries (older than 2x the dedup window)
+    const cleanupThreshold = dedupWindow * 2;
+    for (const [key, time] of recentCalls.entries()) {
+        if (now - time > cleanupThreshold) {
+            recentCalls.delete(key);
+        }
+    }
+    // Record this call
+    recentCalls.set(hash, now);
+    return false;
+}
+/**
+ * Clear all tracked calls (useful for testing)
+ */
+function clearRecentCalls() {
+    recentCalls.clear();
+}
+/**
+ * Get the number of tracked calls (useful for testing)
+ */
+function getRecentCallsCount() {
+    return recentCalls.size;
+}
+// Track last processed message ID per session to prevent duplicate triggers
+const lastProcessedMessageId = new Map();
+/**
+ * Check if we've already processed this message for a session
+ * Returns true if this message was already processed (should skip)
+ * @deprecated Use tryMarkMessageProcessed for atomic check-and-mark
+ */
+function hasProcessedMessage(sessionId, messageId) {
+    if (!messageId)
+        return false;
+    const lastId = lastProcessedMessageId.get(sessionId);
+    return lastId === messageId;
+}
+/**
+ * Mark a message as processed for a session
+ * @deprecated Use tryMarkMessageProcessed for atomic check-and-mark
+ */
+function markMessageProcessed(sessionId, messageId) {
+    if (!messageId)
+        return;
+    lastProcessedMessageId.set(sessionId, messageId);
+    // Clean up old entries (keep max 100 sessions)
+    if (lastProcessedMessageId.size > 100) {
+        const firstKey = lastProcessedMessageId.keys().next().value;
+        if (firstKey)
+            lastProcessedMessageId.delete(firstKey);
+    }
+}
+/**
+ * Atomically check if message was processed and mark it if not.
+ * Returns true if this call should proceed (message was NOT already processed).
+ * Returns false if should skip (message was already processed by another call).
+ *
+ * This prevents race conditions where two concurrent calls both check
+ * hasProcessedMessage() before either calls markMessageProcessed().
+ */
+function tryMarkMessageProcessed(sessionId, messageId) {
+    if (!messageId)
+        return true; // No message ID = proceed (can't dedupe)
+    const lastId = lastProcessedMessageId.get(sessionId);
+    if (lastId === messageId) {
+        // Already processed - skip
+        return false;
+    }
+    // Mark as processed immediately (atomic with check above in single-threaded JS)
+    lastProcessedMessageId.set(sessionId, messageId);
+    // Clean up old entries (keep max 100 sessions)
+    if (lastProcessedMessageId.size > 100) {
+        const firstKey = lastProcessedMessageId.keys().next().value;
+        if (firstKey)
+            lastProcessedMessageId.delete(firstKey);
+    }
+    return true; // Proceed - we claimed this message
+}
+/**
+ * Clear processed message tracking (for testing)
+ */
+function clearProcessedMessages() {
+    lastProcessedMessageId.clear();
+}
+//# sourceMappingURL=dedup-utils.js.map

package/dist/plugins/hooks/lib/hook-utils.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Hook Utility Functions
+ *
+ * Shared utilities for hook processing including template interpolation
+ * and ID extraction from tool outputs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolatePrompt = interpolatePrompt;
+exports.extractRequestId = extractRequestId;
+exports.extractTaskId = extractTaskId;
+exports.extractFilePath = extractFilePath;
+exports.sanitizeTemplateValue = sanitizeTemplateValue;
+/**
+ * Interpolate template variables in prompt
+ * Replaces {{variableName}} patterns with corresponding values from variables object
+ *
+ * @param template - The template string with {{variable}} placeholders
+ * @param variables - Key-value pairs to substitute into the template
+ * @returns The interpolated string with all variables replaced
+ */
+function interpolatePrompt(template, variables) {
+    let result = template;
+    for (const [key, value] of Object.entries(variables)) {
+        result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), value);
+    }
+    return result;
+}
+/**
+ * Extract request ID from tool output
+ * Matches patterns like "Request completed: req001234" or "Request req001234 completed successfully"
+ *
+ * @param text - The tool output text to search
+ * @returns The request ID (e.g., "req001234") or null if not found
+ */
+function extractRequestId(text) {
+    const patterns = [
+        /Request completed:\s*(req\d+)/i,
+        /Request (req\d+) completed/i,
+        /completed.*?(req\d{6})/i,
+        /Request finalized:\s*(req\d+)/i,
+        /Request (req\d+) finalized/i,
+        /finalized.*?(req\d{6})/i,
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/**
+ * Extract task ID from tool output
+ * Matches patterns like "Task tas002152 has been marked as completed"
+ *
+ * @param text - The tool output text to search
+ * @returns The task ID (e.g., "tas002152") or null if not found
+ */
+function extractTaskId(text) {
+    const match = text.match(/Task\s+(tas\d+).*(?:completed|marked as completed)/i);
+    return match ? match[1] : null;
+}
+/**
+ * Extract file path from write_file tool output
+ * Matches patterns like "Created file path/to/file.ts"
+ *
+ * @param text - The tool output text to search
+ * @returns The file path or null if not found
+ */
+function extractFilePath(text) {
+    // Match "Created file X" or "**Created file X**"
+    const createdMatch = text.match(/\*?\*?Created file\s+([^\s*]+)/i);
+    if (createdMatch)
+        return createdMatch[1];
+    // Match "File Modified: Yes" with path context
+    const modifiedMatch = text.match(/File \d+:\s*([^\n]+)\n.*File Modified:\s*Yes/i);
+    if (modifiedMatch)
+        return modifiedMatch[1];
+    return null;
+}
+/**
+ * Sanitize a value for use in template interpolation
+ * Truncates long values and escapes special characters
+ *
+ * @param value - The value to sanitize
+ * @param maxLength - Maximum length before truncation (default: 1000)
+ * @returns The sanitized string
+ */
+function sanitizeTemplateValue(value, maxLength = 1000) {
+    if (!value)
+        return '';
+    if (value.length > maxLength) {
+        return value.substring(0, maxLength) + '... (truncated)';
+    }
+    return value;
+}
+//# sourceMappingURL=hook-utils.js.map

package/dist/plugins/hooks/plugin.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * OpenCode Event Hooks Plugin — Thin Event Emitter
+ *
+ * Detects events from OpenCode (tool execution, session lifecycle) and POSTs
+ * them to the action server's /api/hook-event endpoint. All hook logic
+ * (fetching, condition evaluation, template interpolation, execution) lives
+ * in the action server.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+const ACTION_SERVER_PORT = 3456;
+const ACTION_SERVER_URL = `http://localhost:${ACTION_SERVER_PORT}/api/hook-event`;
+// Singleton guard — OpenCode calls plugin init twice
+let initializedDirectory = null;
+let cachedHandlers = null;
+/**
+ * Extract request ID from tool output
+ */
+function extractRequestId(text) {
+    const patterns = [
+        /Request completed:\s*(req\d+)/i,
+        /Request (req\d+) completed/i,
+        /completed.*?(req\d{6})/i,
+        /Request finalized:\s*(req\d+)/i,
+        /Request (req\d+) finalized/i,
+        /finalized.*?(req\d{6})/i,
+        /Request (req\d+) merged/i,
+        /merged.*?(req\d{6})/i,
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/**
+ * Extract task ID from tool output
+ */
+function extractTaskId(text) {
+    const match = text.match(/Task\s+(tas\d+).*(?:completed|marked as completed)/i);
+    return match ? match[1] : null;
+}
+/**
+ * Fire-and-forget POST to action server. Does not throw.
+ */
+function postHookEvent(eventType, sessionId, variables, timing) {
+    fetch(ACTION_SERVER_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ eventType, sessionId, variables, timing }),
+    }).catch(() => { }); // Fire-and-forget
+}
+/**
+ * Await POST to action server. Returns silently on failure.
+ */
+async function postHookEventAsync(eventType, sessionId, variables, timing) {
+    try {
+        await fetch(ACTION_SERVER_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ eventType, sessionId, variables, timing }),
+        });
+    }
+    catch {
+        // Non-fatal
+    }
+}
+/**
+ * Detect tool type and determine event type + variables from tool execution context.
+ */
+function extractToolEventInfo(toolName, input, resultText, sessionId) {
+    const events = [];
+    const baseVars = {
+        output: resultText || '',
+        toolName,
+        sessionId: sessionId || '',
+    };
+    const isRequestOps = toolName.includes('request_operations') || toolName.includes('complete_request');
+    const isTaskOps = toolName.includes('task_operations') || toolName.includes('complete_task');
+    const isWriteFile = toolName.includes('write_file');
+    const isReplaceInFiles = toolName.includes('replace_in_files');
+    const isQuickEdit = toolName.includes('quick_write') || toolName.includes('quick_replace') || toolName.includes('quick_manage');
+    const isReadFiles = toolName.includes('read_files');
+    const isSearch = toolName.includes('search');
+    const isManageFiles = toolName.includes('manage_files');
+    const isDocumentOps = toolName.includes('document_operations');
+    const isQueryHistory = toolName.includes('query_history');
+    if (isRequestOps && resultText) {
+        const requestId = extractRequestId(resultText);
+        if (requestId) {
+            events.push({
+                eventType: 'request_completed',
+                variables: { ...baseVars, requestId },
+            });
+        }
+    }
+    else if (isTaskOps && resultText) {
+        const taskId = extractTaskId(resultText);
+        if (taskId) {
+            events.push({
+                eventType: 'task_completed',
+                variables: { ...baseVars, taskId },
+            });
+        }
+    }
+    else if (isWriteFile) {
+        const pathMatch = resultText?.match(/(?:Created|Updated|Wrote)\s+(?:file\s+)?([^\s\n]+)/i);
+        events.push({
+            eventType: 'write_file',
+            variables: { ...baseVars, path: pathMatch?.[1] || '' },
+        });
+    }
+    else if (isReplaceInFiles) {
+        const operations = input?.input?.operations || [];
+        const paths = operations.map((op) => op.path || op.documentId).filter(Boolean);
+        events.push({
+            eventType: 'replace_in_files',
+            variables: { ...baseVars, paths: paths.join(', '), fileCount: String(paths.length) },
+        });
+    }
+    else if (isQuickEdit) {
+        const vars = {
+            ...baseVars,
+            path: input?.input?.operationArgs?.path || '',
+            title: input?.input?.title || '',
+        };
+        const qeRequestMatch = resultText?.match(/\*\*Request:\*\*\s*(req\d+)/i);
+        if (qeRequestMatch)
+            vars.requestId = qeRequestMatch[1];
+        events.push({ eventType: 'quick_edit', variables: vars });
+        // Quick-edit auto-completes requests — also emit request_completed
+        if (vars.requestId) {
+            events.push({
+                eventType: 'request_completed',
+                variables: { ...baseVars, requestId: vars.requestId },
+            });
+        }
+    }
+    else if (isReadFiles) {
+        const pathsInput = input?.input?.paths || [];
+        const paths = pathsInput.map((p) => p.path || p.documentId).filter(Boolean);
+        events.push({
+            eventType: 'read_files',
+            variables: { ...baseVars, paths: paths.join(', '), fileCount: String(paths.length) },
+        });
+    }
+    else if (isSearch) {
+        events.push({
+            eventType: 'search',
+            variables: {
+                ...baseVars,
+                query: input?.input?.needle || '',
+                directory: input?.input?.directory || '',
+                fileExtension: input?.input?.options?.fileExtension || '*',
+            },
+        });
+    }
+    else if (isManageFiles) {
+        const operations = input?.input?.operations || [];
+        const opTypes = operations.map((op) => op.operationType).filter(Boolean);
+        events.push({
+            eventType: 'manage_files',
+            variables: { ...baseVars, operationTypes: [...new Set(opTypes)].join(', ') },
+        });
+    }
+    else if (isDocumentOps) {
+        events.push({ eventType: 'document_operations', variables: baseVars });
+    }
+    else if (isQueryHistory) {
+        events.push({ eventType: 'query_history', variables: baseVars });
+    }
+    // Always emit tool_executed for any tool
+    events.push({
+        eventType: 'tool_executed',
+        variables: {
+            tool: toolName,
+            toolName,
+            output: resultText || '',
+            sessionId: sessionId || '',
+        },
+    });
+    return events;
+}
+/**
+ * Fetch recent output from a session (for lastOutput variable in session_idle).
+ */
+async function fetchRecentSessionOutput(sessionId, directory) {
+    try {
+        const configPath = (0, path_1.join)(directory, '.alchemy_lab', 'opencode.json');
+        if (!(0, fs_1.existsSync)(configPath))
+            return { output: '' };
+        const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
+        const serverUrl = config.port ? `http://127.0.0.1:${config.port}` : null;
+        if (!serverUrl)
+            return { output: '' };
+        const url = `${serverUrl}/session/${sessionId}/message?limit=5`;
+        const response = await fetch(url);
+        if (!response.ok)
+            return { output: '' };
+        const messages = await response.json();
+        const assistantMessages = messages.filter(m => m.info.role === 'assistant');
+        const lastAssistantMessage = assistantMessages[0];
+        const assistantOutput = assistantMessages
+            .flatMap(m => m.parts)
+            .filter(p => p.type === 'text' && p.text)
+            .map(p => p.text)
+            .join('\n');
+        return { output: assistantOutput, lastMessageId: lastAssistantMessage?.info?.id };
+    }
+    catch {
+        return { output: '' };
+    }
+}
+exports.default = async ({ directory }) => {
+    const dir = directory || process.cwd();
+    // Singleton guard
+    if (initializedDirectory === dir && cachedHandlers) {
+        return cachedHandlers;
+    }
+    initializedDirectory = dir;
+    const handlers = {
+        "tool.execute.before": async (input) => {
+            const toolName = input?.tool || input?.name;
+            if (!toolName)
+                return;
+            const sessionId = input?.sessionID || '';
+            const inputText = JSON.stringify(input?.input || {}).substring(0, 1000);
+            postHookEvent('tool_executed', sessionId, {
+                tool: toolName,
+                toolName,
+                input: inputText,
+            }, 'before');
+        },
+        "tool.execute.after": async (input, output) => {
+            const toolName = input?.tool || input?.name;
+            if (!toolName)
+                return;
+            const sessionId = input?.sessionID || '';
+            const resultText = output?.content?.[0]?.text;
+            if (!resultText)
+                return;
+            const events = extractToolEventInfo(toolName, input, resultText, sessionId);
+            for (const { eventType, variables } of events) {
+                await postHookEventAsync(eventType, sessionId, variables, 'after');
+            }
+        },
+        event: async ({ event }) => {
+            switch (event.type) {
+                case 'session.idle': {
+                    const sessionId = event.properties.sessionID || '';
+                    const { output: lastOutput, lastMessageId } = await fetchRecentSessionOutput(sessionId, dir);
+                    // Fire-and-forget — process is dying
+                    postHookEvent('session_idle', sessionId, {
+                        sessionId,
+                        lastOutput,
+                        lastMessageId: lastMessageId || '',
+                    });
+                    return;
+                }
+                case 'session.created': {
+                    const sessionInfo = event.properties.info;
+                    const sessionId = sessionInfo?.id || '';
+                    if (!sessionId)
+                        return;
+                    // Delay to allow workflow assignment
+                    setTimeout(() => {
+                        postHookEvent('session_created', sessionId, { sessionId });
+                    }, 500);
+                    return;
+                }
+            }
+        },
+    };
+    cachedHandlers = handlers;
+    return handlers;
+};
+//# sourceMappingURL=plugin.js.map

package/dist/plugins/inject-session.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * OpenCode Inject Session Plugin
+ *
+ * Injects the current session ID into spawn-background-work tool calls
+ * so that spawned background sessions can be linked as children of the parent.
+ *
+ * Hooks into tool.execute.before to modify args before the MCP tool executes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+// Log immediately when module is loaded
+try {
+    const logFile = (0, path_1.join)(process.env.HOME || '/tmp', 'inject-session-plugin.log');
+    (0, fs_1.appendFileSync)(logFile, `[${new Date().toISOString()}] MODULE LOADED - file was imported\n`);
+}
+catch (e) {
+    // ignore
+}
+const debugLog = (msg, data) => {
+    const logFile = (0, path_1.join)(process.env.HOME || '/tmp', 'inject-session-plugin.log');
+    const line = `[${new Date().toISOString()}] ${msg}${data ? ' ' + JSON.stringify(data) : ''}\n`;
+    try {
+        (0, fs_1.appendFileSync)(logFile, line);
+    }
+    catch (e) {
+        // ignore
+    }
+    console.log('[inject-session-plugin]', msg, data || '');
+};
+exports.default = async ({ project, directory }) => {
+    debugLog('Plugin loaded', { project: project?.id, directory });
+    return {
+        "tool.execute.before": async (context, data) => {
+            debugLog('tool.execute.before called', {
+                tool: context.tool,
+                sessionID: context.sessionID,
+                hasArgs: !!data?.args
+            });
+            try {
+                // Check if this is a spawn-background-work tool
+                // MCP tool names can use dashes or underscores depending on how they're registered
+                const toolName = context.tool;
+                if (!toolName || (!toolName.includes('spawn_background_work') && !toolName.includes('spawn-background-work'))) {
+                    return; // Not logging every non-matching tool to avoid spam
+                }
+                debugLog('Matched spawn-background-work tool!');
+                // Inject parentSessionId into args if not already set
+                if (!data.args.parentSessionId && context.sessionID) {
+                    data.args.parentSessionId = context.sessionID;
+                    debugLog('Injected parentSessionId', context.sessionID);
+                }
+                else {
+                    debugLog('parentSessionId already set or no sessionID', {
+                        existing: data.args.parentSessionId,
+                        sessionID: context.sessionID
+                    });
+                }
+            }
+            catch (error) {
+                debugLog('Error', { error: String(error) });
+            }
+        }
+    };
+};
+//# sourceMappingURL=inject-session.js.map