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

package/lib/controller.d.ts

@@ -0,0 +1,19 @@
+/** Serial profile edits, cancellable observations/probes and official reconciliation. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Mutation, Outcome, Selection, State } from './shared.ts';
+import { ToolPolicy } from './policy.ts';
+export declare class McpManager {
+    private ctx;
+    readonly policy: ToolPolicy;
+    private tail;
+    private closing;
+    private abort;
+    private reads;
+    private tests;
+    constructor(ctx: Context);
+    start(): Promise<void>;
+    private observe;
+    state(selection: Selection, signal?: AbortSignal): Promise<State>;
+    mutate(operation: Mutation, signal?: AbortSignal): Promise<Outcome>;
+    dispose(): Promise<void>;
+}

package/lib/controller.js

@@ -0,0 +1,178 @@
+import { readProfilePatches, reconcileProfilePatches } from '@deepseek-ai/dsh-app-boot';
+import { withFileLock } from '@deepseek-ai/dsh-atomic-write';
+import { randomUUID } from 'node:crypto';
+import { isMap, isSeq } from 'yaml';
+import { MCP } from "./shared.js";
+import { commit, document, hash, ManagerError, readOwnedFile, replaceBlock, rowsIn } from "./storage.js";
+import { appendRow, rawManaged, serverRecords, writeConfig } from "./servers.js";
+import { ToolPolicy } from "./policy.js";
+import { directory, selectionView, withToolView } from "./view.js";
+import { probe } from "./probe.js";
+export class McpManager {
+    ctx;
+    policy;
+    tail = Promise.resolve();
+    closing = false;
+    abort = new AbortController();
+    reads = new Set();
+    tests = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.policy = new ToolPolicy(ctx, ctx.profileContext.dir);
+    }
+    async start() {
+        await this.policy.start();
+    }
+    observe(signal, action) {
+        if (this.closing)
+            return Promise.reject(new ManagerError('Plugin is unloading', 503));
+        const task = action(signal ? AbortSignal.any([signal, this.abort.signal]) : this.abort.signal);
+        this.reads.add(task);
+        void task.then(() => this.reads.delete(task), () => this.reads.delete(task));
+        return task;
+    }
+    state(selection, signal) {
+        return this.observe(signal, async (signal) => {
+            await this.policy.refresh();
+            const selected = await selectionView(this.ctx, selection, signal);
+            return await withToolView(this.ctx, selected.selectedSessionId, signal, async (view) => {
+                this.policy.scan();
+                const text = await readOwnedFile(this.ctx.profileContext.patchPath), records = await serverRecords(this.ctx, text);
+                return {
+                    profile: this.ctx.profileContext.name,
+                    patchRevision: hash(text),
+                    policyRevision: this.policy.revision,
+                    ...selected,
+                    scopeKind: view.kind,
+                    presetId: view.presetId,
+                    tools: directory(this.ctx, view, records, this.policy),
+                    servers: records.map((record) => ({
+                        ...record.item,
+                        tested: this.tests.get(hash(`${record.item.id}\0${JSON.stringify(record.raw)}`)) ?? null
+                    })),
+                    notices: view.kind === 'global'
+                        ? ['Only the global registry is observed; session visibility is unknown']
+                        : view.kind === 'preset'
+                            ? ['Current preset definition is observed; no Agent was created']
+                            : []
+                };
+            });
+        });
+    }
+    mutate(operation, signal) {
+        if (this.closing)
+            return Promise.reject(new ManagerError('Plugin is unloading', 503));
+        const task = this.tail.then(async () => {
+            if (this.closing)
+                throw new ManagerError('Plugin is unloading', 503);
+            if (operation.kind === 'policy') {
+                const state = await this.state(operation.selection, signal);
+                if (!state.tools.some((tool) => tool.name === operation.name))
+                    throw new ManagerError('Tool no longer exists in this view', 409);
+                await this.policy.set(operation.name, operation.enabled, operation.revision);
+                return { application: 'applied' };
+            }
+            if (operation.kind === 'probe')
+                return await this.observe(signal, async (signal) => {
+                    const text = await readOwnedFile(this.ctx.profileContext.patchPath);
+                    if (hash(text) !== operation.revision)
+                        throw new ManagerError('Configuration changed; refresh and retry', 409);
+                    const entry = (await serverRecords(this.ctx, text)).find((r) => r.item.id === operation.id);
+                    if (!entry)
+                        throw new ManagerError('MCP entry no longer exists', 404);
+                    const raw = entry.patchId ? rawManaged(text, entry.patchId) : entry.raw;
+                    const outcome = await probe(raw, signal);
+                    this.tests.set(hash(`${entry.item.id}\0${JSON.stringify(entry.raw)}`), outcome);
+                    return {
+                        application: 'tested',
+                        notice: outcome.ok
+                            ? 'Independent connection test succeeded'
+                            : 'Independent connection test failed; check configuration and local DSH diagnostics'
+                    };
+                });
+            if (operation.kind === 'enable') {
+                const text = await readOwnedFile(this.ctx.profileContext.patchPath);
+                if (hash(text) !== operation.revision)
+                    throw new ManagerError('Configuration changed; refresh and retry', 409);
+                const entry = (await serverRecords(this.ctx, text)).find((r) => r.item.id === operation.id);
+                const official = (await this.ctx.pluginManager.listPlugins()).find((r) => r.entryId === entry?.entry?.id);
+                if (!entry?.item.toggleable || !official)
+                    throw new ManagerError('Entry is controlled by its configuration source', 409);
+                const result = await this.ctx.pluginManager.setPluginEnabled(official.entryId, operation.enabled);
+                return {
+                    application: result.application === 'cancelled' ? 'failed' : result.application,
+                    ...(result.error ? { notice: 'Official plugin manager could not apply this change' } : {})
+                };
+            }
+            return await withFileLock(`${this.ctx.profileContext.dir}/package.json`, async () => {
+                const action = async () => {
+                    const path = this.ctx.profileContext.patchPath, text = await readOwnedFile(path);
+                    if (hash(text) !== operation.revision)
+                        throw new ManagerError('Configuration changed; refresh and retry', 409);
+                    const entries = await serverRecords(this.ctx, text);
+                    let body;
+                    if (operation.kind === 'create') {
+                        if (entries.some((r) => r.item.scope === 'profile' && r.item.serverName === operation.config.serverName))
+                            throw new ManagerError('Server namespace already exists', 409);
+                        body = appendRow(text, `libing-mcp-${randomUUID()}`, operation.config);
+                    }
+                    else {
+                        const entry = entries.find((r) => r.item.id === operation.id);
+                        if (!entry?.patchId || !entry.item.editable)
+                            throw new ManagerError('This configuration is read-only', 409);
+                        if (entry.item.enabled)
+                            throw new ManagerError('Disable the service before editing or deleting its configuration', 409);
+                        if (operation.kind === 'update' &&
+                            operation.config.serverName !== entry.item.serverName)
+                            throw new ManagerError('Server namespace cannot be changed; create a new service');
+                        const { doc, rows } = rowsIn(text), index = rows?.items.findIndex((r) => isMap(r) && r.get('id') === entry.patchId) ?? -1;
+                        if (!rows || index < 0)
+                            throw new ManagerError('Managed entry changed', 409);
+                        if (operation.kind === 'update')
+                            writeConfig(doc, [0, 'insert', index, 'config'], operation.config);
+                        else
+                            rows.delete(index);
+                        body = String(doc);
+                        if (operation.kind === 'delete') {
+                            // Check external rows before removing our insertion.
+                            const block = replaceBlock(text, body), outer = document(block);
+                            if (!isSeq(outer.contents))
+                                throw new ManagerError('Invalid patch');
+                            const foreign = outer.contents.items.filter((item) => isMap(item) && item.get('id') === entry.patchId);
+                            if (foreign.some((item) => (isMap(item) &&
+                                item.items.some((pair) => !['id', 'name', 'disabled'].includes(String(pair.key)))) ||
+                                (isMap(item) && item.has('name') && item.get('name') !== MCP)))
+                                throw new ManagerError('External override exists; remove it at its source first', 409);
+                            // AST serialization only for removing official overrides would change foreign bytes;
+                            // refuse instead of rewriting them. A disabled override is harmless after removal.
+                        }
+                    }
+                    await commit(path, text, replaceBlock(text, body));
+                    const hmr = this.ctx.get('hmr');
+                    if (!hmr)
+                        return { application: 'restart-required' };
+                    try {
+                        await reconcileProfilePatches(this.ctx.root, readProfilePatches('dsh', this.ctx.profileContext), 'dsh');
+                        return { application: 'applied' };
+                    }
+                    catch {
+                        return {
+                            application: 'failed',
+                            notice: 'Configuration saved, but the official loader could not apply it; refresh or restart DSH'
+                        };
+                    }
+                };
+                const hmr = this.ctx.get('hmr');
+                return hmr ? await hmr.runExclusive(action) : await action();
+            }, { waitMs: 10000 });
+        });
+        this.tail = task.catch(() => { });
+        return task;
+    }
+    async dispose() {
+        this.closing = true;
+        this.abort.abort();
+        await Promise.allSettled([this.tail, ...this.reads]);
+        this.policy.dispose();
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+/** Connection owns authentication and origin checks; this context owns all routes. */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "libing-mcp-manager";
+export declare const inject: string[];
+export declare function apply(ctx: Context): Promise<void>;

