dsh-connect 0.8.0 → 0.9.2

package/lib/settings/namespace.d.ts

@@ -0,0 +1,263 @@
+/**
+ * The `dsh-connect` user-settings seam.
+ *
+ * DSH 0.2 replaced the plugin-facing settings API. The old `ctx.settings`
+ * namespace contract (`installSection(owner, ns, schema, entry, hooks)` backed by
+ * a `$DSH_HOME/settings.yaml` section keyed by the plugin *name*) is gone; what
+ * is left is `SettingsForms`, which edits a plugin's **profile entry** and
+ * hot-commits the fields that plugin declared `volatile`:
+ *
+ * - **Reads come from our own config.** A field declared with
+ *   `z.…volatile()` arrives in `apply()` as a *reference* (`{ get() }`) rather
+ *   than a value, and the loader updates that reference in place when the
+ *   profile entry changes — no remount, no `apply()` re-entry. So there is no
+ *   read API to call: the live state is `refs.get()`, and this module's
+ *   `materializeConfig()` turns the ref-carrying config into a plain snapshot.
+ * - **Writes go through `SettingsForms.replace(ns, section)`**, where `ns` is
+ *   the profile entry id (`connect`) — *not* the package name. `replace` resets
+ *   every live field to its inherited value and then applies the supplied ones,
+ *   which is exactly "this is the user's complete visible config" — and why a
+ *   *partial* section is a destructive write: a field the caller omits is
+ *   reset, not preserved. Callers that mean to preserve something must merge
+ *   it in first ({@link mergeSections}).
+ * - **`volatileForm(schema)` must not be empty**, or `replace` refuses the
+ *   write with `Plugin entry "connect" has no volatile fields`. That is why
+ *   `paneConfigFields()` exists and must keep declaring the pane's field set.
+ *
+ * **Only volatile *leaves* may be declared — never a volatile container.**
+ * `projectForm(form, base)` projects the *base* layer down to volatile fields
+ * before the write is merged: if `feishu` itself were volatile it would be
+ * copied whole into the settings document, `appSecret` and all. Declaring the
+ * leaves keeps every non-pane key (`appSecret`, `appId`, …) in the raw
+ * remainder, where `strip()` leaves ordinary config untouched. This is the same
+ * hazard `sectionOf()` guards on the write path, from the other side: an
+ * undeclared key in a *submitted* section must not reach the document either.
+ *
+ * Secrets therefore never appear in either declared surface: they live in the
+ * DSH credential store (`ctx.credentials`), which is where onboarding and the
+ * `FEISHU_*`-style env layering already put them, and `settings`-side documents
+ * are plain files users are invited to paste into bug reports.
+ *
+ * @module dsh-connect/settings/namespace
+ */
+import z from "@deepseek-ai/schemastery";
+import { type ChannelName, type LoggerLike } from "./channels.js";
+/**
+ * The section key the pre-0.2 harness read from `$DSH_HOME/settings.yaml`, keyed
+ * by plugin *name*. Nothing writes it any more; `legacy-import.ts` reads it once
+ * so an upgrading user's pane settings survive the switch to the new store.
+ */
+export declare const LEGACY_CONNECT_SECTION = "dsh-connect";
+/**
+ * The automatic-page policy for our entry. `auto: false` stops the host's
+ * Plugins page from generating a second, generic form for `connect`: this
+ * plugin ships its own client pane (`client/settings-client.mjs`), and two
+ * editors writing the same fields through different UIs is how a save silently
+ * reverts. Register it with `settings.configure(policy, ctx.fiber)` — the
+ * `owner` argument matters, see `index.ts`.
+ */
+export declare const CONNECT_PRESENTATION: Record<string, unknown>;
+/** A config reference: a stable handle whose value the loader replaces in place. */
+export interface ConfigRef<T = unknown> {
+    /** The current immutable snapshot; `undefined` for a field absent from the config. */
+    get(): T;
+}
+/** Whether a parsed config value is a volatile reference rather than plain data. */
+export declare function isConfigRef(value: unknown): value is ConfigRef;
+/**
+ * Copy a ref-carrying config into plain data: every reference replaced by its
+ * current snapshot, recursively, so callers can hand the result to code that
+ * only understands plain objects (the adapters, the settings pane, tests).
+ *
+ * The copy is *fresh* rather than the snapshot itself, deliberately: snapshots
+ * are deeply frozen, and both `ChannelRuntime` (which spreads a channel's
+ * config into a new object) and the pane (which holds a form to edit) want
+ * mutable data. Cycles in ordinary config are tolerated via `seen`; a snapshot
+ * cannot contain references (the loader commits plain data), but the walk
+ * treats them uniformly so it does not matter.
+ *
+ * **A key that materializes to `undefined` is dropped, not copied.** Every
+ * declared volatile leaf is present in the parsed config even when the profile
+ * never set it — `z.object({transport: z.any().volatile()})` resolves an absent
+ * `transport` to a reference to `undefined` — so a faithful copy would hand the
+ * adapters `{transport: undefined, language: undefined, …}`. That is not the
+ * same as absent: `ChannelRuntime` resolves a channel as
+ * `{...channelDefaults, ...overrides}`, and since `language` is a key of *both*
+ * tables, a channel's own `language: undefined` would mask the shared
+ * `channelDefaults.language` every other channel still gets. Config here is
+ * JSON-shaped (a profile entry, a YAML document, the settings RPC), where
+ * `undefined` can only ever mean "this key was not set", so dropping it restores
+ * exactly the shape a plain `z.any()` field used to produce.
+ */
+export declare function materializeConfig<T>(value: T): T;
+/**
+ * The volatile half of the plugin `Config`, derived from the same field tables
+ * the settings pane renders. Deriving rather than restating them is the point:
+ * a field added to `CHANNEL_CONFIG_FIELDS` becomes user-editable *and*
+ * hot-appliable in one edit, and a field the pane offers can never be missing
+ * from the schema (a write of an undeclared path is refused by the host).
+ *
+ * Every leaf is `z.any()` on purpose. A stricter node would let a stale value
+ * in a profile — a `webhookPort` written as a string, a `dmMode` from a version
+ * that spelled it differently — abort config validation and keep the bridge
+ * from loading at all. The pane's own `coerceConfigValue` is what keeps types
+ * honest; the schema's job here is only to say "these paths are live-editable".
+ *
+ * `channels` is a loose `z.array(z.string())` for the same reason, and it is
+ * safe because `ChannelRuntime` skips a name it has no adapter for (with a log
+ * line) instead of throwing. Its explicit `.default([...CHANNELS])` is load
+ * bearing, not cosmetic: a volatile *array* resolves an absent key to `[]`
+ * rather than `undefined`, so a profile that never set `channels` would
+ * otherwise materialize an empty list and start no adapter at all, where the
+ * documented default — and the pre-volatile behaviour — is every channel. A
+ * default also keeps `replace()`'s reset target honest: an omitted `channels`
+ * in a section resets to all channels, not to none. `[...CHANNELS]` rather than
+ * `CHANNELS` so the schema cannot hand out the module's own array.
+ */
+export declare function paneConfigFields(): Record<string, z<any>>;
+/** Channel-agnostic defaults section of the namespace. */
+export type ConnectSectionDefaults = Record<string, unknown> & {
+    language?: string;
+    notifyLevel?: string;
+};
+/**
+ * The pane-editable slice of the config: the whole of what this plugin stores
+ * on the user's behalf. Every field is optional — a user who only ever edits
+ * `channels` leaves the rest absent, and each adapter applies its own default
+ * for anything missing.
+ */
+export interface ConnectSection {
+    channels?: ChannelName[];
+    channelDefaults?: ConnectSectionDefaults;
+    feishu?: Record<string, unknown>;
+    telegram?: Record<string, unknown>;
+    dingtalk?: Record<string, unknown>;
+    web?: Record<string, unknown>;
+}
+export interface SectionOptions {
+    /**
+     * Materialize `channels` even when the source omits the key. True (the
+     * default) for the *write* path: there an absent key means "the caller did
+     * not speak to the channel list", and a section without `channels` handed to
+     * `replace()` is a reset — reading it as "activate nothing" would switch
+     * every adapter off. False for the legacy import, where an absent key must
+     * stay absent so the profile's own `channels` keeps applying.
+     *
+     * Note this is about the *key being absent*, not about an empty array: a user
+     * who unchecks every channel saves `channels: []`, which is an explicit
+     * "none" and is left alone.
+     */
+    defaultChannels?: boolean;
+}
+/**
+ * Project a config onto the pane's field set: declared, non-secret keys only.
+ *
+ * Two callers, one guard. For a **read** the input is a materialized snapshot
+ * of our own config (a profile may legitimately carry `appSecret`, and it must
+ * not travel out through the snapshot the pane receives); for a **write** the
+ * input is untrusted JSON from the settings RPC, and an undeclared key would
+ * otherwise be preserved into the profile by schemastery's passthrough. Both
+ * are the same projection, so both get the same answer.
+ *
+ * `channels` is emitted unconditionally on the write path because an absent
+ * array resolves to `[]` (schemastery's array default), which would read as
+ * "activate nothing". Unknown channel names are dropped rather than refused:
+ * a name this version does not know is not a reason to reject the whole save.
+ */
+export declare function sectionOf(config: unknown, options?: SectionOptions): ConnectSection;
+/**
+ * Layer one section over another: for each channel and for the shared defaults,
+ * the override's own keys win and the base's surviving keys are kept.
+ *
+ * This exists because of how `replace()` treats an omission — see the module
+ * doc. A caller that has a section in force and only wants to change part of it
+ * must merge, never pass the part alone: `feishu: { transport }` resets every
+ * other declared `feishu` field, and a section without `channels` resets the
+ * channel list itself, which switches every adapter off.
+ */
+export declare function mergeSections(base: ConnectSection, override: ConnectSection): ConnectSection;
+/**
+ * The slice of `SettingsForms` this module calls. Declared structurally so the
+ * plugin keeps no dependency on `@deepseek-ai/dsh-settings` (a `dsh-base` row we
+ * cannot import at build time): a missing method degrades to "no live store"
+ * rather than a crash, and the settings service falls back to its JSON file.
+ */
+export interface SettingsProviderLike {
+    /**
+     * Register this plugin instance's page policy. `owner` must be the plugin's
+     * own fiber — the default is the *service's* fiber, which would make the
+     * policy invisible to this instance's page and leak on every reload.
+     * @returns Disposer; register it with the plugin's effects.
+     */
+    configure?(presentation: Record<string, unknown>, owner?: unknown): () => void;
+    /**
+     * Reset every live field to its inherited value, then apply `section`;
+     * ordinary (non-live) config is preserved.
+     *
+     * `expectedRevision` is deliberately omitted by every caller here: `write`
+     * only enforces the revision check when it is defined, and we read our state
+     * from config references rather than from `describe()`, so there is no
+     * revision to round-trip. Two concurrent editors of the pane would still both
+     * land, last write winning — the same behaviour the JSON store had.
+     */
+    replace?(ns: string, section: unknown, expectedRevision?: number): Promise<unknown>;
+}
+/** A live handle onto the profile entry: read the effective section, write a new one. */
+export interface LiveConnectSection {
+    /** The section in force right now, read from the config references. */
+    read(): ConnectSection;
+    /**
+     * Replace the user's section with the declared-key projection of `config`,
+     * then hand the new section to `onChange`. Rejects if the host refuses the
+     * write (a non-volatile path, a missing entry) — the caller is expected to
+     * surface that rather than swallow it.
+     */
+    write(config: unknown): Promise<void>;
+}
+/** Outcome of wiring the seam. */
+export interface InstallConnectSectionResult {
+    /** True when a write handle exists, i.e. a save can land and take effect. */
+    live: boolean;
+    /** The section in force at install time. */
+    section: ConnectSection;
+    /** Read/write onto the profile entry; absent when the seam is unavailable. */
+    handle?: LiveConnectSection;
+}
+export interface InstallConnectSectionOptions<Ctx extends LoggerLike> {
+    /** The plugin's own context: `logger` for diagnostics, and the fallback owner. */
+    owner: Ctx;
+    settings: SettingsProviderLike | undefined;
+    /** The ref-carrying config this plugin was applied with (see `materializeConfig`). */
+    config: unknown;
+    /** The profile entry id (`connect`), from the loader entry. */
+    ns: string | undefined;
+    /** Called with the in-force section at install and after every successful write. */
+    onChange: (section: ConnectSection) => void;
+}
+/**
+ * Wire the plugin's config references to the host's settings service.
+ *
+ * Never throws. A host without `SettingsForms`, a context where the entry id
+ * cannot be resolved (a bare unit-test context, or a plugin mounted outside the
+ * loader) and a refused `replace` all degrade to `live: false` with one warning
+ * line — a settings integration that cannot work must never be the reason a
+ * bridge fails to start.
+ */
+export declare function installConnectSection<Ctx extends LoggerLike>(options: InstallConnectSectionOptions<Ctx>): InstallConnectSectionResult;
+declare module "@deepseek-ai/cordis" {
+    interface Events {
+        /**
+         * Dispatched to the owning fiber when the loader commits changed volatile
+         * config paths **in place**, without remounting the plugin — a settings-pane
+         * save, or an edit to a running profile's patch. The payload is the changed
+         * paths; a consumer re-reads the references it was applied with
+         * ({@link materializeConfig}) rather than being told the new values.
+         *
+         * Declared here because cordis's `on()` typechecks event names against this
+         * interface and nothing this plugin depends on names the event — an
+         * undeclared name would be a type error at the only call site (`index.ts`).
+         */
+        "loader/volatile-update"(paths: readonly (readonly string[])[]): void;
+    }
+}
+//# sourceMappingURL=namespace.d.ts.map

