fix: repair intel desktop and provider saves

Author: waydelyle

README.md

@@ -151,14 +151,14 @@ clawhub install swarmclaw
 
 [Browse on ClawHub](https://clawhub.ai/skills/swarmclaw)
 
-## v1.9.26 Highlights
+## v1.9.27 Highlights
 
-Output hygiene follow-up: empty successful LLM turns now stay silent instead of being rewritten as user-visible errors.
+Desktop compatibility and provider-save repair for Intel Mac users and OpenRouter setup.
 
-- **Silent empty completions.** Blank successful runs no longer become `Error: Run completed...` assistant messages.
-- **Connector-safe final text.** Slack and other connectors no longer receive synthetic error text for intentional silence or quiet no-op turns.
-- **Real errors preserved.** Explicit provider failures and streamed provider errors still surface as terminal errors.
-- **Regression coverage.** Chat-execution tests now lock the distinction between empty success and real failure.
+- **Intel macOS native modules.** The desktop packaging hook now rebuilds Electron-loaded native modules with the target architecture and blocks a release if an x64 macOS bundle contains an arm64-only required addon.
+- **OpenRouter save repair.** Provider updates now tolerate UI metadata fields like `id`, `type`, `createdAt`, and `updatedAt` without persisting them, while still rejecting unrelated unknown fields.
+- **Downloads clarity.** The downloads page no longer guesses Apple Silicon when a browser hides the Mac architecture, so Intel users can choose the x64 DMG explicitly.
+- **Regression coverage.** Provider route and Electron after-pack tests cover the reported failure modes.
 
 ## Hosted Deploys
 
@@ -410,6 +410,15 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.9.27 Highlights
+
+Desktop compatibility and provider-save repair for Intel Mac users and OpenRouter setup.
+
+- **Intel macOS native modules.** The desktop packaging hook now rebuilds Electron-loaded native modules with the target architecture and blocks a release if an x64 macOS bundle contains an arm64-only required addon.
+- **OpenRouter save repair.** Provider updates now tolerate UI metadata fields like `id`, `type`, `createdAt`, and `updatedAt` without persisting them, while still rejecting unrelated unknown fields.
+- **Downloads clarity.** The downloads page no longer guesses Apple Silicon when a browser hides the Mac architecture, so Intel users can choose the x64 DMG explicitly.
+- **Regression coverage.** Provider route and Electron after-pack tests cover the reported failure modes.
+
 ### v1.9.26 Highlights
 
 Output hygiene follow-up: empty successful LLM turns now stay silent instead of being rewritten as user-visible errors.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.9.26",
+  "version": "1.9.27",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package.json

@@ -16,17 +16,78 @@ const STANDALONE_REBUILD_MODULES = [
   'better-sqlite3',
   'utf-8-validate',
 ]
+const STANDALONE_NATIVE_ARCH_CHECKS = [
+  ['better-sqlite3', 'build', 'Release', 'better_sqlite3.node'],
+  ['utf-8-validate', 'build', 'Release', 'validation.node'],
+]
+const EXPECTED_MACHO_ARCH = {
+  x64: 'x86_64',
+  arm64: 'arm64',
+}
+
+function nativeBinaryPartsForModule(moduleName) {
+  return STANDALONE_NATIVE_ARCH_CHECKS.filter(([nativeModuleName]) => nativeModuleName === moduleName)
+}
 
 function readElectronVersion(projectDir) {
   const electronPkg = path.join(projectDir, 'node_modules', 'electron', 'package.json')
   const raw = fs.readFileSync(electronPkg, 'utf8')
   return JSON.parse(raw).version
 }
 
+function copyNativeModuleSourceForRebuild(projectDir, standaloneDir, moduleName) {
+  const sourceDir = path.join(projectDir, 'node_modules', moduleName)
+  const targetDir = path.join(standaloneDir, 'node_modules', moduleName)
+  if (!fs.existsSync(sourceDir) || !fs.existsSync(targetDir)) return false
+
+  fs.rmSync(targetDir, { recursive: true, force: true })
+  fs.cpSync(sourceDir, targetDir, {
+    recursive: true,
+    force: true,
+    filter: (src) => {
+      const relative = path.relative(sourceDir, src)
+      return relative !== 'build' && !relative.startsWith(`build${path.sep}`)
+    },
+  })
+  return true
+}
+
+function prepareStandaloneNativeModuleSources(projectDir, standaloneDir, modules) {
+  for (const moduleName of modules) {
+    copyNativeModuleSourceForRebuild(projectDir, standaloneDir, moduleName)
+  }
+}
+
+function snapshotProjectNativeBinaries(projectDir, modules = STANDALONE_REBUILD_MODULES) {
+  const snapshots = []
+
+  for (const moduleName of modules) {
+    for (const nativeParts of nativeBinaryPartsForModule(moduleName)) {
+      const nativePath = path.join(projectDir, 'node_modules', ...nativeParts)
+      if (!fs.existsSync(nativePath)) continue
+      snapshots.push({
+        nativePath,
+        data: fs.readFileSync(nativePath),
+        mode: fs.statSync(nativePath).mode,
+      })
+    }
+  }
+
+  return () => {
+    for (const snapshot of snapshots) {
+      fs.mkdirSync(path.dirname(snapshot.nativePath), { recursive: true })
+      fs.writeFileSync(snapshot.nativePath, snapshot.data, { mode: snapshot.mode })
+    }
+  }
+}
+
 function rebuildStandaloneNativeModules(projectDir, standaloneDir, archName) {
   const modules = STANDALONE_REBUILD_MODULES.filter((moduleName) => fs.existsSync(path.join(standaloneDir, 'node_modules', moduleName)))
   if (modules.length === 0) return
 
+  const restoreProjectNativeBinaries = snapshotProjectNativeBinaries(projectDir, modules)
+  prepareStandaloneNativeModuleSources(projectDir, standaloneDir, modules)
+
   const electronRebuild = path.join(
     projectDir,
     'node_modules',
@@ -35,29 +96,56 @@ function rebuildStandaloneNativeModules(projectDir, standaloneDir, archName) {
   )
   const electronVersion = readElectronVersion(projectDir)
   const cacheDir = path.join(projectDir, '.tmp-electron-rebuild-cache')
-  const result = spawnSync(
-    electronRebuild,
-    [
-      '--version', electronVersion,
-      '--module-dir', standaloneDir,
-      '--only', modules.join(','),
-      '--arch', archName,
-      '--sequential',
-      '--force',
-      '--disable-pre-gyp-copy',
-    ],
-    {
-      cwd: projectDir,
-      stdio: 'inherit',
-      shell: process.platform === 'win32',
-      env: {
-        ...process.env,
-        npm_config_cache: process.env.npm_config_cache || cacheDir,
+  try {
+    const result = spawnSync(
+      electronRebuild,
+      [
+        '--version', electronVersion,
+        '--module-dir', standaloneDir,
+        '--only', modules.join(','),
+        '--arch', archName,
+        '--sequential',
+        '--force',
+        '--disable-pre-gyp-copy',
+        '--build-from-source',
+      ],
+      {
+        cwd: projectDir,
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+        env: {
+          ...process.env,
+          npm_config_arch: archName,
+          npm_config_target_arch: archName,
+          npm_config_build_from_source: 'true',
+          npm_config_cache: process.env.npm_config_cache || cacheDir,
+        },
       },
-    },
-  )
-  if (result.status !== 0) {
-    throw new Error(`afterPack: electron-rebuild failed with status ${result.status}`)
+    )
+    if (result.status !== 0) {
+      throw new Error(`afterPack: electron-rebuild failed with status ${result.status}`)
+    }
+  } finally {
+    restoreProjectNativeBinaries()
+  }
+}
+
+function validateStandaloneNativeModuleArch(standaloneDir, archName) {
+  const expected = EXPECTED_MACHO_ARCH[archName]
+  if (!expected) return
+
+  for (const nativeParts of STANDALONE_NATIVE_ARCH_CHECKS) {
+    const nativePath = path.join(standaloneDir, 'node_modules', ...nativeParts)
+    if (!fs.existsSync(nativePath)) continue
+
+    const result = spawnSync('file', [nativePath], { encoding: 'utf8' })
+    if (result.status !== 0) {
+      throw new Error(`afterPack: failed to inspect ${nativePath}: ${result.stderr || result.error?.message || 'file command failed'}`)
+    }
+    const output = `${result.stdout || ''}${result.stderr || ''}`
+    if (!output.includes(expected)) {
+      throw new Error(`afterPack: ${nativePath} expected ${expected} for arch=${archName}, got: ${output.trim()}`)
+    }
   }
 }
 
@@ -99,6 +187,9 @@ exports.default = async function afterPack(context) {
 
   console.log(`[after-pack] rebuilding required standalone native modules for arch=${archName}`)
   rebuildStandaloneNativeModules(projectDir, standaloneDir, archName)
+  if (context.electronPlatformName === 'darwin') validateStandaloneNativeModuleArch(standaloneDir, archName)
 
   if (context.electronPlatformName === 'darwin') signMacApp(context)
 }
+
+exports.validateStandaloneNativeModuleArch = validateStandaloneNativeModuleArch

scripts/electron-after-pack.cjs

@@ -8,7 +8,10 @@ import { describe, it } from 'node:test'
 
 const require = createRequire(import.meta.url)
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
-const { default: afterPack } = require(path.join(repoRoot, 'scripts', 'electron-after-pack.cjs'))
+const {
+  default: afterPack,
+  validateStandaloneNativeModuleArch,
+} = require(path.join(repoRoot, 'scripts', 'electron-after-pack.cjs'))
 
 describe('electron afterPack hook', () => {
   it('rebuilds required native modules inside Linux standalone resources', async () => {
@@ -17,11 +20,18 @@ describe('electron afterPack hook', () => {
     const appOutDir = path.join(tempDir, 'dist', 'linux-unpacked')
     const electronPkg = path.join(projectDir, 'node_modules', 'electron', 'package.json')
     const rebuildBin = path.join(projectDir, 'node_modules', '.bin', 'electron-rebuild')
+    const sourcePkg = path.join(projectDir, 'node_modules', 'better-sqlite3')
     const standalonePkg = path.join(appOutDir, 'resources', '.next', 'standalone', 'node_modules', 'better-sqlite3')
     const standaloneNative = path.join(standalonePkg, 'build', 'Release', 'better_sqlite3.node')
 
     fs.mkdirSync(path.dirname(electronPkg), { recursive: true })
     fs.writeFileSync(electronPkg, JSON.stringify({ version: '33.4.11' }))
+    fs.mkdirSync(path.join(sourcePkg, 'src'), { recursive: true })
+    fs.mkdirSync(path.join(sourcePkg, 'build', 'Release'), { recursive: true })
+    fs.writeFileSync(path.join(sourcePkg, 'package.json'), JSON.stringify({ name: 'better-sqlite3' }))
+    fs.writeFileSync(path.join(sourcePkg, 'binding.gyp'), '{}')
+    fs.writeFileSync(path.join(sourcePkg, 'src', 'addon.cpp'), '// source')
+    fs.writeFileSync(path.join(sourcePkg, 'build', 'Release', 'better_sqlite3.node'), 'host-arch')
     fs.mkdirSync(path.dirname(rebuildBin), { recursive: true })
     fs.writeFileSync(rebuildBin, `#!/bin/sh
 set -eu
@@ -34,13 +44,18 @@ while [ "$#" -gt 0 ]; do
     *) shift ;;
   esac
 done
+test -f "$module_dir/node_modules/better-sqlite3/binding.gyp"
+test ! -f "$module_dir/node_modules/better-sqlite3/build/Release/stale.node"
 mkdir -p "$module_dir/node_modules/better-sqlite3/build/Release"
-printf "electron-abi-build-%s" "$arch" > "$module_dir/node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+printf "electron-abi-build-%s env:%s/%s" "$arch" "$npm_config_arch" "$npm_config_target_arch" > "$module_dir/node_modules/better-sqlite3/build/Release/better_sqlite3.node"
+project_dir="$(cd "$(dirname "$0")/../.." && pwd)"
+printf "mutated-root-%s" "$arch" > "$project_dir/node_modules/better-sqlite3/build/Release/better_sqlite3.node"
 `)
     fs.chmodSync(rebuildBin, 0o755)
     fs.mkdirSync(standalonePkg, { recursive: true })
     fs.mkdirSync(path.dirname(standaloneNative), { recursive: true })
     fs.writeFileSync(standaloneNative, 'host-node-build')
+    fs.writeFileSync(path.join(path.dirname(standaloneNative), 'stale.node'), 'stale')
 
     try {
       await afterPack({
@@ -53,9 +68,40 @@ printf "electron-abi-build-%s" "$arch" > "$module_dir/node_modules/better-sqlite
         },
       })
 
-      assert.equal(fs.readFileSync(standaloneNative, 'utf8'), 'electron-abi-build-x64')
+      assert.equal(fs.readFileSync(standaloneNative, 'utf8'), 'electron-abi-build-x64 env:x64/x64')
+      assert.equal(
+        fs.readFileSync(path.join(sourcePkg, 'build', 'Release', 'better_sqlite3.node'), 'utf8'),
+        'host-arch',
+      )
     } finally {
       fs.rmSync(tempDir, { recursive: true, force: true })
     }
   })
+
+  it('rejects a macOS x64 package that contains an arm64-only required native module', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-after-pack-arch-'))
+    const standaloneDir = path.join(tempDir, 'standalone')
+    const nativePath = path.join(standaloneDir, 'node_modules', 'better-sqlite3', 'build', 'Release', 'better_sqlite3.node')
+    const binDir = path.join(tempDir, 'bin')
+
+    fs.mkdirSync(path.dirname(nativePath), { recursive: true })
+    fs.writeFileSync(nativePath, 'fake-native')
+    fs.mkdirSync(binDir, { recursive: true })
+    fs.writeFileSync(path.join(binDir, 'file'), `#!/bin/sh
+printf '%s: Mach-O 64-bit bundle arm64\\n' "$1"
+`)
+    fs.chmodSync(path.join(binDir, 'file'), 0o755)
+
+    const oldPath = process.env.PATH
+    process.env.PATH = `${binDir}${path.delimiter}${oldPath || ''}`
+    try {
+      assert.throws(
+        () => validateStandaloneNativeModuleArch(standaloneDir, 'x64'),
+        /expected x86_64/,
+      )
+    } finally {
+      process.env.PATH = oldPath
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
 })

scripts/electron-after-pack.test.mjs

@@ -48,7 +48,52 @@ test('provider route upserts builtin override records for enablement changes', (
   assert.equal(output.responsePayload.isEnabled, false)
 })
 
-test('provider route rejects unknown fields per ProviderUpdateSchema.strict()', () => {
+test('provider route ignores frontend metadata fields without persisting them', () => {
+  const output = runWithTempDataDir<{
+    status: number
+    providerConfig: {
+      id: string
+      type: string
+      name: string
+      isEnabled: boolean
+      updatedAt: number
+    }
+  }>(`
+    const storageMod = await import('./src/lib/server/storage')
+    const routeMod = await import('./src/app/api/providers/[id]/route')
+    const storage = storageMod.default || storageMod
+    const route = routeMod.default || routeMod
+
+    const response = await route.PUT(
+      new Request('http://local/api/providers/openai', {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          id: 'wrong-id',
+          type: 'custom',
+          createdAt: '123',
+          updatedAt: '456',
+          isEnabled: false,
+        }),
+      }),
+      { params: Promise.resolve({ id: 'openai' }) },
+    )
+
+    console.log(JSON.stringify({
+      status: response.status,
+      providerConfig: storage.loadProviderConfigs().openai,
+    }))
+  `, { prefix: 'swarmclaw-provider-route-strict-test-' })
+
+  assert.equal(output.status, 200)
+  assert.equal(output.providerConfig.id, 'openai')
+  assert.equal(output.providerConfig.type, 'builtin')
+  assert.equal(output.providerConfig.name, 'OpenAI')
+  assert.equal(output.providerConfig.isEnabled, false)
+  assert.equal(typeof output.providerConfig.updatedAt, 'number')
+})
+
+test('provider route still rejects unknown non-metadata fields', () => {
   const output = runWithTempDataDir<{ status: number }>(`
     const routeMod = await import('./src/app/api/providers/[id]/route')
     const route = routeMod.default || routeMod
@@ -57,13 +102,13 @@ test('provider route rejects unknown fields per ProviderUpdateSchema.strict()',
       new Request('http://local/api/providers/openai', {
         method: 'PUT',
         headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ type: 'builtin', isEnabled: true }),
+        body: JSON.stringify({ unexpectedField: true, isEnabled: true }),
       }),
       { params: Promise.resolve({ id: 'openai' }) },
     )
 
     console.log(JSON.stringify({ status: response.status }))
-  `, { prefix: 'swarmclaw-provider-route-strict-test-' })
+  `, { prefix: 'swarmclaw-provider-route-unknown-field-test-' })
 
   assert.equal(output.status, 400)
 })