package/lib/index.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { McpManager } from "./controller.js";
+import { API, mutationSchema, selectionSchema } from "./shared.js";
+import { ManagerError, message } from "./storage.js";
+export const name = 'libing-mcp-manager';
+export const inject = [
+    'connection',
+    'tools',
+    'sessionQuery',
+    'pluginManager',
+    'profileContext',
+    'loader'
+];
+export async function apply(ctx) {
+    const manager = new McpManager(ctx);
+    ctx.effect(() => () => manager.dispose(), 'libing-mcp-manager: operations');
+    await manager.start();
+    const route = (path, method, action) => ctx.effect(() => ctx.connection.fetch.register({
+        path: `${API}/${path}`,
+        methods: [method],
+        requestBody: 'buffered',
+        fetch: async (request) => {
+            try {
+                return Response.json(await action(request), {
+                    headers: { 'cache-control': 'no-store' }
+                });
+            }
+            catch (error) {
+                return Response.json({ error: message(error) }, {
+                    status: error instanceof ManagerError
+                        ? error.status
+                        : error instanceof z.ZodError || error instanceof SyntaxError
+                            ? 400
+                            : 500,
+                    headers: { 'cache-control': 'no-store' }
+                });
+            }
+        }
+    }), `libing-mcp-manager: ${path}`);
+    route('state', 'GET', async (request) => {
+        const entries = [...new URL(request.url).searchParams];
+        if (new Set(entries.map(([key]) => key)).size !== entries.length)
+            throw new ManagerError('Duplicate query parameter');
+        return await manager.state(selectionSchema.parse(Object.fromEntries(entries)), request.signal);
+    });
+    route('mutate', 'POST', async (request) => {
+        if (request.headers.get('content-type')?.split(';')[0]?.trim() !== 'application/json')
+            throw new ManagerError('Expected application/json', 415);
+        const bytes = await request.arrayBuffer();
+        if (bytes.byteLength > 65536)
+            throw new ManagerError('Request exceeds byte limit', 413);
+        return await manager.mutate(mutationSchema.parse(JSON.parse(new TextDecoder().decode(bytes))), request.signal);
+    });
+}

