@hubium/hubium-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,809 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { ContextManager } from './context/contextManager.js';
+import { TokenStore } from './token/tokenStore.js';
+import { runDoctor } from './doctor/doctor.js';
+import { HubiumClient, HubiumClientError } from '@hubium/client';
+import crypto from 'crypto';
+import { Redactor } from './token/redactor.js';
+export function createServer(deps) {
+    const contextManager = deps?.contextManager ?? new ContextManager();
+    const tokenStore = deps?.tokenStore ?? new TokenStore();
+    const hubiumClientFactory = deps?.hubiumClientFactory ?? ((input) => new HubiumClient({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        userAgent: 'hubium-mcp/0.0.0',
+        maxRetries: 0,
+    }));
+    const safeMode = deps?.safeMode ?? getSafeMode();
+    const rateLimiter = deps?.rateLimiter ?? createRateLimiterFromEnv();
+    const server = new Server({
+        name: 'hubium-mcp',
+        version: '0.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    registerTools(server, { contextManager, tokenStore, hubiumClientFactory, safeMode, rateLimiter, fetchImpl: deps?.fetchImpl });
+    return server;
+}
+export async function runServerStdio(options) {
+    const server = createServer({ safeMode: options?.safeMode });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export function registerTools(server, deps) {
+    const handlers = buildToolHandlers(deps);
+    server.setRequestHandler(ListToolsRequestSchema, handlers.listTools);
+    server.setRequestHandler(CallToolRequestSchema, handlers.callTool);
+}
+export function buildToolHandlers(deps) {
+    const redactor = new Redactor();
+    let cachedWhoami = null;
+    async function getWhoamiOnce(baseUrl, token) {
+        if (cachedWhoami) {
+            return cachedWhoami;
+        }
+        const client = deps.hubiumClientFactory({ baseUrl, token });
+        const whoami = await client.whoami();
+        cachedWhoami = whoami;
+        return whoami;
+    }
+    return {
+        listTools: async () => ({
+            tools: [
+                {
+                    name: 'hubium.ping',
+                    description: 'Health check for hubium-mcp server',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.get_context',
+                    description: 'Get the current hubium-mcp context',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.set_context',
+                    description: 'Update the hubium-mcp context',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            base_url: { type: 'string' },
+                            workspace_id: { type: 'string' },
+                            workspace_ids: { type: 'array', items: { type: 'string' } },
+                            allow_insecure_http: { type: 'boolean' },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.clear_context',
+                    description: 'Clear the hubium-mcp context',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.whoami',
+                    description: 'Return the authenticated Hubium actor identity',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.search',
+                    description: 'Search Hubium cases with preview/full access',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string' },
+                            mode: { type: 'string', enum: ['auto', 'preview', 'full'] },
+                            workspace_id: { type: 'string' },
+                            workspace_ids: { type: 'array', items: { type: 'string' } },
+                            limit: { type: 'number' },
+                            offset: { type: 'number' },
+                        },
+                        required: ['query'],
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.get_case',
+                    description: 'Get a single Hubium case by id',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            case_id: { type: 'string' },
+                            workspace_id: { type: 'string' },
+                            workspace_ids: { type: 'array', items: { type: 'string' } },
+                        },
+                        required: ['case_id'],
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.create_case',
+                    description: 'Create a new Hubium case',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string' },
+                            description: { type: ['string', 'null'] },
+                            final_solution: { type: ['string', 'null'] },
+                            resolution_status: { type: 'string', enum: ['unsolved', 'workaround', 'solved'] },
+                            visibility_intent: { type: 'string', enum: ['public', 'private'] },
+                            workspace_id: { type: 'string' },
+                            model_name: { type: ['string', 'null'] },
+                            tags: { type: 'array', items: { type: 'string' } },
+                            category: { type: ['string', 'null'] },
+                            severity: { type: ['string', 'null'] },
+                            environment: { type: ['string', 'null'] },
+                            steps_to_reproduce: { type: ['string', 'null'] },
+                            expected: { type: ['string', 'null'] },
+                            actual: { type: ['string', 'null'] },
+                            idempotency_key: { type: 'string' },
+                        },
+                        required: ['title', 'visibility_intent'],
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.doctor',
+                    description: 'Diagnose hubium-mcp configuration and connectivity (no secrets printed)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            base_url: { type: 'string' },
+                            workspace_id: { type: 'string' },
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                {
+                    name: 'hubium.feedback',
+                    description: 'Append feedback to a Hubium case',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            case_id: { type: 'string' },
+                            feedback_type: { type: 'string', enum: ['comment', 'analysis', 'resolution', 'signal'] },
+                            content: { type: 'string' },
+                            workspace_id: { type: 'string' },
+                            visibility: { type: 'string', enum: ['internal', 'public'] },
+                            idempotency_key: { type: 'string' },
+                        },
+                        required: ['case_id', 'feedback_type', 'content'],
+                        additionalProperties: false,
+                    },
+                },
+            ],
+        }),
+        callTool: async (request) => {
+            const rate = deps.rateLimiter.allow();
+            if (!rate.ok) {
+                return textResponse({ ok: false, error: 'rate_limited', retry_after_ms: rate.retryAfterMs });
+            }
+            const tool = request.params.name;
+            const local_request_id = crypto.randomUUID();
+            const start = Date.now();
+            const emitToolLog = (event, extra = {}) => {
+                const line = {
+                    ts: new Date().toISOString(),
+                    level: 'info',
+                    event,
+                    tool,
+                    local_request_id,
+                    duration_ms: Date.now() - start,
+                    ...extra,
+                };
+                process.stderr.write(JSON.stringify(line) + '\n');
+            };
+            emitToolLog('tool_start');
+            let result;
+            try {
+                result = await (async () => {
+                    switch (tool) {
+                        case 'hubium.ping':
+                            return textResponse({ ok: true });
+                        case 'hubium.get_context': {
+                            const context = await deps.contextManager.load();
+                            const resolved = deps.contextManager.resolveBaseUrl();
+                            return textResponse({ context, resolved_base_url: resolved });
+                        }
+                        case 'hubium.set_context': {
+                            const input = normalizeArguments(request.params.arguments);
+                            const allowInsecure = input.allow_insecure_http === true;
+                            if (input.base_url !== undefined) {
+                                const baseUrl = String(input.base_url);
+                                if (baseUrl.trim().length === 0) {
+                                    throw new Error('base_url must be a non-empty string');
+                                }
+                                const url = new URL(baseUrl);
+                                if (url.protocol !== 'https:' && !allowInsecure) {
+                                    throw new Error('base_url must be https:// unless allow_insecure_http is true');
+                                }
+                            }
+                            const context = await deps.contextManager.save({
+                                base_url: input.base_url ? String(input.base_url) : undefined,
+                                workspace_id: input.workspace_id ? String(input.workspace_id) : undefined,
+                                workspace_ids: Array.isArray(input.workspace_ids)
+                                    ? input.workspace_ids.map((value) => String(value))
+                                    : undefined,
+                            });
+                            deps.tokenStore.clearFollowupToken();
+                            const resolved = deps.contextManager.resolveBaseUrl();
+                            return textResponse({ context, resolved_base_url: resolved });
+                        }
+                        case 'hubium.clear_context': {
+                            await deps.contextManager.clear();
+                            deps.tokenStore.clearFollowupToken();
+                            return textResponse({ ok: true });
+                        }
+                        case 'hubium.whoami': {
+                            if (deps.safeMode) {
+                                return textResponse({ ok: false, error: 'safe_mode' });
+                            }
+                            const context = await deps.contextManager.load();
+                            const baseUrl = deps.contextManager.resolveBaseUrl();
+                            if (!baseUrl) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_base_url',
+                                    next_step: {
+                                        action: 'set_base_url',
+                                        message_for_human: 'Set via hubium-mcp context set --base-url ... or HUBIUM_BASE_URL',
+                                    },
+                                });
+                            }
+                            const tokenResult = await deps.tokenStore.getToken();
+                            if (!tokenResult) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_token',
+                                    next_step: {
+                                        action: 'set_token',
+                                        message_for_human: 'Set HUBIUM_TOKEN or store via keychain in later ticket.',
+                                    },
+                                });
+                            }
+                            const client = deps.hubiumClientFactory({ baseUrl, token: tokenResult.token });
+                            const whoami = await client.whoami();
+                            return textResponse({
+                                ok: true,
+                                actor: whoami.actor,
+                                base_url: baseUrl,
+                                workspace_defaults: {
+                                    workspace_id: context.workspace_id,
+                                    workspace_ids: context.workspace_ids,
+                                },
+                            });
+                        }
+                        case 'hubium.search': {
+                            const input = normalizeArguments(request.params.arguments);
+                            const queryValue = typeof input.query === 'string' ? input.query.trim() : '';
+                            if (!queryValue) {
+                                throw new Error('query is required');
+                            }
+                            enforceMaxLength('query', queryValue, 2000);
+                            if (input.workspace_id !== undefined && input.workspace_ids !== undefined) {
+                                throw new Error('Provide only one of workspace_id or workspace_ids');
+                            }
+                            const modeRaw = typeof input.mode === 'string' ? input.mode : 'auto';
+                            const mode = modeRaw === 'preview' || modeRaw === 'full' || modeRaw === 'auto' ? modeRaw : 'auto';
+                            const effectiveMode = deps.safeMode ? 'preview' : mode;
+                            const limit = sanitizeLimit(input.limit);
+                            const offset = sanitizeOffset(input.offset);
+                            const context = await deps.contextManager.load();
+                            const baseUrl = deps.contextManager.resolveBaseUrl();
+                            if (!baseUrl) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_base_url',
+                                    next_step: {
+                                        action: 'set_base_url',
+                                        message_for_human: 'Set via hubium-mcp context set --base-url ... or HUBIUM_BASE_URL',
+                                    },
+                                });
+                            }
+                            const tokenResult = deps.safeMode ? null : await deps.tokenStore.getToken();
+                            const hasAuth = Boolean(tokenResult) && !deps.safeMode;
+                            const followupToken = effectiveMode === 'preview' ? null : deps.tokenStore.getFollowupToken();
+                            const workspaceSelection = resolveWorkspaceSelection({
+                                input,
+                                context,
+                                hasAuth,
+                                baseUrl,
+                                token: hasAuth ? tokenResult?.token ?? null : null,
+                                getWhoamiOnce,
+                            });
+                            const resolvedWorkspaces = await workspaceSelection;
+                            const params = {
+                                query: queryValue,
+                                limit,
+                                offset,
+                                ...resolvedWorkspaces,
+                            };
+                            const runSearch = async (token) => {
+                                const client = deps.hubiumClientFactory({ baseUrl, token: token ?? undefined });
+                                return client.search(params, followupToken ? { followupToken } : undefined);
+                            };
+                            if (effectiveMode === 'preview') {
+                                const response = await runSearch(null);
+                                persistFollowupToken(response, deps.tokenStore);
+                                logFollowupUsed(response, redactor, await collectSecrets(deps.tokenStore));
+                                return textResponse(response);
+                            }
+                            if (effectiveMode === 'full') {
+                                if (!tokenResult) {
+                                    return textResponse({ ok: false, error: 'missing_token' });
+                                }
+                                const response = await runSearch(tokenResult.token);
+                                persistFollowupToken(response, deps.tokenStore);
+                                logFollowupUsed(response, redactor, await collectSecrets(deps.tokenStore));
+                                return textResponse(response);
+                            }
+                            if (tokenResult) {
+                                try {
+                                    const response = await runSearch(tokenResult.token);
+                                    persistFollowupToken(response, deps.tokenStore);
+                                    logFollowupUsed(response, redactor, await collectSecrets(deps.tokenStore));
+                                    return textResponse(response);
+                                }
+                                catch (error) {
+                                    if (error instanceof HubiumClientError && (error.status === 401 || error.status === 403)) {
+                                        const response = await runSearch(null);
+                                        persistFollowupToken(response, deps.tokenStore);
+                                        logFollowupUsed(response, redactor, await collectSecrets(deps.tokenStore));
+                                        return textResponse(response);
+                                    }
+                                    throw error;
+                                }
+                            }
+                            const response = await runSearch(null);
+                            persistFollowupToken(response, deps.tokenStore);
+                            logFollowupUsed(response, redactor, await collectSecrets(deps.tokenStore));
+                            return textResponse(response);
+                        }
+                        case 'hubium.get_case': {
+                            const input = normalizeArguments(request.params.arguments);
+                            const caseId = typeof input.case_id === 'string' ? input.case_id.trim() : '';
+                            if (!caseId) {
+                                throw new Error('case_id is required');
+                            }
+                            if (input.workspace_id !== undefined && input.workspace_ids !== undefined) {
+                                throw new Error('Provide only one of workspace_id or workspace_ids');
+                            }
+                            const context = await deps.contextManager.load();
+                            const baseUrl = deps.contextManager.resolveBaseUrl();
+                            if (!baseUrl) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_base_url',
+                                    next_step: {
+                                        action: 'set_base_url',
+                                        message_for_human: 'Set via hubium-mcp context set --base-url ... or HUBIUM_BASE_URL',
+                                    },
+                                });
+                            }
+                            const tokenResult = deps.safeMode ? null : await deps.tokenStore.getToken();
+                            const resolvedWorkspaces = await resolveWorkspaceSelection({
+                                input,
+                                context,
+                                hasAuth: Boolean(tokenResult) && !deps.safeMode,
+                                baseUrl,
+                                token: deps.safeMode ? null : tokenResult?.token ?? null,
+                                getWhoamiOnce,
+                            });
+                            const client = deps.hubiumClientFactory({ baseUrl, token: deps.safeMode ? undefined : tokenResult?.token });
+                            const response = await client.getCase(caseId, resolvedWorkspaces);
+                            return textResponse(response);
+                        }
+                        case 'hubium.create_case': {
+                            if (deps.safeMode) {
+                                return textResponse({ ok: false, error: 'safe_mode' });
+                            }
+                            const input = normalizeArguments(request.params.arguments);
+                            const title = typeof input.title === 'string' ? input.title.trim() : '';
+                            if (!title) {
+                                throw new Error('title is required');
+                            }
+                            enforceMaxLength('title', title, 200);
+                            const visibility = typeof input.visibility_intent === 'string' ? input.visibility_intent : '';
+                            if (visibility !== 'public' && visibility !== 'private') {
+                                throw new Error('visibility_intent is required');
+                            }
+                            if (input.workspace_ids !== undefined) {
+                                throw new Error('workspace_ids is not supported for create_case');
+                            }
+                            const context = await deps.contextManager.load();
+                            const baseUrl = deps.contextManager.resolveBaseUrl();
+                            if (!baseUrl) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_base_url',
+                                    next_step: {
+                                        action: 'set_base_url',
+                                        message_for_human: 'Set via hubium-mcp context set --base-url ... or HUBIUM_BASE_URL',
+                                    },
+                                });
+                            }
+                            const tokenResult = deps.safeMode ? null : await deps.tokenStore.getToken();
+                            if (!tokenResult) {
+                                return textResponse({ ok: false, error: 'missing_token' });
+                            }
+                            if (!input.workspace_id && context.workspace_ids && context.workspace_ids.length > 0) {
+                                return textResponse({ ok: false, error: 'missing_workspace' });
+                            }
+                            const resolved = await resolveWorkspaceSelection({
+                                input: { workspace_id: input.workspace_id },
+                                context,
+                                hasAuth: true,
+                                baseUrl,
+                                token: tokenResult.token,
+                                getWhoamiOnce,
+                            });
+                            if (!resolved.workspace_id) {
+                                return textResponse({ ok: false, error: 'missing_workspace' });
+                            }
+                            const tags = Array.isArray(input.tags)
+                                ? input.tags.map((value) => String(value))
+                                : undefined;
+                            enforceTags(tags);
+                            enforceOptionalMaxLength('description', input.description, 10000);
+                            enforceOptionalMaxLength('final_solution', input.final_solution, 10000);
+                            enforceOptionalMaxLength('environment', input.environment, 10000);
+                            enforceOptionalMaxLength('steps_to_reproduce', input.steps_to_reproduce, 10000);
+                            enforceOptionalMaxLength('expected', input.expected, 10000);
+                            enforceOptionalMaxLength('actual', input.actual, 10000);
+                            const payload = {
+                                title,
+                                description: normalizeOptionalString(input.description),
+                                final_solution: normalizeOptionalString(input.final_solution),
+                                resolution_status: normalizeOptionalString(input.resolution_status),
+                                visibility_intent: visibility,
+                                workspace_id: resolved.workspace_id,
+                                model_name: normalizeOptionalString(input.model_name),
+                                tags,
+                                category: normalizeOptionalString(input.category),
+                                severity: normalizeOptionalString(input.severity),
+                                environment: normalizeOptionalString(input.environment),
+                                steps_to_reproduce: normalizeOptionalString(input.steps_to_reproduce),
+                                expected: normalizeOptionalString(input.expected),
+                                actual: normalizeOptionalString(input.actual),
+                                source_agent: 'hubium-mcp',
+                            };
+                            const idempotencyKey = typeof input.idempotency_key === 'string' && input.idempotency_key.trim().length > 0
+                                ? input.idempotency_key.trim()
+                                : undefined;
+                            const client = deps.hubiumClientFactory({ baseUrl, token: tokenResult.token });
+                            try {
+                                const response = await client.createCase(payload, idempotencyKey ? { idempotencyKey } : undefined);
+                                return textResponse(response);
+                            }
+                            catch (error) {
+                                const secrets = await collectSecrets(deps.tokenStore, idempotencyKey ? [idempotencyKey] : []);
+                                return safeErrorResponse(error, redactor, secrets);
+                            }
+                        }
+                        case 'hubium.doctor': {
+                            const input = normalizeArguments(request.params.arguments);
+                            const baseUrl = typeof input.base_url === 'string' ? input.base_url.trim() || undefined : undefined;
+                            const workspaceId = typeof input.workspace_id === 'string' ? input.workspace_id.trim() || undefined : undefined;
+                            const result = await runDoctor({ base_url: baseUrl, workspace_id: workspaceId }, {
+                                contextManager: deps.contextManager,
+                                tokenStore: deps.tokenStore,
+                                getSafeMode: () => deps.safeMode,
+                                fetchImpl: deps.fetchImpl,
+                            });
+                            return textResponse(result);
+                        }
+                        case 'hubium.feedback': {
+                            if (deps.safeMode) {
+                                return textResponse({ ok: false, error: 'safe_mode' });
+                            }
+                            const input = normalizeArguments(request.params.arguments);
+                            const caseId = typeof input.case_id === 'string' ? input.case_id.trim() : '';
+                            if (!caseId) {
+                                throw new Error('case_id is required');
+                            }
+                            const feedbackType = typeof input.feedback_type === 'string' ? input.feedback_type : '';
+                            if (!['comment', 'analysis', 'resolution', 'signal'].includes(feedbackType)) {
+                                throw new Error('feedback_type is required');
+                            }
+                            const content = typeof input.content === 'string' ? input.content.trim() : '';
+                            if (!content) {
+                                throw new Error('content is required');
+                            }
+                            enforceMaxLength('content', content, 10000);
+                            if (input.workspace_ids !== undefined) {
+                                throw new Error('workspace_ids is not supported for feedback');
+                            }
+                            const context = await deps.contextManager.load();
+                            const baseUrl = deps.contextManager.resolveBaseUrl();
+                            if (!baseUrl) {
+                                return textResponse({
+                                    ok: false,
+                                    error: 'missing_base_url',
+                                    next_step: {
+                                        action: 'set_base_url',
+                                        message_for_human: 'Set via hubium-mcp context set --base-url ... or HUBIUM_BASE_URL',
+                                    },
+                                });
+                            }
+                            const tokenResult = await deps.tokenStore.getToken();
+                            if (!tokenResult) {
+                                return textResponse({ ok: false, error: 'missing_token' });
+                            }
+                            if (!input.workspace_id && context.workspace_ids && context.workspace_ids.length > 0) {
+                                return textResponse({ ok: false, error: 'missing_workspace' });
+                            }
+                            const resolved = await resolveWorkspaceSelection({
+                                input: { workspace_id: input.workspace_id },
+                                context,
+                                hasAuth: true,
+                                baseUrl,
+                                token: tokenResult.token,
+                                getWhoamiOnce,
+                            });
+                            if (!resolved.workspace_id) {
+                                return textResponse({ ok: false, error: 'missing_workspace' });
+                            }
+                            const visibilityRaw = typeof input.visibility === 'string' ? input.visibility : undefined;
+                            if (visibilityRaw !== undefined && visibilityRaw !== 'internal' && visibilityRaw !== 'public') {
+                                throw new Error('visibility must be one of: internal, public');
+                            }
+                            const payload = {
+                                feedback_type: feedbackType,
+                                content,
+                                workspace_id: resolved.workspace_id,
+                                visibility: visibilityRaw,
+                            };
+                            const idempotencyKey = typeof input.idempotency_key === 'string' && input.idempotency_key.trim().length > 0
+                                ? input.idempotency_key.trim()
+                                : undefined;
+                            const client = deps.hubiumClientFactory({ baseUrl, token: tokenResult.token });
+                            try {
+                                const response = await client.addFeedback(caseId, payload, idempotencyKey ? { idempotencyKey } : undefined);
+                                return textResponse(response);
+                            }
+                            catch (error) {
+                                const secrets = await collectSecrets(deps.tokenStore, idempotencyKey ? [idempotencyKey] : []);
+                                return safeErrorResponse(error, redactor, secrets);
+                            }
+                        }
+                        default:
+                            return textResponse({ error: 'Unknown tool' });
+                    }
+                })();
+                try {
+                    const parsed = JSON.parse(result.content[0].text);
+                    if (parsed.error === 'hubium_client_error') {
+                        const backendRequestId = parsed.requestId ?? parsed.request_id;
+                        emitToolLog('tool_error', backendRequestId ? { backend_request_id: backendRequestId } : {});
+                    }
+                    else {
+                        emitToolLog('tool_end');
+                    }
+                }
+                catch {
+                    emitToolLog('tool_end');
+                }
+                return result;
+            }
+            catch (error) {
+                emitToolLog('tool_error', {
+                    backend_request_id: error instanceof HubiumClientError ? error.requestId : undefined,
+                });
+                const secrets = await collectSecrets(deps.tokenStore);
+                return safeErrorResponse(error, redactor, secrets);
+            }
+        },
+    };
+}
+function normalizeArguments(input) {
+    if (!input || typeof input !== 'object') {
+        return {};
+    }
+    return input;
+}
+function textResponse(payload) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(payload),
+            },
+        ],
+    };
+}
+function sanitizeLimit(limit) {
+    if (limit === undefined) {
+        return undefined;
+    }
+    if (typeof limit !== 'number' || Number.isNaN(limit)) {
+        throw new Error('limit must be a number');
+    }
+    return Math.max(0, Math.min(100, Math.floor(limit)));
+}
+function sanitizeOffset(offset) {
+    if (offset === undefined) {
+        return undefined;
+    }
+    if (typeof offset !== 'number' || Number.isNaN(offset)) {
+        throw new Error('offset must be a number');
+    }
+    return Math.max(0, Math.min(10_000, Math.floor(offset)));
+}
+async function resolveWorkspaceSelection(params) {
+    if (typeof params.input.workspace_id === 'string' && params.input.workspace_id.trim().length > 0) {
+        return { workspace_id: params.input.workspace_id.trim() };
+    }
+    if (Array.isArray(params.input.workspace_ids)) {
+        const ids = params.input.workspace_ids
+            .filter((value) => typeof value === 'string')
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+        if (ids.length > 0) {
+            return { workspace_ids: ids };
+        }
+    }
+    if (params.context.workspace_ids && params.context.workspace_ids.length > 0) {
+        return { workspace_ids: params.context.workspace_ids };
+    }
+    if (params.context.workspace_id && params.context.workspace_id.trim().length > 0) {
+        return { workspace_id: params.context.workspace_id };
+    }
+    if (params.hasAuth && params.token) {
+        const whoami = await params.getWhoamiOnce(params.baseUrl, params.token);
+        const workspaces = Array.isArray(whoami.workspaces) ? whoami.workspaces : [];
+        if (workspaces.length > 0) {
+            const first = workspaces[0];
+            if (first?.id) {
+                return { workspace_id: String(first.id) };
+            }
+        }
+    }
+    return {};
+}
+function persistFollowupToken(response, tokenStore) {
+    const followupToken = response.search_session?.followup_token;
+    if (followupToken && followupToken.trim().length > 0) {
+        tokenStore.setFollowupToken(followupToken);
+    }
+}
+function logFollowupUsed(response, redactor, secrets) {
+    if (!process.env.DEBUG) {
+        return;
+    }
+    if (response.search_session?.is_followup) {
+        const safe = redactor.redact({ search_session_id: response.search_session.id, is_followup: true }, secrets);
+        process.stderr.write(`[hubium-mcp] followup session ${JSON.stringify(safe)}\n`);
+    }
+}
+async function collectSecrets(tokenStore, extra = []) {
+    const secrets = [];
+    try {
+        const tokenResult = await tokenStore.getToken();
+        if (tokenResult?.token) {
+            secrets.push(tokenResult.token);
+        }
+    }
+    catch {
+        // ignore token resolution errors
+    }
+    const followup = tokenStore.getFollowupToken();
+    if (followup) {
+        secrets.push(followup);
+    }
+    const envTokens = [
+        process.env.HUBIUM_TOKEN,
+        process.env.HUBIUM_API_TOKEN,
+    ].filter((value) => typeof value === 'string' && value.trim().length > 0);
+    secrets.push(...envTokens, ...extra);
+    return secrets;
+}
+function redactString(redactor, value, secrets) {
+    if (secrets.length === 0) {
+        return value;
+    }
+    const result = redactor.redact(value, secrets);
+    return typeof result === 'string' ? result : value;
+}
+function safeErrorResponse(error, redactor, secrets) {
+    if (error instanceof HubiumClientError) {
+        const message = redactString(redactor, error.message, secrets);
+        return textResponse({
+            error: 'hubium_client_error',
+            kind: error.kind,
+            status: error.status,
+            requestId: error.requestId,
+            message,
+        });
+    }
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    return textResponse({ error: redactString(redactor, message, secrets) });
+}
+function normalizeOptionalString(value) {
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function enforceMaxLength(field, value, max) {
+    if (value.length > max) {
+        throw new Error(`${field} exceeds max length ${max}`);
+    }
+}
+function enforceOptionalMaxLength(field, value, max) {
+    if (typeof value !== 'string') {
+        return;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length > max) {
+        throw new Error(`${field} exceeds max length ${max}`);
+    }
+}
+function enforceTags(tags) {
+    if (!tags) {
+        return;
+    }
+    if (tags.length > 50) {
+        throw new Error('tags exceeds max length 50');
+    }
+    for (const tag of tags) {
+        if (tag.length > 64) {
+            throw new Error('tag exceeds max length 64');
+        }
+    }
+}
+export function createRateLimiterFromEnv() {
+    const perMin = Number.parseInt(process.env.HUBIUM_MCP_RATE_LIMIT_PER_MIN ?? '60', 10);
+    const limit = Number.isNaN(perMin) || perMin <= 0 ? 60 : perMin;
+    return new LocalRateLimiter(limit, 60_000);
+}
+export class LocalRateLimiter {
+    limit;
+    windowMs;
+    timestamps = [];
+    constructor(limit, windowMs) {
+        this.limit = limit;
+        this.windowMs = windowMs;
+    }
+    allow() {
+        const now = Date.now();
+        while (this.timestamps.length > 0 && now - this.timestamps[0] >= this.windowMs) {
+            this.timestamps.shift();
+        }
+        if (this.timestamps.length >= this.limit) {
+            const retryAfterMs = Math.max(0, this.windowMs - (now - this.timestamps[0]));
+            return { ok: false, retryAfterMs };
+        }
+        this.timestamps.push(now);
+        return { ok: true };
+    }
+}
+function getSafeMode() {
+    return process.env.HUBIUM_SAFE_MODE === '1';
+}
+//# sourceMappingURL=server.js.map