@dsh-plus/secret-env 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,100 @@
+import z from "@deepseek-ai/schemastery";
+import { Context, Service } from "@deepseek-ai/cordis";
+//#region src/config.d.ts
+declare const Config: z<Schemastery.ObjectS<{
+  secrets: z<unknown[], any[]>;
+}>, Schemastery.ObjectT<{
+  secrets: z<unknown[], any[]>;
+}>>;
+type SecretEnvConfig = Schemastery.TypeT<typeof Config>;
+//#endregion
+//#region src/service.d.ts
+/** 列表端点的全局条目（describe 视图，绝无值）。 */
+interface GlobalEntry {
+  name: string;
+  envName: string;
+  description: string;
+  configured: boolean;
+  source?: string;
+  writable: boolean;
+}
+/** 列表端点的会话条目。 */
+interface SessionEntry {
+  name: string;
+  envName: string;
+  description: string;
+  once: boolean;
+  createdAt: string;
+}
+declare class SecretEnvService extends Service {
+  static [Context.inject]: string[];
+  /** 全局值镜像（seam resolve 为异步，contributor 同步读这里）。 */
+  private readonly globalMirror;
+  /** 会话桶：sessionId → 后缀 → 条目。 */
+  private readonly buckets;
+  /** 变量名 → contributor 注销器（shell-env 要求一键一主）。 */
+  private readonly contributors;
+  /** 行级 config（settings 缺席时的索引来源）。 */
+  private readonly base;
+  /** installSection 给的实时 getter（scope.get 的活视图，读即最新，无时序竞态）。 */
+  private readIndex;
+  /** 上次调和时的索引快照（onChange 差量用）。 */
+  private lastMeta;
+  private settingsRef;
+  /** 启动镜像建立完成（测试与需要确定性的调用方可等待）。 */
+  readonly ready: Promise<void>;
+  constructor(ctx: Context, config: SecretEnvConfig | undefined);
+  /** 当前生效索引（settings 活视图优先，缺席回落行级 config）。 */
+  private currentMeta;
+  /** 索引成员判定（索引是全局名管理面的唯一事实源）。 */
+  private isIndexed;
+  /** 索引差量调和：新名建镜像，移出名撤镜像并回收其独占的 contributor。 */
+  private reconcile;
+  /** 重新 resolve 一个全局名并同步镜像与 contributor（外部热编辑亦走此路）。 */
+  private refreshMirror;
+  /** contributor 登记簿：有任一来源（全局镜像或任一会话桶）则注册，否则注销。 */
+  private syncContributor;
+  private registerContributor;
+  /** 注入解析：会话值优先，未命中回落全局镜像；once 命中即焚（注销推迟到微任务，避免 collect 迭代中改注册表）。 */
+  private resolveFor;
+  /** 会话终结：整桶清除并回收其独占的 contributor。 */
+  private dropBucket;
+  private persistMeta;
+  /** 列表（值永不出现；global 条目来自 credentials.describe 的安全视图）。 */
+  list(sessionId?: string): Promise<{
+    global: GlobalEntry[];
+    session: SessionEntry[];
+  }>;
+  /** 写入全局值（seam 拒绝继承环境遮蔽与空值，此处先行给出结构化错误）。 */
+  setGlobal(suffix: string, value: string, description: string): Promise<void>;
+  /** 删除全局值与元数据。 */
+  unsetGlobal(suffix: string): Promise<void>;
+  /** 写入会话级值（纯内存；host 重启或会话终结即失）。 */
+  setSession(sessionId: string, suffix: string, value: string, description: string, once: boolean): void;
+  /** 删除会话级值。 */
+  unsetSession(sessionId: string, suffix: string): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/errors.d.ts
+/**
+ * 结构化错误（独立模块，避免 service ↔ api 循环依赖）。
+ * 端点映射为 HTTP 状态码 + 错误码，UI 按码给文案。
+ * @module secret-env/errors
+ */
+declare class SecretEnvError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "dsh-plus-secret-env";
+declare const inject: readonly ["credentials", "shellEnv"];
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    secretEnv: SecretEnvService;
+  }
+}
+declare function apply(ctx: Context, config?: SecretEnvConfig): void;
+//#endregion
+export { Config, SecretEnvError, SecretEnvService, apply, inject, name };