package/lib/policy.d.ts

@@ -0,0 +1,19 @@
+/** Profile-wide monotonic denial; no mutation of a ToolRuntime's private registry. */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const protectedTool: (name: string) => name is "run_code" | "respond";
+export declare class ToolPolicy {
+    private ctx;
+    private denied;
+    private raw;
+    private disposers;
+    private closing;
+    readonly file: string;
+    constructor(ctx: Context, dir: string);
+    start(): Promise<void>;
+    scan(): void;
+    allowed(name: string): boolean;
+    get revision(): string;
+    refresh(): Promise<void>;
+    set(name: string, enabled: boolean, revision: string): Promise<void>;
+    dispose(): void;
+}

package/lib/policy.js

@@ -0,0 +1,99 @@
+import ToolRuntime from '@deepseek-ai/dsh-tools';
+import { z } from 'zod';
+import { join } from 'node:path';
+import { withFileLock } from '@deepseek-ai/dsh-atomic-write';
+import { commit, hash, ManagerError, readOwnedFile } from "./storage.js";
+export const protectedTool = (name) => name === 'run_code' || name === 'respond';
+const schema = z.object({ denied: z.array(z.string().min(1).max(512)).max(10000) }).strict();
+export class ToolPolicy {
+    ctx;
+    denied = new Set();
+    raw = '';
+    disposers = new Map();
+    closing = false;
+    file;
+    constructor(ctx, dir) {
+        this.ctx = ctx;
+        this.file = join(dir, 'libing-tool-policy.json');
+    }
+    async start() {
+        await this.refresh();
+        this.scan();
+        // A Service announces itself during super(), before its fields initialize.
+        this.ctx.on('internal/service', (name) => {
+            if (name === 'tools')
+                queueMicrotask(() => {
+                    if (!this.closing)
+                        this.scan();
+                });
+        }, { global: true });
+        // Covers a synchronously published service before its queued observer, and
+        // installs guards before the registry performs its monotonic guard stage.
+        this.ctx.on('tools/pre-execute', async (exec, next) => {
+            this.scan();
+            return this.allowed(exec.name)
+                ? await next()
+                : { kind: 'deny', reason: 'Disabled in LiBing MCP Center' };
+        }, { global: true, prepend: true });
+    }
+    scan() {
+        const current = new Set();
+        for (const key of Object.getOwnPropertySymbols(this.ctx.reflect.store)) {
+            const value = this.ctx.reflect.store[key]?.value;
+            if (!(value instanceof ToolRuntime))
+                continue;
+            current.add(value);
+            if (this.disposers.has(value))
+                continue;
+            const owned = this.ctx.reflect.trace(value);
+            const dispose = owned.guard((exec) => this.allowed(exec.name) ? undefined : 'Disabled in LiBing MCP Center');
+            this.disposers.set(value, dispose);
+        }
+        for (const [runtime, dispose] of this.disposers)
+            if (!current.has(runtime)) {
+                dispose();
+                this.disposers.delete(runtime);
+            }
+    }
+    allowed(name) {
+        return !this.denied.has(name);
+    }
+    get revision() {
+        return hash(this.raw);
+    }
+    async refresh() {
+        await withFileLock(this.file, async () => {
+            const raw = await readOwnedFile(this.file), rules = schema.parse(raw ? JSON.parse(raw) : { denied: [] });
+            if (rules.denied.some(protectedTool))
+                throw new ManagerError('Policy cannot deny internal orchestration tools', 409);
+            this.raw = raw;
+            this.denied = new Set(rules.denied);
+        });
+    }
+    async set(name, enabled, revision) {
+        if (protectedTool(name))
+            throw new ManagerError('Internal orchestration tools are protected');
+        return await withFileLock(this.file, async () => {
+            if (this.closing)
+                throw new ManagerError('Plugin is unloading', 503);
+            const before = await readOwnedFile(this.file);
+            if (hash(before) !== revision || before !== this.raw)
+                throw new ManagerError('Policy changed; refresh and retry', 409);
+            const next = new Set(this.denied);
+            if (enabled)
+                next.delete(name);
+            else
+                next.add(name);
+            const raw = JSON.stringify({ denied: [...next].sort() }, null, 2) + '\n';
+            await commit(this.file, before, raw);
+            this.raw = raw;
+            this.denied = next;
+        });
+    }
+    dispose() {
+        this.closing = true;
+        for (const dispose of this.disposers.values())
+            dispose();
+        this.disposers.clear();
+    }
+}

