dsh-skill-importer 0.1.0

package/lib/index.js

@@ -0,0 +1,463 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/frontmatter.ts
+/** Kebab-case name rule shared with `dsh-skill` (`^[a-z0-9]+(?:-[a-z0-9]+)*$`). */
+const KEBAB_CASE$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** True when the name satisfies the harness skill-name rule. */
+function isValidSkillName(name) {
+	return KEBAB_CASE$1.test(name);
+}
+const BOOLEAN_TRUE = /* @__PURE__ */ new Set([
+	"true",
+	"yes",
+	"on",
+	"1"
+]);
+const BOOLEAN_FALSE = /* @__PURE__ */ new Set([
+	"false",
+	"no",
+	"off",
+	"0"
+]);
+/** Parse one frontmatter scalar: quoted strings, booleans, or plain text. */
+function parseScalar(raw) {
+	const value = raw.trim();
+	if (value.length === 0) return void 0;
+	const lower = value.toLowerCase();
+	if (BOOLEAN_TRUE.has(lower)) return true;
+	if (BOOLEAN_FALSE.has(lower)) return false;
+	if (value.startsWith("\"") && value.endsWith("\"") && value.length >= 2 || value.startsWith("'") && value.endsWith("'") && value.length >= 2) return value.slice(1, -1);
+	return value;
+}
+/**
+* Parse a skill Markdown file's frontmatter block.
+* @param text - full file text.
+* @returns parsed frontmatter and body; a file without a leading `---` block
+*   yields an empty frontmatter with the whole text as body.
+*/
+function parseSkillFile(text) {
+	const frontmatter = {};
+	if (!text.startsWith("---\n")) return {
+		frontmatter,
+		body: text
+	};
+	const end = text.indexOf("\n---", 4);
+	if (end < 0) return {
+		frontmatter,
+		body: text
+	};
+	const block = text.slice(4, end);
+	const body = text.slice(end + 4).replace(/^\n/, "");
+	for (const line of block.split("\n")) {
+		const colon = line.indexOf(":");
+		if (colon <= 0) continue;
+		const key = line.slice(0, colon).trim();
+		const value = parseScalar(line.slice(colon + 1));
+		if (value === void 0) continue;
+		switch (key) {
+			case "name":
+				if (typeof value === "string") frontmatter.name = value;
+				break;
+			case "description":
+				if (typeof value === "string") frontmatter.description = value;
+				break;
+			case "whenToUse":
+				if (typeof value === "string") frontmatter.whenToUse = value;
+				break;
+			case "disable-model-invocation":
+				if (typeof value === "boolean") frontmatter.disableModelInvocation = value;
+				break;
+			case "user-invocable": if (typeof value === "boolean") frontmatter.userInvocable = value;
+		}
+	}
+	return {
+		frontmatter,
+		body
+	};
+}
+//#endregion
+//#region src/server.ts
+/**
+* Host-side skill importer logic: direct filesystem writes, skill-root
+* scanning, and URL fetching. Pure Node — no Cordis imports — so the route
+* handlers stay unit-testable and the plugin body is only wiring.
+*
+* This is the "direct write" path: the host process owns the filesystem
+* (no agent sandbox, no approval), so an import lands the file immediately
+* and the skill-filesystem watcher discovers it in place.
+*/
+/** Hard cap for one imported skill body (matches the client preview limit). */
+const MAX_CONTENT_BYTES = 262144;
+/** Cap for one request body read (JSON overhead above the content cap). */
+const MAX_BODY_BYTES = 1048576;
+const KEBAB_CASE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** The harness home (`$DSH_HOME`, defaulting to `~/.dsh`). */
+function dshHomeDir() {
+	return process.env.DSH_HOME ?? join(homedir(), ".dsh");
+}
+/** Absolute skill root for one target under one workspace. */
+function skillRoot(target, workspacePath) {
+	switch (target) {
+		case "user": return join(dshHomeDir(), "skills");
+		case "project-agents": return join(workspacePath, ".agents", "skills");
+		case "project-dsh": return join(workspacePath, ".dsh", "skills");
+	}
+}
+/** Discovery rank per root (lower wins), mirroring dsh-skill-filesystem. */
+const ROOT_RANK = {
+	"project-dsh": 100,
+	"project-agents": 200,
+	user: 400
+};
+/** Scan order: project roots first so project skills win duplicate names. */
+const SCAN_ORDER = [
+	"project-dsh",
+	"project-agents",
+	"user"
+];
+/**
+* Quote one frontmatter string value when plain YAML would mis-parse it:
+* a value containing `: ` (or any colon), leading/trailing whitespace, a
+* leading YAML special character, or ` #` would fail or change meaning
+* under the strict YAML parser `dsh-skill-filesystem` uses — such a file is
+* silently skipped by discovery. `JSON.stringify` emits a YAML-compatible
+* double-quoted scalar.
+*/
+function yamlScalar(value) {
+	if (value.length === 0 || /^[\s]/.test(value) || /[\s]$/.test(value) || /:/.test(value) || /#/.test(value) || /^[!&*{}\[\],|>'"%@`?]/.test(value)) return JSON.stringify(value);
+	return value;
+}
+/**
+* Rebuild a skill file's frontmatter in the canonical, strictly-YAML-valid
+* form the harness's provider parses. Unknown keys are dropped (the harness
+* only consumes name/description/whenToUse and the two invocation flags);
+* the body is preserved verbatim (trimmed).
+*/
+function normalizeSkillText(text) {
+	const { frontmatter, body } = parseSkillFile(text);
+	if (frontmatter.name === void 0 || frontmatter.description === void 0) throw new Error("frontmatter 缺少 name 或 description 字段");
+	const lines = ["---"];
+	lines.push(`name: ${frontmatter.name}`);
+	lines.push(`description: ${yamlScalar(frontmatter.description)}`);
+	if (frontmatter.whenToUse !== void 0) lines.push(`whenToUse: ${yamlScalar(frontmatter.whenToUse)}`);
+	if (frontmatter.disableModelInvocation !== void 0) lines.push(`disable-model-invocation: ${frontmatter.disableModelInvocation}`);
+	if (frontmatter.userInvocable !== void 0) lines.push(`user-invocable: ${frontmatter.userInvocable}`);
+	lines.push("---");
+	const normalizedBody = body.trim();
+	return lines.join("\n") + (normalizedBody.length > 0 ? `\n\n${normalizedBody}\n` : "\n");
+}
+/**
+* Write one skill file atomically: `<root>/<name>/SKILL.md`, created via a
+* same-directory temp file plus rename so a crash never leaves a torn file.
+* The content's frontmatter is normalized first so the harness's strict YAML
+* discovery always finds the skill.
+* @param name - kebab-case skill name (validated).
+* @param target - which skill root to write into.
+* @param content - full Markdown text (frontmatter included).
+* @param workspacePath - canonical workspace path; required for project targets.
+* @returns the absolute path of the written file.
+*/
+function writeSkillFile(name, target, content, workspacePath) {
+	if (!KEBAB_CASE.test(name)) throw new Error("技能名必须是 kebab-case（小写字母、数字、短横线）");
+	if (Buffer.byteLength(content, "utf8") > 262144) throw new Error(`内容超过 ${MAX_CONTENT_BYTES / 1024} KB`);
+	if (target !== "user" && workspacePath === void 0) throw new Error("项目目标需要 workspacePath（当前工作区路径）");
+	const normalized = normalizeSkillText(content);
+	const directory = join(skillRoot(target, workspacePath ?? ""), name);
+	mkdirSync(directory, { recursive: true });
+	const file = join(directory, "SKILL.md");
+	const temporary = `${file}.tmp`;
+	writeFileSync(temporary, normalized, "utf8");
+	renameSync(temporary, file);
+	return file;
+}
+/** Scan one skill root and fold its skills into the name-keyed map (rank-aware). */
+function scanRoot(root, source, out) {
+	if (!existsSync(root)) return;
+	for (const entry of readdirSync(root, { withFileTypes: true })) {
+		const entryPath = join(root, entry.name);
+		let file;
+		if (entry.isDirectory()) {
+			const candidate = join(entryPath, "SKILL.md");
+			if (existsSync(candidate)) file = candidate;
+		} else if (entry.isFile() && entry.name.endsWith(".md")) file = entryPath;
+		if (file === void 0) continue;
+		const { frontmatter } = parseSkillFile(readFileSync(file, "utf8"));
+		if (frontmatter.name === void 0 || frontmatter.description === void 0) continue;
+		if (!isValidSkillName(frontmatter.name)) continue;
+		const existing = out.get(frontmatter.name);
+		if (existing !== void 0 && ROOT_RANK[existing.source] <= ROOT_RANK[source]) continue;
+		out.set(frontmatter.name, {
+			name: frontmatter.name,
+			description: frontmatter.description,
+			...frontmatter.whenToUse !== void 0 ? { whenToUse: frontmatter.whenToUse } : {},
+			modelInvocable: frontmatter.disableModelInvocation !== true,
+			userInvocable: frontmatter.userInvocable !== false,
+			source
+		});
+	}
+}
+/**
+* List every installed skill across every registered workspace's project
+* roots plus the user root. No rank deduplication: the management surface
+* shows every location's copy (the framework's own catalog still applies
+* rank at discovery time). Display order groups by source, then name.
+* @param workspacePaths - canonical paths of the registered workspaces.
+*/
+function listSkills(workspacePaths) {
+	const rows = [];
+	for (const target of SCAN_ORDER) {
+		const out = /* @__PURE__ */ new Map();
+		for (const path of target === "user" ? [dshHomeDir()] : workspacePaths) scanRoot(skillRoot(target, path), target, out);
+		rows.push(...out.values());
+	}
+	return rows.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+* Delete one installed skill (its whole bundle directory `<root>/<name>/`,
+* or the flat `<root>/<name>.md`), scoped to the skill roots only.
+* @param name - kebab-case skill name (validated).
+* @param source - which root the copy lives in.
+* @param workspacePath - canonical workspace path; required for project sources.
+* @returns true when something was removed, false when nothing matched.
+*/
+function deleteSkillFile(name, source, workspacePath) {
+	if (!KEBAB_CASE.test(name)) throw new Error("技能名必须是 kebab-case（小写字母、数字、短横线）");
+	if (source !== "user" && workspacePath === void 0) throw new Error("项目来源需要 workspacePath（当前工作区路径）");
+	const root = skillRoot(source, workspacePath ?? "");
+	const directory = join(root, name);
+	if (existsSync(directory)) {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	}
+	const flat = join(root, `${name}.md`);
+	if (existsSync(flat)) {
+		rmSync(flat);
+		return true;
+	}
+	return false;
+}
+/** Strip HTML down to a plain-Markdown-ish text body (best effort). */
+function extractHtmlText(html) {
+	const withoutBlocks = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<!--[\s\S]*?-->/g, "");
+	const title = withoutBlocks.match(/<title[^>]*>([\s\S]*?)<\/title>/i)?.[1]?.trim() ?? "";
+	const body = withoutBlocks.replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/[ \t]{2,}/g, " ").replace(/\n{3,}/g, "\n\n").trim();
+	return title.length > 0 ? `# ${title}\n\n${body}` : body;
+}
+/**
+* Fetch a URL's content for import. Markdown/plain responses pass through
+* verbatim; HTML is roughly extracted to text (the import UI recommends
+* `.md` sources).
+* @param url - the source URL.
+* @returns the text to write as the skill body.
+*/
+async function fetchUrlContent(url) {
+	const response = await fetch(url, {
+		redirect: "follow",
+		signal: AbortSignal.timeout(15e3)
+	});
+	if (!response.ok) throw new Error(`抓取失败：HTTP ${response.status}`);
+	const type = response.headers.get("content-type") ?? "";
+	const text = await response.text();
+	return type.includes("html") ? extractHtmlText(text) : text;
+}
+/**
+* Resolve one import request into a written file path. Shared by the file
+* and URL routes; URL imports fetch first, then reuse the same write path.
+* @param request - validated import body.
+* @returns the absolute path of the written SKILL.md.
+*/
+async function resolveImport(request) {
+	const content = "content" in request ? request.content : await fetchUrlContent(request.url);
+	return writeSkillFile(request.name, request.target, content, request.workspacePath);
+}
+/** Read and parse a JSON request body within a byte cap. */
+function readJsonBody(req, limit = MAX_BODY_BYTES) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > limit) {
+				reject(/* @__PURE__ */ new Error("请求体过大"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+			} catch {
+				reject(/* @__PURE__ */ new Error("无效的 JSON"));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+/**
+* Origin fence: the routes are served on the harness's loopback-only web
+* server, so only the browser page itself (or a local curl) reaches them.
+* A cross-origin page (any other website) is refused. Requests without an
+* Origin header (curl, same-origin GET) pass.
+*/
+function originAllowed(req) {
+	const origin = req.headers.origin;
+	if (origin === void 0) return true;
+	try {
+		const hostname = new URL(origin).hostname;
+		return hostname === "127.0.0.1" || hostname === "localhost";
+	} catch {
+		return false;
+	}
+}
+/** Send one JSON response. */
+function sendJson(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+/** Send a JSON error response with the given status. */
+function sendError(res, status, error) {
+	sendJson(res, status, {
+		ok: false,
+		error
+	});
+}
+//#endregion
+//#region src/index.ts
+/** Route paths this plugin owns (exact matches; the client fetches the same literals). */
+const ROUTES = {
+	health: "/skill-importer/health",
+	list: "/skill-importer/list",
+	import: "/skill-importer/import",
+	importUrl: "/skill-importer/import-url",
+	delete: "/skill-importer/delete"
+};
+/** Required services: the harness web server's route registry and the workspace registry. */
+const inject = ["webServer", "workspaceRegistry"];
+const handle = (fn) => (req, res) => {
+	fn(req, res).catch((error) => {
+		if (res.writableEnded) return;
+		sendError(res, 500, error instanceof Error ? error.message : String(error));
+	});
+};
+/**
+* Host plugin body: register the importer routes.
+* @param ctx - host plugin context (provides `ctx.webServer`).
+*/
+function apply(ctx) {
+	const projectPaths = () => ctx.workspaceRegistry.list().map((workspace) => workspace.path);
+	const routes = [
+		{
+			kind: "exact",
+			path: ROUTES.health,
+			handler: (_req, res) => sendJson(res, 200, { ok: true })
+		},
+		{
+			kind: "exact",
+			path: ROUTES.list,
+			handler: handle(async (_req, res) => {
+				sendJson(res, 200, {
+					ok: true,
+					skills: listSkills(projectPaths())
+				});
+			})
+		},
+		{
+			kind: "exact",
+			path: ROUTES.import,
+			handler: handle(async (req, res) => {
+				if (!originAllowed(req)) {
+					sendError(res, 403, "origin 不被允许");
+					return;
+				}
+				const body = await readJsonBody(req);
+				if (typeof body.name !== "string" || typeof body.content !== "string" || body.target !== "user" && body.target !== "project-agents" && body.target !== "project-dsh") {
+					sendError(res, 400, "请求缺少 name / content / target 字段");
+					return;
+				}
+				const workspacePath = requireWorkspace(body.target, body.workspacePath);
+				sendJson(res, 200, {
+					ok: true,
+					path: await resolveImport({
+						name: body.name,
+						target: body.target,
+						content: body.content,
+						workspacePath
+					})
+				});
+			})
+		},
+		{
+			kind: "exact",
+			path: ROUTES.importUrl,
+			handler: handle(async (req, res) => {
+				if (!originAllowed(req)) {
+					sendError(res, 403, "origin 不被允许");
+					return;
+				}
+				const body = await readJsonBody(req);
+				if (typeof body.name !== "string" || typeof body.url !== "string" || body.target !== "user" && body.target !== "project-agents" && body.target !== "project-dsh") {
+					sendError(res, 400, "请求缺少 name / url / target 字段");
+					return;
+				}
+				const workspacePath = requireWorkspace(body.target, body.workspacePath);
+				sendJson(res, 200, {
+					ok: true,
+					path: await resolveImport({
+						name: body.name,
+						target: body.target,
+						url: body.url,
+						workspacePath
+					})
+				});
+			})
+		},
+		{
+			kind: "exact",
+			path: ROUTES.delete,
+			handler: handle(async (req, res) => {
+				if (!originAllowed(req)) {
+					sendError(res, 403, "origin 不被允许");
+					return;
+				}
+				const body = await readJsonBody(req);
+				if (typeof body.name !== "string" || body.source !== "user" && body.source !== "project-agents" && body.source !== "project-dsh") {
+					sendError(res, 400, "请求缺少 name / source 字段");
+					return;
+				}
+				const workspacePath = requireWorkspace(body.source, body.workspacePath);
+				sendJson(res, 200, {
+					ok: true,
+					removed: deleteSkillFile(body.name, body.source, workspacePath)
+				});
+			})
+		}
+	];
+	/**
+	* Resolve and validate the workspace for a project target: the path must
+	* come from the client and must be a registered workspace (never derived
+	* from the host process cwd, which may differ from the user's workspace).
+	*/
+	function requireWorkspace(target, candidate) {
+		if (target === "user") return void 0;
+		if (typeof candidate !== "string") throw new Error("项目目标需要 workspacePath（当前工作区路径）");
+		if (!projectPaths().includes(candidate)) throw new Error("workspacePath 不是已注册的工作区");
+		return candidate;
+	}
+	ctx.effect(() => {
+		const disposers = routes.map((route) => ctx.webServer.register(route));
+		return () => {
+			for (const dispose of disposers) dispose();
+		};
+	}, "dsh-skill-importer: routes");
+}
+//#endregion
+export { ROUTES, apply, inject };

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

@@ -0,0 +1,16 @@
+/**
+ * Skill importer settings section, styled after the harness's General
+ * settings rows: one Setting-Cell per block (title + control, hairline
+ * separator), design tokens throughout, full zh/en copy.
+ *
+ * Rows: entry-points description · installed list · file/URL import · target
+ * directory · import action. Pure presentation — all data and actions arrive
+ * through the four props shares.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SkillImporterInjected } from './index.ts';
+/** Props the renderer binds for the section. */
+export type SkillImporterProps = PropsRuntime<'settings.section'> & PropsLocale<'skills.importer'> & InjectFace<SkillImporterInjected>;
+/** The settings section's page body. */
+export declare function SkillImporterSection({ t, useSkills, useWorkspaces, actions }: SkillImporterProps): ReactNode;

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

@@ -0,0 +1,16 @@
+/**
+ * Composer skill picker: a compact pill trigger in the composer's tool row
+ * (`conversation.input.left`, right after the resident chrome), styled like
+ * the permission (access-mode) select beside it. Opens a top-anchored panel
+ * with a name-filter search box; each row shows a first-letter avatar and
+ * the bare skill name (no leading `/`). Picking a skill prefixes the draft
+ * with `/name ` — the native text gesture — highlighted via the plugin's
+ * lexicon contribution.
+ */
+import type { ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SkillImporterInjected } from './index.ts';
+/** Props the renderer binds for the picker. */
+export type SkillsPickerProps = PropsRuntime<'conversation.input.left'> & PropsLocale<'skills.importer'> & InjectFace<SkillImporterInjected>;
+/** One row of the composer skill picker. */
+export declare function SkillsPicker({ t, useSkills, useInput, inputActions, actions }: SkillsPickerProps): ReactNode;

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

@@ -0,0 +1,39 @@
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SkillImporterProps } from './SkillImporterSection.tsx';
+import type { SkillsPickerProps } from './SkillsPicker.tsx';
+import { type SkillImporterKey } from './locales.ts';
+import type { DeleteRequest, ImportRequest, ImportUrlRequest, SkillListResponse } from '../types.ts';
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The skill importer section's copy. */
+        'skills.importer': SkillImporterKey;
+    }
+}
+/** Installed skill catalog snapshot (global — not per-session anymore). */
+export type SkillCatalogSnapshot = SkillListResponse["skills"];
+/** Registration-side business face for the section. */
+export interface SkillImporterInjected {
+    hooks: {
+        /** Last successful `/skill-importer/list` result. */
+        skills: HostObservable<SkillCatalogSnapshot>;
+    };
+    actions: {
+        /** Re-fetch the installed catalog; resolves to the fresh rows. */
+        refreshSkills: () => Promise<SkillCatalogSnapshot>;
+        /** Write one skill file via the host route; resolves to the written path. */
+        importSkill: (request: ImportRequest) => Promise<string>;
+        /** Fetch a URL and write the skill via the host route; resolves to the written path. */
+        importUrl: (request: ImportUrlRequest) => Promise<string>;
+        /** Delete one installed skill copy via the host route. */
+        deleteSkill: (request: DeleteRequest) => Promise<boolean>;
+    };
+}
+/** Required services (cordis fiber inject). */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the section and its dictionaries.
+ * @param ctx - the browser plugin context.
+ */
+export declare function apply(ctx: ClientContext): void;
+export type { SkillImporterProps, SkillsPickerProps };

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

@@ -0,0 +1,117 @@
+/**
+ * Locale dictionaries for the skill importer settings section.
+ *
+ * Product copy is Chinese; English is the fallback dictionary.
+ * The key-set source of truth is the zh dictionary (`keyof typeof zh`),
+ * matching the locale contract's namespace-key union shape.
+ */
+/** Dictionary namespace owned by this plugin. */
+export declare const NS = "skills.importer";
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    nav: string;
+    pickerLabel: string;
+    pickerPlaceholder: string;
+    pickerSearchPlaceholder: string;
+    pickerEmpty: string;
+    commandDescription: string;
+    entryTitle: string;
+    entryDescription: string;
+    installedTitle: string;
+    refresh: string;
+    installedEmpty: string;
+    sourceAgents: string;
+    sourceDsh: string;
+    sourceUser: string;
+    delete: string;
+    deleteConfirm: string;
+    deleteFailed: string;
+    deleted: string;
+    installedFailed: string;
+    userOnly: string;
+    modelOnly: string;
+    importTitle: string;
+    fileTab: string;
+    urlTab: string;
+    chooseFile: string;
+    fileHelp: string;
+    previewTitle: string;
+    previewName: string;
+    previewDescription: string;
+    previewWhenToUse: string;
+    previewMissingName: string;
+    previewInvalidName: string;
+    previewMissingDescription: string;
+    previewOk: string;
+    fileTooLarge: string;
+    unreadableFile: string;
+    urlLabel: string;
+    urlNameLabel: string;
+    urlNameHelp: string;
+    targetLabel: string;
+    targetUser: string;
+    targetProjectAgents: string;
+    targetProjectDsh: string;
+    targetProjectNoWorkspace: string;
+    noWorkspace: string;
+    import: string;
+    importing: string;
+    imported: string;
+    importFailed: string;
+    hostUnreachable: string;
+};
+/** The skill importer namespace key union. */
+export type SkillImporterKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    nav: string;
+    pickerLabel: string;
+    pickerPlaceholder: string;
+    pickerSearchPlaceholder: string;
+    pickerEmpty: string;
+    commandDescription: string;
+    entryTitle: string;
+    entryDescription: string;
+    installedTitle: string;
+    refresh: string;
+    installedEmpty: string;
+    sourceAgents: string;
+    sourceDsh: string;
+    sourceUser: string;
+    delete: string;
+    deleteConfirm: string;
+    deleteFailed: string;
+    deleted: string;
+    installedFailed: string;
+    userOnly: string;
+    modelOnly: string;
+    importTitle: string;
+    fileTab: string;
+    urlTab: string;
+    chooseFile: string;
+    fileHelp: string;
+    previewTitle: string;
+    previewName: string;
+    previewDescription: string;
+    previewWhenToUse: string;
+    previewMissingName: string;
+    previewInvalidName: string;
+    previewMissingDescription: string;
+    previewOk: string;
+    fileTooLarge: string;
+    unreadableFile: string;
+    urlLabel: string;
+    urlNameLabel: string;
+    urlNameHelp: string;
+    targetLabel: string;
+    targetUser: string;
+    targetProjectAgents: string;
+    targetProjectDsh: string;
+    targetProjectNoWorkspace: string;
+    noWorkspace: string;
+    import: string;
+    importing: string;
+    imported: string;
+    importFailed: string;
+    hostUnreachable: string;
+};

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

@@ -0,0 +1,5 @@
+/**
+ * URL-derived kebab-case skill name (pure, browser-safe).
+ */
+/** Kebab-case name for a URL import (derived from the URL's last path segment). */
+export declare function nameFromUrl(url: string): string;