@khorsheed/dsh-local-agent-dsh 0.1.0-rc.6

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

@@ -0,0 +1,76 @@
+/** `local-agent-dsh` namespace dictionaries. */
+/** Dictionary namespace owned by this plugin (matches the settings namespace). */
+export declare const NS = "local-agent-dsh";
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'card.title': string;
+    'card.description': string;
+    'card.expand': string;
+    'card.collapse': string;
+    'auth.title': string;
+    'model.title': string;
+    'model.info.aria': string;
+    'model.info': string;
+    'model.placeholder': string;
+    'model.menu': string;
+    'model.menuDefault': string;
+    'model.menuDefault.cli-config': string;
+    'model.menuDefault.cli-builtin': string;
+    'model.menuDefault.last-observed': string;
+    'model.save': string;
+    'model.applied': string;
+    'model.error': string;
+    'auth.host': string;
+    'enable.title': string;
+    'enable.switch': string;
+    'enable.switch.aria': string;
+    'enable.on': string;
+    'enable.off': string;
+    'live.title': string;
+    'live.info.aria': string;
+    'live.info': string;
+    'live.applied': string;
+    'live.error': string;
+    'live.unavailable': string;
+};
+/** The local-agent-dsh namespace key union. */
+export type LocalAgentDshKey = keyof typeof zh;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The dsh harness settings card copy. */
+        'local-agent-dsh': LocalAgentDshKey;
+    }
+}
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'card.title': string;
+    'card.description': string;
+    'card.expand': string;
+    'card.collapse': string;
+    'auth.title': string;
+    'model.title': string;
+    'model.info.aria': string;
+    'model.info': string;
+    'model.placeholder': string;
+    'model.menu': string;
+    'model.menuDefault': string;
+    'model.menuDefault.cli-config': string;
+    'model.menuDefault.cli-builtin': string;
+    'model.menuDefault.last-observed': string;
+    'model.save': string;
+    'model.applied': string;
+    'model.error': string;
+    'auth.host': string;
+    'enable.title': string;
+    'enable.switch': string;
+    'enable.switch.aria': string;
+    'enable.on': string;
+    'enable.off': string;
+    'live.title': string;
+    'live.info.aria': string;
+    'live.info': string;
+    'live.applied': string;
+    'live.error': string;
+    'live.unavailable': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/locales.js