package/lib/probe.d.ts

@@ -0,0 +1,2 @@
+import type { ServerItem } from './shared.ts';
+export declare function probe(raw: Record<string, unknown>, signal: AbortSignal, budget?: number): Promise<NonNullable<ServerItem['tested']>>;

package/lib/probe.js

@@ -0,0 +1,58 @@
+/** Explicit, independent initialize/listTools probe, with one bounded lifetime. */
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
+import { scrubbedParentEnv } from '@deepseek-ai/dsh-subprocess';
+import { resolvedConfig } from "./servers.js";
+export async function probe(raw, signal, budget = 8000) {
+    const config = resolvedConfig(raw), start = Date.now(), abort = AbortSignal.any([signal, AbortSignal.timeout(budget)]);
+    abort.throwIfAborted();
+    const client = new Client({ name: 'libing-mcp-probe', version: '0.1.0' }, { capabilities: {} });
+    const transport = config.transport === 'stdio'
+        ? new StdioClientTransport({
+            command: config.command,
+            args: config.args,
+            cwd: config.cwd,
+            env: { ...scrubbedParentEnv(), ...config.credentials },
+            stderr: 'ignore'
+        })
+        : new StreamableHTTPClientTransport(new URL(config.url), {
+            requestInit: { headers: config.credentials, signal: abort }
+        });
+    let stopped;
+    const close = () => (stopped ??= (async () => {
+        await transport.close().catch(() => { });
+        await client.close().catch(() => { });
+    })());
+    const stop = () => {
+        void close();
+    };
+    abort.addEventListener('abort', stop, { once: true });
+    let rejectAbort;
+    const aborted = new Promise((_, reject) => {
+        rejectAbort = reject;
+    });
+    const reject = () => rejectAbort?.(abort.reason);
+    abort.addEventListener('abort', reject, { once: true });
+    const work = (async () => {
+        await client.connect(transport);
+        return await client.listTools();
+    })();
+    try {
+        const tools = await Promise.race([work, aborted]);
+        return {
+            ok: true,
+            at: new Date().toISOString(),
+            durationMs: Date.now() - start,
+            toolCount: tools.tools.length
+        };
+    }
+    catch {
+        return { ok: false, at: new Date().toISOString(), durationMs: Date.now() - start };
+    }
+    finally {
+        abort.removeEventListener('abort', stop);
+        abort.removeEventListener('abort', reject);
+        await close();
+        await work.catch(() => { });
+    }
+}

