@2en/clawly-plugins 1.19.2 → 1.20.1

package/gateway/plugins.ts

@@ -17,6 +17,8 @@ import {stripCliLogs} from '../lib/stripCliLogs'
 
 $.verbose = false
 
+const PLUGIN_SENTINEL = 'openclaw.plugin.json'
+
 interface NpmViewCache {
   version: string
   versions: string[]
@@ -56,6 +58,74 @@ async function fetchNpmView(npmPkgName: string): Promise<NpmViewCache | null> {
   }
 }
 
+/**
+ * Back up plugin dir before an install/update operation, verify the sentinel
+ * file exists after, and rollback from backup on failure.  Prevents the
+ * "deleted plugin dir with no recovery" scenario seen in failed auto-updates.
+ */
+async function withPluginBackup<T>(
+  api: PluginApi,
+  pluginId: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  const stateDir = resolveStateDir(api)
+  if (!stateDir) return operation()
+
+  const extensionDir = path.join(stateDir, 'extensions', pluginId)
+  const backupDir = `${extensionDir}.update-backup`
+
+  // Back up only if there's a valid existing installation.
+  // If backup fails, abort — a working plugin is more valuable than a risky update.
+  const hasExisting = fs.existsSync(path.join(extensionDir, PLUGIN_SENTINEL))
+  if (hasExisting) {
+    try {
+      if (fs.existsSync(backupDir)) await $`rm -rf ${backupDir}`
+      await $`cp -a ${extensionDir} ${backupDir}`
+      api.logger.info(`plugins: backed up ${pluginId}`)
+    } catch (err) {
+      // Clean up partial backup before aborting
+      if (fs.existsSync(backupDir)) await $`rm -rf ${backupDir}`.catch(() => {})
+      throw new Error(
+        `plugin backup failed, aborting update: ${err instanceof Error ? err.message : String(err)}`,
+      )
+    }
+  }
+
+  try {
+    const result = await operation()
+
+    // Verify sentinel exists after operation
+    if (!fs.existsSync(path.join(extensionDir, PLUGIN_SENTINEL))) {
+      // Clean up partial install if no backup exists (first-time install failure)
+      if (!hasExisting && fs.existsSync(extensionDir)) {
+        await $`rm -rf ${extensionDir}`.catch(() => {})
+      }
+      throw new Error(`plugin files missing after operation (${PLUGIN_SENTINEL} not found)`)
+    }
+
+    // Clean backup on success
+    if (fs.existsSync(backupDir)) {
+      await $`rm -rf ${backupDir}`.catch(() => {})
+    }
+
+    return result
+  } catch (err) {
+    if (fs.existsSync(backupDir)) {
+      api.logger.warn(`plugins: rolling back ${pluginId} from backup`)
+      try {
+        if (fs.existsSync(extensionDir)) await $`rm -rf ${extensionDir}`
+        await $`mv ${backupDir} ${extensionDir}`
+        api.logger.info(`plugins: rollback complete`)
+      } catch (rollbackErr) {
+        api.logger.error(
+          `plugins: rollback failed — ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`,
+        )
+      }
+    }
+    throw err
+  }
+}
+
 export function registerPlugins(api: PluginApi) {
   // ── clawly.plugins.version ──────────────────────────────────────
 
@@ -179,41 +249,48 @@ export function registerPlugins(api: PluginApi) {
           // ignore
         }
 
-        // 3. Remove extension dir to force clean install
-        const extensionDir = path.join(stateDir, 'extensions', pluginId)
-        if (fs.existsSync(extensionDir)) {
-          api.logger.info(`plugins: force — removing ${extensionDir}`)
-          await $`rm -rf ${extensionDir}`
-        }
-
-        // 4. Install fresh
-        api.logger.info(`plugins: force — installing ${installTarget}`)
-        const result = await $`openclaw plugins install ${installTarget}`
-        output = result.stdout.trim()
-
-        // 5. Merge saved config back into plugins.entries.<id>
+        // 3-4. Back up existing dir, remove, install — rollback on failure
         try {
-          const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
-          if (!config.plugins) config.plugins = {}
-          if (!config.plugins.entries) config.plugins.entries = {}
-          config.plugins.entries[pluginId] = {
-            ...config.plugins.entries[pluginId],
-            ...savedEntry,
+          output = await withPluginBackup(api, pluginId, async () => {
+            const extensionDir = path.join(stateDir, 'extensions', pluginId)
+            if (fs.existsSync(extensionDir)) {
+              api.logger.info(`plugins: force — removing ${extensionDir}`)
+              await $`rm -rf ${extensionDir}`
+            }
+
+            api.logger.info(`plugins: force — installing ${installTarget}`)
+            const result = await $`openclaw plugins install ${installTarget}`
+            return result.stdout.trim()
+          })
+        } finally {
+          // 5. Always restore config entry (both on success and after rollback)
+          try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+            if (!config.plugins) config.plugins = {}
+            if (!config.plugins.entries) config.plugins.entries = {}
+            config.plugins.entries[pluginId] = {
+              ...config.plugins.entries[pluginId],
+              ...savedEntry,
+            }
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
+            api.logger.info(`plugins: force — restored entry config for ${pluginId}`)
+          } catch (err) {
+            api.logger.warn(
+              `plugins: force — failed to restore entry config: ${err instanceof Error ? err.message : String(err)}`,
+            )
           }
-          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
-          api.logger.info(`plugins: force — restored entry config for ${pluginId}`)
-        } catch (err) {
-          api.logger.warn(
-            `plugins: force — failed to restore entry config: ${err instanceof Error ? err.message : String(err)}`,
-          )
         }
       } else if (strategy === 'update') {
-        const result = await $`openclaw plugins update ${pluginId}`
-        output = result.stdout.trim()
+        output = await withPluginBackup(api, pluginId, async () => {
+          const result = await $`openclaw plugins update ${pluginId}`
+          return result.stdout.trim()
+        })
       } else {
         // install
-        const result = await $`openclaw plugins install ${installTarget}`
-        output = result.stdout.trim()
+        output = await withPluginBackup(api, pluginId, async () => {
+          const result = await $`openclaw plugins install ${installTarget}`
+          return result.stdout.trim()
+        })
       }
 
       // Invalidate npm cache for this package

