@2en/clawly-plugins 1.17.3 → 1.17.5

package/gateway/config-repair.ts

@@ -0,0 +1,119 @@
+/**
+ * Config repair RPC: detects and fixes missing/incomplete clawly-model-gateway
+ * provider in openclaw.json.
+ *
+ * Methods:
+ * - clawly.config.repair({ dryRun? }) → { ok/repaired, detail }
+ */
+
+import path from 'node:path'
+
+import type {PluginApi} from '../index'
+import {
+  PROVIDER_NAME,
+  readOpenclawConfig,
+  resolveStateDir,
+  writeOpenclawConfig,
+} from '../model-gateway-setup'
+
+export function registerConfigRepair(api: PluginApi) {
+  api.registerGatewayMethod('clawly.config.repair', async ({params, respond}) => {
+    const dryRun = params.dryRun === true
+
+    const cfg = api.pluginConfig as Record<string, unknown> | undefined
+    const baseUrl =
+      typeof cfg?.modelGatewayBaseUrl === 'string' ? cfg.modelGatewayBaseUrl.replace(/\/$/, '') : ''
+    const token = typeof cfg?.modelGatewayToken === 'string' ? cfg.modelGatewayToken : ''
+
+    if (!baseUrl || !token) {
+      respond(true, {
+        ...(dryRun ? {ok: false} : {repaired: false}),
+        detail: 'Plugin config missing modelGatewayBaseUrl or modelGatewayToken — cannot repair',
+      })
+      return
+    }
+
+    const stateDir = resolveStateDir(api)
+    if (!stateDir) {
+      respond(true, {
+        ...(dryRun ? {ok: false} : {repaired: false}),
+        detail: 'Cannot resolve state dir',
+      })
+      return
+    }
+
+    const configPath = path.join(stateDir, 'openclaw.json')
+    const config = readOpenclawConfig(configPath)
+
+    // Check current provider state
+    const providers = (config.models as any)?.providers as Record<string, any> | undefined
+    const provider = providers?.[PROVIDER_NAME] as Record<string, unknown> | undefined
+    const currentBaseUrl = typeof provider?.baseUrl === 'string' ? provider.baseUrl : ''
+    const currentApiKey = typeof provider?.apiKey === 'string' ? provider.apiKey : ''
+
+    const needsRepair = !provider || !currentBaseUrl || !currentApiKey
+
+    if (!needsRepair) {
+      respond(true, {
+        ...(dryRun ? {ok: true} : {repaired: false}),
+        detail: 'Provider credentials intact',
+      })
+      return
+    }
+
+    // Dry-run: report status without mutating
+    if (dryRun) {
+      const missing: string[] = []
+      if (!provider) missing.push('provider entry')
+      else {
+        if (!currentBaseUrl) missing.push('baseUrl')
+        if (!currentApiKey) missing.push('apiKey')
+      }
+      respond(true, {ok: false, detail: `Missing: ${missing.join(', ')}`})
+      return
+    }
+
+    // Repair: derive models from agents.defaults (same logic as model-gateway-setup)
+    const defaultModelFull: string = (config.agents as any)?.defaults?.model?.primary ?? ''
+    const imageModelFull: string = (config.agents as any)?.defaults?.imageModel?.primary ?? ''
+
+    const prefix = `${PROVIDER_NAME}/`
+    const defaultModel = defaultModelFull.startsWith(prefix)
+      ? defaultModelFull.slice(prefix.length)
+      : defaultModelFull
+    const imageModel = imageModelFull.startsWith(prefix)
+      ? imageModelFull.slice(prefix.length)
+      : imageModelFull
+
+    const models = !defaultModel
+      ? (provider?.models ?? [])
+      : defaultModel === imageModel || !imageModel
+        ? [{id: defaultModel, name: defaultModel, input: ['text', 'image']}]
+        : [
+            {id: defaultModel, name: defaultModel, input: ['text']},
+            {id: imageModel, name: imageModel, input: ['text', 'image']},
+          ]
+
+    if (!config.models) config.models = {}
+    if (!(config.models as any).providers) (config.models as any).providers = {}
+    ;(config.models as any).providers[PROVIDER_NAME] = {
+      ...(provider ?? {}),
+      baseUrl,
+      apiKey: token,
+      api: 'openai-completions',
+      models,
+    }
+
+    try {
+      writeOpenclawConfig(configPath, config)
+      api.logger.info(`config.repair: restored provider credentials (baseUrl + apiKey)`)
+      respond(true, {repaired: true, detail: 'Provider credentials restored'})
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      api.logger.error(`config.repair: write failed — ${msg}`)
+      respond(true, {repaired: false, detail: `Write failed: ${msg}`})
+    }
+  })
+
+  api.logger.info('config-repair: registered clawly.config.repair')
+}

package/gateway/index.ts

@@ -2,6 +2,7 @@ import type {PluginApi} from '../index'
 import {registerAgentSend} from './agent'
 import {registerChannelsConfigure} from './channels-configure'
 import {registerClawhub2gateway} from './clawhub2gateway'