package/lib/providers.d.ts

@@ -0,0 +1,3 @@
+export declare const declaredProviders: Readonly<Record<string, readonly string[]>>;
+/** Official delegation and workflow plugins support a configurable toolName. */
+export declare function declaresTool(owner: string, config: unknown, name: string): boolean;

package/lib/providers.js

@@ -0,0 +1,75 @@
+/** Tool contracts verified against the installed DSH 0.2.0-rc.2 packages.
+ * A name is only a candidate: view.ts also checks the active entry, service,
+ * scope and exact resolved definition. Unknown third-party names stay unknown.
+ */
+const contracts = {
+    '@deepseek-ai/dsh-tool-ask-user': ['ask_user_question'],
+    '@deepseek-ai/dsh-tool-bash': ['bash'],
+    '@deepseek-ai/dsh-tool-bash-persistent': ['bash'],
+    '@deepseek-ai/dsh-tool-pwsh': ['pwsh'],
+    '@deepseek-ai/dsh-tool-pwsh-persistent': ['pwsh'],
+    '@deepseek-ai/dsh-tool-fs': ['edit', 'read', 'read_image', 'write'],
+    '@deepseek-ai/dsh-tool-fs-search': ['glob', 'grep'],
+    '@deepseek-ai/dsh-tool-jobs': ['job_kill', 'job_list', 'job_output'],
+    '@deepseek-ai/dsh-tool-skill': ['skill'],
+    '@deepseek-ai/dsh-tool-todo': ['todo_write'],
+    '@deepseek-ai/dsh-tool-goal': ['create_goal', 'get_goal', 'update_goal'],
+    '@deepseek-ai/dsh-tool-web': ['web_fetch', 'web_search'],
+    '@deepseek-ai/dsh-tool-cordis': ['cordis_inspect_list', 'cordis_inspect_query'],
+    '@deepseek-ai/dsh-tool-present': ['present'],
+    '@deepseek-ai/dsh-tool-ralph': ['ralph'],
+    '@deepseek-ai/dsh-tool-str-replace-editor': ['str_replace_editor'],
+    '@deepseek-ai/dsh-tool-workspace-dependencies': ['load_workspace_dependencies'],
+    '@deepseek-ai/dsh-tool-subagent': ['list_subagent_models'],
+    '@deepseek-ai/dsh-tool-subagent-control': ['interrupt_agent', 'send_message'],
+    '@deepseek-ai/dsh-tool-subagent-control/list-agents': ['list_agents'],
+    '@deepseek-ai/dsh-experimental-tool-agent-team': [
+        'interrupt_agent',
+        'list_agents',
+        'send_message',
+        'spawn_teammate',
+        'team_task_create',
+        'team_task_get',
+        'team_task_list',
+        'team_task_update',
+        'wait_agent'
+    ],
+    '@deepseek-ai/dsh-plan-mode': ['exit_plan_mode'],
+    '@deepseek-ai/dsh-schedule': [
+        'schedule_create',
+        'schedule_delete',
+        'schedule_list',
+        'schedule_update'
+    ],
+    '@dsh-libing/hello': ['libing_hello'],
+    '@dsh-libing/knowledge-base': [
+        'libing_kb_search',
+        'libing_kb_build',
+        'libing_kb_catalog',
+        'libing_kb_job',
+        'libing_kb_read_image',
+        'libing_kb_read'
+    ]
+};
+export const declaredProviders = Object.fromEntries([...new Set(Object.values(contracts).flat())].map((name) => [
+    name,
+    Object.entries(contracts)
+        .filter(([, names]) => names.includes(name))
+        .map(([owner]) => owner)
+]));
+/** Official delegation and workflow plugins support a configurable toolName. */
+export function declaresTool(owner, config, name) {
+    if (declaredProviders[name]?.includes(owner))
+        return true;
+    const defaultName = owner === '@deepseek-ai/dsh-tool-subagent'
+        ? 'subagent'
+        : owner === '@deepseek-ai/dsh-tool-workflow'
+            ? 'workflow'
+            : undefined;
+    if (defaultName === undefined)
+        return false;
+    const toolName = typeof config === 'object' && config !== null && 'toolName' in config
+        ? config.toolName
+        : undefined;
+    return name === (typeof toolName === 'string' ? toolName : defaultName);
+}

