@kafca/agentdock 0.1.56 → 0.1.58

package/dist-electron/packages/core-sdk/src/client.js

@@ -0,0 +1,455 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreClient = exports.LOCAL_AI_CORE_ORIGIN = exports.LOCAL_AI_CORE_BASE = exports.LOCAL_CORE_EVENT_NAMES = void 0;
+exports.normalizeLocalAiCoreBase = normalizeLocalAiCoreBase;
+exports.createCoreClient = createCoreClient;
+const DEFAULT_LOCAL_AI_CORE_ORIGIN = 'http://127.0.0.1:9831';
+const DEFAULT_LOCAL_AI_CORE_BASE = `${DEFAULT_LOCAL_AI_CORE_ORIGIN}/api/local/v1`;
+exports.LOCAL_CORE_EVENT_NAMES = [
+    'runtime.updated',
+    'runtime.detect.started',
+    'runtime.detect.completed',
+    'runtime.detect.failed',
+    'runtime.status.changed',
+    'thread.updated',
+    'thread.session.activated',
+    'message.created',
+    'message.updated',
+    'run.updated',
+    'scheduler.job.updated',
+    'scheduler.run.updated',
+    'automation.monitor.updated',
+    'automation.monitor.run.updated',
+    'presence.updated',
+    'stream.updated',
+];
+function normalizeLocalAiCoreBase(baseUrl) {
+    const trimmed = baseUrl.trim();
+    return (trimmed || DEFAULT_LOCAL_AI_CORE_BASE).replace(/\/+$/, '');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasString(value, key) {
+    return typeof value[key] === 'string';
+}
+function hasBoolean(value, key) {
+    return typeof value[key] === 'boolean';
+}
+function hasRecord(value, key) {
+    return isRecord(value[key]);
+}
+function isChannelRoute(value) {
+    return isRecord(value) && hasString(value, 'type') && hasString(value, 'channelId');
+}
+function isAutomationMonitorCondition(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const conditionValue = value.value;
+    return hasString(value, 'metric') &&
+        hasString(value, 'operator') &&
+        (typeof conditionValue === 'number' || typeof conditionValue === 'string' || typeof conditionValue === 'boolean');
+}
+function isThreadSummary(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'workspaceId') &&
+        hasString(value, 'title') &&
+        hasBoolean(value, 'live') &&
+        hasString(value, 'updatedAt') &&
+        hasString(value, 'createdAt') &&
+        typeof value.historyCount === 'number' &&
+        hasString(value, 'excerpt');
+}
+function isThreadMessage(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'role') &&
+        hasString(value, 'content') &&
+        hasString(value, 'timestamp');
+}
+function isThreadMessagePatch(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (value.id === undefined || typeof value.id === 'string') &&
+        (value.role === undefined || ['user', 'assistant', 'system'].includes(value.role)) &&
+        (value.content === undefined || typeof value.content === 'string') &&
+        (value.timestamp === undefined || typeof value.timestamp === 'string');
+}
+function isRunSummary(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'threadId') &&
+        hasString(value, 'status') &&
+        hasString(value, 'startedAt') &&
+        hasString(value, 'updatedAt');
+}
+function isScheduledJob(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'workspaceId') &&
+        hasString(value, 'platform') &&
+        isChannelRoute(value.route) &&
+        hasString(value, 'executionMode') &&
+        hasString(value, 'triggerType') &&
+        hasString(value, 'promptTemplate') &&
+        hasString(value, 'description') &&
+        hasBoolean(value, 'enabled') &&
+        hasString(value, 'concurrencyPolicy') &&
+        hasString(value, 'createdAt') &&
+        hasString(value, 'updatedAt');
+}
+function isScheduledJobRun(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'jobId') &&
+        hasString(value, 'status') &&
+        hasString(value, 'triggeredAt');
+}
+function isAutomationMonitor(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'workspaceId') &&
+        hasString(value, 'title') &&
+        hasString(value, 'sourceType') &&
+        hasRecord(value, 'sourceConfig') &&
+        isAutomationMonitorCondition(value.condition) &&
+        hasString(value, 'promptTemplate') &&
+        hasString(value, 'platform') &&
+        isChannelRoute(value.route) &&
+        hasString(value, 'executionMode') &&
+        hasBoolean(value, 'enabled') &&
+        typeof value.cooldownMs === 'number' &&
+        hasString(value, 'concurrencyPolicy') &&
+        hasString(value, 'createdAt') &&
+        hasString(value, 'updatedAt');
+}
+function isAutomationMonitorRun(value) {
+    return isRecord(value) &&
+        hasString(value, 'id') &&
+        hasString(value, 'monitorId') &&
+        hasString(value, 'status') &&
+        hasString(value, 'triggeredAt');
+}
+function isInstalledAgentRuntime(value) {
+    return isRecord(value) &&
+        hasString(value, 'agentType') &&
+        hasString(value, 'runtimeId') &&
+        hasString(value, 'displayName') &&
+        hasString(value, 'status') &&
+        hasBoolean(value, 'installed') &&
+        hasString(value, 'detectedAt') &&
+        hasString(value, 'summary') &&
+        Array.isArray(value.issues) &&
+        Array.isArray(value.recommendedActions) &&
+        hasString(value, 'source');
+}
+function isDesktopRuntimeStatus(value) {
+    return isRecord(value) &&
+        value.mode === 'desktop' &&
+        hasString(value, 'phase') &&
+        hasBoolean(value, 'pendingRestart') &&
+        hasRecord(value, 'service') &&
+        hasRecord(value, 'roles') &&
+        hasRecord(value, 'settings') &&
+        hasRecord(value, 'runtimeConfig') &&
+        Array.isArray(value.logs) &&
+        value.logs.every((entry) => typeof entry === 'string');
+}
+function isDesktopBridgeEvent(value) {
+    return isRecord(value) && hasString(value, 'type');
+}
+// isLocalCoreEvent guards the *structure* of events arriving on the shared SSE
+// stream (rejecting malformed or missing-field payloads) but intentionally does
+// NOT hardcode enum value lists (run status, bridge type, policy, role, ...).
+// Hardcoded whitelists would silently drop events the moment the contract adds a
+// new status/type, with no telemetry. Unknown enum strings are accepted; consumers
+// already fall through to safe defaults for values they do not recognize.
+function isLocalCoreEvent(value) {
+    if (!isRecord(value) || !hasString(value, 'type')) {
+        return false;
+    }
+    switch (value.type) {
+        case 'runtime.updated':
+            return isDesktopRuntimeStatus(value.runtime);
+        case 'runtime.detect.started':
+            return hasString(value, 'detectedAt');
+        case 'runtime.detect.completed':
+            return hasString(value, 'detectedAt') &&
+                Array.isArray(value.runtimes) &&
+                value.runtimes.every(isInstalledAgentRuntime);
+        case 'runtime.detect.failed':
+            return hasString(value, 'detectedAt') && hasString(value, 'error');
+        case 'runtime.status.changed':
+            return isInstalledAgentRuntime(value.runtime);
+        case 'thread.updated':
+            return isThreadSummary(value.thread);
+        case 'thread.session.activated':
+            return hasString(value, 'workspaceId') &&
+                hasString(value, 'threadId') &&
+                hasString(value, 'reason');
+        case 'message.created':
+            return hasString(value, 'threadId') && isThreadMessage(value.message) &&
+                (value.stream === undefined || isDesktopBridgeEvent(value.stream));
+        case 'message.updated':
+            return hasString(value, 'threadId') && isThreadMessagePatch(value.message) &&
+                (value.stream === undefined || isDesktopBridgeEvent(value.stream));
+        case 'run.updated':
+            return isRunSummary(value.run) && (value.stream === undefined || isDesktopBridgeEvent(value.stream));
+        case 'scheduler.job.updated':
+            return isScheduledJob(value.job);
+        case 'scheduler.run.updated':
+            return isScheduledJobRun(value.run);
+        case 'automation.monitor.updated':
+            return isAutomationMonitor(value.monitor);
+        case 'automation.monitor.run.updated':
+            return isAutomationMonitorRun(value.run);
+        case 'presence.updated':
+            return hasBoolean(value, 'live') && (value.stream === undefined || isDesktopBridgeEvent(value.stream));
+        case 'stream.updated':
+            return isDesktopBridgeEvent(value.stream);
+        case 'external.run.snapshot':
+            return isRecord(value.snapshot) && hasString(value.snapshot, 'runId');
+        case 'external.run.stream':
+            return hasString(value, 'runId') && isDesktopBridgeEvent(value.stream);
+        default:
+            return false;
+    }
+}
+function bridgeEventFromLocalCoreEvent(event) {
+    if (event.type === 'stream.updated') {
+        return event.stream;
+    }
+    if ((event.type === 'message.created' || event.type === 'message.updated' || event.type === 'run.updated') &&
+        event.stream) {
+        return event.stream;
+    }
+    return null;
+}
+// Shared SSE connections, keyed by normalized base URL. The first createCoreClient
+// to subscribe for a given baseUrl donates the transport (eventSourceFactory /
+// scheduleReconnect / cancelReconnect); subsequent clients reuse that connection
+// and their own transport options are intentionally ignored — sharing one socket
+// per origin is the point. This is safe because the connection is removed by
+// `onIdle` once its last subscriber unsubscribes, so a discarded client's deps
+// never outlive active subscribers.
+const eventConnections = new Map();
+function createCoreEventConnection(baseUrl, deps, onIdle) {
+    const listeners = new Set();
+    const connectionStateListeners = new Set();
+    let eventSource = null;
+    let reconnectHandle = null;
+    let currentState = 'disconnected';
+    const notifyConnectionState = (state) => {
+        currentState = state;
+        connectionStateListeners.forEach((listener) => {
+            try {
+                listener(state);
+            }
+            catch {
+                // Connection observers are isolated for the same reason as event subscribers.
+            }
+        });
+    };
+    const cancelPendingReconnect = () => {
+        if (reconnectHandle !== null) {
+            deps.cancelReconnect(reconnectHandle);
+            reconnectHandle = null;
+        }
+    };
+    const closeEventSource = () => {
+        eventSource?.close();
+        eventSource = null;
+    };
+    const shutdown = () => {
+        cancelPendingReconnect();
+        closeEventSource();
+        onIdle();
+    };
+    const ensureEventSource = () => {
+        if (eventSource || (listeners.size === 0 && connectionStateListeners.size === 0)) {
+            return;
+        }
+        const source = deps.eventSourceFactory(`${baseUrl}/events`);
+        eventSource = source;
+        source.onopen = () => {
+            if (eventSource === source) {
+                notifyConnectionState('connected');
+            }
+        };
+        const forward = (message) => {
+            try {
+                const payload = JSON.parse(message.data);
+                if (isLocalCoreEvent(payload)) {
+                    listeners.forEach((listener) => {
+                        try {
+                            listener(payload);
+                        }
+                        catch {
+                            // Subscribers are isolated so one renderer callback cannot block the rest.
+                        }
+                    });
+                }
+            }
+            catch {
+                // A malformed local event must not tear down the shared stream.
+            }
+        };
+        exports.LOCAL_CORE_EVENT_NAMES.forEach((eventName) => source.addEventListener(eventName, forward));
+        source.onerror = () => {
+            if (eventSource !== source) {
+                return;
+            }
+            closeEventSource();
+            notifyConnectionState('disconnected');
+            if ((listeners.size > 0 || connectionStateListeners.size > 0) && reconnectHandle === null) {
+                reconnectHandle = deps.scheduleReconnect(() => {
+                    reconnectHandle = null;
+                    ensureEventSource();
+                }, 1000);
+            }
+        };
+    };
+    return {
+        subscribe(listener) {
+            const registration = (event) => listener(event);
+            listeners.add(registration);
+            ensureEventSource();
+            return () => {
+                if (!listeners.delete(registration)) {
+                    return;
+                }
+                if (listeners.size === 0) {
+                    if (connectionStateListeners.size === 0) {
+                        shutdown();
+                    }
+                }
+            };
+        },
+        subscribeConnectionState(listener) {
+            connectionStateListeners.add(listener);
+            ensureEventSource();
+            // If the shared source is already open, onopen has already fired in the past
+            // and will not repeat — replay the current state so a late subscriber learns
+            // it is connected (otherwise it would wait until the next disconnect/reconnect).
+            if (currentState === 'connected') {
+                try {
+                    listener('connected');
+                }
+                catch {
+                    // Late connection observers are isolated for the same reason as live ones.
+                }
+            }
+            return () => {
+                if (!connectionStateListeners.delete(listener)) {
+                    return;
+                }
+                if (listeners.size === 0 && connectionStateListeners.size === 0) {
+                    shutdown();
+                }
+            };
+        },
+    };
+}
+function getCoreEventConnection(baseUrl, deps) {
+    const existing = eventConnections.get(baseUrl);
+    if (existing) {
+        return existing;
+    }
+    let connection;
+    connection = createCoreEventConnection(baseUrl, deps, () => {
+        if (eventConnections.get(baseUrl) === connection) {
+            eventConnections.delete(baseUrl);
+        }
+    });
+    eventConnections.set(baseUrl, connection);
+    return connection;
+}
+function createCoreClient(options) {
+    const baseUrl = normalizeLocalAiCoreBase(options.baseUrl);
+    const fetchImpl = options.fetchImpl || globalThis.fetch.bind(globalThis);
+    const eventSourceFactory = options.eventSourceFactory || ((url) => new EventSource(url));
+    const scheduleReconnect = options.scheduleReconnect || ((callback, delayMs) => setTimeout(callback, delayMs));
+    const cancelReconnect = options.cancelReconnect || ((handle) => clearTimeout(handle));
+    const unsubscribeHandlers = new Set();
+    const subscribe = (listener) => {
+        const eventConnection = getCoreEventConnection(baseUrl, { eventSourceFactory, scheduleReconnect, cancelReconnect });
+        const unsubscribe = eventConnection.subscribe(listener);
+        unsubscribeHandlers.add(unsubscribe);
+        return () => {
+            unsubscribeHandlers.delete(unsubscribe);
+            unsubscribe();
+        };
+    };
+    const subscribeConnectionState = (listener) => {
+        const eventConnection = getCoreEventConnection(baseUrl, { eventSourceFactory, scheduleReconnect, cancelReconnect });
+        const unsubscribe = eventConnection.subscribeConnectionState(listener);
+        unsubscribeHandlers.add(unsubscribe);
+        return () => {
+            unsubscribeHandlers.delete(unsubscribe);
+            unsubscribe();
+        };
+    };
+    const request = async (method, path, body) => {
+        const response = await fetchImpl(`${baseUrl}${path}`, {
+            method,
+            headers: { 'Content-Type': 'application/json' },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const json = await response.json();
+        if (!response.ok || !json.ok) {
+            throw new Error(json.error || `Local AI Core request failed: ${response.status}`);
+        }
+        return json.data;
+    };
+    return {
+        baseUrl,
+        request,
+        async detect(timeoutMs = 350) {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                const response = await fetchImpl(`${baseUrl}/health`, { signal: controller.signal });
+                const json = await response.json();
+                return response.ok && json.ok && json.data?.name === 'local-ai-core';
+            }
+            catch {
+                return false;
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+        events: {
+            subscribe,
+            subscribeConnectionState,
+            subscribeRuntime(listener) {
+                return subscribe((event) => {
+                    if (event.type === 'runtime.updated') {
+                        listener(event.runtime);
+                    }
+                });
+            },
+            subscribeBridge(listener) {
+                return subscribe((event) => {
+                    const bridgeEvent = bridgeEventFromLocalCoreEvent(event);
+                    if (bridgeEvent) {
+                        listener(bridgeEvent);
+                    }
+                });
+            },
+            close() {
+                const handlers = Array.from(unsubscribeHandlers);
+                unsubscribeHandlers.clear();
+                handlers.forEach((unsubscribe) => unsubscribe());
+            },
+        },
+    };
+}
+exports.LOCAL_AI_CORE_BASE = normalizeLocalAiCoreBase(typeof __LOCAL_AI_CORE_BASE__ !== 'undefined' ? __LOCAL_AI_CORE_BASE__ : '');
+exports.LOCAL_AI_CORE_ORIGIN = exports.LOCAL_AI_CORE_BASE.endsWith('/api/local/v1')
+    ? exports.LOCAL_AI_CORE_BASE.slice(0, -'/api/local/v1'.length) || DEFAULT_LOCAL_AI_CORE_ORIGIN
+    : DEFAULT_LOCAL_AI_CORE_ORIGIN;
+exports.coreClient = createCoreClient({ baseUrl: exports.LOCAL_AI_CORE_BASE });