@2en/clawly-plugins 1.20.0 → 1.21.0

package/gateway/index.ts

@@ -1,6 +1,5 @@
 import type {PluginApi} from '../index'
 import {registerAgentSend} from './agent'
-import {registerChannelsConfigure} from './channels-configure'
 import {registerClawhub2gateway} from './clawhub2gateway'
 import {registerConfigRepair} from './config-repair'
 import {registerPairing} from './pairing'
@@ -17,7 +16,6 @@ export function registerGateway(api: PluginApi) {
   registerMemoryBrowser(api)
   registerClawhub2gateway(api)
   registerPlugins(api)
-  registerChannelsConfigure(api)
   registerOfflinePush(api)
   registerConfigRepair(api)
   registerPairing(api)

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

@@ -123,6 +123,28 @@ export function setupModelGateway(api: PluginApi): void {
       }
     }
 
+    // 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.',
+        )
+      }
+    }
+
     if (dirty) {
       existingProvider.models = existingModels
       defaults.models = existingAliases

package/package.json

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

package/gateway/channels-configure.ts

@@ -1,151 +0,0 @@
-/**
- * Channel configuration management via openclaw.json.
- *
- * Methods:
- * - clawly.channels.configure — add/update a channel account config
- * - clawly.channels.disconnect — remove a channel account config
- */
-
-import fs from 'node:fs'
-import path from 'node:path'
-
-import type {PluginApi} from '../index'
-
-const TOKEN_CHANNELS = new Set(['telegram', 'discord', 'slack', 'irc', 'googlechat'])
-
-function resolveStateDir(api: PluginApi): string {
-  return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
-}
-
-function readOpenclawConfig(configPath: string): Record<string, unknown> {
-  try {
-    return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
-  } catch {
-    return {}
-  }
-}
-
-function writeOpenclawConfig(configPath: string, config: Record<string, unknown>) {
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
-}
-
-export function registerChannelsConfigure(api: PluginApi) {
-  // ── clawly.channels.configure ──────────────────────────────────
-
-  api.registerGatewayMethod('clawly.channels.configure', async ({params, respond}) => {
-    const channel = typeof params.channel === 'string' ? params.channel.trim() : ''
-    const accountId = typeof params.accountId === 'string' ? params.accountId.trim() : 'default'
-    const config =
-      params.config && typeof params.config === 'object' && !Array.isArray(params.config)
-        ? (params.config as Record<string, unknown>)
-        : null
-
-    if (!channel) {
-      respond(false, undefined, {code: 'invalid_params', message: 'channel is required'})
-      return
-    }
-
-    if (!TOKEN_CHANNELS.has(channel)) {
-      respond(false, undefined, {
-        code: 'invalid_params',
-        message: `unsupported channel: ${channel}. Supported: ${[...TOKEN_CHANNELS].join(', ')}`,
-      })
-      return
-    }
-
-    if (!config) {
-      respond(false, undefined, {code: 'invalid_params', message: 'config object is required'})
-      return
-    }
-
-    const stateDir = resolveStateDir(api)
-    if (!stateDir) {
-      respond(false, undefined, {code: 'internal', message: 'cannot resolve openclaw state dir'})
-      return
-    }
-
-    const configPath = path.join(stateDir, 'openclaw.json')
-
-    try {
-      const ocConfig = readOpenclawConfig(configPath)
-
-      // Ensure channels.<channel>.accounts.<accountId> path exists
-      if (!ocConfig.channels || typeof ocConfig.channels !== 'object') {
-        ocConfig.channels = {}
-      }
-      const channels = ocConfig.channels as Record<string, unknown>
-
-      if (!channels[channel] || typeof channels[channel] !== 'object') {
-        channels[channel] = {}
-      }
-      const channelConfig = channels[channel] as Record<string, unknown>
-
-      if (!channelConfig.accounts || typeof channelConfig.accounts !== 'object') {
-        channelConfig.accounts = {}
-      }
-      const accounts = channelConfig.accounts as Record<string, unknown>
-
-      // Merge config with enabled: true
-      accounts[accountId] = {
-        ...((accounts[accountId] as Record<string, unknown>) ?? {}),
-        ...config,
-        enabled: true,
-      }
-
-      writeOpenclawConfig(configPath, ocConfig)
-      api.logger.info(`channels.configure: wrote ${channel}/${accountId} to openclaw.json`)
-
-      respond(true, {ok: true, channel, accountId})
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      api.logger.error(`channels.configure: failed — ${msg}`)
-      respond(false, undefined, {code: 'internal', message: msg})
-    }
-  })
-
-  // ── clawly.channels.disconnect ─────────────────────────────────
-
-  api.registerGatewayMethod('clawly.channels.disconnect', async ({params, respond}) => {
-    const channel = typeof params.channel === 'string' ? params.channel.trim() : ''
-    const accountId = typeof params.accountId === 'string' ? params.accountId.trim() : 'default'
-
-    if (!channel) {
-      respond(false, undefined, {code: 'invalid_params', message: 'channel is required'})
-      return
-    }
-
-    const stateDir = resolveStateDir(api)
-    if (!stateDir) {
-      respond(false, undefined, {code: 'internal', message: 'cannot resolve openclaw state dir'})
-      return
-    }
-
-    const configPath = path.join(stateDir, 'openclaw.json')
-
-    try {
-      const ocConfig = readOpenclawConfig(configPath)
-      const channels = ocConfig.channels as Record<string, unknown> | undefined
-
-      if (channels && typeof channels === 'object') {
-        const channelConfig = channels[channel] as Record<string, unknown> | undefined
-        if (channelConfig && typeof channelConfig === 'object') {
-          const accounts = channelConfig.accounts as Record<string, unknown> | undefined
-          if (accounts && typeof accounts === 'object' && accountId in accounts) {
-            delete accounts[accountId]
-          }
-        }
-      }
-
-      writeOpenclawConfig(configPath, ocConfig)
-      api.logger.info(`channels.disconnect: removed ${channel}/${accountId} from openclaw.json`)
-
-      respond(true, {ok: true, channel, accountId})
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      api.logger.error(`channels.disconnect: failed — ${msg}`)
-      respond(false, undefined, {code: 'internal', message: msg})
-    }
-  })
-
-  api.logger.info('channels: registered clawly.channels.configure + clawly.channels.disconnect')
-}