@dsh-libing/mcp-manager 0.0.0-stage → 0.1.0

package/lib/servers.js

@@ -0,0 +1,270 @@
+import { livePresetMounts } from '@deepseek-ai/dsh-agent-preset-registry';
+import { isMap, isNode, isScalar, isSeq, Scalar, visit, YAMLMap } from 'yaml';
+import { MCP, configSchema } from "./shared.js";
+import { document, hash, ManagerError, rowsIn } from "./storage.js";
+export function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function publicConfig(raw) {
+    const parsed = configSchema.safeParse({
+        serverName: raw.serverName,
+        transport: raw.transport,
+        command: raw.command ?? '',
+        args: raw.args ?? [],
+        cwd: raw.cwd ?? '',
+        url: raw.url ?? '',
+        secrets: [],
+        toolCallTimeoutMs: raw.toolCallTimeoutMs ?? 60000,
+        reconnect: record(raw.reconnect).enabled ?? true
+    });
+    // No non-credential expression or unsupported extension is silently rewritten.
+    const allowed = new Set([
+        'serverName',
+        'transport',
+        'command',
+        'args',
+        'cwd',
+        'url',
+        'env',
+        'headers',
+        'toolCallTimeoutMs',
+        'reconnect',
+        'failOnStartupError',
+        'maxInstructionBytes'
+    ]);
+    return parsed.success && Object.keys(raw).every((key) => allowed.has(key)) ? parsed.data : null;
+}
+export async function serverRecords(ctx, text) {
+    const managed = rowsIn(text), rows = managed.rows?.items ?? [], result = [];
+    for (const node of rows) {
+        if (!isMap(node) || node.get('name') !== MCP || typeof node.get('id') !== 'string')
+            throw new ManagerError('Unsupported managed entry', 409);
+        const raw = record(node.get('config', true)?.toJSON()), id = String(node.get('id'));
+        if (!/^libing-mcp-[a-f0-9-]+$/u.test(id))
+            throw new ManagerError('Unsupported managed identity', 409);
+        const keys = Object.keys(record(raw[raw.transport === 'stdio' ? 'env' : 'headers']));
+        const configNode = node.get('config', true);
+        let unsupported = false;
+        if (isMap(configNode))
+            for (const pair of configNode.items) {
+                if (isScalar(pair.key) && ['env', 'headers'].includes(String(pair.key.value)))
+                    continue;
+                if (isNode(pair.value))
+                    visit(pair.value, {
+                        Scalar(_key, value) {
+                            if (value.tag === 'tag:yaml.org,2002:js')
+                                unsupported = true;
+                        }
+                    });
+            }
+        const config = unsupported ? null : publicConfig(raw);
+        result.push({
+            patchId: id,
+            raw,
+            item: {
+                id: hash(`profile\0${id}`),
+                serverName: typeof raw.serverName === 'string' ? raw.serverName : id,
+                scope: 'profile',
+                origin: 'managed',
+                transport: String(raw.transport ?? ''),
+                enabled: node.get('disabled') !== true,
+                phase: null,
+                toolCount: null,
+                editable: config !== null,
+                toggleable: false,
+                config,
+                credentialKeys: keys,
+                tested: null
+            }
+        });
+    }
+    const official = await ctx.pluginManager.listPlugins();
+    const trees = [
+        { scope: 'profile', entries: [...ctx.loader.entries()] },
+        ...livePresetMounts(ctx.root.fiber).map((mount) => ({
+            scope: `preset:${mount.presetId}`,
+            entries: [...mount.tree.entries()]
+        }))
+    ];
+    const seen = new Set();
+    for (const tree of trees)
+        for (const entry of tree.entries) {
+            if (entry.options.name !== MCP || seen.has(entry))
+                continue;
+            seen.add(entry);
+            const mount = livePresetMounts(ctx.root.fiber).find((m) => [...m.tree.entries()].includes(entry));
+            const isPreset = mount !== undefined;
+            const scope = mount ? `preset:${mount.presetId}:${mount.fiber.uid}` : 'profile';
+            const raw = record(entry.options.config), config = publicConfig(raw), manager = official.find((row) => row.entryId === entry.id);
+            const owned = !isPreset ? result.find((row) => row.patchId === entry.options.id) : undefined;
+            const tools = entry.fiber?.ctx.get('tools'), prefix = typeof raw.serverName === 'string' ? `mcp__${raw.serverName}__` : null;
+            const count = tools && prefix
+                ? tools
+                    .schemas(isPreset
+                    ? livePresetMounts(ctx.root.fiber).find((m) => [...m.tree.entries()].includes(entry))?.key
+                    : undefined)
+                    .filter((tool) => tool.name.startsWith(prefix)).length
+                : null;
+            const item = {
+                id: owned?.item.id ?? hash(`${scope}\0${entry.id}`),
+                serverName: typeof raw.serverName === 'string' ? raw.serverName : entry.id,
+                scope,
+                origin: owned ? 'managed' : isPreset ? 'preset' : 'profile',
+                transport: typeof raw.transport === 'string' ? raw.transport : 'unknown',
+                enabled: !entry.disabled,
+                phase: manager?.fiberPhase ??
+                    (entry.fiber
+                        ? (['pending', 'loading', 'active', 'failed', null, 'unloading'][entry.fiber.state] ??
+                            null)
+                        : null),
+                toolCount: count,
+                editable: !!owned &&
+                    owned.item.editable &&
+                    config !== null &&
+                    JSON.stringify(config) === JSON.stringify(owned.item.config),
+                toggleable: manager?.patchId !== undefined,
+                config: owned &&
+                    owned.item.editable &&
+                    JSON.stringify(config) === JSON.stringify(owned.item.config)
+                    ? config
+                    : null,
+                credentialKeys: Object.keys(record(raw[raw.transport === 'stdio' ? 'env' : 'headers'])),
+                tested: null
+            };
+            if (owned) {
+                owned.entry = entry;
+                owned.item = item;
+                owned.raw = raw;
+            }
+            else
+                result.push({ item, entry, raw, ...(mount?.key ? { scopeKey: mount.key } : {}) });
+        }
+    return result;
+}
+/** Keep secret nodes by default. Only constrained generated references use !!js. */
+export function writeConfig(node, path, config) {
+    const old = node.getIn(path, true), previous = isMap(old) ? old : undefined;
+    const secrets = previous?.get(config.transport === 'stdio' ? 'env' : 'headers', true);
+    const next = new YAMLMap();
+    for (const [key, value] of Object.entries({
+        transport: config.transport,
+        serverName: config.serverName,
+        ...(config.transport === 'stdio'
+            ? { command: config.command, args: config.args, cwd: config.cwd }
+            : { url: config.url }),
+        toolCallTimeoutMs: config.toolCallTimeoutMs,
+        reconnect: { enabled: config.reconnect }
+    }))
+        next.set(key, node.createNode(value));
+    // Preserve official options not owned by the form, including reconnect tuning.
+    for (const key of ['failOnStartupError', 'maxInstructionBytes'])
+        if (previous?.has(key))
+            next.set(key, previous.get(key, true));
+    const reconnect = previous?.get('reconnect', true);
+    if (isMap(reconnect)) {
+        next.set('reconnect', reconnect);
+        reconnect.set('enabled', config.reconnect);
+    }
+    const credentials = new YAMLMap();
+    if (isMap(secrets))
+        for (const pair of secrets.items) {
+            if (isScalar(pair.key) && typeof pair.key.value === 'string')
+                credentials.set(pair.key.value, pair.value);
+        }
+    for (const secret of config.secrets) {
+        if (secret.action === 'keep') {
+            if (!credentials.has(secret.key))
+                throw new ManagerError('Credential no longer exists', 409);
+        }
+        else if (secret.action === 'remove')
+            credentials.delete(secret.key);
+        else if (secret.action === 'value')
+            credentials.set(secret.key, secret.value);
+        else {
+            const expression = new Scalar(`process.env[${JSON.stringify(secret.value)}] ?? ''`);
+            expression.tag = 'tag:yaml.org,2002:js';
+            credentials.set(secret.key, expression);
+        }
+    }
+    next.set(config.transport === 'stdio' ? 'env' : 'headers', credentials);
+    node.setIn(path, next);
+}
+/** Resolve only literal values or the exact ENV expression this editor emits. */
+export function resolvedConfig(raw) {
+    const config = publicConfig(raw);
+    if (!config)
+        throw new ManagerError('This configuration cannot be tested safely; use its source', 409);
+    const credentials = Object.create(null);
+    for (const [key, value] of Object.entries(record(raw[config.transport === 'stdio' ? 'env' : 'headers']))) {
+        const expression = record(value).__jsExpr;
+        if (typeof value === 'string')
+            credentials[key] = value;
+        else if (typeof expression === 'string') {
+            const match = /^process\.env\["([A-Za-z_][A-Za-z0-9_]{0,127})"\] \?\? ''$/u.exec(expression);
+            const variable = match?.[1];
+            if (!variable)
+                throw new ManagerError('Unsupported credential expression; test from its source', 409);
+            credentials[key] = process.env[variable] ?? '';
+        }
+        else
+            throw new ManagerError('Unsupported credential configuration', 409);
+    }
+    return { ...config, credentials };
+}
+export function rawManaged(text, id) {
+    const { doc, rows } = rowsIn(text), index = rows?.items.findIndex((item) => isMap(item) && item.get('id') === id) ?? -1;
+    if (index < 0)
+        throw new ManagerError('MCP entry no longer exists', 404);
+    // Convert tags to inert expressions rather than evaluating foreign code.
+    const raw = document(String(doc));
+    const config = raw.getIn([0, 'insert', index, 'config'], true);
+    if (!isMap(config))
+        throw new ManagerError('Missing MCP configuration', 409);
+    let unsupported = false;
+    const initial = record(config.toJSON()), field = initial.transport === 'stdio' ? 'env' : 'headers';
+    for (const pair of config.items) {
+        if (isScalar(pair.key) && String(pair.key.value) === field)
+            continue;
+        if (isNode(pair.value))
+            visit(pair.value, {
+                Scalar(_key, value) {
+                    if (value.tag === 'tag:yaml.org,2002:js')
+                        unsupported = true;
+                }
+            });
+    }
+    if (unsupported)
+        throw new ManagerError('Unsupported configuration expression; use its source', 409);
+    const value = initial, keys = config.get(field, true);
+    if (isMap(keys)) {
+        const creds = {};
+        for (const pair of keys.items) {
+            if (isScalar(pair.key) && typeof pair.key.value === 'string') {
+                const node = pair.value;
+                creds[pair.key.value] =
+                    isScalar(node) && node.tag === 'tag:yaml.org,2002:js'
+                        ? { __jsExpr: node.value }
+                        : isScalar(node)
+                            ? node.value
+                            : undefined;
+            }
+        }
+        value[field] = creds;
+    }
+    return value;
+}
+export function appendRow(text, id, config) {
+    const { doc, rows } = rowsIn(text);
+    if (!rows) {
+        doc.contents = doc.createNode([{ insert: [] }]);
+    }
+    const insert = doc.getIn([0, 'insert'], true);
+    if (!isSeq(insert))
+        throw new ManagerError('Invalid managed entries', 409);
+    const index = insert.items.length;
+    insert.add(doc.createNode({ id, name: MCP, disabled: true, config: {} }));
+    writeConfig(doc, [0, 'insert', index, 'config'], config);
+    return String(doc);
+}

