@2en/clawly-plugins 1.30.0 → 1.31.0

package/config-setup.ts

@@ -24,7 +24,6 @@ import {
   ENV_KEY_API_KEY,
   ENV_KEY_BASE,
   PROVIDER_NAME,
-  patchModelGateway,
   readOpenclawConfig,
   stripPathname,
   writeOpenclawConfig,
@@ -340,48 +339,82 @@ export function patchSession(config: OpenClawConfig): boolean {
   return dirty
 }
 
-const INCLUDE_PATH = './extensions/clawly-plugins/clawly-config-defaults.json5'
+const DEFAULTS_PATH = './extensions/clawly-plugins/clawly-config-defaults.json5'
+const LEGACY_INCLUDE_PATH = DEFAULTS_PATH
 
 /**
- * Ensures our defaults file is listed in the config's `$include` array.
- * Returns true if `$include` was modified.
+ * Remove legacy `$include` reference to our defaults file.
+ * Returns true if config was modified.
  */
-export function ensureInclude(config: OpenClawConfig & Record<string, unknown>): boolean {
+export function removeInclude(config: OpenClawConfig & Record<string, unknown>): boolean {
   const existing = config.$include
-  let includes: string[]
+  if (existing === undefined) return false
 
-  if (Array.isArray(existing)) {
-    includes = existing as string[]
-  } else if (typeof existing === 'string') {
-    includes = [existing]
-  } else {
-    includes = []
+  if (typeof existing === 'string') {
+    if (existing === LEGACY_INCLUDE_PATH) {
+      delete config.$include
+      return true
+    }
+    return false
   }
 
-  if (includes.includes(INCLUDE_PATH)) return false
+  if (Array.isArray(existing)) {
+    const includes = existing as string[]
+    const idx = includes.indexOf(LEGACY_INCLUDE_PATH)
+    if (idx === -1) return false
+    includes.splice(idx, 1)
+    if (includes.length === 0) {
+      delete config.$include
+    } else if (includes.length === 1) {
+      config.$include = includes[0]
+    }
+    return true
+  }
 
-  includes.push(INCLUDE_PATH)
-  config.$include = includes.length === 1 ? includes[0] : includes
-  return true
+  return false
 }
 
 /**
- * Restrict the $include defaults file to owner-only (0o600), matching
- * openclaw.json. npm/plugin-install creates files with 0o644 by default,
- * which would leave config readable by other local users.
+ * Deep-merge defaults into config. Config values take precedence;
+ * defaults only fill in missing keys. Arrays are not merged — config wins.
+ * Returns true if any key was added.
  */
-function hardenIncludePermissions(stateDir: string, api: PluginApi): void {
-  const includePath = path.join(stateDir, INCLUDE_PATH)
-  try {
-    const stat = fs.statSync(includePath)
-    const mode = stat.mode & 0o777
-    if (mode !== 0o600) {
-      fs.chmodSync(includePath, 0o600)
-      api.logger.info(`Hardened ${INCLUDE_PATH} permissions to 0600.`)
+export function deepMergeDefaults(
+  config: Record<string, unknown>,
+  defaults: Record<string, unknown>,
+): boolean {
+  let merged = false
+  for (const key of Object.keys(defaults)) {
+    const defaultVal = defaults[key]
+    const configVal = config[key]
+
+    if (configVal === undefined) {
+      config[key] = defaultVal
+      merged = true
+      continue
     }
-  } catch {
-    // File may not exist yet (first install before plugin copies files)
+
+    // Both are plain objects → recurse
+    if (
+      defaultVal !== null &&
+      typeof defaultVal === 'object' &&
+      !Array.isArray(defaultVal) &&
+      configVal !== null &&
+      typeof configVal === 'object' &&
+      !Array.isArray(configVal)
+    ) {
+      if (
+        deepMergeDefaults(
+          configVal as Record<string, unknown>,
+          defaultVal as Record<string, unknown>,
+        )
+      ) {
+        merged = true
+      }
+    }
+    // For arrays and primitives: config wins, do nothing
   }
+  return merged
 }
 
 const PLUGIN_ID = 'clawly-plugins'
@@ -450,89 +483,12 @@ function repairLegacyProvisionState(api: PluginApi, config: OpenClawConfig, stat
   return installRecordPatched
 }
 
-/**
- * Remove fields from config that are identical to the included defaults.
- * Since `$include` deep-merges with main config winning, residual values
- * from old JS set-if-missing code "shadow" the json5 defaults and prevent
- * future default updates from taking effect.
- *
- * Only prunes leaf values that exactly match.
- * Returns true if any field was deleted.
- */
-function stableStringify(v: unknown): string {
-  if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
-    const obj = v as Record<string, unknown>
-    return `{${Object.keys(obj)
-      .sort()
-      .map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`)
-      .join(',')}}`
-  }
-  return JSON.stringify(v)
-}
-
-export function pruneIncludedDefaults(
-  config: Record<string, unknown>,
-  defaults: Record<string, unknown>,
-): boolean {
-  let pruned = false
-
-  function walk(defaultsNode: Record<string, unknown>, configNode: Record<string, unknown>): void {
-    for (const key of Object.keys(defaultsNode)) {
-      const defaultVal = defaultsNode[key]
-      const configVal = configNode[key]
-      if (configVal === undefined) continue
-
-      // Both are plain objects → recurse
-      if (
-        defaultVal !== null &&
-        typeof defaultVal === 'object' &&
-        !Array.isArray(defaultVal) &&
-        configVal !== null &&
-        typeof configVal === 'object' &&
-        !Array.isArray(configVal)
-      ) {
-        walk(defaultVal as Record<string, unknown>, configVal as Record<string, unknown>)
-        // Clean up empty parent objects left behind after pruning
-        if (Object.keys(configVal as Record<string, unknown>).length === 0) {
-          delete configNode[key]
-          pruned = true
-        }
-        continue
-      }
-
-      // Both are non-empty arrays → remove config elements that exist in defaults
-      if (Array.isArray(defaultVal) && defaultVal.length > 0 && Array.isArray(configVal)) {
-        const defaultSet = new Set(defaultVal.map((v) => stableStringify(v)))
-        const filtered = configVal.filter((v) => !defaultSet.has(stableStringify(v)))
-        if (filtered.length !== configVal.length) {
-          if (filtered.length === 0) {
-            delete configNode[key]
-          } else {
-            configNode[key] = filtered
-          }
-          pruned = true
-        }
-        continue
-      }
-
-      // Leaf comparison: use stableStringify for key-order-insensitive deep equality
-      if (stableStringify(configVal) === stableStringify(defaultVal)) {
-        delete configNode[key]
-        pruned = true
-      }
-    }
-  }
-
-  walk(defaults, config)
-  return pruned
-}
-
 /**
  * Load and parse clawly-config-defaults.json5 from the plugin install directory.
  * Uses the bundled `json5` package (declared in package.json).
  */
-function loadIncludedDefaults(stateDir: string): Record<string, unknown> | null {
-  const defaultsPath = path.join(stateDir, INCLUDE_PATH)
+function loadDefaults(stateDir: string): Record<string, unknown> | null {
+  const defaultsPath = path.join(stateDir, DEFAULTS_PATH)
   try {
     const raw = fs.readFileSync(defaultsPath, 'utf-8')
     return JSON5.parse(raw) as Record<string, unknown>
@@ -565,13 +521,12 @@ function reconcileRuntimeConfig(
   dirty = patchGateway(config) || dirty
   dirty = patchBrowser(config) || dirty
   dirty = patchSession(config) || dirty
-  dirty = patchModelGateway(config, api) || dirty
 
-  const defaults = loadIncludedDefaults(stateDir)
+  const defaults = loadDefaults(stateDir)
   if (defaults) {
-    dirty = pruneIncludedDefaults(config, defaults) || dirty
+    dirty = deepMergeDefaults(config, defaults) || dirty
   } else {
-    api.logger.warn('Config setup: failed to load included defaults, skipping dedup.')
+    api.logger.warn('Config setup: failed to load defaults json5, skipping merge.')
   }
 
   return dirty
@@ -588,22 +543,15 @@ export function setupConfig(api: PluginApi): void {
     return
   }
 
-  // OpenClaw exposes three config layers:
-  //   parsed   — raw JSON from openclaw.json (no $include, no env expansion)
-  //   resolved — parsed + $include deep-merge + ${ENV} interpolation
-  //   runtime  — resolved + SecretRef resolution, cached in-memory snapshot
-  //
-  // We need parsed: patchers mutate raw fields and write back via
-  // writeConfigFile, which diffs against the runtime snapshot and projects
-  // changes onto the source file. Using resolved/runtime would inline
-  // $include defaults into openclaw.json, defeating the json5 migration.
+  // Read the raw parsed config from openclaw.json (no env expansion).
+  // Patchers mutate fields in place; defaults from json5 are deep-merged
+  // to fill missing keys. The result is written back as the full config.
   const configPath = path.join(stateDir, 'openclaw.json')
   const config = readOpenclawConfig(configPath)
   const pc = toPCMerged(api, config)
 
   let dirty = false
-  dirty = ensureInclude(config) || dirty
-  hardenIncludePermissions(stateDir, api)
+  dirty = removeInclude(config) || dirty
   dirty = repairLegacyProvisionState(api, config, stateDir) || dirty
   dirty = reconcileRuntimeConfig(api, config, pc, stateDir) || dirty
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2en/clawly-plugins",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "module": "index.ts",
   "type": "module",
   "repository": {

package/tools/clawly-search.test.ts

@@ -289,7 +289,7 @@ describe('clawly_kimi_search', () => {
     expect(call.body?.model).toBe('kimi-k2-turbo-preview')
     expect(call.body?.stream).toBe(false)
     expect(call.body?.messages).toEqual([{role: 'user', content: 'Chinese news'}])
-    expect(call.body?.tools).toEqual([{type: 'builtin_function', function: {name: 'web_search'}}])
+    expect(call.body?.tools).toEqual([{type: 'builtin_function', function: {name: '$web_search'}}])
 
     expect(res.answer).toBe('Kimi answer with [source](https://example.com/page)')
     expect(res.citations).toEqual(['https://example.com/page'])

package/tools/create-search-tool.ts

@@ -53,7 +53,7 @@ export function buildKimiBody(model: string, query: string): Record<string, unkn
     model,
     stream: false,
     messages: [{role: 'user', content: query}],
-    tools: [{type: 'builtin_function', function: {name: 'web_search'}}],
+    tools: [{type: 'builtin_function', function: {name: '$web_search'}}],
   }
 }