@karmaniverous/jeeves 0.6.0-0 → 0.6.0-1

package/README.md

@@ -229,6 +229,8 @@ OpenClaw must already be installed; `jeeves` checks for it and never installs it
 3. Removes any legacy `<openclaw dir>/extensions/<id>` copy left by the v0.x installer, but only if its `package.json` names the expected package.
 4. Sets `plugins.entries.<id>.hooks.allowConversationAccess: true` for plugins that [declare conversation hooks](#declaring-conversation-hooks), and the plugin config (`plugins.entries.<id>.config.<key>`, see [Plugin config](#plugin-config)), with one `openclaw config set --batch-file <file>` call. The file is created owner-only in a fresh temp directory (mode `0600` in a `0700` directory on Linux/macOS; on Windows the directory ACL is reduced to the current user with `icacls`) and deleted afterwards, so no value, secret or not, appears on a command line. Every write targets a leaf path, so unrelated keys are kept. `plugins.installs` is never written.
 
+   Right after an install, OpenClaw can refuse to edit a plugin's config until it finishes that plugin's data/settings upgrade (`Plugin "<id>" data/settings upgrade is unfinished: ... has not converged`). Only that refusal is retried: the same batch file is resubmitted after 2s, 4s, 8s, 16s, then every 30s, for up to 120s of waiting in total, with one log line per retry. If the plugin still hasn't converged, the command fails and names the plugin; wait and rerun it (the writes are idempotent). Any other error fails at once. The `openclaw config unset` repairs after an uninstall follow the same rule. A dry run never retries.
+
 Plugin specs can be short (`watcher`, `watcher@1.2.3`, `runner@^1`) or full (`@karmaniverous/jeeves-watcher-openclaw@1.2.3`). Only `@karmaniverous/jeeves-*-openclaw` packages are accepted. `--content-only` skips the plugins.
 
 `jeeves update` runs steps 2 to 4 for the named packages, or for every Jeeves plugin that has a `plugins.entries` record, at `latest`. It takes the same plugin options as `jeeves install` (including `--plugin-config` and `--force-reinstall`) and fills in missing plugin config with the same precedence: existing values are kept unless you pass them, and a missing required value fails the command before anything changes.

package/dist/cli/jeeves/index.js

@@ -140,14 +140,14 @@ const DEFAULT_PORTS = {
  * Core library version, inlined at build time.
  *
  * @remarks
- * The `0.5.12` placeholder is replaced by
+ * The `0.6.0-0` placeholder is replaced by
  * `@rollup/plugin-replace` during the build with the actual version
  * from `package.json`. This ensures the correct version survives
  * when consumers bundle core into their own dist (where runtime
  * `import.meta.url`-based resolution would find the wrong package.json).
  */
 /** The core library version from package.json (inlined at build time). */
-const CORE_VERSION = '0.5.12';
+const CORE_VERSION = '0.6.0-0';
 
 /**
  * Shared internal utility functions.
@@ -1626,6 +1626,103 @@ function configuredPluginIds(plugins, isJeeves) {
         .sort();
 }
 
+/**
+ * Retry OpenClaw config writes while freshly installed plugins converge.
+ *
+ * @remarks
+ * Right after `openclaw plugins install`, OpenClaw can refuse to edit a
+ * plugin's retained config until that plugin's deferred data/settings
+ * migration finishes. OpenClaw v2026.9.6 throws (from
+ * `src/config/deferred-plugin-migration-config.ts`, message built by
+ * `formatDeferredPluginMigration` in `src/infra/deferred-plugin-migrations.ts`):
+ *
+ * `Cannot edit retained config at "<path>". Plugin "<id>" data/settings upgrade is unfinished: <reason> ...`
+ *
+ * Only that signal is retried, with exponential backoff inside a fixed wait
+ * budget; any other failure is rethrown at once. Config writes are idempotent
+ * leaf sets/unsets, so repeating one is safe.
+ *
+ * @module
+ */
+/** Default policy: 2s, 4s, 8s, 16s, then 30s steps; 120s of waiting in total. */
+const DEFAULT_CONVERGENCE_RETRY = {
+    initialDelayMs: 2_000,
+    maxDelayMs: 30_000,
+    budgetMs: 120_000,
+};
+/** Default sleep adapter (real timer). */
+const timerSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const UNCONVERGED_PLUGIN = /Plugin "([^"]+)" data\/settings upgrade is unfinished/g;
+const UNCONVERGED_ANY = /upgrade is unfinished|has not converged/i;
+/**
+ * Detect OpenClaw's "plugin not yet converged" refusal in a failure.
+ *
+ * @param error - The thrown value.
+ * @returns The plugin ids still converging (`['unknown plugin']` when the
+ *   signal is present without an id), or `undefined` when this is some other
+ *   failure.
+ */
+function unconvergedPlugins(error) {
+    if (!(error instanceof CommandFailedError))
+        return undefined;
+    const text = `${error.result.stderr}\n${error.result.stdout}`;
+    if (!UNCONVERGED_ANY.test(text))
+        return undefined;
+    const ids = [
+        ...new Set([...text.matchAll(UNCONVERGED_PLUGIN)].map((m) => m[1])),
+    ];
+    return ids.length > 0 ? ids : ['unknown plugin'];
+}
+/**
+ * Delays for a policy: doubling from `initialDelayMs`, capped at
+ * `maxDelayMs`, until the next delay would exceed the budget.
+ *
+ * @param policy - Retry policy.
+ * @returns Delays in ms.
+ */
+function retryDelays(policy) {
+    const delays = [];
+    let total = 0;
+    let next = policy.initialDelayMs;
+    while (next > 0 && total + next <= policy.budgetMs) {
+        delays.push(next);
+        total += next;
+        next = Math.min(next * 2, policy.maxDelayMs);
+    }
+    return delays;
+}
+/**
+ * Run an idempotent OpenClaw config write, retrying only while plugins are
+ * still converging.
+ *
+ * @param action - The write.
+ * @param options - Sleep, logger, policy.
+ * @throws The original error for any other failure; an `Error` naming the
+ *   plugins still converging once the budget is spent.
+ */
+async function withConvergenceRetry(action, options) {
+    const delays = retryDelays(options.policy ?? DEFAULT_CONVERGENCE_RETRY);
+    let waited = 0;
+    for (let attempt = 0;; attempt++) {
+        try {
+            await action();
+            return;
+        }
+        catch (error) {
+            const plugins = unconvergedPlugins(error);
+            if (!plugins)
+                throw error;
+            const delay = delays.at(attempt);
+            if (delay === undefined) {
+                throw new Error(`OpenClaw still refuses the config write after ${String(waited / 1000)}s: plugin(s) ${plugins.join(', ')} have not finished converging after install. Wait, then rerun the command (or run "openclaw doctor --fix").`, { cause: error });
+            }
+            options.log(`OpenClaw has not finished converging plugin(s) ${plugins.join(', ')}; retrying in ${String(delay / 1000)}s (retry ${String(attempt + 1)}/${String(delays.length)})`);
+            await options.sleep(delay);
+            waited += delay;
+        }
+    }
+}
+
 /**
  * Pure builders for every `openclaw` / `npm` argument vector the jeeves CLI
  * runs. No I/O.
@@ -2046,10 +2143,19 @@ function createNodePrivateTempFiles(runner, platform = process.platform, baseDir
  * Live: runs steps in order and stops at the first failure; a non-zero exit
  * from any `openclaw` command throws {@link CommandFailedError}, which the CLI
  * turns into a non-zero exit. Config batches are written to an owner-only
- * temp file, passed with `--batch-file`, and deleted afterwards.
+ * temp file, passed with `--batch-file`, and deleted afterwards. Config
+ * writes (batches and unsets) are retried with bounded backoff only while
+ * OpenClaw reports that a freshly installed plugin has not converged yet
+ * (see {@link withConvergenceRetry}); the batch file is kept for the retries
+ * and deleted once.
  *
  * @module
  */
