@logictan/dsh-browser-agent 0.1.1 → 0.2.0

package/cordis.patch.yml

@@ -1,9 +1,9 @@
 # dsh-browser-agent bundle patch layer.
 #
 # One bare plugin row. The package ships two halves — the host half
-# (exports ".") registers the `browser-agent` settings namespace and the
-# `browser_agent` model tool, the browser half (exports "./client") registers
-# the Plugins-page configuration card.
+# (exports ".") registers the `browser_agent` model tool and exports the
+# `Config` schema the Plugins page derives its form from, the browser half
+# (exports "./client") registers the Plugins-page configuration card.
 #
 # The row must stay a BARE package name: the web plugin table locates each
 # package's `dsh.client` manifest from the specifier of the loader row that

package/lib/client.js

@@ -11,13 +11,29 @@
  *
  * The field list mirrors the schema in `src/config.js`; the two are kept in
  * step by hand because this half ships as plain browser code.
+ *
+ * As of the 0.1.7-alpha.1 settings redesign the settings service is
+ * `configForms`, not `settingsScope`: a form is addressed by loader ENTRY ID
+ * (`configForms.get(entryId)`) rather than bound by namespace, and the shared
+ * describe mirror is reached through `configForms.describe()`. The service is
+ * injected NESTED inside `apply` rather than declared in `inject`, so a host
+ * without the settings UI loses only this card instead of failing the page's
+ * boot audit.
  */
 window.__ModuleLoader__.load({
   id: "@logictan/dsh-browser-agent",
   factory: function (require) {
     var React = require("react");
 
-    /** Settings namespace the host half registers. */
+    /**
+     * Loader entry id this card's form is keyed by.
+     *
+     * `configForms.get(entryId)` addresses the entry the Host serves, and
+     * `dsh-settings` keys that entry by profile entry id — which the repo
+     * convention pins to the host half's `export const name`. It is the same
+     * string the mirror rows carry as `ns`, which is how the secret sidecar
+     * below is found.
+     */
     var NS = "browser-agent";
     /** The patch row this card configures (cordis.patch.yml). */
     var ROW_ID = "browser-agent";
@@ -256,14 +272,17 @@ window.__ModuleLoader__.load({
      * whether a key is set — overridden() is false for a saved key, which would
      * make the reset button skip it and silently leave it stored. The describe
      * sidecar is the one read that carries the fact: a { path, set } entry per
-     * schema-declared secret, with the value itself never sent. The bound
-     * namespace scope does not project the sidecar, so this reads the shared
-     * describe mirror directly.
+     * schema-declared secret, with the value itself never sent.
+     *
+     * The shared describe mirror is reached through `configForms.describe()`.
+     * It exposes the whole document — `view.namespaces`, one row per served
+     * entry — and the form controller bound to this entry does NOT project the
+     * sidecar, so the lookup is done here against the mirror's own snapshot.
      *
      * @returns a map from field key to whether that secret currently has a value.
      */
     function useSecretStatus(ctx) {
-      var mirror = ctx.settingsScope.describe();
+      var mirror = ctx.configForms.describe();
       var subscribe = React.useCallback(
         function (onChange) {
           return mirror.subscribe(onChange);
@@ -276,9 +295,13 @@ window.__ModuleLoader__.load({
         },
         [mirror],
       );
-      React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+      var snapshot = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 
-      var row = mirror.namespace(NS);
+      var namespaces = (snapshot && snapshot.view && snapshot.view.namespaces) || [];
+      var row = null;
+      for (var i = 0; i < namespaces.length; i++) {
+        if (namespaces[i].ns === NS) row = namespaces[i];
+      }
       var set = {};
       ((row && row.secrets) || []).forEach(function (secret) {
         if (secret.path.length === 1 && secret.set) set[secret.path[0]] = true;
@@ -312,8 +335,9 @@ window.__ModuleLoader__.load({
     /**
      * The row's configuration card.
      *
-     * `scope` is the settings namespace bound on this plugin's own fiber by
-     * `apply`; `ctx` supplies the live model directory.
+     * `scope` is the configuration form `apply` obtained for this entry from
+     * `configForms.get(NS)`; `ctx` is the scoped context it was obtained on,
+     * which supplies the live model directory.
      */
     function BrowserAgentSettingsCard(props) {
       var scope = props.scope;
@@ -793,30 +817,44 @@ window.__ModuleLoader__.load({
     }
 
     /**
-     * Client plugin body: bind the settings namespace and register the card.
+     * Client plugin body: bind the configuration form and register the card.
+     *
+     * `configForms` is injected NESTED rather than declared in this plugin's
+     * `inject` list. A plugin that waits on a service the profile does not
+     * provide never activates, and the Web UI's boot audit turns that into a
+     * hard failure for the WHOLE page ("web boot: N entries did not activate"),
+     * not just for this card. Nested, a host without the settings UI loses only
+     * this card — which is the same trade `dsh-market` makes.
+     *
+     * The nested context inherits the services declared here (`slots`,
+     * `remote`), so the card is handed the scoped context and can reach both the
+     * form and the model directory through it.
+     *
      * @param ctx - client root context.
      */
     function apply(ctx) {
-      var scope = ctx.settingsScope.bind({ namespace: NS });
-      BUNDLE_NAMES.forEach(function (bundle) {
-        ctx.slots.inject("plugins.row.config", function () {
-          return ctx.slots.register(
-            {
-              name: "plugins.row.config",
-              key: bundle + "#" + ROW_ID,
-              inject: function () {
-                return { scope: scope, ctx: ctx };
+      ctx.inject(["configForms"], function (scoped) {
+        var scope = scoped.configForms.get(NS);
+        BUNDLE_NAMES.forEach(function (bundle) {
+          scoped.slots.inject("plugins.row.config", function () {
+            return scoped.slots.register(
+              {
+                name: "plugins.row.config",
+                key: bundle + "#" + ROW_ID,
+                inject: function () {
+                  return { scope: scope, ctx: scoped };
+                },
               },
-            },
-            BrowserAgentSettingsCard,
-          );
+              BrowserAgentSettingsCard,
+            );
+          });
         });
       });
     }
 
     return {
       name: "dsh-browser-agent",
-      inject: ["slots", "settingsScope", "remote", "remote.session"],
+      inject: ["slots", "remote", "remote.session"],
       apply: apply,
     };
   },

package/lib/config.js

@@ -1,11 +1,24 @@
 /**
  * Configuration surface of the browser agent.
  *
- * The settings namespace is the one contract three surfaces share: the host
- * half reads it when a run starts, the Plugins-page card edits it, and the
- * client half's field list mirrors it. The card ships as plain browser code and
- * cannot import this module, so the two field lists are kept in step by hand —
- * changing a key here means changing `src/client.js` too.
+ * As of the 0.1.7-alpha.1 settings redesign this schema is the ONE contract
+ * every surface shares: the host half reads it when a run starts, and
+ * `dsh-settings` derives the Plugins-page form from it — keyed by the loader
+ * entry id, which is why {@link ENTRY_ID} must equal both the row id in
+ * `cordis.patch.yml` and the host half's `export const name`. The card ships as
+ * plain browser code and cannot import this module, so its field list is kept in
+ * step by hand — changing a key here means changing `src/client.js` too.
+ *
+ * Two rules follow from the redesign, and both are load-bearing:
+ *
+ *  - The schema must be reachable as `entry.fiber.runtime.Config`, i.e. exported
+ *    from the PACKAGE ENTRY (`lib/index.js`), not merely from this module. That
+ *    is where `dsh-settings` looks; a schema exported only from a subpath is
+ *    invisible and the entry simply has no form.
+ *  - Every field must be `volatile()`. The marker is what makes the field
+ *    editable without a remount — and it is also what makes the Loader hand
+ *    `apply` a live `{ get() }` reference instead of a value, which is the only
+ *    shape the host half reads.
  *
  * @module @logictan/dsh-browser-agent/config
  */
@@ -14,11 +27,18 @@ import { DEFAULT_ENDPOINT as DEFAULT_CDP_ENDPOINT } from './cdp.js';
 import { DEFAULT_MAX_STEPS } from './loop.js';
 import { DEFAULT_ENDPOINT as DEFAULT_TYPESAFE_ENDPOINT, DEFAULT_MODEL } from './typesafe.js';
 
-/** Settings namespace the host half registers and the card binds. */
-export const SETTINGS_NAMESPACE = 'browser-agent';
+/**
+ * The loader entry id this plugin's configuration form is keyed by.
+ *
+ * `dsh-settings` keys a form by the profile entry id, which the repo convention
+ * pins to the host half's `export const name`; the browser half passes the same
+ * string to `configForms.get`. A mismatch does not throw — the card simply binds
+ * a form that is never served, and every field renders as unset.
+ */
+export const ENTRY_ID = 'browser-agent';
 
 /**
- * Schema of the `browser-agent` settings section.
+ * Schema of the `browser-agent` configuration.
  *
  * The TypeSafe key is `role('secret')`: it is stored in the local settings
  * document and stripped by every redacting surface, including config sync. That
@@ -35,16 +55,20 @@ export const SETTINGS_NAMESPACE = 'browser-agent';
  * "use the session's own current route", which is the only default that stays
  * correct after config sync moves the file to a machine with different
  * providers; a hard-coded model would point at a model the target may not have.
+ *
+ * `volatile()` order matters for the secret: `role()` must come first, because
+ * `volatile()` wraps the schema and a second wrap throws `volatile schema is
+ * already wrapped`.
  */
 export const Config = z.object({
-  typesafeApiKey: z.string().role('secret'),
-  typesafeEndpoint: z.string().default(DEFAULT_TYPESAFE_ENDPOINT),
-  typesafeModel: z.string().default(DEFAULT_MODEL),
-  cdpEndpoint: z.string().default(DEFAULT_CDP_ENDPOINT),
-  maxSteps: z.number().step(1).min(1).default(DEFAULT_MAX_STEPS),
-  textProvider: z.string().default(''),
-  textModel: z.string().default(''),
-  textReasoningEffort: z.string().default(''),
+  typesafeApiKey: z.string().role('secret').volatile(),
+  typesafeEndpoint: z.string().default(DEFAULT_TYPESAFE_ENDPOINT).volatile(),
+  typesafeModel: z.string().default(DEFAULT_MODEL).volatile(),
+  cdpEndpoint: z.string().default(DEFAULT_CDP_ENDPOINT).volatile(),
+  maxSteps: z.number().step(1).min(1).default(DEFAULT_MAX_STEPS).volatile(),
+  textProvider: z.string().default('').volatile(),
+  textModel: z.string().default('').volatile(),
+  textReasoningEffort: z.string().default('').volatile(),
 });
 
 /**
@@ -60,7 +84,8 @@ export const Config = z.object({
  * agent fields off the context short-circuits every optional chain and silently
  * reports "unconfigured" on a session that has a perfectly good route.
  *
- * @param config - the resolved settings section.
+ * @param config - the configuration in effect, as plain values (the host half
+ *   unwraps the live references before calling).
  * @param exec - the tool execution context; its `agent` is the caller.
  * @returns the route to call; empty provider/model means "unconfigured".
  */

package/lib/index.js

@@ -1,15 +1,26 @@
 /**
  * dsh-browser-agent — host half.
  *
- * Registers two things: the `browser-agent` settings namespace, and the
- * `browser_agent` model tool that runs the decision loop over CDP against the
- * user's own Chrome.
+ * Registers one thing: the `browser_agent` model tool that runs the decision
+ * loop over CDP against the user's own Chrome.
+ *
+ * Configuration arrives as `apply`'s second argument. As of the 0.1.7-alpha.1
+ * settings redesign the plugin's own `Config` schema is the only config surface
+ * — `dsh-settings` derives the Plugins-page form from `entry.fiber.runtime.Config`,
+ * keyed by the entry id — and every field of it is `volatile()`, so the Loader
+ * hands `apply` one live `{ get() }` reference per field rather than a value.
+ * The former `settings.register(ns, schema)` and `settings.get(ns)` seams were
+ * removed in that generation, which is why this plugin failed to activate on it.
+ *
+ * `Config` is therefore re-exported from the package entry: that is the exact
+ * object `dsh-settings` looks for, and a schema exported only from `./config.js`
+ * would leave the entry with no form at all.
  *
  * The tool is registered through `ctx.get('tools')` rather than the `ctx.tools`
  * property. Cordis requires a declared `inject` before a service property may
  * be read, and `tools` is genuinely optional here — a headless deployment that
- * composes no tool registry still has a working settings namespace — so it must
- * not be injected. Reading it optionally is the same choice
+ * composes no tool registry still has a working configuration — so it must not
+ * be injected. Reading it optionally is the same choice
  * `dsh-config-manager`'s `registerModelTools` makes, for the same reason.
  *
  * @module @logictan/dsh-browser-agent
@@ -17,9 +28,11 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 
 import { attach, activePage } from './cdp.js';
-import { Config, SETTINGS_NAMESPACE, resolveTextRoute } from './config.js';
+import { resolveTextRoute } from './config.js';
 import { run } from './loop.js';
 
+export { Config } from './config.js';
+
 /** Plugin row id; must equal the row id in `cordis.patch.yml`. */
 export const name = 'browser-agent';
 
@@ -27,25 +40,47 @@ export const name = 'browser-agent';
  * Services this plugin needs before it can mount.
  *
  * `llm` is required: the TYPE_TEXT step cannot work without it, and a silent
- * degradation there would be worse than a load failure. `settings` is required
- * for the same reason — every run reads its configuration from it.
+ * degradation there would be worse than a load failure. `settings` is NOT
+ * injected — the plugin neither reads nor registers a settings namespace any
+ * more, and waiting on a service a profile does not provide is precisely what
+ * left this entry `pending` (and took the whole Web UI's boot audit down) on
+ * 0.1.7-alpha.1.
  */
-export const inject = ['settings', 'llm'];
+export const inject = ['llm'];
 
 /**
  * Register the `browser_agent` tool.
  *
  * @param ctx - the plugin context.
+ * @param config - one live reference per {@link Config} field.
  */
-export function apply(ctx) {
-  const settings = ctx.settings;
+export function apply(ctx, config) {
   const llm = ctx.llm;
   const tools = ctx.get('tools');
 
-  // The namespace must be registered before anything reads or writes it: an
-  // unregistered namespace makes `settings.get` return undefined and every
-  // Plugins-page write fail with "settings namespace ... is not registered".
-  settings.register(SETTINGS_NAMESPACE, Config);
+  /**
+   * The configuration in effect right now, as plain values.
+   *
+   * Resolved at each use rather than captured at activation: the Loader commits
+   * a Plugins-page edit into these very references (`loader/volatile-update`)
+   * instead of remounting the plugin, so a snapshot taken here would pin the
+   * values the profile started with and the card's save button would appear to
+   * do nothing.
+   *
+   * @returns the resolved configuration.
+   */
+  function currentConfig() {
+    return {
+      typesafeApiKey: config.typesafeApiKey.get(),
+      typesafeEndpoint: config.typesafeEndpoint.get(),
+      typesafeModel: config.typesafeModel.get(),
+      cdpEndpoint: config.cdpEndpoint.get(),
+      maxSteps: config.maxSteps.get(),
+      textProvider: config.textProvider.get(),
+      textModel: config.textModel.get(),
+      textReasoningEffort: config.textReasoningEffort.get(),
+    };
+  }
 
   const definition = defineTool({
     name: 'browser_agent',
@@ -62,7 +97,7 @@ export function apply(ctx) {
       render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
     },
     async execute(args, exec) {
-      const current = Config(settings.get(SETTINGS_NAMESPACE) ?? {});
+      const current = currentConfig();
       // An unset optional field resolves to undefined; a cleared one to ''.
       if (current.typesafeApiKey === undefined || current.typesafeApiKey === '') {
         throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logictan/dsh-browser-agent",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "DSH browser agent: a dynamic operation+target decision loop. TypeSafe picks the action, this plugin executes it over CDP against the user's own Chrome. DSH 浏览器 Agent 子插件。",
   "type": "module",
   "main": "lib/index.js",
@@ -16,7 +16,6 @@
     "client": {
       "inject": [
         "slots",
-        "settingsScope",
         "remote",
         "remote.session"
       ],
@@ -59,9 +58,8 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-llm": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-settings": "^0.1.6-alpha.2",
     "@deepseek-ai/dsh-tools": "^0.1.6-alpha.2",
-    "@deepseek-ai/schemastery": "^3.18.2"
+    "@deepseek-ai/schemastery": "^3.18.3"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -70,9 +68,6 @@
     "@deepseek-ai/dsh-llm": {
       "optional": true
     },
-    "@deepseek-ai/dsh-settings": {
-      "optional": true
-    },
     "@deepseek-ai/dsh-tools": {
       "optional": true
     },
@@ -83,8 +78,7 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-llm": "^0.1.6-alpha.2",
-    "@deepseek-ai/dsh-settings": "^0.1.6-alpha.2",
     "@deepseek-ai/dsh-tools": "^0.1.6-alpha.2",
-    "@deepseek-ai/schemastery": "^3.18.2"
+    "@deepseek-ai/schemastery": "^3.18.3"
   }
 }