dsh-auto-flow 0.1.0

package/lib/index.js

@@ -0,0 +1,592 @@
+import { Service } from "@deepseek-ai/cordis";
+import { HarnessError } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { Remote, RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import z from "@deepseek-ai/schemastery";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z as z$1 } from "zod";
+//#region src/domain.ts
+/**
+* dsh-auto-flow 的持久化领域（dsh-storage domain）声明。
+*
+* 插件的持久化状态一律进 **domain storage**（这里），与 session 日志完全隔离
+* （`dsh-storage-domain` 只存非会话数据、不追加会话事件）。不要把机器执行信息 /
+* 运行态写成会话里的 durable 节点——往会话日志里塞非会话数据，会导致该会话在
+* dsh 重启后无法正常打开。
+*
+* 领域用 `defineDomain` 声明一次（表 schema 用 zod，`z.infer` 派生类型），
+* 由 `ctx.storageDomain.open(spec)` 打开，返回的 `Domain` 提供同步读 + 串行化落盘写。
+*
+* 高级选项（DomainSpec）与适用场景：
+* - layout: 'single'（默认）整单元一文档；'per-record' 按记录分文档，适合大/稀疏/可
+*   独立丢弃的记录（如投影缓存），并逐记录做版本隔离（过期记录文档被丢弃而非迁移）。
+* - compatibleVersions: 列旧版本号，声明当前 record schema 仍能接受旧记录（把旧字段
+*   声明为可选）。升级 version 后写这里。
+* - invalidRecords: 缺省（打开遇坏记录直接拒绝）——权威数据用这个；'backup-and-skip'
+*   把坏记录移到备份、打开继续——可丢弃的派生数据用这个。全局槽始终拒绝。
+* - global: 全局单例槽（schema + 未写前 initial），见下方示例。
+*/
+/** 领域名：UNIT_NAME_RE /^[a-z][a-z0-9_]*$/，由脚手架按包名推导（dsh_auto_flow）。 */
+const GreetingDomain = defineDomain({
+	name: "dsh_auto_flow",
+	version: 1,
+	layout: "single",
+	global: {
+		schema: z$1.object({ lastGreetedAt: z$1.number().nullable() }),
+		initial: { lastGreetedAt: null }
+	},
+	tables: { greetings: domainTable(z$1.object({
+		id: z$1.number(),
+		text: z$1.string(),
+		createdAt: z$1.number()
+	})) }
+});
+//#endregion
+//#region src/invariant.ts
+/**
+* 断言助手：失败抛 HarnessError（稳定机器可路由码 INVARIANT）。
+* 官方参考：@deepseek-ai/dsh-goal 的 ./invariant 出口。
+*/
+/**
+* 断言 condition 为真，否则抛 INVARIANT 错误（route on code，勿解析 message）。
+* @param condition - 期望为真的条件。
+* @param message - 失败时的人类可读消息。
+*/
+function invariant(condition, message) {
+	if (!condition) throw new HarnessError(message, "INVARIANT");
+}
+//#endregion
+//#region src/index.ts
+/**
+* dsh-auto-flow — Host 半（dsh 的 Node 进程内运行）。
+*
+* 通信与平台集成（业务开发按此分工）：
+* - 重通道：AutoFlowService（Cordis 服务，@Remote 严格模式暴露给浏览器，
+*   契约由 `pnpm typert:gen` 生成——双向 zod 校验 + 完整类型）
+* - 轻执行也走 @Remote：`exec` 在宿主内经 ctx.shell（与 bash 工具同一执行器、不经过
+*   模型）执行；`runInBackground` 走 shell.start 自管后台进程 + `execRead`/`execKill` 消费。
+* - 模型工具：plugin_auto_flow（复用上面的服务；presentCall + presentResult）
+* - 斜杠命令：/auto-flow（ctx.commands 注册，用户键入后直接进 handler，不经过模型）
+* - 持久化：greetings 写入 domain storage（dsh-storage-domain，与 session 日志隔离；
+*   不追加自定义会话事件——harness 持久化读路径会拒绝未知事件类型，见 send 的说明）
+
+* - 事件：声明 + 发出 + 监听 `autoFlow/recorded`（跨插件实时通知 seam）
+* - 系统提示词：ctx.systemPrompt.section 贡献一条模型可见指引
+* - 设置：同一份 Config schema 注册为 settings namespace，UI 内可编辑、可 watch
+* - 生命周期：持久层异步打开走 `[Service.init]`（Cordis 类插件 init 钩子）
+*/
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** 模型可见的工具名。 */
+const TOOL_NAME = "plugin_auto_flow";
+/** 斜杠命令名（小写、不带斜杠前缀）。 */
+const COMMAND_NAME = "auto-flow";
+/** 设置命名空间：与插件短名一致（小写字母开头，字母/数字/连字符）。 */
+const SETTINGS_NS = "auto-flow";
+/** 默认问候前缀。 */
+const DEFAULT_PREFIX = "Hello";
+/** 单条 `exec` 命令允许的最大 UTF-8 字节长度（随部署变化，可经 Config / settings 覆盖）。 */
+const DEFAULT_MAX_COMMAND_BYTES = 1024;
+/** dsh-auto-flow 的领域错误：extends HarnessError 以便工具结果/重放保留失败类别。 */
+var GreetingError = class extends HarnessError {
+	constructor(message, code) {
+		super(message, code);
+	}
+};
+/** 在边界处校验并归一化一份配置。 */
+function resolveConfig(config = {}) {
+	const prefix = (config.prefix ?? DEFAULT_PREFIX).trim();
+	if (prefix === "") throw new GreetingError("auto-flow: prefix 不能是空字符串", "GREETING_EMPTY_PREFIX");
+	const maxCommandBytes = config.maxCommandBytes ?? DEFAULT_MAX_COMMAND_BYTES;
+	if (!Number.isSafeInteger(maxCommandBytes) || maxCommandBytes < 1) throw new GreetingError(`auto-flow: maxCommandBytes 必须是正的安全整数，收到 ${String(maxCommandBytes)}`, "GREETING_INVALID_MAX_BYTES");
+	return {
+		prefix,
+		maxCommandBytes
+	};
+}
+/** 配置 schema：既是 Loader 校验的类静态 Config，也是 settings namespace 的 schema。 */
+const ConfigSchema = z.object({
+	prefix: z.string().default(DEFAULT_PREFIX),
+	maxCommandBytes: z.number().step(1).min(1).default(DEFAULT_MAX_COMMAND_BYTES)
+});
+/** 把 ShellRunResult 映射为客户端安全的 ExecForegroundResult（保留截断/沙箱事实）。 */
+function mapRunResult(result) {
+	return {
+		kind: "foreground",
+		exitCode: result.exitCode,
+		signal: result.signal,
+		timedOut: result.timedOut,
+		aborted: result.aborted,
+		timeoutMs: result.timeoutMs,
+		stdout: {
+			text: result.stdout.text,
+			truncated: result.stdout.truncated,
+			...result.stdout.spillPath !== void 0 ? { spillPath: result.stdout.spillPath } : {}
+		},
+		stderr: {
+			text: result.stderr.text,
+			truncated: result.stderr.truncated,
+			...result.stderr.spillPath !== void 0 ? { spillPath: result.stderr.spillPath } : {}
+		},
+		...result.sandbox !== void 0 ? { sandbox: {
+			mode: result.sandbox.mode,
+			denied: result.sandbox.denied,
+			...result.sandbox.enforcement !== void 0 ? { enforcement: result.sandbox.enforcement } : {},
+			...result.sandbox.runnerFailed !== void 0 ? { runnerFailed: result.sandbox.runnerFailed } : {}
+		} } : {}
+	};
+}
+/** 后台进程增量读取：附上丢失/溢出提示（与 tool-bash 的 renderProcessRead 同构）。 */
+function renderProcessRead(read) {
+	const notices = [];
+	if (read.lossy) {
+		const paths = [read.stdoutSpillPath, read.stderrSpillPath].filter((path) => path !== void 0);
+		notices.push(`[部分输出被丢弃；完整输出：${paths.length > 0 ? paths.join(", ") : "(unavailable)"}]`);
+	}
+	if (notices.length === 0) return read.delta;
+	return `${read.delta}${read.delta.length > 0 && !read.delta.endsWith("\n") ? "\n" : ""}${notices.join("\n")}`;
+}
+/**
+* 示例服务：类本身就是插件——static inject / Config 是 Cordis 类插件的约定，
+* 构造器里的注册（工具/事件/设置/命令）随插件卸载自动回收。
+*
+* 平台服务消费方式（跨插件协作走 Cordis 服务、禁止互相 import）：
+* - 必需依赖用 `static inject`（tools）；
+* - 可选依赖用 `ctx.inject([...], cb)`（settings / commands / systemPrompt /
+*   autoFlowFormatter）——服务缺失时插件照常加载；
+* - shell / sandboxPolicy 是可选服务：用 `ctx.get(...)` 读取，未组合时
+*   `exec` 报错、插件其余部分照常工作；
+* - 持久层异步打开走 `[Service.init]`（storageDomain 可选：缺省退化为内存态）。
+*/
+let AutoFlowService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _send_decorators;
+	let _list_decorators;
+	let _last_decorators;
+	let _exec_decorators;
+	let _execRead_decorators;
+	let _execKill_decorators;
+	return class AutoFlowService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_send_decorators = [Remote("send")];
+			_list_decorators = [Remote("list")];
+			_last_decorators = [Remote("last")];
+			_exec_decorators = [Remote("exec")];
+			_execRead_decorators = [Remote("execRead")];
+			_execKill_decorators = [Remote("execKill")];
+			__esDecorate(this, null, _send_decorators, {
+				kind: "method",
+				name: "send",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "send" in obj,
+					get: (obj) => obj.send
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _list_decorators, {
+				kind: "method",
+				name: "list",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "list" in obj,
+					get: (obj) => obj.list
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _last_decorators, {
+				kind: "method",
+				name: "last",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "last" in obj,
+					get: (obj) => obj.last
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _exec_decorators, {
+				kind: "method",
+				name: "exec",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "exec" in obj,
+					get: (obj) => obj.exec
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _execRead_decorators, {
+				kind: "method",
+				name: "execRead",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "execRead" in obj,
+					get: (obj) => obj.execRead
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _execKill_decorators, {
+				kind: "method",
+				name: "execKill",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "execKill" in obj,
+					get: (obj) => obj.execKill
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		/** 依赖的服务；缺失时 Loader 会等待其出现。 */
+		static inject = ["tools"];
+		/** Config 的 Schema（Cordis 类插件约定：Loader 读类静态 `Config` 校验注入并补齐默认值；
+		* 模块级同名导出不会被 Loader 识别——生成插件请把 Schema 放在类上）。 */
+		static Config = ConfigSchema;
+		/** 校验后的配置（settings scope 可在运行时覆盖，故非 readonly）。 */
+		resolved = __runInitializers(this, _instanceExtraInitializers);
+		/** 问候的内存视图（domain storage 是持久层）。 */
+		greetings = [];
+		/** 已打开的持久化领域；无后端时保持 null（内存态兜底）。 */
+		storage = null;
+		/** 第二包提供的格式化服务；未安装第二包时保持 null（可选依赖）。 */
+		formatter = null;
+		/** 最近一次提交的问候（由 `autoFlow/recorded` 监听器维护，供 @Remote last）。 */
+		lastRecorded = null;
+		/** 后台进程句柄（@Remote 轻执行自管；不依赖 ctx.jobs，见 exec 说明）。 */
+		background = /* @__PURE__ */ new Map();
+		nextBgId = 1;
+		nextId = 1;
+		constructor(ctx, config = {}) {
+			super(ctx, "autoFlow");
+			this.resolved = resolveConfig(config);
+			this.registerTool(ctx);
+			this.registerSettings(ctx, config);
+			this.registerCommand(ctx);
+			this.registerSystemPrompt(ctx);
+			this.registerCore(ctx);
+			this.registerEvents(ctx);
+			this.registerBackgroundCleanup(ctx);
+		}
+		/**
+		* 异步初始化钩子（Cordis 类插件约定）：构造完成后运行。持久层在这里打开——
+		* 与 @deepseek-ai/dsh-message-feedback 的 `[Service.init]` 同构；storageDomain
+		* 是可选服务，缺失时保持内存态兜底。
+		*/
+		async [Service.init]() {
+			const storageDomain = this.ctx.get("storageDomain");
+			if (storageDomain === void 0) return;
+			try {
+				this.storage = await storageDomain.open(GreetingDomain);
+				this.hydrateFromStorage();
+			} catch {}
+		}
+		/** 模型工具：复用 @Remote send；presentCall + presentResult 双态展示。 */
+		registerTool(ctx) {
+			ctx.tools.register(defineTool({
+				name: TOOL_NAME,
+				description: "追加一条问候记录，返回新记录与当前总数。",
+				parameters: { text: {
+					type: "string",
+					required: true,
+					description: "问候内容"
+				} },
+				output: {
+					schema: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							hello: {
+								type: "object",
+								required: true,
+								additionalProperties: false,
+								properties: {
+									id: {
+										type: "integer",
+										required: true
+									},
+									text: {
+										type: "string",
+										required: true
+									},
+									createdAt: {
+										type: "integer",
+										required: true
+									}
+								}
+							},
+							total: {
+								type: "integer",
+								required: true
+							}
+						}
+					},
+					render: (_args, value) => [{
+						type: "text",
+						text: `已记录：${value.hello.text}（共 ${value.total} 条）`
+					}]
+				},
+				presentCall: (args) => ({
+					card: "generic",
+					title: "记录问候",
+					kind: "other",
+					rawInput: args.text
+				}),
+				presentResult: (_args, result) => {
+					const block = result.content[0];
+					if (block === void 0 || block.type !== "text") return void 0;
+					return {
+						card: "generic",
+						title: "问候已记录",
+						content: [{
+							type: "text",
+							text: block.text
+						}]
+					};
+				},
+				execute: async (args) => {
+					return {
+						hello: await this.send(args.text),
+						total: this.greetings.length
+					};
+				}
+			}));
+		}
+		/** 设置：同一份 Config schema 注册为可编辑 namespace，入口配置作为 base 层。 */
+		registerSettings(ctx, config) {
+			ctx.inject(["settings"], (settingsCtx) => {
+				let readConfig = () => config;
+				settingsCtx.settings.installSection(ctx, SETTINGS_NS, ConfigSchema, config, {
+					validate: (value) => {
+						resolveConfig(value);
+					},
+					setSource: (current) => {
+						readConfig = current;
+					},
+					onChange: () => {
+						this.resolved = resolveConfig(readConfig());
+					}
+				});
+			});
+		}
+		/** 从持久化领域恢复内存视图与自增 id。 */
+		hydrateFromStorage() {
+			if (this.storage === null) return;
+			const table = this.storage.table("greetings");
+			const restored = [];
+			let maxId = 0;
+			for (const [, greeting] of table.entries()) {
+				restored.push(greeting);
+				if (greeting.id > maxId) maxId = greeting.id;
+			}
+			restored.sort((a, b) => a.id - b.id);
+			this.greetings.length = 0;
+			this.greetings.push(...restored);
+			this.nextId = maxId + 1;
+			invariant(this.greetings.length === restored.length, "水合后的内存视图应与恢复记录一致");
+		}
+		/** 斜杠命令：用户键入 /auto-flow 后直接进 handler（不经过模型）。 */
+		registerCommand(ctx) {
+			ctx.inject(["commands"], (commandsCtx) => {
+				commandsCtx.commands.register({
+					name: COMMAND_NAME,
+					description: "记录一条问候并返回当前总数",
+					input: { hint: "问候内容" },
+					handler: async (invocation) => {
+						const text = invocation.rawInput.trim();
+						if (text === "") return {
+							kind: "error",
+							text: "问候内容不能为空"
+						};
+						return {
+							kind: "success",
+							text: `已记录：${(await this.send(text)).text}（共 ${this.greetings.length} 条）`
+						};
+					}
+				});
+			});
+		}
+		/** 系统提示词：贡献一条模型可见指引（name 唯一、order 升序拼接）。 */
+		registerSystemPrompt(ctx) {
+			ctx.inject(["systemPrompt"], (promptCtx) => {
+				promptCtx.systemPrompt.section({
+					name: "auto-flow",
+					order: 900,
+					text: "auto-flow: 问候通过模型工具 plugin_auto_flow 或斜杠命令 /auto-flow 追加，落插件 domain storage；exec 轻执行输出只回调用方、不进会话日志。"
+				});
+			});
+		}
+		/** 事件：监听自身域事件维护 lastRecorded 缓存（演示 ctx.on —— 监听器随 fiber 回收）。
+		* 其它插件也可 ctx.on('autoFlow/recorded', ...) 订阅，实现跨插件实时通知。 */
+		registerEvents(ctx) {
+			ctx.on("autoFlow/recorded", ({ greeting }) => {
+				this.lastRecorded = greeting;
+			});
+		}
+		/** 卸载时回收所有未结束的后台进程（@Remote 轻执行自管句柄，必须随 fiber 清理）。 */
+		registerBackgroundCleanup(ctx) {
+			ctx.effect(() => () => {
+				for (const proc of this.background.values()) proc.kill();
+				this.background.clear();
+			}, "auto-flow: 后台进程清理");
+		}
+		/** 跨插件服务消费：第二包（dsh-auto-flow-core）可选提供 autoFlowFormatter。
+		* 用 ctx.inject 而非 static inject——第二包未安装时插件照常加载（send 走无格式化兜底）。 */
+		registerCore(ctx) {
+			ctx.inject(["autoFlowFormatter"], (coreCtx) => {
+				this.formatter = coreCtx.get("autoFlowFormatter");
+			});
+		}
+		/**
+		* 追加一条问候并返回记录（写透 domain storage；若有第二包则先格式化；提交后发域事件）。
+		*
+		* 不追加自定义会话事件：harness 的 session 持久化读路径会拒绝 `KNOWN_SESSION_EVENT_TYPES`
+		* 之外的事件类型（除非信封标记 `ignorable`，而 `Session.append` 无此参数），把插件
+		* 自定义事件写进会话日志会导致该会话在重启后无法打开。
+		*/
+		async send(text) {
+			const raw = this.resolved.prefix + text;
+			const greeting = {
+				id: this.nextId,
+				text: this.formatter !== null ? this.formatter.format(raw) : raw,
+				createdAt: Date.now()
+			};
+			invariant(Number.isSafeInteger(greeting.id) && greeting.id >= 1, "greeting id 必须是正安全整数");
+			this.nextId += 1;
+			this.greetings.push(greeting);
+			if (this.storage !== null) try {
+				await this.storage.table("greetings").put(String(greeting.id), greeting);
+				await this.storage.global.set({ lastGreetedAt: greeting.createdAt });
+			} catch {}
+			this.ctx.emit("autoFlow/recorded", { greeting });
+			return greeting;
+		}
+		/** 返回全部问候记录（内存视图，已由 domain storage 水合）。 */
+		list() {
+			return Promise.resolve([...this.greetings]);
+		}
+		/** 返回最近一次提交的问候（由域事件监听器维护），首次提交前为 null。 */
+		last() {
+			return Promise.resolve(this.lastRecorded);
+		}
+		/**
+		* 执行一条命令行（宿主内经 ctx.shell，与 bash 工具同一执行器，绝不经过模型）。
+		* 输出只回调用方、不进会话日志。@Remote 严格契约保证浏览器端完整类型与校验。
+		*
+		* 相比模型工具（@deepseek-ai/dsh-tool-bash）的 shell 面，@Remote 轻执行只能拿到
+		* 能映射过来的子集：timeoutMs / stdoutMaxBytes / sandboxPolicy / 后台任务 / 结果保真。
+		* 模型工具专属的 seam（shellEnv.collect 需要 ToolExecution、sandbox 升级需要 approval
+		* + callId、abort 需要 ToolExecution.signal）不适用于 @Remote，此处不做。
+		*
+		* 注意：@Remote 方法不能带 `agent: Agent` 参数——第三方仓库的 typert 生成器无法解析
+		* `agent` lookup（其 wire 类型 SessionId 是 branded 类型，官方 monorepo 内才可用）。
+		* 因此沙箱策略退化为「部署默认」（`sandboxPolicy.resolve()` 无 session）。
+		*
+		* 后台执行不走 ctx.jobs（那是给模型工具 job_output/job_kill 用的，需要 agent owner +
+		* dsh-tool-jobs 控制器，@Remote 里拿不到）：直接用 `shell.start()` 拿 ShellProcess
+		* 句柄，自管在 this.background Map 里，execRead/execKill 直接操作句柄；卸载时统一 kill。
+		*
+		* shell / sandboxPolicy 是可选依赖：未组合时抛对应 RemoteError，插件其余照常。
+		*/
+		async exec(request) {
+			const command = request.command.trim();
+			if (command === "") throw new RemoteError("gateway/bad-request", "命令不能为空", {});
+			const actualBytes = Buffer.byteLength(command, "utf8");
+			if (actualBytes > this.resolved.maxCommandBytes) throw new RemoteError("autoFlow/command-too-long", `命令超过 ${this.resolved.maxCommandBytes} 字节`, {
+				maxBytes: this.resolved.maxCommandBytes,
+				actualBytes
+			});
+			const shell = this.ctx.get("shell");
+			if (shell === void 0) throw new RemoteError("autoFlow/shell-missing", "exec 需要组合 shell 提供方（@deepseek-ai/dsh-shell）", {});
+			const sandboxPolicy = this.ctx.get("sandboxPolicy")?.resolve();
+			const spec = shell.resolve({
+				command,
+				...request.workdir !== void 0 ? { workdir: request.workdir } : {},
+				...request.timeoutMs !== void 0 ? { timeoutMs: request.timeoutMs } : {},
+				...request.stdoutMaxBytes !== void 0 ? { stdoutMaxBytes: request.stdoutMaxBytes } : {},
+				...sandboxPolicy !== void 0 ? { sandboxPolicy } : {}
+			});
+			if (request.runInBackground === true) {
+				const proc = shell.start(spec);
+				const jobId = `auto-flow-${this.nextBgId}`;
+				this.nextBgId += 1;
+				this.background.set(jobId, proc);
+				return {
+					kind: "background",
+					jobId
+				};
+			}
+			return mapRunResult(await shell.run(spec));
+		}
+		/** 读后台进程的下一次增量/终态输出（自管 ShellProcess 句柄，不依赖 ctx.jobs）。 */
+		async execRead(jobId) {
+			const proc = this.background.get(jobId);
+			if (proc === void 0) throw new RemoteError("autoFlow/job-not-found", "后台任务不存在或已结束", {});
+			const settled = proc.status === "completed" || proc.status === "killed";
+			return {
+				text: renderProcessRead(proc.readOutput()),
+				status: proc.status,
+				...settled ? { detail: proc.signal !== null ? `signal: ${proc.signal}` : `exit code: ${proc.exitCode ?? 0}` } : {}
+			};
+		}
+		/** 请求取消后台进程（自管 ShellProcess 句柄，不依赖 ctx.jobs）。 */
+		async execKill(jobId) {
+			const proc = this.background.get(jobId);
+			if (proc === void 0) return { kind: "already-finished" };
+			return { kind: proc.kill() ? "requested" : "already-finished" };
+		}
+	};
+})();
+//#endregion
+export { AutoFlowService, AutoFlowService as default };
+
+//# sourceMappingURL=index.js.map

package/lib/typert.host.d.ts

@@ -0,0 +1,3 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */
+
+export declare const TYPERT: unknown