@@ -0,0 +1,67 @@
+/** `local-agent-dsh` namespace dictionaries. */
+/** Dictionary namespace owned by this plugin (matches the settings namespace). */
+export const NS = 'local-agent-dsh';
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export const zh = {
+    'card.title': 'Local Agent · dsh',
+    'card.description': 'dsh 自委派：开关、认证状态与常驻模式（live）',
+    'card.expand': '展开',
+    'card.collapse': '收起',
+    'auth.title': '认证',
+    'model.title': '默认模型',
+    'model.info.aria': '默认模型说明',
+    'model.info': '留空 = 跟随默认（输入框里显示的就是当前跟随的模型）。从列表选择或手动输入一个模型后保存，之后的每轮委派都以它起子 dsh（`--model <provider/model>`；只写模型名则沿用宿主实例的 provider）。单次委派自带的模型优先级更高；成员会话里还可用作曲器按会话切换，不影响这里的默认。改动在下一轮委派生效，进行中的轮次不受影响；评测 run 的条件在建立时冻结，中途换模型会被下一轮的模型回读判为 misattributed 而拦下。',
+    'model.placeholder': '留空 = 不传，用宿主实例的默认模型',
+    'model.menu': '选择模型',
+    'model.menuDefault': '默认（跟随宿主实例默认）',
+    'model.menuDefault.cli-config': '默认（跟随宿主默认模型：{model}）',
+    'model.menuDefault.cli-builtin': '默认（跟随宿主默认：{model}）',
+    'model.menuDefault.last-observed': '默认（跟随宿主实例默认（最近：{model}））',
+    'model.save': '保存',
+    'model.applied': '已保存，下一轮委派生效；进行中的轮次不受影响',
+    'model.error': '保存失败，请重试',
+    'auth.host': 'dsh 凭据走宿主实例的凭证设置，无需单独登录。',
+    'enable.title': 'DeepSeek 委派',
+    'enable.switch': '启用',
+    'enable.switch.aria': 'DeepSeek 委派开关',
+    'enable.on': '已开启：模型可使用 subagent_dsh 委派给本机 dsh',
+    'enable.off': '已关闭：委派只走官方内置子代理工具',
+    'live.title': '常驻模式（live）',
+    'live.info.aria': '常驻模式说明',
+    'live.info': '常驻模式 = 成员进程常驻：输出实时流入成员会话、取消不杀进程、崩溃后自动续上原会话；关闭则每轮独立进程，跑完一次性出结果。设置为全局偏好，对所有后续委派生效。',
+    'live.applied': '已保存，下一轮委派生效；进行中的轮次不受影响',
+    'live.error': '保存失败，请重试',
+    'live.unavailable': '设置服务不可用（宿主未注册 local-agent-dsh 命名空间）',
+};
+/** English dictionary, checked complete against the zh key set. */
+export const en = {
+    'card.title': 'Local Agent · dsh',
+    'card.description': 'dsh self-delegation: toggle, credential status, and resident (live) mode',
+    'card.expand': 'Expand',
+    'card.collapse': 'Collapse',
+    'auth.title': 'Authentication',
+    'model.title': 'Default model',
+    'model.info.aria': 'About the default model',
+    'model.info': "Blank = follow the default (the input shows the model it currently follows). Pick from the list or type a model by hand and save, and every later delegation round starts the sub-dsh with it (`--model <provider/model>`; a bare id keeps the host instance provider). A model named by one delegation outranks this key; inside a member session the composer can also switch the model per session, without touching this default. A change applies to the next round and never disturbs a round in flight; an evaluation run freezes its condition at setup, so switching mid-run is caught by the model read-back on the next round and fails the run as misattributed.",
+    'model.placeholder': "Blank = pass none, use the host instance default",
+    'model.menu': 'Pick a model',
+    'model.menuDefault': 'Default (follow the host instance default)',
+    'model.menuDefault.cli-config': 'Default (follow the host default model: {model})',
+    'model.menuDefault.cli-builtin': 'Default (follow the host default: {model})',
+    'model.menuDefault.last-observed': 'Default (follow the host instance default (last: {model}))',
+    'model.save': 'Save',
+    'model.applied': 'Saved — takes effect on the next delegation round; rounds in flight are unaffected',
+    'model.error': 'Save failed, please retry',
+    'auth.host': 'dsh authenticates through the host instance’s credential settings — no separate sign-in.',
+    'enable.title': 'DeepSeek delegation',
+    'enable.switch': 'Enabled',
+    'enable.switch.aria': 'DeepSeek delegation switch',
+    'enable.on': 'ON: the model can delegate to the local dsh via subagent_dsh',
+    'enable.off': 'OFF: delegation goes through the official in-process subagent tool only',
+    'live.title': 'Resident mode (live)',
+    'live.info.aria': 'About resident mode',
+    'live.info': 'Resident mode keeps the member process alive: output streams into the member session in real time, cancelling does not kill the process, and a crash resumes the same session. Off means every round runs as an independent one-shot process. The setting is global and applies to every later delegation.',
+    'live.applied': 'Saved — takes effect on the next delegation round; rounds in flight are unaffected',
+    'live.error': 'Save failed, please retry',
+    'live.unavailable': 'Settings service unavailable (the host did not register the local-agent-dsh namespace)',
+};

package/lib/types/dsh-cli-provider.d.ts