+/** Retry an idempotent config write while plugins converge. */
+const retryingConfigWrite = (ctx, action) => withConvergenceRetry(action, {
+    sleep: ctx.sleep ?? timerSleep,
+    log: ctx.log,
+});
 /** Run one command (echoing its output), logging its command line first. */
 async function runLogged(ctx, command, args) {
     ctx.log(`$ ${formatCommand(command, args)}`);
@@ -2067,12 +2173,9 @@ async function runConfigBatch(ctx, ops, redact) {
     ctx.log(`$ ${command}`);
     for (const line of details)
         ctx.log(line);
-    await withPrivateTempFile(ctx.tempFiles, BATCH_FILE_NAME, configBatchPayload(ops), async (path) => {
-        await runChecked(ctx.runner, OPENCLAW_BIN, configSetBatchFileArgs(path), {
-            echo: true,
-            ...(redact ? { redact } : {}),
-        });
-    }, ctx.log);
+    await withPrivateTempFile(ctx.tempFiles, BATCH_FILE_NAME, configBatchPayload(ops), (path) => retryingConfigWrite(ctx, async () => {
+        await runChecked(ctx.runner, OPENCLAW_BIN, configSetBatchFileArgs(path), { echo: true, ...(redact ? { redact } : {}) });
+    }), ctx.log);
 }
 /** Execute one step for real. */
 async function executeStep(step, ctx) {
@@ -2101,7 +2204,7 @@ async function executeStep(step, ctx) {
             const after = await readPluginsConfig(ctx.runner);
             const repair = computePostUninstallRepair(step.before, after, step.pluginIds);
             for (const path of repair.unsetPaths) {
-                await runLogged(ctx, OPENCLAW_BIN, configUnsetArgs(path));
+                await retryingConfigWrite(ctx, () => runLogged(ctx, OPENCLAW_BIN, configUnsetArgs(path)));
             }
             if (repair.setOps.length > 0)
                 await runConfigBatch(ctx, repair.setOps);

package/dist/index.js

@@ -142,14 +142,14 @@ const DEFAULT_PORTS = {
  * Core library version, inlined at build time.
  *
  * @remarks
- * The `0.5.12` placeholder is replaced by
+ * The `0.6.0-0` placeholder is replaced by
  * `@rollup/plugin-replace` during the build with the actual version
  * from `package.json`. This ensures the correct version survives
  * when consumers bundle core into their own dist (where runtime
  * `import.meta.url`-based resolution would find the wrong package.json).
  */
 /** The core library version from package.json (inlined at build time). */
-const CORE_VERSION = '0.5.12';
+const CORE_VERSION = '0.6.0-0';
 
 /**
  * Workspace and config root initialization.

package/package.json

@@ -133,7 +133,7 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "0.6.0-0",
+  "version": "0.6.0-1",
   "allowScripts": {
     "lefthook": true
   }