@khorsheed/dsh-capability-catalog 0.1.95

package/lib/types/capabilities.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The capability FINGERPRINT: a canonical form of a catalog snapshot, and the
+ * sha256 over it.
+ *
+ * A catalog snapshot is a listing — ordered by registration, worded for a
+ * human, stamped with file mtimes. None of that is the capability face. Two
+ * instances that register the same tools in a different order have the same
+ * capabilities; an instance whose tool description was reworded has the same
+ * capabilities; an instance whose tool gained a parameter does NOT. This
+ * module decides which of those differences count, so a condition document
+ * can claim `preset: X` and something can check the claim instead of
+ * believing it.
+ *
+ * What enters the fingerprint, and why:
+ *
+ * | Row | Fields | Left out |
+ * |---|---|---|
+ * | skill | `name`, `source`, `body` (sha256 of SKILL.md) | `description`, `whenToUse`, `provider`, `updatedAt` |
+ * | tool | `name`, `channel`, `parameters` | `description`, `confidence`, `owner` |
+ * | mcpServer | `name`, `tools` (its tool names) | tool count (derived) |
+ * | channel | the names | the counts (derived from the rows) |
+ *
+ * The exclusions are deliberate and each one is a claim: **prose is not a
+ * capability**. Rewording a tool description, or a skill's routing blurb,
+ * changes what the model reads but not what it can do — and a factor that
+ * moves when someone fixes a typo is a factor nobody can hold still across a
+ * run. A skill's BODY is the opposite: it is the procedure the model
+ * executes, so it enters as a sha. `updatedAt` is a filesystem fact, not a
+ * capability: touching a file must not mint a new subject.
+ *
+ * Determinism is the whole product. Every list is sorted by name, and the
+ * digest is taken over canonical JSON (sorted keys, no whitespace), so the
+ * same capability face hashes the same on two machines and in two processes.
+ * @module @khorsheed/dsh-capability-catalog/capabilities
+ */
+import type { CapabilityCatalogSnapshot, CatalogJsonValue } from './types.ts';
+/** Prefix of the human-facing capability tag (`caps:<sha256>`). */
+export declare const CAPS_TAG_PREFIX = "caps:";
+/** One skill as the fingerprint sees it. */
+export interface CanonicalSkill {
+    readonly name: string;
+    readonly source: string;
+    /** sha256 of the SKILL.md body, or null when the skill has no readable body. */
+    readonly body: string | null;
+}
+/** One tool as the fingerprint sees it. */
+export interface CanonicalTool {
+    readonly name: string;
+    readonly channel: string;
+    /** The model-facing parameter schema, or null when the tool declares none. */
+    readonly parameters: CatalogJsonValue | null;
+}
+/** One MCP server as the fingerprint sees it. */
+export interface CanonicalMcpServer {
+    readonly name: string;
+    /** The server's tool names, sorted. */
+    readonly tools: readonly string[];
+}
+/** The canonical capability face of one snapshot. */
+export interface CanonicalCapabilities {
+    readonly skills: readonly CanonicalSkill[];
+    readonly tools: readonly CanonicalTool[];
+    readonly mcpServers: readonly CanonicalMcpServer[];
+    readonly channels: readonly string[];
+}
+/**
+ * Canonical JSON: object keys sorted (code-unit order), no whitespace, arrays
+ * in document order. Two documents differing only in key order canonicalize
+ * alike.
+ *
+ * Deliberately duplicated rather than imported from `@khorsheed/dsh-eval`:
+ * community plugins never depend on siblings, and the two copies are pinned
+ * against each other by the eval contract tests that consume a `caps:` tag.
+ * @param value - any JSON value.
+ * @returns its canonical serialization.
+ */
+export declare function canonicalJson(value: unknown): string;
+/**
+ * Project a snapshot onto its canonical capability face.
+ *
+ * Pure and total: it reads nothing but the snapshot, and a row missing an
+ * optional field contributes `null` rather than disappearing — a tool with no
+ * parameter schema is a different capability from one whose schema is `{}`,
+ * and both are different from the tool being absent.
+ * @param snapshot - a catalog snapshot (its own `sha` field, if any, is ignored).
+ * @returns the canonical form the digest is taken over.
+ */
+export declare function canonicalCapabilities(snapshot: CapabilityCatalogSnapshot): CanonicalCapabilities;
+/**
+ * The capability hash: sha256 hex of the canonical form's canonical JSON.
+ * @param snapshot - a catalog snapshot.
+ * @returns the 64-hex digest.
+ */
+export declare function hashOf(snapshot: CapabilityCatalogSnapshot): string;
+/**
+ * The human-facing tag form of a capability hash.
+ * @param sha - a sha256 hex digest (or the hash of a snapshot).
+ * @returns `caps:<sha>`.
+ */
+export declare function capsTag(sha: string): string;
+/** sha256 hex of a skill body, the form {@link CanonicalSkill.body} carries. */
+export declare function hashSkillBody(content: string): string;
+//# sourceMappingURL=capabilities.d.ts.map