package/lib/index.js

@@ -0,0 +1,428 @@
+import z from "@deepseek-ai/schemastery";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+//#region src/ns.ts
+/**
+* settings 命名空间字面量（纯常量，零依赖，浏览器半可安全引入）。
+* 服务端以字面量注册元数据索引，浏览器半作为 settings.section 页标识。
+* @module secret-env/ns
+*/
+const SETTINGS_NS = "dsh-plus-secret-env";
+//#endregion
+//#region src/config.ts
+/**
+* 配置单一事实源：cordis 行级 Config（组合默认值）与 settings namespace
+* （用户层，$DSH_HOME/settings.yaml 热生效）共用同一 schemastery schema。
+* `secrets` 只是全局密钥的**元数据索引**（后缀/描述/创建时间），
+* 值永远走 dsh-credentials seam（$DSH_HOME/.credentials.yaml），不进本文件。
+* @module secret-env/config
+*/
+/** 一条全局密钥的元数据（值不在此处）。 */
+const SecretMetaSchema = z.object({
+	name: z.string().min(1).description("变量名后缀（如 GITHUB_TOKEN）").default(""),
+	description: z.string().description("用途描述（仅人读，不进提示词）").default(""),
+	createdAt: z.string().description("创建时间 ISO").default("")
+});
+const Config = z.object({ secrets: z.array(SecretMetaSchema).description("全局密钥元数据索引（值存凭据库）").default([]) });
+//#endregion
+//#region src/errors.ts
+/**
+* 结构化错误（独立模块，避免 service ↔ api 循环依赖）。
+* 端点映射为 HTTP 状态码 + 错误码，UI 按码给文案。
+* @module secret-env/errors
+*/
+var SecretEnvError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/names.ts
+/**
+* 变量名语法（纯函数，零依赖；node 半与浏览器半共用）：
+* 用户给出后缀（如 `GITHUB_TOKEN`），插件拼出完整受管变量名
+* `DSH_SECRET_GITHUB_TOKEN`——即模型经 `env | grep ^DSH_` 可见、
+* 在 shell 命令中以 `$DSH_SECRET_*` 引用的那个名字。
+* @module secret-env/names
+*/
+/** 受管变量名前缀（属 dsh-shell-env 的 DSH_* 受管命名空间）。 */
+const ENV_PREFIX = "DSH_SECRET_";
+/** 后缀语法：POSIX 环境变量名，大写字母开头，总长（含前缀）不超过 79。 */
+const SUFFIX_PATTERN = /^[A-Z][A-Z0-9_]*$/;
+const MAX_SUFFIX_LENGTH = 64;
+/** 规范化用户输入：去空白并转大写。 */
+function normalizeSuffix(raw) {
+	return raw.trim().toUpperCase();
+}
+/** 校验规范化后的后缀；合法返回 null，非法返回失败码。 */
+function validateSuffix(suffix) {
+	if (suffix.length === 0) return "empty";
+	if (suffix.length > MAX_SUFFIX_LENGTH) return "too-long";
+	if (!SUFFIX_PATTERN.test(suffix)) return "bad-charset";
+	return null;
+}
+/** 由后缀拼出完整受管变量名（调用方保证后缀已通过校验）。 */
+function envNameOf(suffix) {
+	return `${ENV_PREFIX}${suffix}`;
+}
+/** 判断一个完整变量名是否属本插件管理（用于凭据热更事件过滤）。 */
+function isManagedEnvName(envName) {
+	return envName.startsWith("DSH_SECRET_") && envName.length > 11;
+}
+/** 由完整变量名反解后缀；非本插件名返回 undefined。 */
+function suffixOf(envName) {
+	return isManagedEnvName(envName) ? envName.slice(11) : void 0;
+}
+//#endregion
+//#region src/api.ts
+const ROUTE = "/dsh-plus/secret-env";
+function sendJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+/** 解析并校验请求里的变量名后缀；失败抛 SecretEnvError。 */
+function readSuffix(raw) {
+	if (typeof raw !== "string") throw new SecretEnvError("invalid-name", "name must be a string");
+	const suffix = normalizeSuffix(raw);
+	const failure = validateSuffix(suffix);
+	if (failure !== null) throw new SecretEnvError("invalid-name", `invalid name: ${failure}`);
+	return suffix;
+}
+function readString(raw) {
+	return typeof raw === "string" ? raw : "";
+}
+/** 错误 → HTTP 映射（值类错误 400，遮蔽/冲突 409，其余 500；均只带错误码与消息）。 */
+function sendError(res, error) {
+	if (error instanceof SecretEnvError) {
+		sendJson(res, error.code === "shadowed" || error.code === "conflict" ? 409 : 400, {
+			ok: false,
+			error: error.code,
+			message: error.message
+		});
+		return;
+	}
+	sendJson(res, 500, {
+		ok: false,
+		error: "internal"
+	});
+}
+/** 注册端点（webServer 缺席时由调用方保证不调用）。 */
+function registerSecretEnvApi(ctx, service) {
+	const logger = ctx.logger("secret-env");
+	const guard = (label, run, res) => {
+		run().catch((error) => {
+			if (!(error instanceof SecretEnvError)) logger.warn(`${label} failed: ${error instanceof Error ? error.message : String(error)}`);
+			sendError(res, error);
+		});
+	};
+	ctx.webServer.register({
+		kind: "prefix",
+		path: `${ROUTE}/list`,
+		handler: async (req, res) => {
+			const sessionId = new URL(req.url ?? "", "http://localhost").searchParams.get("sessionId") ?? void 0;
+			guard("list", async () => sendJson(res, 200, await service.list(sessionId)), res);
+		}
+	});
+	ctx.webServer.register({
+		kind: "prefix",
+		path: `${ROUTE}/global/set`,
+		handler: async (req, res) => {
+			guard("global/set", async () => {
+				if (req.method !== "POST") throw new SecretEnvError("method", "POST only");
+				const body = JSON.parse(await readBody(req));
+				await service.setGlobal(readSuffix(body.name), readString(body.value), readString(body.description));
+				sendJson(res, 200, { ok: true });
+			}, res);
+		}
+	});
+	ctx.webServer.register({
+		kind: "prefix",
+		path: `${ROUTE}/global/unset`,
+		handler: async (req, res) => {
+			guard("global/unset", async () => {
+				if (req.method !== "POST") throw new SecretEnvError("method", "POST only");
+				const body = JSON.parse(await readBody(req));
+				await service.unsetGlobal(readSuffix(body.name));
+				sendJson(res, 200, { ok: true });
+			}, res);
+		}
+	});
+	ctx.webServer.register({
+		kind: "prefix",
+		path: `${ROUTE}/session/set`,
+		handler: async (req, res) => {
+			guard("session/set", async () => {
+				if (req.method !== "POST") throw new SecretEnvError("method", "POST only");
+				const body = JSON.parse(await readBody(req));
+				service.setSession(readString(body.sessionId), readSuffix(body.name), readString(body.value), readString(body.description), body.once === true);
+				sendJson(res, 200, { ok: true });
+			}, res);
+		}
+	});
+	ctx.webServer.register({
+		kind: "prefix",
+		path: `${ROUTE}/session/unset`,
+		handler: async (req, res) => {
+			guard("session/unset", async () => {
+				if (req.method !== "POST") throw new SecretEnvError("method", "POST only");
+				const body = JSON.parse(await readBody(req));
+				service.unsetSession(readString(body.sessionId), readSuffix(body.name));
+				sendJson(res, 200, { ok: true });
+			}, res);
+		}
+	});
+}
+//#endregion
+//#region src/service.ts
+/**
+* secret-env 服务主体（host 半）：
+* - 全局臂：值经 dsh-credentials seam 持久（$DSH_HOME/.credentials.yaml），
+*   服务内存中维护同步镜像（contributor.resolve 是同步签名，无法现查异步 seam）；
+* - 会话臂：Map<SessionId, Map<后缀, 值>> 纯内存，session/disposed 清除；
+* - 注入臂：每个变量名一个 dsh-shell-env contributor，每次 shell 执行由
+*   注册表 collect 现取——写入/删除下一条命令即生效，不进消息流、不动前缀。
+*
+* 红线：值只流经「端点 → 本服务 → dshEnv」，任何日志/事件/返回值不带值。
+* @module secret-env/service
+*/
+function asMeta(value) {
+	if (value === void 0 || value === null || typeof value !== "object") return [];
+	const list = value.secrets;
+	if (!Array.isArray(list)) return [];
+	return list.filter((item) => typeof item === "object" && item !== null).map((item) => ({
+		name: typeof item.name === "string" ? item.name : "",
+		description: typeof item.description === "string" ? item.description : "",
+		createdAt: typeof item.createdAt === "string" ? item.createdAt : ""
+	})).filter((item) => item.name.length > 0);
+}
+var SecretEnvService = class extends Service {
+	static [Context.inject] = ["credentials", "shellEnv"];
+	/** 全局值镜像（seam resolve 为异步，contributor 同步读这里）。 */
+	globalMirror = /* @__PURE__ */ new Map();
+	/** 会话桶：sessionId → 后缀 → 条目。 */
+	buckets = /* @__PURE__ */ new Map();
+	/** 变量名 → contributor 注销器（shell-env 要求一键一主）。 */
+	contributors = /* @__PURE__ */ new Map();
+	/** 行级 config（settings 缺席时的索引来源）。 */
+	base;
+	/** installSection 给的实时 getter（scope.get 的活视图，读即最新，无时序竞态）。 */
+	readIndex;
+	/** 上次调和时的索引快照（onChange 差量用）。 */
+	lastMeta = [];
+	settingsRef;
+	/** 启动镜像建立完成（测试与需要确定性的调用方可等待）。 */
+	ready;
+	constructor(ctx, config) {
+		super(ctx, "secretEnv");
+		this.base = config ?? { secrets: [] };
+		ctx.inject(["settings"], (settingsCtx) => {
+			const settings = settingsCtx.settings;
+			settings.installSection(ctx, SETTINGS_NS, Config, this.base, {
+				setSource: (source) => {
+					this.readIndex = source;
+				},
+				onChange: () => {
+					this.reconcile();
+				}
+			});
+			this.settingsRef = settings;
+			this.reconcile();
+		});
+		ctx.root.on("session/disposed", (session) => {
+			this.dropBucket(session.id);
+		});
+		ctx.on("credentials/reference-updated", (ref) => {
+			const suffix = suffixOf(String(ref));
+			if (suffix !== void 0 && this.isIndexed(suffix)) this.refreshMirror(suffix);
+		});
+		ctx.inject(["webServer"], (webCtx) => {
+			registerSecretEnvApi(webCtx, this);
+		});
+		this.ready = this.reconcile();
+	}
+	/** 当前生效索引（settings 活视图优先，缺席回落行级 config）。 */
+	currentMeta() {
+		return asMeta(this.readIndex !== void 0 ? this.readIndex() : this.base);
+	}
+	/** 索引成员判定（索引是全局名管理面的唯一事实源）。 */
+	isIndexed(suffix) {
+		return this.currentMeta().some((item) => item.name === suffix);
+	}
+	/** 索引差量调和：新名建镜像，移出名撤镜像并回收其独占的 contributor。 */
+	async reconcile() {
+		const next = this.currentMeta();
+		const removed = this.lastMeta.filter((item) => !next.some((n) => n.name === item.name));
+		const added = next.filter((item) => !this.lastMeta.some((p) => p.name === item.name));
+		this.lastMeta = next;
+		for (const item of removed) {
+			this.globalMirror.delete(item.name);
+			this.syncContributor(item.name);
+		}
+		for (const item of added) await this.refreshMirror(item.name);
+	}
+	/** 重新 resolve 一个全局名并同步镜像与 contributor（外部热编辑亦走此路）。 */
+	async refreshMirror(suffix) {
+		const resolved = await this.ctx.credentials.resolve(credentialRef(envNameOf(suffix)));
+		if (resolved === void 0) this.globalMirror.delete(suffix);
+		else this.globalMirror.set(suffix, resolved.value);
+		this.syncContributor(suffix);
+	}
+	/** contributor 登记簿：有任一来源（全局镜像或任一会话桶）则注册，否则注销。 */
+	syncContributor(suffix) {
+		const envName = envNameOf(suffix);
+		const hasGlobal = this.globalMirror.has(suffix);
+		let hasSession = false;
+		for (const bucket of this.buckets.values()) if (bucket.has(suffix)) {
+			hasSession = true;
+			break;
+		}
+		const registered = this.contributors.has(envName);
+		if ((hasGlobal || hasSession) && !registered) {
+			this.registerContributor(suffix, envName);
+			return;
+		}
+		if (!hasGlobal && !hasSession && registered) {
+			this.contributors.get(envName)?.();
+			this.contributors.delete(envName);
+		}
+	}
+	registerContributor(suffix, envName) {
+		const found = this.currentMeta().find((item) => item.name === suffix)?.description;
+		const description = found !== void 0 && found.trim() !== "" ? found : "secret variable";
+		try {
+			const dispose = this.ctx.shellEnv.register({
+				name: `secret-env:${suffix}`,
+				variables: { [envName]: { description } },
+				resolve: (execution) => {
+					const value = this.resolveFor(suffix, execution);
+					return value === void 0 ? {} : { [envName]: value };
+				}
+			});
+			this.contributors.set(envName, dispose);
+		} catch (error) {
+			throw new SecretEnvError("conflict", `variable ${envName} conflicts with an existing contributor: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	/** 注入解析：会话值优先，未命中回落全局镜像；once 命中即焚（注销推迟到微任务，避免 collect 迭代中改注册表）。 */
+	resolveFor(suffix, execution) {
+		const sessionId = execution.agent?.id;
+		const bucket = sessionId === void 0 ? void 0 : this.buckets.get(String(sessionId));
+		const entry = bucket?.get(suffix);
+		if (entry !== void 0) {
+			if (entry.once && bucket !== void 0) {
+				bucket.delete(suffix);
+				queueMicrotask(() => this.syncContributor(suffix));
+			}
+			return entry.value;
+		}
+		return this.globalMirror.get(suffix);
+	}
+	/** 会话终结：整桶清除并回收其独占的 contributor。 */
+	dropBucket(sessionId) {
+		const bucket = this.buckets.get(sessionId);
+		if (bucket === void 0) return;
+		this.buckets.delete(sessionId);
+		for (const suffix of bucket.keys()) this.syncContributor(suffix);
+	}
+	async persistMeta(next) {
+		if (this.settingsRef === void 0) return;
+		await this.settingsRef.update(SETTINGS_NS, { secrets: next });
+	}
+	/** 列表（值永不出现；global 条目来自 credentials.describe 的安全视图）。 */
+	async list(sessionId) {
+		return {
+			global: await Promise.all(this.currentMeta().map(async (item) => {
+				const info = await this.ctx.credentials.describe(credentialRef(envNameOf(item.name)));
+				return {
+					name: item.name,
+					envName: envNameOf(item.name),
+					description: item.description,
+					configured: info.configured,
+					source: info.source,
+					writable: info.writable
+				};
+			})),
+			session: [...(sessionId === void 0 ? void 0 : this.buckets.get(sessionId))?.entries() ?? []].map(([name, entry]) => ({
+				name,
+				envName: envNameOf(name),
+				description: entry.description,
+				once: entry.once,
+				createdAt: entry.createdAt
+			}))
+		};
+	}
+	/** 写入全局值（seam 拒绝继承环境遮蔽与空值，此处先行给出结构化错误）。 */
+	async setGlobal(suffix, value, description) {
+		if (value.length === 0) throw new SecretEnvError("empty-value", "value must not be empty");
+		try {
+			await this.ctx.credentials.set(credentialRef(envNameOf(suffix)), value);
+		} catch (error) {
+			throw new SecretEnvError("shadowed", error instanceof Error ? error.message : String(error));
+		}
+		const meta = this.currentMeta();
+		const next = meta.find((item) => item.name === suffix) === void 0 ? [...meta, {
+			name: suffix,
+			description,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		}] : meta.map((item) => item.name === suffix ? {
+			...item,
+			description
+		} : item);
+		await this.persistMeta(next);
+		this.lastMeta = next;
+		await this.refreshMirror(suffix);
+	}
+	/** 删除全局值与元数据。 */
+	async unsetGlobal(suffix) {
+		await this.ctx.credentials.unset(credentialRef(envNameOf(suffix)));
+		const next = this.currentMeta().filter((item) => item.name !== suffix);
+		await this.persistMeta(next);
+		this.lastMeta = next;
+		this.globalMirror.delete(suffix);
+		this.syncContributor(suffix);
+	}
+	/** 写入会话级值（纯内存；host 重启或会话终结即失）。 */
+	setSession(sessionId, suffix, value, description, once) {
+		if (sessionId.length === 0) throw new SecretEnvError("no-session", "sessionId required");
+		if (value.length === 0) throw new SecretEnvError("empty-value", "value must not be empty");
+		const bucket = this.buckets.get(sessionId) ?? /* @__PURE__ */ new Map();
+		bucket.set(suffix, {
+			value,
+			description,
+			once,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		this.buckets.set(sessionId, bucket);
+		this.syncContributor(suffix);
+	}
+	/** 删除会话级值。 */
+	unsetSession(sessionId, suffix) {
+		const bucket = this.buckets.get(sessionId);
+		if (bucket === void 0 || !bucket.delete(suffix)) return;
+		if (bucket.size === 0) this.buckets.delete(sessionId);
+		this.syncContributor(suffix);
+	}
+	dispose() {
+		for (const disposeContributor of this.contributors.values()) disposeContributor();
+		this.contributors.clear();
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "dsh-plus-secret-env";
+const inject = ["credentials", "shellEnv"];
+function apply(ctx, config) {
+	ctx.plugin(SecretEnvService, config);
+}
+//#endregion
+export { Config, SecretEnvError, SecretEnvService, apply, inject, name };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@dsh-plus/secret-env",
+  "version": "0.1.0",
+  "description": "dsh-plus service+ui plugin: 密钥环境变量——以 $DSH_SECRET_* 变量名向 agent 暴露密钥（全局持久/会话级/一次性），执行期经 dsh-shell-env 原生注入，值不进消息流，不影响缓存率",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src"
+  ],
+  "dependencies": {
+    "@dsh-plus/shared": "0.1.7"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-credentials": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-settings": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-shell-env": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/dsh-credentials": "0.1.2-alpha.2",
+    "@deepseek-ai/dsh-host-webserver": "0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.2-alpha.2",
+    "@deepseek-ai/dsh-settings": "0.1.2-alpha.2",
+    "@deepseek-ai/dsh-shell-env": "0.1.2-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "3.18.2",
+    "@types/node": "26.4.0",
+    "@types/react": "~18.3.31",
+    "react": "^18.2.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "watch": "tsdown --watch"
+  }
+}