package/lib/servers.d.ts

@@ -0,0 +1,24 @@
+/** MCP identity is a scope plus entry, never just a server namespace. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Entry } from '@deepseek-ai/cordis-plugin-loader';
+import type { ScopeKey } from '@deepseek-ai/dsh-scope';
+import type { ServerConfig, ServerItem } from './shared.ts';
+import { document } from './storage.ts';
+export interface ServerRecord {
+    item: ServerItem;
+    entry?: Entry;
+    patchId?: string;
+    scopeKey?: ScopeKey;
+    raw: Record<string, unknown>;
+}
+export declare function record(value: unknown): Record<string, unknown>;
+export declare function publicConfig(raw: Record<string, unknown>): ServerConfig | null;
+export declare function serverRecords(ctx: Context, text: string): Promise<ServerRecord[]>;
+/** Keep secret nodes by default. Only constrained generated references use !!js. */
+export declare function writeConfig(node: ReturnType<typeof document>, path: (string | number)[], config: ServerConfig): void;
+/** Resolve only literal values or the exact ENV expression this editor emits. */
+export declare function resolvedConfig(raw: Record<string, unknown>): ServerConfig & {
+    credentials: Record<string, string>;
+};
+export declare function rawManaged(text: string, id: string): Record<string, unknown>;
+export declare function appendRow(text: string, id: string, config: ServerConfig): string;