@2en/clawly-plugins 1.28.1 → 1.29.0-beta.1

package/gateway/plugins.test.ts

@@ -1,472 +0,0 @@
-import {afterEach, beforeEach, describe, expect, test} from 'bun:test'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-import {
-  withPluginBackup,
-  recoverOrphanedBackup,
-  cleanOrphanedStagingDirs,
-  BACKUP_DIR_SUFFIX,
-  LEGACY_BACKUP_ZIP_SUFFIX,
-  STAGING_DIR_PREFIX,
-} from './plugins'
-import type {PluginApi} from '../types'
-
-const PLUGIN_ID = 'test-plugin'
-const SENTINEL = 'openclaw.plugin.json'
-
-function makeTmpDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'clawly-plugins-test-'))
-}
-
-function makeApi(stateDir: string): PluginApi {
-  const logs: string[] = []
-  return {
-    id: 'test',
-    name: 'test',
-    runtime: {state: {resolveStateDir: () => stateDir}},
-    logger: {
-      info: (msg: string) => logs.push(`info: ${msg}`),
-      warn: (msg: string) => logs.push(`warn: ${msg}`),
-      error: (msg: string) => logs.push(`error: ${msg}`),
-    },
-    registerGatewayMethod: () => {},
-    registerTool: () => {},
-    registerCommand: () => {},
-    registerChannel: () => {},
-    registerHttpRoute: () => {},
-    on: () => {},
-    _logs: logs,
-  } as unknown as PluginApi & {_logs: string[]}
-}
-
-function setupPluginDir(stateDir: string): string {
-  const extensionDir = path.join(stateDir, 'extensions', PLUGIN_ID)
-  fs.mkdirSync(extensionDir, {recursive: true})
-  fs.writeFileSync(path.join(extensionDir, SENTINEL), '{}')
-  fs.writeFileSync(path.join(extensionDir, 'package.json'), '{"version":"1.0.0"}')
-  return extensionDir
-}
-
-/** Simulate openclaw plugins install writing to a staging dir */
-function simulateStagedInstall(stagingDir: string, pluginId: string, version: string) {
-  const stagedPluginDir = path.join(stagingDir, 'extensions', pluginId)
-  fs.mkdirSync(stagedPluginDir, {recursive: true})
-  fs.writeFileSync(path.join(stagedPluginDir, SENTINEL), '{}')
-  fs.writeFileSync(path.join(stagedPluginDir, 'package.json'), JSON.stringify({version}))
-}
-
-let tmpDir: string
-
-beforeEach(() => {
-  tmpDir = makeTmpDir()
-})
-
-afterEach(() => {
-  fs.rmSync(tmpDir, {recursive: true, force: true})
-})
-
-describe('withPluginBackup (staging mode — default)', () => {
-  test('successful install: original stays live during operation, atomic swap at end', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    const result = await withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-      // Original dir should still exist during the operation
-      expect(fs.existsSync(extensionDir)).toBe(true)
-      expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-      // Staging dir should be provided and exist
-      expect(stagingDir).toBeDefined()
-      expect(fs.existsSync(stagingDir!)).toBe(true)
-      // Staging dir should be under extensions/
-      expect(stagingDir!.startsWith(path.join(tmpDir, 'extensions'))).toBe(true)
-
-      simulateStagedInstall(stagingDir!, PLUGIN_ID, '2.0.0')
-      return 'installed'
-    })
-
-    expect(result).toBe('installed')
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(backupDir)).toBe(false)
-    expect(
-      JSON.parse(fs.readFileSync(path.join(extensionDir, 'package.json'), 'utf-8')).version,
-    ).toBe('2.0.0')
-    // Staging dir should be cleaned up
-    const remainingStaging = fs
-      .readdirSync(path.join(tmpDir, 'extensions'))
-      .filter((f) => f.startsWith(STAGING_DIR_PREFIX))
-    expect(remainingStaging).toHaveLength(0)
-  })
-
-  test('failed install: original dir untouched, staging dir cleaned up', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-
-    await expect(
-      withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-        expect(fs.existsSync(extensionDir)).toBe(true)
-        expect(stagingDir).toBeDefined()
-        throw new Error('npm install failed')
-      }),
-    ).rejects.toThrow('npm install failed')
-
-    // Original dir should be untouched
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-    expect(
-      JSON.parse(fs.readFileSync(path.join(extensionDir, 'package.json'), 'utf-8')).version,
-    ).toBe('1.0.0')
-    // No staging dirs left
-    const remainingStaging = fs
-      .readdirSync(path.join(tmpDir, 'extensions'))
-      .filter((f) => f.startsWith(STAGING_DIR_PREFIX))
-    expect(remainingStaging).toHaveLength(0)
-  })
-
-  test('missing sentinel in staging: throws, original untouched', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-
-    await expect(
-      withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-        // Install to staging but forget sentinel
-        const stagedPluginDir = path.join(stagingDir!, 'extensions', PLUGIN_ID)
-        fs.mkdirSync(stagedPluginDir, {recursive: true})
-        fs.writeFileSync(path.join(stagedPluginDir, 'package.json'), '{"version":"2.0.0"}')
-        return 'done'
-      }),
-    ).rejects.toThrow('plugin files missing after operation')
-
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-  })
-
-  test('first-time install (no existing dir): staging works without backup', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    fs.mkdirSync(path.join(tmpDir, 'extensions'), {recursive: true})
-
-    const result = await withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-      expect(fs.existsSync(extensionDir)).toBe(false)
-      simulateStagedInstall(stagingDir!, PLUGIN_ID, '1.0.0')
-      return 'first install'
-    })
-
-    expect(result).toBe('first install')
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-  })
-
-  test('first-time install failure: no leftover dirs', async () => {
-    const api = makeApi(tmpDir)
-    fs.mkdirSync(path.join(tmpDir, 'extensions'), {recursive: true})
-
-    await expect(
-      withPluginBackup(api, PLUGIN_ID, async () => {
-        throw new Error('install failed')
-      }),
-    ).rejects.toThrow('install failed')
-
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    expect(fs.existsSync(extensionDir)).toBe(false)
-    const remainingStaging = fs
-      .readdirSync(path.join(tmpDir, 'extensions'))
-      .filter((f) => f.startsWith(STAGING_DIR_PREFIX))
-    expect(remainingStaging).toHaveLength(0)
-  })
-
-  test('staging dir is on same filesystem as extensions/', async () => {
-    const api = makeApi(tmpDir)
-    setupPluginDir(tmpDir)
-    const extensionsBase = path.join(tmpDir, 'extensions')
-
-    await withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-      // Verify staging dir is a sibling inside extensions/
-      expect(path.dirname(stagingDir!)).toBe(extensionsBase)
-      simulateStagedInstall(stagingDir!, PLUGIN_ID, '2.0.0')
-      return 'ok'
-    })
-  })
-})
-
-describe('withPluginBackup (in-place mode — staging: false)', () => {
-  test('preserves original dir for in-place update', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    const result = await withPluginBackup(
-      api,
-      PLUGIN_ID,
-      async () => {
-        // Original dir should still exist (copied, not renamed)
-        expect(fs.existsSync(extensionDir)).toBe(true)
-        expect(fs.existsSync(backupDir)).toBe(true)
-        // Simulate in-place update
-        fs.writeFileSync(path.join(extensionDir, 'package.json'), '{"version":"2.0.0"}')
-        return 'updated'
-      },
-      {staging: false},
-    )
-
-    expect(result).toBe('updated')
-    expect(fs.existsSync(backupDir)).toBe(false)
-    expect(
-      JSON.parse(fs.readFileSync(path.join(extensionDir, 'package.json'), 'utf-8')).version,
-    ).toBe('2.0.0')
-  })
-
-  test('first install failure: cleans up partial extensionDir', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    fs.mkdirSync(path.join(tmpDir, 'extensions'), {recursive: true})
-
-    await expect(
-      withPluginBackup(
-        api,
-        PLUGIN_ID,
-        async () => {
-          // Simulate partial install — dir created but operation fails
-          fs.mkdirSync(extensionDir, {recursive: true})
-          fs.writeFileSync(path.join(extensionDir, 'package.json'), '{"version":"1.0.0"}')
-          throw new Error('install failed')
-        },
-        {staging: false},
-      ),
-    ).rejects.toThrow('install failed')
-
-    // Partial dir should be cleaned up
-    expect(fs.existsSync(extensionDir)).toBe(false)
-  })
-
-  test('rollback on success-without-sentinel', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    await expect(
-      withPluginBackup(
-        api,
-        PLUGIN_ID,
-        async () => {
-          // Operation succeeds but removes sentinel
-          fs.unlinkSync(path.join(extensionDir, SENTINEL))
-          return 'done'
-        },
-        {staging: false},
-      ),
-    ).rejects.toThrow('plugin files missing after operation')
-
-    // Should be rolled back to original (backup had sentinel)
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-    expect(fs.existsSync(backupDir)).toBe(false)
-  })
-
-  test('rollback restores original on failure', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-
-    await expect(
-      withPluginBackup(
-        api,
-        PLUGIN_ID,
-        async () => {
-          // Corrupt the dir
-          fs.unlinkSync(path.join(extensionDir, SENTINEL))
-          throw new Error('update failed')
-        },
-        {staging: false},
-      ),
-    ).rejects.toThrow('update failed')
-
-    // Should be rolled back to original
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-    expect(
-      JSON.parse(fs.readFileSync(path.join(extensionDir, 'package.json'), 'utf-8')).version,
-    ).toBe('1.0.0')
-  })
-})
-
-describe('withPluginBackup (no stateDir)', () => {
-  test('passes through to operation', async () => {
-    const api = makeApi(tmpDir)
-    ;(api.runtime.state as any).resolveStateDir = () => ''
-
-    const result = await withPluginBackup(api, PLUGIN_ID, async () => 'passthrough')
-    expect(result).toBe('passthrough')
-  })
-})
-
-describe('recoverOrphanedBackup', () => {
-  test('recovers from orphaned backup dir when plugin dir is missing', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    // Create orphaned backup (as if update was interrupted)
-    fs.mkdirSync(backupDir, {recursive: true})
-    fs.writeFileSync(path.join(backupDir, SENTINEL), '{}')
-    fs.writeFileSync(path.join(backupDir, 'package.json'), '{"version":"1.0.0"}')
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(path.join(extensionDir, SENTINEL))).toBe(true)
-    expect(fs.existsSync(backupDir)).toBe(false)
-  })
-
-  test('warns when recovered dir is missing sentinel', async () => {
-    const api = makeApi(tmpDir) as PluginApi & {_logs: string[]}
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    // Create orphaned backup without sentinel
-    fs.mkdirSync(backupDir, {recursive: true})
-    fs.writeFileSync(path.join(backupDir, 'package.json'), '{"version":"1.0.0"}')
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(backupDir)).toBe(false)
-    expect(api._logs.some((l: string) => l.includes('missing sentinel'))).toBe(true)
-  })
-
-  test('cleans up stale backup when plugin dir is healthy', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-    const backupDir = `${extensionDir}${BACKUP_DIR_SUFFIX}`
-
-    // Create stale backup alongside healthy plugin
-    fs.mkdirSync(backupDir, {recursive: true})
-    fs.writeFileSync(path.join(backupDir, SENTINEL), '{}')
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(backupDir)).toBe(false)
-  })
-
-  test('cleans up stale legacy zip when plugin dir is healthy', async () => {
-    const api = makeApi(tmpDir)
-    const extensionDir = setupPluginDir(tmpDir)
-    const legacyZip = `${extensionDir}${LEGACY_BACKUP_ZIP_SUFFIX}`
-
-    fs.writeFileSync(legacyZip, 'fake-zip-data')
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    expect(fs.existsSync(extensionDir)).toBe(true)
-    expect(fs.existsSync(legacyZip)).toBe(false)
-  })
-
-  test('no-op when no backups and plugin is healthy', async () => {
-    const api = makeApi(tmpDir) as PluginApi & {_logs: string[]}
-    setupPluginDir(tmpDir)
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    // No recovery logs
-    expect((api as any)._logs.filter((l: string) => l.includes('recover'))).toHaveLength(0)
-  })
-
-  test('no-op when plugin dir missing and no backups exist', async () => {
-    const api = makeApi(tmpDir)
-    fs.mkdirSync(path.join(tmpDir, 'extensions'), {recursive: true})
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    const extensionDir = path.join(tmpDir, 'extensions', PLUGIN_ID)
-    expect(fs.existsSync(extensionDir)).toBe(false)
-  })
-
-  test('cleans orphaned staging dirs at startup', async () => {
-    const api = makeApi(tmpDir)
-    setupPluginDir(tmpDir)
-    const extensionsBase = path.join(tmpDir, 'extensions')
-
-    // Create orphaned staging dirs
-    const staging1 = path.join(extensionsBase, `${STAGING_DIR_PREFIX}${PLUGIN_ID}-aabbccdd`)
-    const staging2 = path.join(extensionsBase, `${STAGING_DIR_PREFIX}${PLUGIN_ID}-11223344`)
-    fs.mkdirSync(path.join(staging1, 'extensions', PLUGIN_ID), {recursive: true})
-    fs.writeFileSync(path.join(staging1, 'openclaw.json'), '{}')
-    fs.mkdirSync(staging2, {recursive: true})
-
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-
-    expect(fs.existsSync(staging1)).toBe(false)
-    expect(fs.existsSync(staging2)).toBe(false)
-  })
-
-  test('no-op when no stateDir', async () => {
-    const api = makeApi(tmpDir)
-    ;(api.runtime.state as any).resolveStateDir = () => ''
-
-    // Should not throw
-    await recoverOrphanedBackup(api, PLUGIN_ID)
-  })
-})
-
-describe('cleanOrphanedStagingDirs', () => {
-  test('removes staging dirs for the specified plugin only', () => {
-    const api = makeApi(tmpDir)
-    const extensionsBase = path.join(tmpDir, 'extensions')
-    fs.mkdirSync(extensionsBase, {recursive: true})
-
-    // Create staging dirs for our plugin and another plugin
-    const ours = path.join(extensionsBase, `${STAGING_DIR_PREFIX}${PLUGIN_ID}-aabb1122`)
-    const other = path.join(extensionsBase, `${STAGING_DIR_PREFIX}other-plugin-ccdd3344`)
-    fs.mkdirSync(ours, {recursive: true})
-    fs.mkdirSync(other, {recursive: true})
-
-    cleanOrphanedStagingDirs(api, PLUGIN_ID)
-
-    expect(fs.existsSync(ours)).toBe(false)
-    expect(fs.existsSync(other)).toBe(true)
-  })
-
-  test('does not delete staging dirs of plugin whose ID is a superstring', () => {
-    const api = makeApi(tmpDir)
-    const extensionsBase = path.join(tmpDir, 'extensions')
-    fs.mkdirSync(extensionsBase, {recursive: true})
-
-    // "test-plugin" should NOT match "test-plugin-extra"
-    const ours = path.join(extensionsBase, `${STAGING_DIR_PREFIX}${PLUGIN_ID}-aabb1122`)
-    const longerPlugin = path.join(
-      extensionsBase,
-      `${STAGING_DIR_PREFIX}${PLUGIN_ID}-extra-ccdd3344`,
-    )
-    fs.mkdirSync(ours, {recursive: true})
-    fs.mkdirSync(longerPlugin, {recursive: true})
-
-    cleanOrphanedStagingDirs(api, PLUGIN_ID)
-
-    expect(fs.existsSync(ours)).toBe(false)
-    // longer plugin name must survive — it's a different plugin
-    expect(fs.existsSync(longerPlugin)).toBe(true)
-  })
-
-  test('staging install cleans previous orphaned staging dirs', async () => {
-    const api = makeApi(tmpDir)
-    setupPluginDir(tmpDir)
-    const extensionsBase = path.join(tmpDir, 'extensions')
-
-    // Create an orphaned staging dir from a previous interrupted attempt
-    const orphaned = path.join(extensionsBase, `${STAGING_DIR_PREFIX}${PLUGIN_ID}-deadbeef`)
-    fs.mkdirSync(path.join(orphaned, 'extensions', PLUGIN_ID), {recursive: true})
-    fs.writeFileSync(path.join(orphaned, 'openclaw.json'), '{}')
-
-    await withPluginBackup(api, PLUGIN_ID, async ({stagingDir}) => {
-      // Orphaned dir should already be cleaned up
-      expect(fs.existsSync(orphaned)).toBe(false)
-      // But our new staging dir should exist
-      expect(fs.existsSync(stagingDir!)).toBe(true)
-      simulateStagedInstall(stagingDir!, PLUGIN_ID, '2.0.0')
-      return 'ok'
-    })
-
-    // No staging dirs left
-    const remaining = fs.readdirSync(extensionsBase).filter((f) => f.startsWith(STAGING_DIR_PREFIX))
-    expect(remaining).toHaveLength(0)
-  })
-})