package/lib/settings/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/settings/namespace.ts"],"names":[],"mappings":"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"}

package/lib/settings/namespace.js

@@ -0,0 +1,287 @@
+/**
+ * The `dsh-connect` user-settings seam.
+ *
+ * DSH 0.2 replaced the plugin-facing settings API. The old `ctx.settings`
+ * namespace contract (`installSection(owner, ns, schema, entry, hooks)` backed by
+ * a `$DSH_HOME/settings.yaml` section keyed by the plugin *name*) is gone; what
+ * is left is `SettingsForms`, which edits a plugin's **profile entry** and
+ * hot-commits the fields that plugin declared `volatile`:
+ *
+ * - **Reads come from our own config.** A field declared with
+ *   `z.…volatile()` arrives in `apply()` as a *reference* (`{ get() }`) rather
+ *   than a value, and the loader updates that reference in place when the
+ *   profile entry changes — no remount, no `apply()` re-entry. So there is no
+ *   read API to call: the live state is `refs.get()`, and this module's
+ *   `materializeConfig()` turns the ref-carrying config into a plain snapshot.
+ * - **Writes go through `SettingsForms.replace(ns, section)`**, where `ns` is
+ *   the profile entry id (`connect`) — *not* the package name. `replace` resets
+ *   every live field to its inherited value and then applies the supplied ones,
+ *   which is exactly "this is the user's complete visible config" — and why a
+ *   *partial* section is a destructive write: a field the caller omits is
+ *   reset, not preserved. Callers that mean to preserve something must merge
+ *   it in first ({@link mergeSections}).
+ * - **`volatileForm(schema)` must not be empty**, or `replace` refuses the
+ *   write with `Plugin entry "connect" has no volatile fields`. That is why
+ *   `paneConfigFields()` exists and must keep declaring the pane's field set.
+ *
+ * **Only volatile *leaves* may be declared — never a volatile container.**
+ * `projectForm(form, base)` projects the *base* layer down to volatile fields
+ * before the write is merged: if `feishu` itself were volatile it would be
+ * copied whole into the settings document, `appSecret` and all. Declaring the
+ * leaves keeps every non-pane key (`appSecret`, `appId`, …) in the raw
+ * remainder, where `strip()` leaves ordinary config untouched. This is the same
+ * hazard `sectionOf()` guards on the write path, from the other side: an
+ * undeclared key in a *submitted* section must not reach the document either.
+ *
+ * Secrets therefore never appear in either declared surface: they live in the
+ * DSH credential store (`ctx.credentials`), which is where onboarding and the
+ * `FEISHU_*`-style env layering already put them, and `settings`-side documents
+ * are plain files users are invited to paste into bug reports.
+ *
+ * @module dsh-connect/settings/namespace
+ */
+import z from "@deepseek-ai/schemastery";
+import { CHANNELS } from "./channels.js";
+import { CHANNEL_CONFIG_FIELDS, CHANNEL_DEFAULT_FIELDS } from "./settings-model.js";
+/**
+ * The section key the pre-0.2 harness read from `$DSH_HOME/settings.yaml`, keyed
+ * by plugin *name*. Nothing writes it any more; `legacy-import.ts` reads it once
+ * so an upgrading user's pane settings survive the switch to the new store.
+ */
+export const LEGACY_CONNECT_SECTION = "dsh-connect";
+/**
+ * The automatic-page policy for our entry. `auto: false` stops the host's
+ * Plugins page from generating a second, generic form for `connect`: this
+ * plugin ships its own client pane (`client/settings-client.mjs`), and two
+ * editors writing the same fields through different UIs is how a save silently
+ * reverts. Register it with `settings.configure(policy, ctx.fiber)` — the
+ * `owner` argument matters, see `index.ts`.
+ */
+export const CONNECT_PRESENTATION = { auto: false };
+/**
+ * The shared cross-ESM volatile protocol (`cosmokit`'s `Symbol.for` key).
+ *
+ * Looked up by symbol rather than by importing `@deepseek-ai/cosmokit`: the
+ * host may hand us refs created by *its* copy of the library, and `Symbol.for`
+ * is the one identifier that is identical across copies. Sniffing the key (as
+ * cosmokit's own `isVolatile` does) is more forgiving than `instanceof`, which
+ * would fail across an ESM/CJS duplicate.
+ */
+const VOLATILE_WRITE = Symbol.for("cosmokit.volatile.write");
+/** Whether a parsed config value is a volatile reference rather than plain data. */
+export function isConfigRef(value) {
+    return typeof value === "object" && value !== null && VOLATILE_WRITE in value;
+}
+/**
+ * Copy a ref-carrying config into plain data: every reference replaced by its
+ * current snapshot, recursively, so callers can hand the result to code that
+ * only understands plain objects (the adapters, the settings pane, tests).
+ *
+ * The copy is *fresh* rather than the snapshot itself, deliberately: snapshots
+ * are deeply frozen, and both `ChannelRuntime` (which spreads a channel's
+ * config into a new object) and the pane (which holds a form to edit) want
+ * mutable data. Cycles in ordinary config are tolerated via `seen`; a snapshot
+ * cannot contain references (the loader commits plain data), but the walk
+ * treats them uniformly so it does not matter.
+ *
+ * **A key that materializes to `undefined` is dropped, not copied.** Every
+ * declared volatile leaf is present in the parsed config even when the profile
+ * never set it — `z.object({transport: z.any().volatile()})` resolves an absent
+ * `transport` to a reference to `undefined` — so a faithful copy would hand the
+ * adapters `{transport: undefined, language: undefined, …}`. That is not the
+ * same as absent: `ChannelRuntime` resolves a channel as
+ * `{...channelDefaults, ...overrides}`, and since `language` is a key of *both*
+ * tables, a channel's own `language: undefined` would mask the shared
+ * `channelDefaults.language` every other channel still gets. Config here is
+ * JSON-shaped (a profile entry, a YAML document, the settings RPC), where
+ * `undefined` can only ever mean "this key was not set", so dropping it restores
+ * exactly the shape a plain `z.any()` field used to produce.
+ */
+export function materializeConfig(value) {
+    return walk(value, new WeakMap());
+}
+function walk(value, seen) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (isConfigRef(value))
+        return walk(value.get(), seen);
+    const known = seen.get(value);
+    if (known !== undefined)
+        return known;
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value)
+            out.push(walk(item, seen));
+        return out;
+    }
+    const out = {};
+    seen.set(value, out);
+    for (const [key, child] of Object.entries(value)) {
+        const materialized = walk(child, seen);
+        if (materialized !== undefined)
+            out[key] = materialized;
+    }
+    return out;
+}
+/**
+ * The volatile half of the plugin `Config`, derived from the same field tables
+ * the settings pane renders. Deriving rather than restating them is the point:
+ * a field added to `CHANNEL_CONFIG_FIELDS` becomes user-editable *and*
+ * hot-appliable in one edit, and a field the pane offers can never be missing
+ * from the schema (a write of an undeclared path is refused by the host).
+ *
+ * Every leaf is `z.any()` on purpose. A stricter node would let a stale value
+ * in a profile — a `webhookPort` written as a string, a `dmMode` from a version
+ * that spelled it differently — abort config validation and keep the bridge
+ * from loading at all. The pane's own `coerceConfigValue` is what keeps types
+ * honest; the schema's job here is only to say "these paths are live-editable".
+ *
+ * `channels` is a loose `z.array(z.string())` for the same reason, and it is
+ * safe because `ChannelRuntime` skips a name it has no adapter for (with a log
+ * line) instead of throwing. Its explicit `.default([...CHANNELS])` is load
+ * bearing, not cosmetic: a volatile *array* resolves an absent key to `[]`
+ * rather than `undefined`, so a profile that never set `channels` would
+ * otherwise materialize an empty list and start no adapter at all, where the
+ * documented default — and the pre-volatile behaviour — is every channel. A
+ * default also keeps `replace()`'s reset target honest: an omitted `channels`
+ * in a section resets to all channels, not to none. `[...CHANNELS]` rather than
+ * `CHANNELS` so the schema cannot hand out the module's own array.
+ */
+export function paneConfigFields() {
+    const fields = {
+        channels: z.array(z.string()).default([...CHANNELS]).volatile(),
+    };
+    const defaults = {};
+    for (const field of CHANNEL_DEFAULT_FIELDS)
+        defaults[field.key] = z.any().volatile();
+    fields.channelDefaults = z.object(defaults);
+    for (const name of CHANNELS) {
+        const channel = {};
+        for (const field of CHANNEL_CONFIG_FIELDS[name])
+            channel[field.key] = z.any().volatile();
+        if (Object.keys(channel).length > 0)
+            fields[name] = z.object(channel);
+    }
+    return fields;
+}
+/**
+ * Project a config onto the pane's field set: declared, non-secret keys only.
+ *
+ * Two callers, one guard. For a **read** the input is a materialized snapshot
+ * of our own config (a profile may legitimately carry `appSecret`, and it must
+ * not travel out through the snapshot the pane receives); for a **write** the
+ * input is untrusted JSON from the settings RPC, and an undeclared key would
+ * otherwise be preserved into the profile by schemastery's passthrough. Both
+ * are the same projection, so both get the same answer.
+ *
+ * `channels` is emitted unconditionally on the write path because an absent
+ * array resolves to `[]` (schemastery's array default), which would read as
+ * "activate nothing". Unknown channel names are dropped rather than refused:
+ * a name this version does not know is not a reason to reject the whole save.
+ */
+export function sectionOf(config, options = {}) {
+    const source = (config !== null && typeof config === "object" ? config : {});
+    const section = {};
+    const rawChannels = source.channels;
+    if (Array.isArray(rawChannels)) {
+        section.channels = rawChannels.filter((name) => CHANNELS.includes(name));
+    }
+    else if (options.defaultChannels !== false) {
+        section.channels = [...CHANNELS];
+    }
+    const defaults = {};
+    const rawDefaults = (source.channelDefaults ?? {});
+    for (const field of CHANNEL_DEFAULT_FIELDS) {
+        if (rawDefaults[field.key] !== undefined)
+            defaults[field.key] = rawDefaults[field.key];
+    }
+    if (Object.keys(defaults).length > 0)
+        section.channelDefaults = defaults;
+    for (const name of CHANNELS) {
+        const raw = (source[name] ?? {});
+        const projected = {};
+        for (const field of CHANNEL_CONFIG_FIELDS[name]) {
+            if (raw[field.key] !== undefined)
+                projected[field.key] = raw[field.key];
+        }
+        if (Object.keys(projected).length > 0)
+            section[name] = projected;
+    }
+    return section;
+}
+/**
+ * Layer one section over another: for each channel and for the shared defaults,
+ * the override's own keys win and the base's surviving keys are kept.
+ *
+ * This exists because of how `replace()` treats an omission — see the module
+ * doc. A caller that has a section in force and only wants to change part of it
+ * must merge, never pass the part alone: `feishu: { transport }` resets every
+ * other declared `feishu` field, and a section without `channels` resets the
+ * channel list itself, which switches every adapter off.
+ */
+export function mergeSections(base, override) {
+    const merged = {};
+    const channels = override.channels ?? base.channels;
+    if (channels !== undefined)
+        merged.channels = [...channels];
+    const defaults = { ...base.channelDefaults, ...override.channelDefaults };
+    if (Object.keys(defaults).length > 0)
+        merged.channelDefaults = defaults;
+    for (const name of CHANNELS) {
+        const fields = { ...base[name], ...override[name] };
+        if (Object.keys(fields).length > 0)
+            merged[name] = fields;
+    }
+    return merged;
+}
+/**
+ * Wire the plugin's config references to the host's settings service.
+ *
+ * Never throws. A host without `SettingsForms`, a context where the entry id
+ * cannot be resolved (a bare unit-test context, or a plugin mounted outside the
+ * loader) and a refused `replace` all degrade to `live: false` with one warning
+ * line — a settings integration that cannot work must never be the reason a
+ * bridge fails to start.
+ */
+export function installConnectSection(options) {
+    const { settings, config, ns, onChange } = options;
+    const warn = (message) => {
+        options.owner.logger?.warn?.(`connect: ${message}`);
+    };
+    const read = () => sectionOf(materializeConfig(config));
+    const section = read();
+    const replace = settings?.replace?.bind(settings);
+    if (replace === undefined || ns === undefined) {
+        // Two different situations, one outcome. No settings service at all is the
+        // normal bare-context case and needs no line. A *present* service with no
+        // resolvable entry id is a real misconfiguration: the pane would silently
+        // stop persisting, so say so once.
+        if (settings !== undefined && ns === undefined) {
+            warn("settings service is present but this plugin's profile entry id could not be resolved; " +
+                "the settings pane will fall back to its state file");
+        }
+        onChange(section);
+        return { live: false, section };
+    }
+    const handle = {
+        read,
+        write: async (value) => {
+            // Materialize first so the write path is shape-agnostic: handed this
+            // plugin's own ref-carrying `config` (a plausible caller mistake), a raw
+            // `sectionOf` would see `channels` as a reference rather than an array,
+            // read it as absent and project *every* channel — turning an unrelated
+            // save into "enable all adapters". Cheap, and it is a save, not a hot path.
+            await replace(ns, sectionOf(materializeConfig(value)));
+            // The loader commits the volatile paths into these references and emits
+            // `loader/volatile-update`; reconciling here as well makes a write take
+            // effect even on a host that does not dispatch it. A repeat apply of the
+            // same values is a no-op (`ChannelRuntime` diffs before it restarts
+            // anything), so the belt is free.
+            onChange(read());
+        },
+    };
+    onChange(section);
+    return { live: true, section, handle };
+}
+//# sourceMappingURL=namespace.js.map