@@ -0,0 +1,213 @@
+/**
+ * One-shot and resumable dsh CLI subagent lifecycle: spawn the sub-dsh
+ * headless profile (`dsh --profile <name> --session-id <uuid> "<task>"` or
+ * `--resume <uuid>`) through the subprocess seam with the harness scoped home
+ * as the child's `$DSH_HOME` and the parent's resolved DeepSeek key injected
+ * explicitly (the shared env scrub drops credential-shaped names and every
+ * `DSH_*` fact; the explicit env layer is the sanctioned override). The
+ * caller-supplied session id is the same uuid on every round: the fresh round
+ * creates the sub-dsh session with it, and each resume round continues exactly
+ * that session. No stdout parsing — the sub-dsh session id is known a priori.
+ * @module @khorsheed/dsh-local-agent-dsh/dsh-cli-provider
+ */
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import { type ResolvedSubagentStartRequest, type SubagentCapabilities, type SubagentProvider, type SubagentRun, type SubagentStartRequest } from '@deepseek-ai/dsh-subagent';
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { DelegationExecTarget } from '@khorsheed/dsh-local-agent/types';
+import type { LocalAgentDshConfig } from './index.ts';
+import type { DshLiveDriver } from './live-driver.ts';
+/**
+ * Spawn-env name carrying the bridge entry path into the sub-dsh process,
+ * where the headless bundle's mcp-client row reads it (`!!js`). The name is a
+ * family-internal contract between this provider and
+ * `@khorsheed/dsh-local-agent-dsh-headless`'s cordis.patch.yml — the member
+ * bridge itself reads only the socket/token env.
+ */
+export declare const MEMBER_BRIDGE_ENTRY_ENV = "DSH_MEMBER_BRIDGE_ENTRY";
+/**
+ * The `NODE_OPTIONS` a containerized round carries. dsh's HTTP client is
+ * node's `fetch` (undici), which does NOT read `HTTP(S)_PROXY` by default: in
+ * an evaluation unit whose only egress is a whitelist proxy the CLI dials the
+ * API directly and fails with a transport error while the proxy never even
+ * receives a `CONNECT`. `--use-env-proxy` opens undici's `EnvHttpProxyAgent`,
+ * which does read those variables. Measured on the T16 image: without it the
+ * round fails, with it the same round answers in 1.3 s. dsh is the only one
+ * of the four CLIs that needs an extra knob to run inside a unit — the other
+ * three carry their own proxy support — so the injection is automatic rather
+ * than something every caller must remember, and the harness reports it in
+ * its effective settings so the condition file can see it.
+ */
+export declare const CONTAINER_NODE_OPTIONS = "--use-env-proxy";
+/** Default POSIX grace between subprocess termination tiers. */
+export declare const DEFAULT_DISPOSE_GRACE_MS = 3000;
+/** Default interval between live session-mirror polls during a run. */
+export declare const DEFAULT_LIVE_MIRROR_INTERVAL_MS = 2000;
+/**
+ * Member channel registration for one sub-dsh process lifetime: mint the
+ * per-run token and prepare the env the sub-dsh's mcp-client row reads (the
+ * headless bundle patch declares the bridge server with `!!js` env lookups;
+ * `@deepseek-ai/dsh-mcp-client` resolves from the installation's dependency
+ * closure linked into the scoped home's profiles/node_modules fallback).
+ * Returns undefined when the mounted core predates the member channel
+ * (declare-and-degrade: the run proceeds unchanged — the row's
+ * failOnStartupError is off, and the bridge itself fails closed on the absent
+ * token). Token-only auth: host 0.1.5 removed the child pid the parentage
+ * cross-check used; the per-run token is the sole credential (see the package
+ * README's threat model). The exec driver registers per round; the live driver
+ * registers per resident process and releases on reclaim.
+ */
+export interface MemberRunHandle {
+    readonly env: Readonly<NodeJS.ProcessEnv>;
+    release(): void;
+}
+/** Register one member run with the channel; see {@link MemberRunHandle}. */
+export declare function registerMemberRun(ctx: Context, providerName: string, childSessionId: string, parentSessionId: string): MemberRunHandle | undefined;
+/**
+ * One-shot dsh CLI subagent provider: every accepted fresh run starts a fresh
+ * sub-dsh headless process in the delegating Session's workspace, under the
+ * harness scoped home; a resume round (the family tool's staged resume intent)
+ * continues the SAME sub-dsh session with `--resume <uuid>` inside the SAME
+ * dsh child session. Mirrors the other family providers' one-shot lifecycle,
+ * including `NO_START_CAPABILITIES` — continuation is the family's own resume
+ * mechanism, not the official Agent-type continuable seam. With the live
+ * driver configured (`live: true`), rounds instead go to the resident sub-dsh
+ * serve process (see live-driver.ts); the exec path below stays the fallback.
+ */
+export declare class DshCliProvider implements SubagentProvider {
+    private readonly ctx;
+    private readonly config;
+    private readonly live?;
+    private readonly model?;
+    private readonly overrides?;
+    readonly name = "dsh-cli";
+    readonly capabilities: SubagentCapabilities;
+    readonly inheritsParentContext = false;
+    /**
+     * @param live - the live driver, or a resolver returning the current
+     *   generation's driver per member (the settings toggle swaps generations;
+     *   a resolver may return undefined to steer one member's round to exec
+     *   while a retiring generation still hosts it).
+     */
+    /**
+     * @param model - resolver for the harness's `model` plugin-config key, read
+     *   PER ROUND so a settings-card write reaches the next delegation without a
+     *   reload. A delegation that names its own model outranks it.
+     * @param overrides - resolver for the member's session-level model override
+     *   (the composer picker, owned by the model broker). It outranks BOTH the
+     *   delegation's recorded model and the configured one: on the exec path it
+     *   re-points the next round's `--model`, and on the live path it is the
+     *   member's start model — a resident runtime bound to a different model is
+     *   retired so the round respawns onto the override.
+     */
+    constructor(ctx: Context, config: LocalAgentDshConfig, live?: DshLiveDriver | ((childSessionId: string) => DshLiveDriver | undefined) | undefined, model?: (() => string | undefined) | undefined, overrides?: ((childSessionId: string) => string | undefined) | undefined);
+    /** Resolve the live driver for one round's member, if live is on for it. */
+    private liveDriver;
+    /** Per-round member-channel registration for the exec path (see {@link registerMemberRun}). */
+    private memberRun;
+    start(request: ResolvedSubagentStartRequest): Promise<SubagentRun>;
+    /** Fresh round: record the child session and delegation, spawn the sub-dsh create. */
+    private startDshFresh;
+    /** Resume round: continue the recorded sub-dsh session inside the existing child session. */
+    private startDshResume;
+}
+/** Fully resolved inputs for one sub-dsh CLI run. */
+export interface DshCliRunSpec {
+    /** Parent Session workspace; also the sub-dsh process cwd. */
+    readonly cwd: string;
+    /** The `dsh` harness's scoped home, injected as the child's `$DSH_HOME`. */
+    readonly homeDir: string;
+    /**
+     * The named scope {@link DshCliRunSpec.homeDir} belongs to, when the round
+     * runs against one. Absent means the default scope. Carried so a completed
+     * round grades the credential of the scope it actually used.
+     */
+    readonly scope?: string | undefined;
+    /** dsh subagent session recording this delegation. */
+    readonly childSession?: Session | undefined;
+    /**
+     * The sub-dsh session id for this round — the caller-supplied uuid, passed
+     * as `--session-id` on a fresh round and `--resume` on a continuation.
+     */
+    readonly sessionId: string;
+    /**
+     * The model this round runs, spelled `provider/model` — passed to the
+     * sub-dsh as `--model`, which overrides the instance's default selection
+     * for that launch. Absent means no flag at all: the sub-dsh runs the
+     * instance's default, exactly as it did before the flag existed.
+     */
+    readonly model?: string | undefined;
+    readonly effort?: string | undefined;
+    /**
+     * Resume round: continue the sub-dsh session named by `sessionId` with
+     * `--resume` instead of a fresh `--session-id`, appending this round into
+     * the same child session under the given turn number.
+     */
+    readonly resume?: {
+        readonly cliSessionId: string;
+        readonly turn: number;
+    } | undefined;
+    /**
+     * Live-mirror poll interval during the run; absent applies the default
+     * ({@link DEFAULT_LIVE_MIRROR_INTERVAL_MS}). Tests inject a small value.
+     */
+    readonly liveMirrorIntervalMs?: number | undefined;
+    /**
+     * Member channel: the per-run bridge coordinates (socket path, token,
+     * bridge entry) merged into the explicit env layer — the sub-dsh's
+     * mcp-client row reads them via `!!js` env lookups.
+     */
+    readonly memberEnv?: Readonly<NodeJS.ProcessEnv> | undefined;
+    /**
+     * Run the sub-dsh inside this container instead of on the host: the argv
+     * below is wrapped in `docker exec` and the explicit env layer is forwarded
+     * through NAME-only `-e` flags (the resolved API key therefore never
+     * reaches the host process table). Absent means the host spawn, unchanged.
+     */
+    readonly exec?: DelegationExecTarget | undefined;
+    /**
+     * The dsh build the round runs, resolved lazily and cached by the family
+     * probe. The sub-dsh session log names its model but never its build, so
+     * this is the only version channel the round's read-back has.
+     */
+    readonly cliVersion?: (() => Promise<string | undefined>) | undefined;
+}
+/** Validate and join the one-shot task before crossing the process boundary. */
+export declare function dshTextTask(prompt: readonly ContentBlock[]): string;
+/**
+ * The dsh launch argv the provider replicates: the parent instance's own
+ * node + tsx import + entry point, so the sub-dsh runs the same dsh build as
+ * its parent. A configured `cliLaunch` replaces this entirely.
+ * @param config - plugin config carrying the optional override.
+ * @returns the launch prefix before the profile flag.
+ */
+export declare function dshLaunchArgv(config: LocalAgentDshConfig): readonly string[];
+/**
+ * The dsh build the sub-dsh runs, probed by asking the very launch argv the
+ * delegation would spawn for its `--version` (the sub-dsh replicates the
+ * parent instance's own node + entry point, so the parent's build IS the
+ * child's). Cached by the family probe against that entry script's identity,
+ * so a harness upgrade re-probes and an unchanged one never spawns twice.
+ * @param ctx - host context carrying the subprocess seam.
+ * @param config - plugin config carrying the optional launch override.
+ * @param homeDir - the harness's scoped home.
+ * @returns the version, or undefined when the launch cannot be asked.
+ */
+export declare function dshCliVersion(ctx: Context, config: LocalAgentDshConfig, homeDir: string): Promise<string | undefined>;
+/**
+ * Start the real sub-dsh headless child and publish its run. The final answer
+ * is printed to stdout; stderr is inherited for diagnostics. The run id is
+ * the child session id for a session-backed run, so the tool's
+ * `resume="<id>"` self-description names the same handle the registry
+ * records.
+ * @param request - resolved shared subagent request.
+ * @param spec - workspace, scoped home, child session, and resume facts.
+ * @returns the published run after the child starts.
+ */
+export declare function startDshCliRun(request: SubagentStartRequest, spec: DshCliRunSpec & {
+    config: LocalAgentDshConfig;
+    ctx: Context;
+}): Promise<SubagentRun>;
+/** Resolve the sub-dsh credential or fail loud before any process spawns. */
+export declare function resolveApiKey(ctx: Context, config: LocalAgentDshConfig): Promise<string>;
+//# sourceMappingURL=dsh-cli-provider.d.ts.map