opencode-dux 1.0.0

package/src/hooks/auto-update-checker/cache.test.ts

@@ -0,0 +1,179 @@
+import { describe, expect, mock, spyOn, test } from 'bun:test';
+import * as fs from 'node:fs';
+import { normalize } from 'node:path';
+import { platform } from 'node:os';
+
+// Mock logger to avoid noise
+mock.module('../../utils/logger', () => ({
+  log: mock(() => {}),
+}));
+
+mock.module('../../cli/config-manager', () => ({
+  stripJsonComments: (s: string) => s,
+  getOpenCodeConfigPaths: () => [
+    normalize('/mock/config/opencode.json'),
+    normalize('/mock/config/opencode.jsonc'),
+  ],
+}));
+
+// Platform-normalize a Unix-style path for the current OS
+function norm(path: string): string {
+  return normalize(path);
+}
+
+// Cache buster for dynamic imports
+let importCounter = 0;
+
+const onWindows = platform() === 'win32';
+
+const RUNTIME_PKG_JSON = norm(
+  '/home/user/.cache/opencode/packages/opencode-dux@latest/node_modules/opencode-dux/package.json',
+);
+const WRAPPER_PKG_JSON = norm(
+  '/home/user/.cache/opencode/packages/opencode-dux@latest/package.json',
+);
+const PKG_DIR = norm(
+  '/home/user/.cache/opencode/packages/opencode-dux@latest/node_modules/opencode-dux',
+);
+const INSTALL_DIR = norm(
+  '/home/user/.cache/opencode/packages/opencode-dux@latest',
+);
+
+function existsSync(path: unknown): boolean {
+  return (
+    path === WRAPPER_PKG_JSON || path === PKG_DIR
+  );
+}
+
+function readFileSync(path: unknown): string | Buffer {
+  if (path === WRAPPER_PKG_JSON) {
+    return JSON.stringify({
+      dependencies: { 'opencode-dux': '0.9.1' },
+    });
+  }
+  return '';
+}
+
+describe('auto-update-checker/cache', () => {
+  describe('resolveInstallContext', () => {
+    test('detects OpenCode packages install root from runtime package path', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (path: unknown) => path === WRAPPER_PKG_JSON,
+      );
+      const { resolveInstallContext } = await import(
+        `./cache?test=${importCounter++}`
+      );
+
+      const context = resolveInstallContext(RUNTIME_PKG_JSON);
+
+      expect(context).toEqual({
+        installDir: INSTALL_DIR,
+        packageJsonPath: WRAPPER_PKG_JSON,
+      });
+
+      existsSpy.mockRestore();
+    });
+
+    test('does not fall back to legacy cache when runtime path is active but wrapper root is invalid', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        () => false,
+      );
+      const { resolveInstallContext } = await import(
+        `./cache?test=${importCounter++}`
+      );
+
+      const context = resolveInstallContext(RUNTIME_PKG_JSON);
+
+      expect(context).toBeNull();
+
+      existsSpy.mockRestore();
+    });
+  });
+
+  describe('preparePackageUpdate', () => {
+    test('returns null when no install context is available', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockReturnValue(false);
+      const { preparePackageUpdate } = await import(
+        `./cache?test=${importCounter++}`
+      );
+
+      const result = preparePackageUpdate('1.0.1');
+      expect(result).toBeNull();
+
+      existsSpy.mockRestore();
+    });
+
+    test('updates packages wrapper dependency and removes installed package', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (path: unknown) => path === WRAPPER_PKG_JSON || path === PKG_DIR,
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          dependencies: { 'opencode-dux': '0.9.1' },
+        }),
+      );
+      const writtenData: string[] = [];
+      const writeSpy = spyOn(fs, 'writeFileSync').mockImplementation(
+        (_path: unknown, data: unknown) => {
+          writtenData.push(data as string);
+        },
+      );
+      const rmSyncSpy = spyOn(fs, 'rmSync').mockReturnValue(undefined);
+      const { preparePackageUpdate } = await import(
+        `./cache?test=${importCounter++}`
+      );
+
+      const result = preparePackageUpdate(
+        '0.9.11',
+        'opencode-dux',
+        RUNTIME_PKG_JSON,
+      );
+
+      expect(result).toBe(INSTALL_DIR);
+      expect(rmSyncSpy).toHaveBeenCalledWith(PKG_DIR, {
+        recursive: true,
+        force: true,
+      });
+      expect(writtenData.length).toBeGreaterThan(0);
+      expect(JSON.parse(writtenData[0])).toEqual({
+        dependencies: { 'opencode-dux': '0.9.11' },
+      });
+
+      existsSpy.mockRestore();
+      readSpy.mockRestore();
+      writeSpy.mockRestore();
+      rmSyncSpy.mockRestore();
+    });
+
+    const testLegacyCache = onWindows ? test.skip : test;
+    testLegacyCache('keeps working when dependency is already on target version', async () => {
+      const legacyCache = norm('/.cache/opencode');
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: unknown) =>
+          (typeof p === 'string' && p.endsWith(norm('/.cache/opencode/package.json'))) ||
+          (typeof p === 'string' && p.endsWith(norm('/.cache/opencode/node_modules/opencode-dux'))),
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          dependencies: { 'opencode-dux': '1.0.1' },
+        }),
+      );
+      const writeSpy = spyOn(fs, 'writeFileSync').mockImplementation(() => {});
+      const rmSyncSpy = spyOn(fs, 'rmSync').mockReturnValue(undefined);
+      const { preparePackageUpdate } = await import(
+        `./cache?test=${importCounter++}`
+      );
+
+      const result = preparePackageUpdate('1.0.1', 'opencode-dux', null);
+
+      expect(typeof result === 'string' && result.endsWith(legacyCache)).toBe(true);
+      expect(writeSpy).not.toHaveBeenCalled();
+      expect(rmSyncSpy).toHaveBeenCalled();
+
+      existsSpy.mockRestore();
+      readSpy.mockRestore();
+      writeSpy.mockRestore();
+      rmSyncSpy.mockRestore();
+    });
+  });
+});