package/lib/shared.d.ts

@@ -0,0 +1,314 @@
+/** Authenticated protocol. Paths and raw config are never browser identities. */
+import { z } from 'zod';
+export declare const API = "/api/libing-mcp-manager";
+export declare const MCP = "@deepseek-ai/dsh-mcp-client";
+export declare const selectionSchema: z.ZodObject<{
+    workspaceId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Selection = z.infer<typeof selectionSchema>;
+export declare const secretSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    key: z.ZodString;
+    action: z.ZodLiteral<"keep">;
+}, z.core.$strict>, z.ZodObject<{
+    key: z.ZodString;
+    action: z.ZodLiteral<"remove">;
+}, z.core.$strict>, z.ZodObject<{
+    key: z.ZodString;
+    action: z.ZodLiteral<"value">;
+    value: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    key: z.ZodString;
+    action: z.ZodLiteral<"env">;
+    value: z.ZodString;
+}, z.core.$strict>], "action">;
+export declare const configSchema: z.ZodObject<{
+    serverName: z.ZodString;
+    transport: z.ZodEnum<{
+        stdio: "stdio";
+        "streamable-http": "streamable-http";
+    }>;
+    command: z.ZodDefault<z.ZodString>;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cwd: z.ZodDefault<z.ZodString>;
+    url: z.ZodDefault<z.ZodString>;
+    secrets: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        key: z.ZodString;
+        action: z.ZodLiteral<"keep">;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        action: z.ZodLiteral<"remove">;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        action: z.ZodLiteral<"value">;
+        value: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        key: z.ZodString;
+        action: z.ZodLiteral<"env">;
+        value: z.ZodString;
+    }, z.core.$strict>], "action">>>;
+    toolCallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    reconnect: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ServerConfig = z.infer<typeof configSchema>;
+export declare const mutationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"create">;
+    revision: z.ZodString;
+    config: z.ZodObject<{
+        serverName: z.ZodString;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            "streamable-http": "streamable-http";
+        }>;
+        command: z.ZodDefault<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"keep">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"remove">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"value">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"env">;
+            value: z.ZodString;
+        }, z.core.$strict>], "action">>>;
+        toolCallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        reconnect: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"update">;
+    id: z.ZodString;
+    revision: z.ZodString;
+    config: z.ZodObject<{
+        serverName: z.ZodString;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            "streamable-http": "streamable-http";
+        }>;
+        command: z.ZodDefault<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"keep">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"remove">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"value">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"env">;
+            value: z.ZodString;
+        }, z.core.$strict>], "action">>>;
+        toolCallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        reconnect: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"delete">;
+    id: z.ZodString;
+    revision: z.ZodString;
+    confirm: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"enable">;
+    id: z.ZodString;
+    revision: z.ZodString;
+    enabled: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"policy">;
+    name: z.ZodString;
+    revision: z.ZodString;
+    enabled: z.ZodBoolean;
+    selection: z.ZodObject<{
+        workspaceId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"probe">;
+    id: z.ZodString;
+    revision: z.ZodString;
+    confirm: z.ZodLiteral<true>;
+}, z.core.$strict>], "kind">;
+export type Mutation = z.infer<typeof mutationSchema>;
+export declare const toolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    output: z.ZodNullable<z.ZodUnknown>;
+    source: z.ZodEnum<{
+        unknown: "unknown";
+        mcp: "mcp";
+        plugin: "plugin";
+        core: "core";
+    }>;
+    owner: z.ZodNullable<z.ZodString>;
+    visible: z.ZodNullable<z.ZodBoolean>;
+    allowed: z.ZodBoolean;
+    protected: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const serverSchema: z.ZodObject<{
+    id: z.ZodString;
+    serverName: z.ZodString;
+    scope: z.ZodString;
+    origin: z.ZodEnum<{
+        managed: "managed";
+        profile: "profile";
+        preset: "preset";
+    }>;
+    transport: z.ZodString;
+    enabled: z.ZodBoolean;
+    phase: z.ZodNullable<z.ZodString>;
+    toolCount: z.ZodNullable<z.ZodNumber>;
+    editable: z.ZodBoolean;
+    toggleable: z.ZodBoolean;
+    config: z.ZodNullable<z.ZodObject<{
+        serverName: z.ZodString;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            "streamable-http": "streamable-http";
+        }>;
+        command: z.ZodDefault<z.ZodString>;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+        secrets: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"keep">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"remove">;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"value">;
+            value: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            key: z.ZodString;
+            action: z.ZodLiteral<"env">;
+            value: z.ZodString;
+        }, z.core.$strict>], "action">>>;
+        toolCallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        reconnect: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    credentialKeys: z.ZodArray<z.ZodString>;
+    tested: z.ZodNullable<z.ZodObject<{
+        ok: z.ZodBoolean;
+        at: z.ZodString;
+        durationMs: z.ZodNumber;
+        toolCount: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const stateSchema: z.ZodObject<{
+    profile: z.ZodString;
+    patchRevision: z.ZodString;
+    policyRevision: z.ZodString;
+    workspaceId: z.ZodString;
+    workspaces: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        cwd: z.ZodString;
+    }, z.core.$strip>>;
+    selectedSessionId: z.ZodNullable<z.ZodString>;
+    scopeKind: z.ZodEnum<{
+        preset: "preset";
+        live: "live";
+        global: "global";
+    }>;
+    presetId: z.ZodNullable<z.ZodString>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        output: z.ZodNullable<z.ZodUnknown>;
+        source: z.ZodEnum<{
+            unknown: "unknown";
+            mcp: "mcp";
+            plugin: "plugin";
+            core: "core";
+        }>;
+        owner: z.ZodNullable<z.ZodString>;
+        visible: z.ZodNullable<z.ZodBoolean>;
+        allowed: z.ZodBoolean;
+        protected: z.ZodBoolean;
+    }, z.core.$strip>>;
+    servers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        serverName: z.ZodString;
+        scope: z.ZodString;
+        origin: z.ZodEnum<{
+            managed: "managed";
+            profile: "profile";
+            preset: "preset";
+        }>;
+        transport: z.ZodString;
+        enabled: z.ZodBoolean;
+        phase: z.ZodNullable<z.ZodString>;
+        toolCount: z.ZodNullable<z.ZodNumber>;
+        editable: z.ZodBoolean;
+        toggleable: z.ZodBoolean;
+        config: z.ZodNullable<z.ZodObject<{
+            serverName: z.ZodString;
+            transport: z.ZodEnum<{
+                stdio: "stdio";
+                "streamable-http": "streamable-http";
+            }>;
+            command: z.ZodDefault<z.ZodString>;
+            args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            cwd: z.ZodDefault<z.ZodString>;
+            url: z.ZodDefault<z.ZodString>;
+            secrets: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                key: z.ZodString;
+                action: z.ZodLiteral<"keep">;
+            }, z.core.$strict>, z.ZodObject<{
+                key: z.ZodString;
+                action: z.ZodLiteral<"remove">;
+            }, z.core.$strict>, z.ZodObject<{
+                key: z.ZodString;
+                action: z.ZodLiteral<"value">;
+                value: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                key: z.ZodString;
+                action: z.ZodLiteral<"env">;
+                value: z.ZodString;
+            }, z.core.$strict>], "action">>>;
+            toolCallTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            reconnect: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        credentialKeys: z.ZodArray<z.ZodString>;
+        tested: z.ZodNullable<z.ZodObject<{
+            ok: z.ZodBoolean;
+            at: z.ZodString;
+            durationMs: z.ZodNumber;
+            toolCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    notices: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type State = z.infer<typeof stateSchema>;
+export type ToolItem = z.infer<typeof toolSchema>;
+export type ServerItem = z.infer<typeof serverSchema>;
+export declare const outcomeSchema: z.ZodObject<{
+    application: z.ZodEnum<{
+        tested: "tested";
+        applied: "applied";
+        "restart-required": "restart-required";
+        overridden: "overridden";
+        failed: "failed";
+    }>;
+    notice: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Outcome = z.infer<typeof outcomeSchema>;