+import {registerConfigRepair} from './config-repair'
 import {registerMemoryBrowser} from './memory'
 import {registerNotification} from './notification'
 import {registerOfflinePush} from './offline-push'
@@ -17,4 +18,5 @@ export function registerGateway(api: PluginApi) {
   registerPlugins(api)
   registerChannelsConfigure(api)
   registerOfflinePush(api)
+  registerConfigRepair(api)
 }

package/gateway/memory.ts

@@ -44,39 +44,57 @@ function resolveStateDir(api: PluginApi): string {
   return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
 }
 
-/** Read the default agent's workspace path from openclaw.json (cached). */
-let _cachedAgentWorkspace: string | null | undefined
-function readAgentWorkspace(api: PluginApi): string | null {
-  if (_cachedAgentWorkspace !== undefined) return _cachedAgentWorkspace
+/** Read agents list from openclaw.json (cached). */
+let _cachedAgentsList: Array<{id?: string; default?: boolean; workspace?: string}> | null | undefined
+function readAgentsList(api: PluginApi): Array<{id?: string; default?: boolean; workspace?: string}> | null {
+  if (_cachedAgentsList !== undefined) return _cachedAgentsList
   try {
     const stateDir = resolveStateDir(api)
     if (!stateDir) {
-      _cachedAgentWorkspace = null
+      _cachedAgentsList = null
       return null
     }
     const raw = fsSync.readFileSync(path.join(stateDir, 'openclaw.json'), 'utf-8')
     const config = JSON.parse(raw)
     const agents = config?.agents?.list
     if (!Array.isArray(agents)) {
-      _cachedAgentWorkspace = null
+      _cachedAgentsList = null
       return null
     }
-    const defaultAgent = agents.find((a: any) => a.default) ?? agents[0]
-    const ws = typeof defaultAgent?.workspace === 'string' ? defaultAgent.workspace : null
-    _cachedAgentWorkspace = ws
-    return ws
+    _cachedAgentsList = agents
+    return agents
   } catch {
-    _cachedAgentWorkspace = null
+    _cachedAgentsList = null
     return null
   }
 }
 
+/** Read workspace path for a specific agent (by id) or the default agent. */
+function readAgentWorkspace(api: PluginApi, agentId?: string): string | null {
+  const agents = readAgentsList(api)
+  if (!agents) return null
+  let agent: (typeof agents)[number] | undefined
+  if (agentId) {
+    agent = agents.find((a) => a.id === agentId)
+  }
+  if (!agent) {
+    agent = agents.find((a) => a.default) ?? agents[0]
+  }
+  return typeof agent?.workspace === 'string' ? agent.workspace : null
+}
+
 /** Resolve the workspace root directory (without /memory suffix). */
 function resolveWorkspaceRoot(api: PluginApi, profile?: string): string {
   const cfg = coercePluginConfig(api)
   const configPath = configString(cfg, 'memoryDir')
   if (configPath) return path.dirname(configPath) // strip /memory if configured
 
+  // If profile is an agent id, look up that agent's workspace directly
+  if (profile && profile !== 'main') {
+    const agentWs = readAgentWorkspace(api, profile)
+    if (agentWs) return agentWs
+  }
+
   const stateDir = resolveStateDir(api)
   const baseDir =
     process.env.OPENCLAW_WORKSPACE ??
@@ -85,6 +103,7 @@ function resolveWorkspaceRoot(api: PluginApi, profile?: string): string {
       ? path.join(stateDir, 'workspace')
       : path.join(os.homedir(), '.openclaw', 'workspace'))
   if (profile && profile !== 'main') {
+    // Fallback: append profile suffix when agent not found in config
     const parentDir = path.dirname(baseDir)
     const baseName = path.basename(baseDir)
     return path.join(parentDir, `${baseName}-${profile}`)

package/model-gateway-setup.ts

@@ -14,13 +14,13 @@ import path from 'node:path'
 
 import type {PluginApi} from './index'
 
-const PROVIDER_NAME = 'clawly-model-gateway'
+export const PROVIDER_NAME = 'clawly-model-gateway'
 
-function resolveStateDir(api: PluginApi): string {
+export function resolveStateDir(api: PluginApi): string {
   return api.runtime.state?.resolveStateDir?.(process.env) ?? process.env.OPENCLAW_STATE_DIR ?? ''
 }
 
-function readOpenclawConfig(configPath: string): Record<string, unknown> {
+export function readOpenclawConfig(configPath: string): Record<string, unknown> {
   try {
     return JSON.parse(fs.readFileSync(configPath, 'utf-8'))
   } catch {
@@ -28,7 +28,7 @@ function readOpenclawConfig(configPath: string): Record<string, unknown> {
   }
 }
 
-function writeOpenclawConfig(configPath: string, config: Record<string, unknown>) {
+export function writeOpenclawConfig(configPath: string, config: Record<string, unknown>) {
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
 }
 

package/package.json

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