package/src/hooks/auto-update-checker/cache.ts

@@ -0,0 +1,188 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { stripJsonComments } from '../../cli/config-manager';
+import { log } from '../../utils/logger';
+import { getCurrentRuntimePackageJsonPath } from './checker';
+import { CACHE_DIR, PACKAGE_NAME } from './constants';
+
+interface BunLockfile {
+  workspaces?: {
+    ''?: {
+      dependencies?: Record<string, string>;
+    };
+  };
+  packages?: Record<string, unknown>;
+}
+
+interface AutoUpdateInstallContext {
+  installDir: string;
+  packageJsonPath: string;
+}
+
+/**
+ * Removes a package from the bun.lock file if it's in JSON format.
+ * Note: Newer Bun versions (1.1+) use a custom text format for bun.lock.
+ * This function handles JSON-based lockfiles gracefully.
+ */
+function removeFromBunLock(installDir: string, packageName: string): boolean {
+  const lockPath = path.join(installDir, 'bun.lock');
+  if (!fs.existsSync(lockPath)) return false;
+
+  try {
+    const content = fs.readFileSync(lockPath, 'utf-8');
+    let lock: BunLockfile;
+
+    try {
+      lock = JSON.parse(stripJsonComments(content)) as BunLockfile;
+    } catch {
+      // If it's not valid JSON(C), it might be the new Bun text format or binary format.
+      // For now, we only support JSON-based lockfile manipulation.
+      return false;
+    }
+
+    let modified = false;
+
+    if (lock.workspaces?.['']?.dependencies?.[packageName]) {
+      delete lock.workspaces[''].dependencies[packageName];
+      modified = true;
+    }
+
+    if (lock.packages?.[packageName]) {
+      delete lock.packages[packageName];
+      modified = true;
+    }
+
+    if (modified) {
+      fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+    }
+
+    return modified;
+  } catch (err) {
+    log(`[auto-update-checker] Failed to process bun.lock:`, err);
+    return false;
+  }
+}
+
+function ensureDependencyVersion(
+  packageJsonPath: string,
+  packageName: string,
+  version: string,
+): boolean {
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  try {
+    const content = fs.readFileSync(packageJsonPath, 'utf-8');
+    const pkgJson = JSON.parse(stripJsonComments(content)) as {
+      dependencies?: Record<string, string>;
+      [key: string]: unknown;
+    };
+
+    const dependencies = { ...(pkgJson.dependencies ?? {}) };
+    if (dependencies[packageName] === version) {
+      return true;
+    }
+
+    dependencies[packageName] = version;
+    pkgJson.dependencies = dependencies;
+    fs.writeFileSync(packageJsonPath, JSON.stringify(pkgJson, null, 2));
+    log(
+      `[auto-update-checker] Updated dependency in package.json: ${packageName} → ${version}`,
+    );
+    return true;
+  } catch (err) {
+    log(
+      `[auto-update-checker] Failed to update package.json dependency for auto-update:`,
+      err,
+    );
+    return false;
+  }
+}
+
+function removeInstalledPackage(
+  installDir: string,
+  packageName: string,
+): boolean {
+  const pkgDir = path.join(installDir, 'node_modules', packageName);
+  if (!fs.existsSync(pkgDir)) return false;
+
+  fs.rmSync(pkgDir, { recursive: true, force: true });
+  log(`[auto-update-checker] Package removed: ${pkgDir}`);
+  return true;
+}
+
+export function resolveInstallContext(
+  runtimePackageJsonPath: string | null = getCurrentRuntimePackageJsonPath(),
+): AutoUpdateInstallContext | null {
+  if (runtimePackageJsonPath) {
+    const packageDir = path.dirname(runtimePackageJsonPath);
+    const nodeModulesDir = path.dirname(packageDir);
+
+    if (
+      path.basename(packageDir) === PACKAGE_NAME &&
+      path.basename(nodeModulesDir) === 'node_modules'
+    ) {
+      const installDir = path.dirname(nodeModulesDir);
+      const packageJsonPath = path.join(installDir, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        return { installDir, packageJsonPath };
+      }
+    }
+
+    return null;
+  }
+
+  const legacyPackageJsonPath = path.join(CACHE_DIR, 'package.json');
+  if (fs.existsSync(legacyPackageJsonPath)) {
+    return { installDir: CACHE_DIR, packageJsonPath: legacyPackageJsonPath };
+  }
+
+  return null;
+}
+
+/**
+ * Prepares the current install root for a clean re-install of the target version.
+ * Returns the install directory to run `bun install` in.
+ */
+export function preparePackageUpdate(
+  version: string,
+  packageName: string = PACKAGE_NAME,
+  runtimePackageJsonPath: string | null = getCurrentRuntimePackageJsonPath(),
+): string | null {
+  try {
+    const installContext = resolveInstallContext(runtimePackageJsonPath);
+    if (!installContext) {
+      log('[auto-update-checker] No install context found for auto-update');
+      return null;
+    }
+
+    const dependencyReady = ensureDependencyVersion(
+      installContext.packageJsonPath,
+      packageName,
+      version,
+    );
+    if (!dependencyReady) {
+      return null;
+    }
+
+    const packageRemoved = removeInstalledPackage(
+      installContext.installDir,
+      packageName,
+    );
+    const lockRemoved = removeFromBunLock(
+      installContext.installDir,
+      packageName,
+    );
+
+    if (!packageRemoved && !lockRemoved) {
+      log(
+        `[auto-update-checker] No cached package artifacts removed for ${packageName}; continuing with updated dependency spec`,
+      );
+    }
+
+    return installContext.installDir;
+  } catch (err) {
+    log('[auto-update-checker] Failed to prepare package update:', err);
+    return null;
+  }
+}