package/lib/settings/namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../src/settings/namespace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,CAAC,MAAM,0BAA0B,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAqC,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEpF;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,aAAa,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA4B,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AAE7E;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;AAQ7D,oFAAoF;AACpF,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,cAAc,IAAI,KAAK,CAAC;AAChF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,iBAAiB,CAAI,KAAQ;IAC3C,OAAO,IAAI,CAAC,KAAK,EAAE,IAAI,OAAO,EAAE,CAAM,CAAC;AACzC,CAAC;AAED,SAAS,IAAI,CAAI,KAAQ,EAAE,IAA8B;IACvD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC9D,IAAI,WAAW,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;IACvD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAe,CAAC,CAAC;IACxC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,GAAG,GAAc,EAAE,CAAC;QAC1B,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACrB,KAAK,MAAM,IAAI,IAAI,KAAK;YAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC;IACb,CAAC;IACD,MAAM,GAAG,GAA4B,EAAE,CAAC;IACxC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;QAC5E,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACvC,IAAI,YAAY,KAAK,SAAS;YAAE,GAAG,CAAC,GAAG,CAAC,GAAG,YAAY,CAAC;IAC1D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,gBAAgB;IAC9B,MAAM,MAAM,GAA2B;QACrC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE;KAChE,CAAC;IACF,MAAM,QAAQ,GAA2B,EAAE,CAAC;IAC5C,KAAK,MAAM,KAAK,IAAI,sBAAsB;QAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;IACrF,MAAM,CAAC,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC5C,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,KAAK,MAAM,KAAK,IAAI,qBAAqB,CAAC,IAAI,CAAC;YAAE,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;QACzF,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAoCD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,SAAS,CAAC,MAAe,EAAE,UAA0B,EAAE;IACrE,MAAM,MAAM,GAAG,CAAC,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAA4B,CAAC;IACxG,MAAM,OAAO,GAAmB,EAAE,CAAC;IAEnC,MAAM,WAAW,GAAG,MAAM,CAAC,QAAQ,CAAC;IACpC,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QAC/B,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAuB,EAAE,CACjE,QAA8B,CAAC,QAAQ,CAAC,IAAc,CAAC,CACzD,CAAC;IACJ,CAAC;SAAM,IAAI,OAAO,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;QAC7C,OAAO,CAAC,QAAQ,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,MAAM,WAAW,GAAG,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAA4B,CAAC;IAC9E,KAAK,MAAM,KAAK,IAAI,sBAAsB,EAAE,CAAC;QAC3C,IAAI,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS;YAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzF,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,CAAC,eAAe,GAAG,QAAkC,CAAC;IAEnG,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAA4B,CAAC;QAC5D,MAAM,SAAS,GAA4B,EAAE,CAAC;QAC9C,KAAK,MAAM,KAAK,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;YAChD,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,SAAS;gBAAE,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1E,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACnE,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,IAAoB,EAAE,QAAwB;IAC1E,MAAM,MAAM,GAAmB,EAAE,CAAC;IAClC,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;IACpD,IAAI,QAAQ,KAAK,SAAS;QAAE,MAAM,CAAC,QAAQ,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;IAE5D,MAAM,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC,eAAe,EAAE,GAAG,QAAQ,CAAC,eAAe,EAAE,CAAC;IAC1E,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,CAAC,eAAe,GAAG,QAAkC,CAAC;IAElG,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACpD,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;IAC5D,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAgED;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAA0C;IAE1C,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IACnD,MAAM,IAAI,GAAG,CAAC,OAAe,EAAQ,EAAE;QACrC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,YAAY,OAAO,EAAE,CAAC,CAAC;IACtD,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,GAAmB,EAAE,CAAC,SAAS,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC;IACxE,MAAM,OAAO,GAAG,IAAI,EAAE,CAAC;IAEvB,MAAM,OAAO,GAAG,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAClD,IAAI,OAAO,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;QAC9C,2EAA2E;QAC3E,0EAA0E;QAC1E,0EAA0E;QAC1E,mCAAmC;QACnC,IAAI,QAAQ,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;YAC/C,IAAI,CACF,wFAAwF;gBACtF,oDAAoD,CACvD,CAAC;QACJ,CAAC;QACD,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClB,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IAClC,CAAC;IAED,MAAM,MAAM,GAAuB;QACjC,IAAI;QACJ,KAAK,EAAE,KAAK,EAAE,KAAc,EAAiB,EAAE;YAC7C,qEAAqE;YACrE,yEAAyE;YACzE,wEAAwE;YACxE,uEAAuE;YACvE,4EAA4E;YAC5E,MAAM,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACvD,wEAAwE;YACxE,wEAAwE;YACxE,yEAAyE;YACzE,oEAAoE;YACpE,kCAAkC;YAClC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;QACnB,CAAC;KACF,CAAC;IACF,QAAQ,CAAC,OAAO,CAAC,CAAC;IAClB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AACzC,CAAC"}