package/model-gateway-setup.ts

@@ -23,6 +23,12 @@ export const EXTRA_GATEWAY_MODELS: Array<{
   alias: string
   input: string[]
 }> = [
+  {
+    id: 'moonshotai/kimi-k2.5',
+    name: 'moonshotai/kimi-k2.5',
+    alias: 'Kimi K2.5',
+    input: ['text', 'image'],
+  },
   {
     id: 'anthropic/claude-sonnet-4.6',
     name: 'anthropic/claude-sonnet-4.6',
@@ -104,15 +110,38 @@ export function setupModelGateway(api: PluginApi): void {
       }
     }
 
-    // Ensure aliases exist for all models
+    // Ensure aliases exist for ALL models (existing + extras)
     const agents = (config.agents ?? {}) as any
     const defaults = agents.defaults ?? {}
     const existingAliases: Record<string, {alias: string}> = defaults.models ?? {}
-    for (const m of EXTRA_GATEWAY_MODELS) {
+    for (const m of existingModels) {
       const key = `${PROVIDER_NAME}/${m.id}`
       if (!existingAliases[key]) {
-        existingAliases[key] = {alias: m.alias}
+        const extra = EXTRA_GATEWAY_MODELS.find((e) => e.id === m.id)
+        existingAliases[key] = {alias: extra?.alias ?? m.id}
+        dirty = true
+      }
+    }
+
+    // Backfill pluginConfig from existing provider credentials (legacy sprites
+    // provisioned before plugin config was written during configure phase).
+    const cfg = api.pluginConfig as Record<string, unknown> | undefined
+    if (
+      existingProvider.baseUrl &&
+      existingProvider.apiKey &&
+      (!cfg?.modelGatewayBaseUrl || !cfg?.modelGatewayToken)
+    ) {
+      const entries = (config.plugins as any)?.entries?.['clawly-plugins']
+      if (entries) {
+        entries.config = {
+          ...entries.config,
+          modelGatewayBaseUrl: existingProvider.baseUrl,
+          modelGatewayToken: existingProvider.apiKey,
+        }
         dirty = true
+        api.logger.info(
+          'Model gateway: backfilled pluginConfig from existing provider credentials.',
+        )
       }
     }
 
@@ -169,9 +198,14 @@ export function setupModelGateway(api: PluginApi): void {
           {id: imageModel, name: imageModel, input: ['text', 'image']},
         ]
 
+  const defaultIds = new Set(defaultModels.map((m) => m.id))
   const models = [
     ...defaultModels,
-    ...EXTRA_GATEWAY_MODELS.map(({id, name, input}) => ({id, name, input})),
+    ...EXTRA_GATEWAY_MODELS.filter((m) => !defaultIds.has(m.id)).map(({id, name, input}) => ({
+      id,
+      name,
+      input,
+    })),
   ]
 
   if (!config.models) config.models = {}

package/package.json

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