package/src/hooks/auto-update-checker/checker.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, mock, spyOn, test } from 'bun:test';
+import * as fs from 'node:fs';
+
+// Mock logger to avoid noise
+mock.module('../../utils/logger', () => ({
+  log: mock(() => {}),
+}));
+
+mock.module('../../cli/config-manager', () => ({
+  stripJsonComments: (s: string) => s,
+  getOpenCodeConfigPaths: () => [
+    '/mock/config/opencode.json',
+    '/mock/config/opencode.jsonc',
+  ],
+}));
+
+// Cache buster for dynamic imports
+let importCounter = 0;
+
+describe('auto-update-checker/checker', () => {
+  describe('extractChannel', () => {
+    test('returns latest for null or empty', async () => {
+      const { extractChannel } = await import(
+        `./checker?test=${importCounter++}`
+      );
+      expect(extractChannel(null)).toBe('latest');
+      expect(extractChannel('')).toBe('latest');
+    });
+
+    test('returns tag if version starts with non-digit', async () => {
+      const { extractChannel } = await import(
+        `./checker?test=${importCounter++}`
+      );
+      expect(extractChannel('beta')).toBe('beta');
+      expect(extractChannel('next')).toBe('next');
+    });
+
+    test('extracts channel from prerelease version', async () => {
+      const { extractChannel } = await import(
+        `./checker?test=${importCounter++}`
+      );
+      expect(extractChannel('1.0.0-alpha.1')).toBe('alpha');
+      expect(extractChannel('2.3.4-beta.5')).toBe('beta');
+      expect(extractChannel('0.1.0-rc.1')).toBe('rc');
+      expect(extractChannel('1.0.0-canary.0')).toBe('canary');
+    });
+
+    test('returns latest for standard versions', async () => {
+      const { extractChannel } = await import(
+        `./checker?test=${importCounter++}`
+      );
+      expect(extractChannel('1.0.0')).toBe('latest');
+    });
+  });
+
+  describe('getLocalDevVersion', () => {
+    test('returns null if no local dev path in config', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockReturnValue(false);
+      const { getLocalDevVersion } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      expect(getLocalDevVersion('/test')).toBeNull();
+
+      existsSpy.mockRestore();
+    });
+
+    test('returns version from local package.json if path exists', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: string) => {
+          if (p.includes('opencode.json')) return true;
+          if (p.includes('package.json')) return true;
+          return false;
+        },
+      );
+      const statSpy = spyOn(fs, 'statSync').mockImplementation(
+        () =>
+          ({
+            isDirectory: () => true,
+          }) as unknown as fs.Stats,
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockImplementation(
+        (p: string) => {
+          if (p.includes('opencode.json')) {
+            return JSON.stringify({
+              plugin: ['file:///dev/opencode-dux'],
+            });
+          }
+          if (p.includes('package.json')) {
+            return JSON.stringify({
+              name: 'opencode-dux',
+              version: '1.2.3-dev',
+            });
+          }
+          return '';
+        },
+      );
+
+      const { getLocalDevVersion } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      expect(getLocalDevVersion('/test')).toBe('1.2.3-dev');
+
+      existsSpy.mockRestore();
+      statSpy.mockRestore();
+      readSpy.mockRestore();
+    });
+  });
+
+  describe('findPluginEntry', () => {
+    test('detects latest version entry', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: string) => p.includes('opencode.json'),
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          plugin: ['opencode-dux'],
+        }),
+      );
+
+      const { findPluginEntry } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      const entry = findPluginEntry('/test');
+      expect(entry).not.toBeNull();
+      expect(entry?.entry).toBe('opencode-dux');
+      expect(entry?.isPinned).toBe(false);
+      expect(entry?.pinnedVersion).toBeNull();
+
+      existsSpy.mockRestore();
+      readSpy.mockRestore();
+    });
+
+    test('detects pinned version entry', async () => {
+      const existsSpy = spyOn(fs, 'existsSync').mockImplementation(
+        (p: string) => p.includes('opencode.json'),
+      );
+      const readSpy = spyOn(fs, 'readFileSync').mockReturnValue(
+        JSON.stringify({
+          plugin: ['opencode-dux@1.0.0'],
+        }),
+      );
+
+      const { findPluginEntry } = await import(
+        `./checker?test=${importCounter++}`
+      );
+
+      const entry = findPluginEntry('/test');
+      expect(entry).not.toBeNull();
+      expect(entry?.isPinned).toBe(true);
+      expect(entry?.pinnedVersion).toBe('1.0.0');
+
+      existsSpy.mockRestore();
+      readSpy.mockRestore();
+    });
+  });
+});