dominds 0.1.0

package/dist/log.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.Logger = void 0;
+exports.extractErrorDetails = extractErrorDetails;
+exports.createLogger = createLogger;
+/**
+ * Module: log
+ *
+ * Lightweight structured logger with levels and tags.
+ * - `Logger` formats records and prints to console
+ * - `log` default instance and `createLogger(tag)` helper
+ */
+const util_1 = require("util");
+const levelPriority = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+function resolveDefaultLevel() {
+    const envLevel = (process.env.DOMINDS_LOG_LEVEL || '').toLowerCase();
+    if (envLevel && envLevel in levelPriority) {
+        return envLevel;
+    }
+    return process.env.NODE_ENV === 'dev' ? 'debug' : 'info';
+}
+function nowTsStr() {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hour = String(date.getHours()).padStart(2, '0');
+    const minute = String(date.getMinutes()).padStart(2, '0');
+    const second = String(date.getSeconds()).padStart(2, '0');
+    return `${year}/${month}/${day}-${hour}:${minute}:${second}`;
+}
+function inspectValue(value) {
+    if (typeof value === 'string')
+        return value;
+    return (0, util_1.inspect)(value, { depth: 5, breakLength: 120, compact: false, sorted: true });
+}
+function extractErrorDetails(error) {
+    if (!error)
+        return {
+            message: `Strange error type='${typeof error}'`,
+        };
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        };
+    }
+    if (typeof error === 'object' && error !== null) {
+        const maybeError = error;
+        const messageValue = maybeError.message;
+        return {
+            name: typeof maybeError.name === 'string' ? maybeError.name : undefined,
+            message: typeof messageValue === 'string'
+                ? messageValue
+                : messageValue === undefined
+                    ? 'Error object has undefined message property'
+                    : `Error object has non-string message property of type '${typeof messageValue}'`,
+            stack: typeof maybeError.stack === 'string' ? maybeError.stack : undefined,
+        };
+    }
+    return {
+        message: inspectValue(error),
+    };
+}
+function getCallerLocation(skipFrames = 0) {
+    const stack = new Error().stack;
+    if (!stack)
+        return undefined;
+    const lines = stack.split('\n');
+    // Skip the first few lines which are the error creation and our own logger methods
+    // skipFrames allows precise caller identification for different logger methods
+    for (let i = 3 + skipFrames; i < Math.min(lines.length, skipFrames + 10); i++) {
+        const line = lines[i];
+        const match = line.match(/at\s+(?:.*\s+)?\(?(.+?):(\d+):(\d+)\)?/);
+        if (match) {
+            const [, file, lineNum, column] = match;
+            // Skip internal Node.js, logger files, and utility functions
+            const skipPatterns = ['node:', 'inspect', 'formatLine', 'extractErrorDetails'];
+            const shouldSkip = skipPatterns.some((pattern) => file.includes(pattern));
+            if (!shouldSkip) {
+                return {
+                    file: file,
+                    line: parseInt(lineNum, 10),
+                    column: parseInt(column, 10),
+                };
+            }
+        }
+    }
+}
+const pkgFilePathPrefix = (() => {
+    const loc = getCallerLocation(0);
+    if (loc?.file) {
+        for (const thisModuPart of ['/src/log.', '/log.']) {
+            const thisModuIdx = loc.file.lastIndexOf(thisModuPart);
+            if (thisModuIdx > 0) {
+                return loc.file.substring(0, thisModuIdx);
+            }
+        }
+    }
+})();
+function stripPkgPrefix(file) {
+    if (pkgFilePathPrefix && file.startsWith(pkgFilePathPrefix)) {
+        return file.substring(pkgFilePathPrefix.length + 1); // +1 to remove the leading slash
+    }
+    return file;
+}
+/**
+ * Logger
+ *
+ * Structured console logger with level gating, tagging, and rich error/extra formatting.
+ * Levels: debug, info, warn, error.
+ */
+class Logger {
+    constructor(tag, level = resolveDefaultLevel()) {
+        this.tag = tag;
+        this.level = level;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    shouldLog(level) {
+        return levelPriority[level] >= levelPriority[this.level];
+    }
+    formatRecord(level, message, error, extraData = []) {
+        const timestamp = nowTsStr();
+        const extraEntries = extraData.map((value) => inspectValue(value));
+        const record = {
+            timestamp,
+            level,
+            message,
+        };
+        if (this.tag) {
+            record.tag = this.tag;
+        }
+        // Include location info for debug level
+        if (this.level === 'debug') {
+            record.location = getCallerLocation(2);
+        }
+        if (error !== undefined && error !== null) {
+            record.error = extractErrorDetails(error);
+        }
+        if (extraEntries.length > 0) {
+            record.extra = extraEntries;
+        }
+        return record;
+    }
+    formatLine(record) {
+        let errorText = '';
+        if (record.error) {
+            const { name, message, stack } = record.error;
+            if (stack) {
+                // When an error object is passed, show only the stack trace to avoid duplication
+                // The log message should already contain the error description
+                errorText = `\n${stack}`;
+            }
+            else if (message) {
+                // Fallback for error objects without stack
+                if (name && message !== name) {
+                    errorText = ` Error: ${name}: ${message}`;
+                }
+                else {
+                    errorText = ` Error: ${message}`;
+                }
+            }
+            else {
+                // Fallback to inspect for complex error objects
+                errorText = ` Error: ${inspectValue(record.error)}`;
+            }
+        }
+        const extraText = record.extra && record.extra.length > 0
+            ? ` Extra: ${record.extra.map((entry) => inspectValue(entry)).join('; ')}`
+            : '';
+        if (record.location) {
+            const prefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}\n  @ ${stripPkgPrefix(record.location.file)}:${record.location.line}:${record.location.column}`;
+            return `${prefix}\n${record.message}${errorText}${extraText}`;
+        }
+        else {
+            const prefix = `[${record.timestamp}] ${record.tag ? `[${record.tag}] ` : ''}${record.level.toUpperCase()}:`;
+            return `${prefix} ${record.message}${errorText}${extraText}`;
+        }
+    }
+    log(level, message, error, ...extraData) {
+        if (!this.shouldLog(level))
+            return;
+        const record = this.formatRecord(level, message, error, extraData);
+        const line = this.formatLine(record);
+        switch (level) {
+            case 'debug':
+                console.debug(line);
+                break;
+            case 'info':
+                console.info(line);
+                break;
+            case 'warn':
+                console.warn(line);
+                break;
+            case 'error':
+                console.error(line);
+                break;
+            default:
+                console.log(line);
+                break;
+        }
+    }
+    debug(message, error, ...extraData) {
+        this.log('debug', message, error, ...extraData);
+    }
+    info(message, error, ...extraData) {
+        this.log('info', message, error, ...extraData);
+    }
+    warn(message, error, ...extraData) {
+        this.log('warn', message, error, ...extraData);
+    }
+    error(message, error, ...extraData) {
+        this.log('error', message, error, ...extraData);
+    }
+}
+exports.Logger = Logger;
+exports.log = new Logger();
+function createLogger(tag) {
+    return new Logger(tag);
+}

package/dist/mcp/config.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMcpYaml = parseMcpYaml;
+const yaml_1 = __importDefault(require("yaml"));
+const log_1 = require("../log");
+const log = (0, log_1.createLogger)('mcp/config');
+/**
+ * NOTE: This loader parses external YAML (untrusted input). Runtime type checks are unavoidable
+ * here to keep the core code statically safe.
+ */
+function parseMcpYaml(rawText) {
+    const doc = yaml_1.default.parseDocument(rawText, { prettyErrors: true });
+    if (doc.errors.length > 0) {
+        const errText = doc.errors.map((e) => String(e)).join('\n');
+        return { ok: false, errorText: errText, rawText };
+    }
+    const parsed = doc.toJS();
+    try {
+        const res = parseWorkspaceConfig(parsed);
+        return {
+            ok: true,
+            config: res.config,
+            invalidServers: res.invalidServers,
+            serverIdsInYamlOrder: res.serverIdsInYamlOrder,
+            validServerIdsInYamlOrder: res.validServerIdsInYamlOrder,
+            rawText,
+        };
+    }
+    catch (err) {
+        return { ok: false, errorText: err instanceof Error ? err.message : String(err), rawText };
+    }
+}
+function parseWorkspaceConfig(value) {
+    const root = asRecord(value, 'mcp.yaml root');
+    const version = root.version;
+    if (version !== 1) {
+        throw new Error(`Invalid mcp.yaml: expected version: 1`);
+    }
+    const serversVal = root.servers;
+    const serversRecord = serversVal === undefined ? {} : asRecord(serversVal, 'servers');
+    const servers = {};
+    const invalidServers = [];
+    const serverIdsInYamlOrder = [];
+    const validServerIdsInYamlOrder = [];
+    for (const [serverId, serverRaw] of Object.entries(serversRecord)) {
+        serverIdsInYamlOrder.push(serverId);
+        try {
+            servers[serverId] = parseServerConfig(serverId, serverRaw);
+            validServerIdsInYamlOrder.push(serverId);
+        }
+        catch (err) {
+            invalidServers.push({
+                serverId,
+                errorText: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    return {
+        config: { version: 1, servers },
+        invalidServers,
+        serverIdsInYamlOrder,
+        validServerIdsInYamlOrder,
+    };
+}
+function parseServerConfig(serverId, value) {
+    const obj = asRecord(value, `servers.${serverId}`);
+    const truelyStatelessVal = obj['truely-stateless'];
+    const truelyStateless = truelyStatelessVal === undefined
+        ? false
+        : typeof truelyStatelessVal === 'boolean'
+            ? truelyStatelessVal
+            : (() => {
+                throw new Error(`Invalid mcp.yaml: servers.${serverId}.truely-stateless must be a boolean`);
+            })();
+    const transport = obj.transport;
+    if (transport !== 'stdio' && transport !== 'streamable_http') {
+        throw new Error(`Invalid mcp.yaml: servers.${serverId}.transport must be 'stdio' or 'streamable_http'`);
+    }
+    const toolsVal = obj.tools;
+    const toolsObj = toolsVal === undefined ? {} : asRecord(toolsVal, `servers.${serverId}.tools`);
+    const whitelist = parseStringArrayOptional(toolsObj.whitelist, `servers.${serverId}.tools.whitelist`);
+    const blacklist = parseStringArrayOptional(toolsObj.blacklist, `servers.${serverId}.tools.blacklist`);
+    const transformVal = obj.transform;
+    const transform = transformVal === undefined ? [] : parseTransformArray(transformVal, serverId);
+    if (transport === 'stdio') {
+        const command = obj.command;
+        if (typeof command !== 'string' || !command.trim()) {
+            throw new Error(`Invalid mcp.yaml: servers.${serverId}.command must be a non-empty string`);
+        }
+        const argsVal = obj.args;
+        const args = argsVal === undefined
+            ? []
+            : Array.isArray(argsVal) && argsVal.every((a) => typeof a === 'string')
+                ? argsVal
+                : (() => {
+                    throw new Error(`Invalid mcp.yaml: servers.${serverId}.args must be string[]`);
+                })();
+        const envVal = obj.env;
+        const envRecord = envVal === undefined ? {} : asRecord(envVal, `servers.${serverId}.env`);
+        const env = {};
+        for (const [k, v] of Object.entries(envRecord)) {
+            if (typeof v === 'string') {
+                env[k] = { kind: 'literal', value: v };
+                continue;
+            }
+            const mapped = asRecord(v, `servers.${serverId}.env.${k}`);
+            const fromEnv = mapped.env;
+            if (typeof fromEnv !== 'string' || !fromEnv.trim()) {
+                throw new Error(`Invalid mcp.yaml: servers.${serverId}.env.${k} must be a string or { env: 'NAME' }`);
+            }
+            env[k] = { kind: 'from_env', env: fromEnv };
+        }
+        return {
+            serverId,
+            truelyStateless,
+            transport: 'stdio',
+            command,
+            args,
+            env,
+            tools: { whitelist, blacklist },
+            transform,
+        };
+    }
+    const url = obj.url;
+    if (typeof url !== 'string' || !url.trim()) {
+        throw new Error(`Invalid mcp.yaml: servers.${serverId}.url must be a non-empty string`);
+    }
+    const parsedUrl = safeParseUrl(url);
+    if (!parsedUrl) {
+        throw new Error(`Invalid mcp.yaml: servers.${serverId}.url must be a valid http(s) URL`);
+    }
+    const headersVal = obj.headers;
+    const headersRecord = headersVal === undefined ? {} : asRecord(headersVal, `servers.${serverId}.headers`);
+    const headers = {};
+    for (const [k, v] of Object.entries(headersRecord)) {
+        if (typeof v === 'string') {
+            headers[k] = { kind: 'literal', value: v };
+            continue;
+        }
+        const mapped = asRecord(v, `servers.${serverId}.headers.${k}`);
+        const fromEnv = mapped.env;
+        if (typeof fromEnv !== 'string' || !fromEnv.trim()) {
+            throw new Error(`Invalid mcp.yaml: servers.${serverId}.headers.${k} must be a string or { env: 'NAME' }`);
+        }
+        headers[k] = { kind: 'from_env', env: fromEnv };
+    }
+    const sessionIdVal = obj.sessionId;
+    const sessionId = sessionIdVal === undefined
+        ? undefined
+        : typeof sessionIdVal === 'string' && sessionIdVal.trim()
+            ? sessionIdVal
+            : (() => {
+                throw new Error(`Invalid mcp.yaml: servers.${serverId}.sessionId must be a string`);
+            })();
+    return {
+        serverId,
+        truelyStateless,
+        transport: 'streamable_http',
+        url: parsedUrl.toString(),
+        headers,
+        sessionId,
+        tools: { whitelist, blacklist },
+        transform,
+    };
+}
+function parseTransformArray(value, serverId) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid mcp.yaml: servers.${serverId}.transform must be an array`);
+    }
+    const out = [];
+    for (let i = 0; i < value.length; i++) {
+        const item = asRecord(value[i], `servers.${serverId}.transform[${i}]`);
+        if ('prefix' in item) {
+            const p = item.prefix;
+            if (typeof p === 'string') {
+                out.push({ kind: 'prefix_add', add: p });
+                continue;
+            }
+            const po = asRecord(p, `servers.${serverId}.transform[${i}].prefix`);
+            const remove = po.remove;
+            const add = po.add;
+            if (typeof remove !== 'string' || typeof add !== 'string') {
+                throw new Error(`Invalid mcp.yaml: servers.${serverId}.transform[${i}].prefix must be string or { remove, add }`);
+            }
+            out.push({ kind: 'prefix_replace', remove, add });
+            continue;
+        }
+        if ('suffix' in item) {
+            const s = item.suffix;
+            if (typeof s !== 'string') {
+                throw new Error(`Invalid mcp.yaml: servers.${serverId}.transform[${i}].suffix must be a string`);
+            }
+            out.push({ kind: 'suffix_add', add: s });
+            continue;
+        }
+        log.warn(`Unknown transform entry ignored in servers.${serverId}.transform[${i}]`);
+    }
+    return out;
+}
+function parseStringArrayOptional(value, pathLabel) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+        throw new Error(`Invalid mcp.yaml: ${pathLabel} must be string[]`);
+    }
+    return value.filter((s) => s.trim().length > 0);
+}
+function asRecord(value, label) {
+    if (!isRecord(value) || Array.isArray(value)) {
+        throw new Error(`Invalid mcp.yaml: expected object at ${label}`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function safeParseUrl(value) {
+    try {
+        const u = new URL(value);
+        if (u.protocol !== 'http:' && u.protocol !== 'https:')
+            return undefined;
+        return u;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/mcp/sdk-client.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpSdkClient = void 0;
+const client_1 = require("@modelcontextprotocol/sdk/client");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+const log_1 = require("../log");
+const log = (0, log_1.createLogger)('mcp/sdk-client');
+class McpSdkClient {
+    constructor(params) {
+        this.closed = false;
+        this.serverId = params.serverId;
+        this.client = params.client;
+    }
+    static async connectStdio(params) {
+        const transport = new stdio_js_1.StdioClientTransport({
+            command: params.command,
+            args: params.args,
+            env: params.env,
+            cwd: params.cwd,
+            stderr: 'pipe',
+        });
+        const stderr = transport.stderr;
+        if (stderr) {
+            stderr.on('data', (chunk) => {
+                const text = typeof chunk === 'string'
+                    ? chunk
+                    : Buffer.isBuffer(chunk)
+                        ? chunk.toString('utf8')
+                        : String(chunk);
+                const trimmed = text.trimEnd();
+                if (!trimmed)
+                    return;
+                log.debug(`[${params.serverId}][stderr] ${trimmed}`);
+            });
+        }
+        return await McpSdkClient.connectWithTransport(params.serverId, transport);
+    }
+    static async connectStreamableHttp(params) {
+        const transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(params.url), {
+            requestInit: { headers: params.headers },
+            sessionId: params.sessionId,
+        });
+        return await McpSdkClient.connectWithTransport(params.serverId, transport);
+    }
+    static async connectWithTransport(serverId, transport) {
+        const client = new client_1.Client({ name: 'dominds', version: 'dev' }, {
+            capabilities: {},
+        });
+        await client.connect(transport, { timeout: 15000 });
+        return new McpSdkClient({ serverId, client });
+    }
+    async listTools(timeoutMs = 15000) {
+        this.ensureOpen();
+        const out = [];
+        let cursor;
+        for (let i = 0; i < 50; i++) {
+            const res = await this.client.listTools(cursor ? { cursor } : {}, { timeout: timeoutMs });
+            for (const t of res.tools) {
+                out.push({
+                    name: t.name,
+                    description: t.description,
+                    inputSchema: t.inputSchema,
+                });
+            }
+            cursor = res.nextCursor;
+            if (!cursor)
+                break;
+        }
+        return out;
+    }
+    async callTool(mcpToolName, args, timeoutMs = 60000) {
+        this.ensureOpen();
+        const res = await this.client.callTool({ name: mcpToolName, arguments: args }, undefined, {
+            timeout: timeoutMs,
+        });
+        return stringifyToolCallResult(res);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            await this.client.close();
+        }
+        catch (err) {
+            log.debug('MCP SDK client close failed', { serverId: this.serverId, err });
+        }
+    }
+    ensureOpen() {
+        if (this.closed) {
+            throw new Error(`MCP client is closed (${this.serverId})`);
+        }
+    }
+}
+exports.McpSdkClient = McpSdkClient;
+function stringifyToolCallResult(value) {
+    if (!isRecord(value) || Array.isArray(value)) {
+        return JSON.stringify(value);
+    }
+    if ('content' in value) {
+        const content = value.content;
+        if (!Array.isArray(content)) {
+            return JSON.stringify(value);
+        }
+        const parts = [];
+        for (const item of content) {
+            if (isRecord(item) && !Array.isArray(item)) {
+                const t = item.type;
+                if (t === 'text' && typeof item.text === 'string') {
+                    parts.push(item.text);
+                    continue;
+                }
+            }
+            parts.push(JSON.stringify(item));
+        }
+        const joined = parts.join('\n').trim();
+        if (joined)
+            return joined;
+        return JSON.stringify(value);
+    }
+    if ('toolResult' in value) {
+        return JSON.stringify(value.toolResult);
+    }
+    return JSON.stringify(value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/mcp/server-runtime.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServerRuntime = void 0;
+const log_1 = require("../log");
+const log = (0, log_1.createLogger)('mcp/server-runtime');
+class McpServerRuntime {
+    constructor(params) {
+        this.inFlightCount = 0;
+        this.stopRequested = false;
+        this.closed = false;
+        this.serverId = params.serverId;
+        this.toolsetName = params.toolsetName;
+        this.client = params.client;
+    }
+    async callTool(mcpToolName, args) {
+        if (this.closed) {
+            throw new Error(`MCP server ${this.serverId} is closed`);
+        }
+        this.inFlightCount++;
+        try {
+            return await this.client.callTool(mcpToolName, args);
+        }
+        finally {
+            this.inFlightCount--;
+            if (this.stopRequested && this.inFlightCount <= 0) {
+                await this.closeNow();
+            }
+        }
+    }
+    requestStop(params) {
+        if (this.stopRequested)
+            return;
+        this.stopRequested = true;
+        const forceKillAfterMs = params?.forceKillAfterMs ?? 30000;
+        if (this.inFlightCount <= 0) {
+            void this.closeNow();
+            return;
+        }
+        if (!this.forceKillTimer) {
+            this.forceKillTimer = setTimeout(() => {
+                log.warn(`Force-killing MCP server after timeout`, { serverId: this.serverId });
+                void this.closeNow();
+            }, forceKillAfterMs);
+        }
+    }
+    async closeNow() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.forceKillTimer) {
+            clearTimeout(this.forceKillTimer);
+            this.forceKillTimer = undefined;
+        }
+        await this.client.close();
+    }
+}
+exports.McpServerRuntime = McpServerRuntime;