package/lib/types/capabilities.js

@@ -0,0 +1,116 @@
+/**
+ * The capability FINGERPRINT: a canonical form of a catalog snapshot, and the
+ * sha256 over it.
+ *
+ * A catalog snapshot is a listing — ordered by registration, worded for a
+ * human, stamped with file mtimes. None of that is the capability face. Two
+ * instances that register the same tools in a different order have the same
+ * capabilities; an instance whose tool description was reworded has the same
+ * capabilities; an instance whose tool gained a parameter does NOT. This
+ * module decides which of those differences count, so a condition document
+ * can claim `preset: X` and something can check the claim instead of
+ * believing it.
+ *
+ * What enters the fingerprint, and why:
+ *
+ * | Row | Fields | Left out |
+ * |---|---|---|
+ * | skill | `name`, `source`, `body` (sha256 of SKILL.md) | `description`, `whenToUse`, `provider`, `updatedAt` |
+ * | tool | `name`, `channel`, `parameters` | `description`, `confidence`, `owner` |
+ * | mcpServer | `name`, `tools` (its tool names) | tool count (derived) |
+ * | channel | the names | the counts (derived from the rows) |
+ *
+ * The exclusions are deliberate and each one is a claim: **prose is not a
+ * capability**. Rewording a tool description, or a skill's routing blurb,
+ * changes what the model reads but not what it can do — and a factor that
+ * moves when someone fixes a typo is a factor nobody can hold still across a
+ * run. A skill's BODY is the opposite: it is the procedure the model
+ * executes, so it enters as a sha. `updatedAt` is a filesystem fact, not a
+ * capability: touching a file must not mint a new subject.
+ *
+ * Determinism is the whole product. Every list is sorted by name, and the
+ * digest is taken over canonical JSON (sorted keys, no whitespace), so the
+ * same capability face hashes the same on two machines and in two processes.
+ * @module @khorsheed/dsh-capability-catalog/capabilities
+ */
+import { createHash } from 'node:crypto';
+/** Prefix of the human-facing capability tag (`caps:<sha256>`). */
+export const CAPS_TAG_PREFIX = 'caps:';
+/**
+ * Canonical JSON: object keys sorted (code-unit order), no whitespace, arrays
+ * in document order. Two documents differing only in key order canonicalize
+ * alike.
+ *
+ * Deliberately duplicated rather than imported from `@khorsheed/dsh-eval`:
+ * community plugins never depend on siblings, and the two copies are pinned
+ * against each other by the eval contract tests that consume a `caps:` tag.
+ * @param value - any JSON value.
+ * @returns its canonical serialization.
+ */
+export function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value) ?? 'null';
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    const obj = value;
+    return `{${Object.keys(obj).sort().map(key => `${JSON.stringify(key)}:${canonicalJson(obj[key])}`).join(',')}}`;
+}
+/** Sort by `name`, code-unit order (the one ordering rule of this module). */
+function byName(rows) {
+    return [...rows].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/**
+ * Project a snapshot onto its canonical capability face.
+ *
+ * Pure and total: it reads nothing but the snapshot, and a row missing an
+ * optional field contributes `null` rather than disappearing — a tool with no
+ * parameter schema is a different capability from one whose schema is `{}`,
+ * and both are different from the tool being absent.
+ * @param snapshot - a catalog snapshot (its own `sha` field, if any, is ignored).
+ * @returns the canonical form the digest is taken over.
+ */
+export function canonicalCapabilities(snapshot) {
+    const tools = byName(snapshot.tools);
+    return {
+        skills: byName(snapshot.skills).map(skill => ({
+            name: skill.name,
+            source: skill.source,
+            body: skill.bodySha ?? null,
+        })),
+        tools: tools.map(tool => ({
+            name: tool.name,
+            channel: tool.channel,
+            parameters: tool.parameters ?? null,
+        })),
+        // The server's tool NAMES, not its tool count: a server that swapped one
+        // tool for another keeps its count and changes its capability face.
+        mcpServers: byName(snapshot.mcpServers).map(server => ({
+            name: server.name,
+            tools: tools.filter(tool => tool.serverName === server.name).map(tool => tool.name),
+        })),
+        // Names only — the counts are derived from the rows above, and a summary
+        // that disagreed with them would make the digest depend on which of the
+        // two was right.
+        channels: [...snapshot.channels].map(channel => channel.channel).sort(),
+    };
+}
+/**
+ * The capability hash: sha256 hex of the canonical form's canonical JSON.
+ * @param snapshot - a catalog snapshot.
+ * @returns the 64-hex digest.
+ */
+export function hashOf(snapshot) {
+    return createHash('sha256').update(canonicalJson(canonicalCapabilities(snapshot))).digest('hex');
+}
+/**
+ * The human-facing tag form of a capability hash.
+ * @param sha - a sha256 hex digest (or the hash of a snapshot).
+ * @returns `caps:<sha>`.
+ */
+export function capsTag(sha) {
+    return `${CAPS_TAG_PREFIX}${sha}`;
+}
+/** sha256 hex of a skill body, the form {@link CanonicalSkill.body} carries. */
+export function hashSkillBody(content) {
+    return createHash('sha256').update(content, 'utf8').digest('hex');
+}

package/lib/types/channels.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tool channel attribution and skill source labels.
+ *
+ * Tools have no source field on `ToolDefinition`, so the catalog infers the
+ * channel from three signals (see the proposal "工具归因" section):
+ *   1. the `mcp__` prefix (exact),
+ *   2. the generated official-tools whitelist (exact),
+ *   3. baseline-diff inference (`builtin?` / `plugin`).
+ *
+ * MCP serverName is resolved by longest-match: the mcp-client server-name
+ * charset permits underscores (`[A-Za-z0-9_-]{1,32}`), so `mcp__a__b__tool`
+ * could belong to server `a` or `a__b`; the longest configured prefix that
+ * leaves a non-empty raw tool name wins.
+ * @module @khorsheed/dsh-capability-catalog/channels
+ */
+import type { CatalogToolChannel } from './types.ts';
+import type { ToolOrigin } from './tool-origin.ts';
+/** The `mcp__` prefix mcp-client stamps on every tool it registers. */
+export declare const MCP_TOOL_PREFIX = "mcp__";
+/** Tool names this plugin itself registers (self-attribution). */
+export declare const SELF_TOOL_NAMES: readonly ['list_capabilities'];
+/** One tool's channel attribution result. */
+export interface ToolAttribution {
+    readonly channel: CatalogToolChannel;
+    readonly confidence: 'exact' | 'inferred';
+    readonly serverName?: string;
+    readonly owner?: string;
+}
+/**
+ * Resolve the channel for one tool name.
+ * @param name - wire tool name.
+ * @param officialTools - official-tools whitelist (Set).
+ * @param mcpServerNames - configured MCP serverNames (longest first).
+ * @param appearedAfterApply - whether the tool appeared after apply-time baseline.
+ */
+export declare function attributeToolChannel(name: string, officialTools: ReadonlySet<string>, mcpServerNames: readonly string[], appearedAfterApply: boolean, toolOrigins?: ReadonlyMap<string, ToolOrigin>): ToolAttribution;
+/** Longest-match MCP serverName resolution. */
+export declare function resolveMcpServerName(name: string, serverNames: readonly string[]): string | undefined;
+/** Human label for a skill channel bucket. */
+export declare function skillChannelLabel(source: string): string;
+//# sourceMappingURL=channels.d.ts.map

package/lib/types/channels.js

@@ -0,0 +1,75 @@
+/**
+ * Tool channel attribution and skill source labels.
+ *
+ * Tools have no source field on `ToolDefinition`, so the catalog infers the
+ * channel from three signals (see the proposal "工具归因" section):
+ *   1. the `mcp__` prefix (exact),
+ *   2. the generated official-tools whitelist (exact),
+ *   3. baseline-diff inference (`builtin?` / `plugin`).
+ *
+ * MCP serverName is resolved by longest-match: the mcp-client server-name
+ * charset permits underscores (`[A-Za-z0-9_-]{1,32}`), so `mcp__a__b__tool`
+ * could belong to server `a` or `a__b`; the longest configured prefix that
+ * leaves a non-empty raw tool name wins.
+ * @module @khorsheed/dsh-capability-catalog/channels
+ */
+/** The `mcp__` prefix mcp-client stamps on every tool it registers. */
+export const MCP_TOOL_PREFIX = 'mcp__';
+/** Tool names this plugin itself registers (self-attribution). */
+export const SELF_TOOL_NAMES = ['list_capabilities'];
+/**
+ * Resolve the channel for one tool name.
+ * @param name - wire tool name.
+ * @param officialTools - official-tools whitelist (Set).
+ * @param mcpServerNames - configured MCP serverNames (longest first).
+ * @param appearedAfterApply - whether the tool appeared after apply-time baseline.
+ */
+export function attributeToolChannel(name, officialTools, mcpServerNames, appearedAfterApply, toolOrigins = new Map()) {
+    if (name.startsWith(MCP_TOOL_PREFIX)) {
+        const serverName = resolveMcpServerName(name, mcpServerNames);
+        return { channel: 'mcp', confidence: 'exact', ...(serverName !== undefined ? { serverName } : {}) };
+    }
+    if (SELF_TOOL_NAMES.includes(name)) {
+        return { channel: 'plugin', confidence: 'exact', owner: '@khorsheed/dsh-capability-catalog' };
+    }
+    // A tagged origin is authoritatively declared by the tool author — honor it
+    // before the official whitelist / baseline fallback.
+    const origin = toolOrigins.get(name);
+    if (origin !== undefined) {
+        return { channel: origin.channel, confidence: 'exact', ...(origin.owner !== undefined ? { owner: origin.owner } : {}) };
+    }
+    if (officialTools.has(name)) {
+        return { channel: 'builtin', confidence: 'exact' };
+    }
+    if (!appearedAfterApply) {
+        return { channel: 'builtin', confidence: 'inferred' };
+    }
+    return { channel: 'plugin', confidence: 'inferred' };
+}
+/** Longest-match MCP serverName resolution. */
+export function resolveMcpServerName(name, serverNames) {
+    const candidates = [...serverNames].sort((a, b) => b.length - a.length);
+    for (const server of candidates) {
+        const prefix = `${MCP_TOOL_PREFIX}${server}__`;
+        if (name.startsWith(prefix) && name.length > prefix.length)
+            return server;
+    }
+    const rest = name.slice(MCP_TOOL_PREFIX.length);
+    const separator = rest.indexOf('__');
+    if (separator > 0)
+        return rest.slice(0, separator);
+    return undefined;
+}
+/** Human label for a skill channel bucket. */
+export function skillChannelLabel(source) {
+    switch (source) {
+        case 'bundled': return '官方 · bundled';
+        case 'runtime': return '插件 · runtime';
+        case 'project-dsh': return '项目 · .dsh';
+        case 'project-agents': return '项目 · .agents';
+        case 'custom': return '自定义';
+        case 'user-dsh': return '用户 · dsh';
+        case 'user-agents': return '用户 · agents';
+        default: return source;
+    }
+}

package/lib/types/client/AddMcpDialog.d.ts

@@ -0,0 +1,13 @@
+import type { CatalogMcpServerConfig, CatalogMcpTool } from '@khorsheed/dsh-capability-catalog/types';
+import type { CapabilityCatalogKey } from './locales.ts';
+/** Add-MCP dialog: paste a server config → parse it into a server card →
+ * configure credentials + enable → add. One server per add. */
+export declare function AddMcpDialog({ onClose, mcpAdd, mcpSetCredential, mcpDiscover, refreshMcp, t }: {
+    onClose: () => void;
+    mcpAdd: (config: CatalogMcpServerConfig) => Promise<boolean>;
+    mcpSetCredential: (ref: string, value: string) => Promise<boolean>;
+    mcpDiscover: (serverName: string) => Promise<readonly CatalogMcpTool[]>;
+    refreshMcp: () => Promise<void>;
+    t: (key: CapabilityCatalogKey) => string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=AddMcpDialog.d.ts.map

package/lib/types/client/AddMcpDialog.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { credentialStoredRefs, parseServerEntry } from '../mcps.js';
+import { ModalShell } from './ModalShell.js';
+import { configDisplay, transportLabel } from './mcp-model.js';
+import css from './CapabilityCatalogCard.module.css';
+/** Extract a single server entry from a pasted snippet, plus its suggested
+ * name. Accepts a bare entry (`command`/`url`), the `mcpServers` wrapper, or a
+ * bare `{name: entry}` map; picks the first entry. */
+function extractServerPreamble(raw) {
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof json !== 'object' || json === null)
+        return null;
+    const obj = json;
+    if (typeof obj['command'] === 'string' || typeof obj['url'] === 'string') {
+        return { entry: obj, suggestedName: '' };
+    }
+    const container = (obj['mcpServers'] ?? obj);
+    const firstKey = Object.keys(container).find((k) => typeof container[k] === 'object' && container[k] !== null);
+    if (firstKey === undefined)
+        return null;
+    return { entry: container[firstKey], suggestedName: firstKey };
+}
+/** Add-MCP dialog: paste a server config → parse it into a server card →
+ * configure credentials + enable → add. One server per add. */
+export function AddMcpDialog({ onClose, mcpAdd, mcpSetCredential, mcpDiscover, refreshMcp, t }) {
+    const [raw, setRaw] = useState('');
+    const [serverName, setServerName] = useState('');
+    const [credValues, setCredValues] = useState({});
+    const [enabled, setEnabled] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [msg, setMsg] = useState(null);
+    const preamble = useMemo(() => (raw.trim() === '' ? null : extractServerPreamble(raw)), [raw]);
+    const parseError = raw.trim() !== '' && preamble === null;
+    const finalName = serverName.trim() !== '' ? serverName.trim() : (preamble?.suggestedName ?? '');
+    const parsed = useMemo(() => {
+        if (preamble === null || finalName === '')
+            return null;
+        return parseServerEntry(finalName, preamble.entry);
+    }, [preamble, finalName]);
+    // Seed the name field once a suggestion appears (does not overwrite edits).
+    useEffect(() => {
+        if (serverName === '' && preamble !== null && preamble.suggestedName !== '') {
+            setServerName(preamble.suggestedName);
+        }
+    }, [preamble, serverName]);
+    const canSubmit = parsed !== null && finalName !== '';
+    const submit = async () => {
+        if (parsed === null || busy)
+            return;
+        setBusy(true);
+        setMsg(null);
+        const config = { ...parsed.config, enabled };
+        const ok = await mcpAdd(config);
+        if (!ok) {
+            setMsg({ ok: false, text: t('addError') });
+            setBusy(false);
+            return;
+        }
+        const refs = credentialStoredRefs(config.serverName, config);
+        for (const cred of parsed.credentials) {
+            const value = credValues[cred.ref] ?? '';
+            if (value === '')
+                continue;
+            await mcpSetCredential(refs[cred.ref] ?? cred.ref, value);
+        }
+        if (enabled)
+            await mcpDiscover(config.serverName);
+        await refreshMcp();
+        onClose();
+    };
+    return (_jsxs(ModalShell, { title: t('mcpAddTitled'), onClose: onClose, className: css.addModal, closeOnMask: false, t: t, children: [_jsx("p", { className: css.confHint, children: t('mcpAddHint') }), _jsx("textarea", { className: css.textarea, rows: 6, value: raw, onChange: (e) => setRaw(e.target.value), placeholder: t('mcpPastePlaceholder'), spellCheck: false }), parseError ? _jsx("div", { className: `${css.addMsg} ${css.addMsgErr}`, children: t('mcpParseFailed') }) : null, parsed === null ? null : (_jsxs("div", { className: css.addPanel, children: [_jsx("label", { className: css.fieldLabel, children: t('mcpServerName') }), _jsx("input", { className: css.input, value: serverName, onChange: (e) => setServerName(e.target.value), placeholder: preamble?.suggestedName !== '' && preamble?.suggestedName !== undefined ? preamble.suggestedName : t('mcpServerNamePlaceholder'), spellCheck: false }), _jsxs("div", { className: css.meta, children: [_jsx("span", { className: css.metaKey, children: t('mcpTransport') }), _jsx("span", { className: css.metaVal, children: transportLabel(t, parsed.config.transport) })] }), _jsxs("div", { children: [_jsx("div", { className: css.mcpBlockLabel, children: t('mcpConfig') }), _jsx("pre", { className: css.mcpConfig, children: configDisplay({ ...parsed.config, enabled }) })] }), parsed.credentials.length > 0 ? (_jsxs("div", { children: [_jsx("div", { className: css.confHint, children: t('mcpNeedsCred') }), parsed.credentials.map((cred) => (_jsxs("div", { className: css.credRow, children: [_jsxs("label", { className: css.credLabel, children: [cred.label, _jsx("span", { className: `${css.badge} ${css.badgeWarn}`, children: t('mcpCredBadge') })] }), _jsx("div", { className: css.credInputRow, children: _jsx("div", { className: css.inputWrap, children: _jsx("input", { className: css.input, type: "password", value: credValues[cred.ref] ?? '', placeholder: t('credPlaceholder'), onChange: (e) => setCredValues((s) => ({ ...s, [cred.ref]: e.target.value })) }) }) })] }, cred.ref)))] })) : null, _jsxs("label", { className: css.switchRow, children: [_jsx("span", { className: css.enableLabel, children: t('mcpEnabled') }), _jsxs("span", { className: css.switch, children: [_jsx("input", { type: "checkbox", checked: enabled, onChange: (e) => setEnabled(e.target.checked) }), _jsx("span", { className: css.track }), _jsx("span", { className: css.thumb })] })] }), msg !== null ? _jsx("div", { className: `${css.addMsg} ${msg.ok ? css.addMsgOk : css.addMsgErr}`, children: msg.text }) : null] })), _jsxs("div", { className: css.actions, children: [_jsx("button", { type: "button", className: css.btnGhost, onClick: onClose, children: t('cancel') }), _jsx("span", { className: css.spacer }), _jsx("button", { type: "button", className: css.btnPrimary, disabled: !canSubmit || busy, onClick: () => void submit(), children: t('mcpAdd') })] })] }));
+}

package/lib/types/client/AddSkillModal.d.ts

@@ -0,0 +1,17 @@
+import type { CapabilityCatalogSnapshot, CatalogAddSkillRequest, CatalogDirSkillInfo } from '@khorsheed/dsh-capability-catalog/types';
+import type { CapabilityCatalogKey } from './locales.ts';
+/** Add-skill modal: file upload (drag-drop), clone-from-source, or local dir. */
+export declare function AddSkillModal({ onClose, addSkill, listDirSkills, pickDirectory, refreshSettled, t }: {
+    onClose: () => void;
+    addSkill: (request: CatalogAddSkillRequest) => Promise<{
+        ok: boolean;
+        error?: string;
+        name?: string;
+        exists?: boolean;
+    }>;
+    listDirSkills: (dirPath: string) => Promise<readonly CatalogDirSkillInfo[]>;
+    pickDirectory: () => Promise<string | null>;
+    refreshSettled: (settled: (snapshot: CapabilityCatalogSnapshot) => boolean) => Promise<boolean>;
+    t: (key: CapabilityCatalogKey) => string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=AddSkillModal.d.ts.map

package/lib/types/client/AddSkillModal.js

@@ -0,0 +1,138 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Button, Modal } from '@deepseek-ai/dsh-client-ui-primitives';
+import { IconFolderOpenOutlineMedium } from './icons.js';
+import { ModalShell } from './ModalShell.js';
+import { installedNames } from './settle.js';
+import css from './CapabilityCatalogCard.module.css';
+/** Add-skill modal: file upload (drag-drop), clone-from-source, or local dir. */
+export function AddSkillModal({ onClose, addSkill, listDirSkills, pickDirectory, refreshSettled, t }) {
+    const [tab, setTab] = useState('upload');
+    const [zipBase64, setZipBase64] = useState(null);
+    const [zipName, setZipName] = useState('');
+    const [dragging, setDragging] = useState(false);
+    const [command, setCommand] = useState('');
+    const [dir, setDir] = useState('');
+    const [dirSkills, setDirSkills] = useState([]);
+    const [selectedSkills, setSelectedSkills] = useState([]);
+    const [modelInvocable, setModelInvocable] = useState(true);
+    const [root, setRoot] = useState('user');
+    const [busy, setBusy] = useState(false);
+    const [msg, setMsg] = useState(null);
+    const [confirm, setConfirm] = useState(null);
+    const rootPath = root === 'user' ? t('rootUserPath') : t('rootProjectPath');
+    const canSubmit = tab === 'upload' ? zipBase64 !== null : tab === 'command' ? command.trim() !== '' : dir !== '' && dirSkills.length > 0 && selectedSkills.length > 0;
+    // Tabs are independent: switching clears the previous tab's message so a
+    // warning on one tab never bleeds into another.
+    const switchTab = (next) => {
+        setTab(next);
+        setMsg(null);
+    };
+    // One picker: open the host's native directory chooser, then auto-parse the
+    // chosen directory for skills (list, or report none found).
+    const browseDir = async () => {
+        setMsg(null);
+        const path = await pickDirectory();
+        if (path === null || path === '')
+            return;
+        setDir(path);
+        const skills = await listDirSkills(path);
+        setDirSkills(skills);
+        setSelectedSkills(skills.map(s => s.name));
+        if (skills.length === 0)
+            setMsg({ ok: false, text: t('noSkillsFound') });
+    };
+    const toggleSkill = (name) => {
+        setSelectedSkills(prev => prev.includes(name) ? prev.filter(n => n !== name) : [...prev, name]);
+    };
+    const readFile = (file) => {
+        const reader = new FileReader();
+        reader.onload = () => setZipBase64(arrayBufferToBase64(reader.result));
+        reader.onerror = () => setMsg({ ok: false, text: t('readFailed') });
+        reader.readAsArrayBuffer(file);
+        setZipName(file.name);
+    };
+    const onFile = (e) => {
+        const file = e.target.files?.[0];
+        if (file !== undefined)
+            readFile(file);
+    };
+    const onDrop = (e) => {
+        e.preventDefault();
+        setDragging(false);
+        const file = e.dataTransfer.files?.[0];
+        if (file !== undefined)
+            readFile(file);
+    };
+    /**
+     * Wait for the installed skill(s) to reach the catalog snapshot. The host
+     * writes the files before its watcher invalidates the registry, so a single
+     * refresh here returns the pre-install snapshot and the new card stays absent
+     * until the panel is reopened.
+     */
+    const settleInstalled = async (name) => {
+        const wanted = installedNames(name);
+        await refreshSettled(s => wanted.every(n => s.skills.some(skill => skill.name === n)));
+    };
+    const submit = async () => {
+        if (!canSubmit || busy)
+            return;
+        setBusy(true);
+        setMsg(null);
+        const req = (() => {
+            if (tab === 'upload')
+                return { channel: 'zip', payload: zipBase64, modelInvocable, root };
+            if (tab === 'command')
+                return { channel: 'command', payload: '', repo: command, modelInvocable, root };
+            // From-directory: a `kind:'self'` entry is the picked dir itself (a single
+            // skill bundle) and is installed with repo=<dir> and no `skills`. Child
+            // entries are sub-dir skills of a container and go in `skills:[name]`.
+            const selfNames = dirSkills.filter(s => s.kind === 'self').map(s => s.name);
+            const childSkills = selectedSkills.filter(n => !selfNames.includes(n));
+            const selfOnly = selfNames.some(n => selectedSkills.includes(n)) && childSkills.length === 0;
+            return selfOnly
+                ? { channel: 'command', payload: '', repo: dir, modelInvocable, root }
+                : { channel: 'command', payload: '', repo: dir, modelInvocable, root, ...(childSkills.length > 0 ? { skills: childSkills } : {}) };
+        })();
+        const res = await addSkill(req);
+        if (res.ok) {
+            await settleInstalled(res.name);
+            setMsg({ ok: true, text: `${t('addSuccess')}${res.name ?? ''}` });
+        }
+        else if (res.exists === true) {
+            // Soft refusal: a same-name skill already lives in the target root. Offer overwrite.
+            setConfirm({ name: res.name ?? '', req });
+        }
+        else {
+            setMsg({ ok: false, text: res.error ?? t('addError') });
+        }
+        setBusy(false);
+    };
+    const overwrite = async () => {
+        if (confirm === null || busy)
+            return;
+        const req = confirm.req;
+        setConfirm(null);
+        setBusy(true);
+        setMsg(null);
+        const res = await addSkill({ ...req, overwrite: true });
+        if (res.ok) {
+            await settleInstalled(res.name);
+            setMsg({ ok: true, text: `${t('addSuccess')}${res.name ?? ''}` });
+        }
+        else {
+            setMsg({ ok: false, text: res.error ?? t('addError') });
+        }
+        setBusy(false);
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs(ModalShell, { title: t('addSkill'), onClose: onClose, className: css.addModal, closeOnMask: false, t: t, children: [_jsxs("div", { className: `${css.tabs} ${css.innerTabs}`, role: "tablist", children: [_jsx("button", { type: "button", className: css.tab, "data-active": tab === 'upload', role: "tab", onClick: () => switchTab('upload'), children: t('addTabUpload') }), _jsx("button", { type: "button", className: css.tab, "data-active": tab === 'command', role: "tab", onClick: () => switchTab('command'), children: t('addTabCommand') }), _jsx("button", { type: "button", className: css.tab, "data-active": tab === 'localdir', role: "tab", onClick: () => switchTab('localdir'), children: t('addTabDir') })] }), _jsxs("div", { className: css.addPanel, children: [tab === 'upload' ? (_jsxs("label", { className: `${css.dropzone} ${dragging ? css.dragging : ''}`, onDragOver: (e) => { e.preventDefault(); setDragging(true); }, onDragLeave: () => setDragging(false), onDrop: onDrop, children: [_jsx("span", { className: css.dropzoneIcon, children: _jsx(IconFolderOpenOutlineMedium, { size: 28 }) }), _jsx("div", { className: css.dropTitle, children: t('dropTitle') }), _jsx("div", { className: css.dropHint, children: t('dropHint') }), _jsx("input", { type: "file", accept: ".zip,.md", className: css.fileInput, onChange: onFile }), zipName !== '' ? _jsx("div", { className: css.fileName, children: zipName }) : null] })) : null, tab === 'command' ? (_jsxs("div", { className: css.command, children: [_jsx("label", { className: css.fieldLabel, children: t('commandLabel') }), _jsx("input", { className: css.input, value: command, onChange: (e) => setCommand(e.target.value), placeholder: t('commandPlaceholder'), spellCheck: false }), _jsx("p", { className: css.confHint, children: t('commandHint') })] })) : null, tab === 'localdir' ? (_jsxs("div", { className: css.command, children: [_jsxs("div", { className: css.dirHintRow, children: [_jsx("button", { type: "button", className: css.btnGhost, onClick: () => void browseDir(), children: t('browseDir') }), _jsx("span", { className: css.dirHintInline, children: t('dirHint') })] }), dir !== '' ? _jsx("p", { className: css.dirPath, children: dir }) : null, dirSkills.length > 0 ? (_jsxs("div", { className: css.skillPick, children: [_jsx("div", { className: css.fieldLabel, children: t('pickSkills') }), dirSkills.map((s) => (_jsxs("label", { className: css.pickRow, children: [_jsxs("span", { className: css.check, children: [_jsx("input", { type: "checkbox", checked: selectedSkills.includes(s.name), onChange: () => toggleSkill(s.name) }), _jsx("span", { className: css.checkMark })] }), _jsxs("div", { className: css.pickText, children: [_jsx("div", { className: css.pickName, children: s.name }), _jsx("div", { className: css.pickDesc, children: s.description })] })] }, s.name)))] })) : null] })) : null, _jsxs("label", { className: css.switchRow, children: [_jsx("span", { className: css.enableLabel, children: t('addModelInvocable') }), _jsxs("span", { className: css.switch, children: [_jsx("input", { type: "checkbox", checked: modelInvocable, onChange: (e) => setModelInvocable(e.target.checked) }), _jsx("span", { className: css.track }), _jsx("span", { className: css.thumb })] })] }), _jsxs("label", { className: css.rootRow, children: [_jsx("span", { className: css.enableLabel, children: t('addRoot') }), _jsxs("select", { className: css.select, value: root, onChange: (e) => setRoot(e.target.value), children: [_jsx("option", { value: "user", children: t('rootUser') }), _jsx("option", { value: "project", children: t('rootProject') })] }), _jsx("span", { className: css.fieldPath, children: rootPath })] }), msg !== null ? _jsx("div", { className: `${css.addMsg} ${msg.ok ? css.addMsgOk : css.addMsgErr}`, children: msg.text }) : null] }), _jsxs("div", { className: css.actions, children: [_jsx("button", { type: "button", className: css.btnGhost, onClick: onClose, children: t('cancel') }), _jsx("span", { className: css.spacer }), _jsx("button", { type: "button", className: css.btnPrimary, disabled: !canSubmit || busy, onClick: () => void submit(), children: t('addSubmit') })] })] }), confirm !== null ? (_jsx(Modal, { open: true, onClose: () => setConfirm(null), title: t('addExistsTitle'), closeLabel: t('close'), description: `「${confirm.name}」${t('addExists')}`, footer: (_jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", onClick: () => setConfirm(null), children: t('cancel') }), _jsx(Button, { variant: "primary", disabled: busy, onClick: () => void overwrite(), children: t('replace') })] })) })) : null] }));
+}
+/** Encode an ArrayBuffer to base64 (chunked to avoid stack overflow). */
+function arrayBufferToBase64(buf) {
+    const bytes = new Uint8Array(buf);
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk)
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    return btoa(binary);
+}

package/lib/types/client/BundleFileTree.d.ts

@@ -0,0 +1,7 @@
+/** Skill-bundle file tree (IDE-explorer anatomy: chevron, folder, indent). */
+export declare function BundleFileTree({ files, selectedPath, onSelect }: {
+    files: readonly string[];
+    selectedPath: string;
+    onSelect: (path: string) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=BundleFileTree.d.ts.map