package/lib/settings/secret-disclosure.d.ts

@@ -0,0 +1,50 @@
+/**
+ * How much of a stored secret the settings pane is allowed to show.
+ *
+ * The user has to be able to *confirm* what they configured — a pane that only
+ * ever says 「已配置」 cannot tell a correct appId from a typo — but a browser
+ * tab (or a screenshot of one) must never hold a usable credential. The two are
+ * reconciled here: the host masks the value **before it crosses the wire**, so
+ * what the pane receives is already unusable, and `maskSecret` is the only
+ * place that decides how much survives.
+ *
+ * Deliberately pure and dependency-free: the host (`settings-service`) masks
+ * with it and the client bundle imports the same compiled module for the input
+ * `type`, so the two can never drift into disagreeing about which keys are
+ * confidential.
+ *
+ * @module dsh-connect/settings/secret-disclosure
+ */
+/**
+ * - `full` — shown verbatim. For identifiers, not authenticators.
+ * - `mask` — head and tail survive, the middle does not.
+ * - `url` — a URL whose *query* carries the token, so only that part is masked.
+ */
+export type Disclosure = "full" | "mask" | "url";
+/**
+ * Per-config-key policy, keyed by the channel config key (`CREDENTIAL`-style
+ * keys are unique across channels: no channel has two fields that share a name
+ * but want different treatment).
+ *
+ * `appId` / `clientId` are `full` on purpose. They are **identifiers**: they
+ * appear in the URL or body of every outbound API call, are readable in the
+ * vendor's own console, and grant nothing without the paired secret. Masking
+ * them would cost the user the one thing this pane is for — checking that the
+ * id they pasted is the one they meant — and buy no secrecy at all.
+ */
+export declare const SECRET_DISCLOSURE: Record<string, Disclosure>;
+/** Policy for a config key; unknown keys are treated as confidential. */
+export declare function disclosureOf(configKey: string): Disclosure;
+/** True when the pane should render this key as a password input. */
+export declare function isMaskedSecret(configKey: string): boolean;
+/**
+ * The display preview for one stored secret. Never returns the input: for
+ * `mask` and `url` the returned string is lossy by construction, so a caller
+ * that echoes it to a browser cannot leak a usable credential.
+ *
+ * Surrounding whitespace is trimmed first — a pasted value commonly carries a
+ * trailing newline, and the mask should describe the stored value, not the
+ * paste.
+ */
+export declare function maskSecret(configKey: string, value: string): string;
+//# sourceMappingURL=secret-disclosure.d.ts.map

package/lib/settings/secret-disclosure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-disclosure.d.ts","sourceRoot":"","sources":["../../src/settings/secret-disclosure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAQvD,CAAC;AAkBH,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,CAE1D;AAED,qEAAqE;AACrE,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEzD;AAqDD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWnE"}