opencode-dux 1.0.0

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

@@ -0,0 +1,308 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { stripJsonComments } from '../../cli/config-manager';
+import { log } from '../../utils/logger';
+import {
+  INSTALLED_PACKAGE_JSON,
+  NPM_FETCH_TIMEOUT,
+  NPM_REGISTRY_URL,
+  PACKAGE_NAME,
+  USER_OPENCODE_CONFIG,
+  USER_OPENCODE_CONFIG_JSONC,
+} from './constants';
+import type {
+  NpmDistTags,
+  OpencodeConfig,
+  PackageJson,
+  PluginEntryInfo,
+} from './types';
+
+function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+function getPluginEntries(config: OpencodeConfig): string[] {
+  return Array.isArray(config.plugin) ? config.plugin.filter(isString) : [];
+}
+
+/**
+ * Checks if a version string indicates a prerelease (contains a hyphen).
+ */
+function isPrereleaseVersion(version: string): boolean {
+  return version.includes('-');
+}
+
+/**
+ * Checks if a version string is an NPM dist-tag (does not start with a digit).
+ */
+function isDistTag(version: string): boolean {
+  return !/^\d/.test(version);
+}
+
+/**
+ * Extracts the update channel (latest, alpha, beta, etc.) from a version string.
+ * @param version The version or tag to analyze.
+ * @returns The channel name.
+ */
+export function extractChannel(version: string | null): string {
+  if (!version) return 'latest';
+
+  if (isDistTag(version)) return version;
+
+  if (isPrereleaseVersion(version)) {
+    const prereleasePart = version.split('-')[1];
+    if (prereleasePart) {
+      const channelMatch = prereleasePart.match(/^(alpha|beta|rc|canary|next)/);
+      if (channelMatch) return channelMatch[1];
+    }
+  }
+
+  return 'latest';
+}
+
+/**
+ * Generates a list of potential OpenCode configuration file paths.
+ * @param directory The current plugin directory to check for local .opencode folders.
+ */
+function getConfigPaths(directory: string): string[] {
+  return [
+    path.join(directory, '.opencode', 'opencode.json'),
+    path.join(directory, '.opencode', 'opencode.jsonc'),
+    USER_OPENCODE_CONFIG,
+    USER_OPENCODE_CONFIG_JSONC,
+  ];
+}
+
+/**
+ * Attempts to find a local development path (file://) for the plugin in configs.
+ */
+function getLocalDevPath(directory: string): string | null {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs.existsSync(configPath)) continue;
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig;
+      const plugins = getPluginEntries(config);
+
+      for (const entry of plugins) {
+        if (entry.startsWith('file://') && entry.includes(PACKAGE_NAME)) {
+          try {
+            return fileURLToPath(entry);
+          } catch {
+            return entry.replace('file://', '');
+          }
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+/**
+ * Recursively searches upwards for a package.json belonging to this plugin.
+ */
+function findPackageJsonUp(startPath: string): string | null {
+  try {
+    const stat = fs.statSync(startPath);
+    let dir = stat.isDirectory() ? startPath : path.dirname(startPath);
+
+    for (let i = 0; i < 10; i++) {
+      const pkgPath = path.join(dir, 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const content = fs.readFileSync(pkgPath, 'utf-8');
+          const pkg = JSON.parse(content) as PackageJson;
+          if (pkg.name === PACKAGE_NAME) return pkgPath;
+        } catch {
+          /* empty */
+        }
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    /* empty */
+  }
+  return null;
+}
+
+/**
+ * Resolves the version of the plugin when running in local development mode.
+ */
+export function getLocalDevVersion(directory: string): string | null {
+  const localPath = getLocalDevPath(directory);
+  if (!localPath) return null;
+
+  try {
+    const pkgPath = findPackageJsonUp(localPath);
+    if (!pkgPath) return null;
+    const content = fs.readFileSync(pkgPath, 'utf-8');
+    const pkg = JSON.parse(content) as PackageJson;
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolves the package.json for the currently running plugin bundle.
+ */
+export function getCurrentRuntimePackageJsonPath(
+  currentModuleUrl: string = import.meta.url,
+): string | null {
+  try {
+    const currentDir = path.dirname(fileURLToPath(currentModuleUrl));
+    return findPackageJsonUp(currentDir);
+  } catch (err) {
+    log('[auto-update-checker] Failed to resolve runtime package path:', err);
+    return null;
+  }
+}
+
+/**
+ * Searches across all config locations to find the current installation entry for this plugin.
+ */
+export function findPluginEntry(directory: string): PluginEntryInfo | null {
+  for (const configPath of getConfigPaths(directory)) {
+    try {
+      if (!fs.existsSync(configPath)) continue;
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig;
+      const plugins = getPluginEntries(config);
+
+      for (const entry of plugins) {
+        if (entry === PACKAGE_NAME) {
+          return { entry, isPinned: false, pinnedVersion: null, configPath };
+        }
+        if (entry.startsWith(`${PACKAGE_NAME}@`)) {
+          const pinnedVersion = entry.slice(PACKAGE_NAME.length + 1);
+          const isPinned = pinnedVersion !== 'latest';
+          return {
+            entry,
+            isPinned,
+            pinnedVersion: isPinned ? pinnedVersion : null,
+            configPath,
+          };
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+const _cachedLocalVersion: string | null = null;
+let cachedPackageVersion: string | null = null;
+
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+export function getCachedVersion(): string | null {
+  if (cachedPackageVersion) return cachedPackageVersion;
+
+  try {
+    const runtimePackageJsonPath = getCurrentRuntimePackageJsonPath();
+    if (runtimePackageJsonPath && fs.existsSync(runtimePackageJsonPath)) {
+      const content = fs.readFileSync(runtimePackageJsonPath, 'utf-8');
+      const pkg = JSON.parse(content) as PackageJson;
+      if (pkg.version) {
+        cachedPackageVersion = pkg.version;
+        return pkg.version;
+      }
+    }
+  } catch {
+    /* empty */
+  }
+
+  try {
+    if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, 'utf-8');
+      const pkg = JSON.parse(content) as PackageJson;
+      if (pkg.version) {
+        cachedPackageVersion = pkg.version;
+        return pkg.version;
+      }
+    }
+  } catch (err) {
+    log(
+      '[auto-update-checker] Failed to resolve version from current directory:',
+      err,
+    );
+  }
+
+  return null;
+}
+
+/**
+ * Safely updates a pinned version in the configuration file.
+ * It attempts to replace the exact plugin string to preserve comments and formatting.
+ */
+export function updatePinnedVersion(
+  configPath: string,
+  oldEntry: string,
+  newVersion: string,
+): boolean {
+  try {
+    if (!fs.existsSync(configPath)) return false;
+
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const newEntry = `${PACKAGE_NAME}@${newVersion}`;
+
+    // Check if the old entry actually exists as a quoted string
+    const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const entryRegex = new RegExp(`(["'])${escapedOldEntry}\\1`, 'g');
+
+    if (!entryRegex.test(content)) {
+      log(
+        `[auto-update-checker] Entry "${oldEntry}" not found in ${configPath}`,
+      );
+      return false;
+    }
+
+    // Perform the replacement
+    const updatedContent = content.replace(entryRegex, `$1${newEntry}$1`);
+
+    if (updatedContent === content) {
+      return false;
+    }
+
+    fs.writeFileSync(configPath, updatedContent, 'utf-8');
+    log(
+      `[auto-update-checker] Updated ${configPath}: ${oldEntry} → ${newEntry}`,
+    );
+    return true;
+  } catch (err) {
+    log(
+      `[auto-update-checker] Failed to update config file ${configPath}:`,
+      err,
+    );
+    return false;
+  }
+}
+
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export async function getLatestVersion(
+  channel: string = 'latest',
+): Promise<string | null> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: { Accept: 'application/json' },
+    });
+
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as NpmDistTags;
+    return data[channel] ?? data.latest ?? null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

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

@@ -0,0 +1,33 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getOpenCodeConfigPaths } from '../../cli/config-manager';
+
+export const PACKAGE_NAME = 'opencode-dux';
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+export const NPM_FETCH_TIMEOUT = 5000;
+
+function getCacheDir(): string {
+  if (process.platform === 'win32') {
+    return path.join(process.env.LOCALAPPDATA ?? os.homedir(), 'opencode');
+  }
+  return path.join(os.homedir(), '.cache', 'opencode');
+}
+
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export const CACHE_DIR = getCacheDir();
+
+/** Path to this plugin's package.json within the OpenCode cache. */
+export const INSTALLED_PACKAGE_JSON = path.join(
+  CACHE_DIR,
+  'node_modules',
+  PACKAGE_NAME,
+  'package.json',
+);
+
+const configPaths = getOpenCodeConfigPaths();
+
+/** Primary OpenCode configuration file path (standard JSON). */
+export const USER_OPENCODE_CONFIG = configPaths[0];
+
+/** Alternative OpenCode configuration file path (JSON with Comments). */
+export const USER_OPENCODE_CONFIG_JSONC = configPaths[1];

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

@@ -0,0 +1,282 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+
+const logMock = mock(() => {});
+
+const checkerMocks = {
+  extractChannel: mock(() => 'latest'),
+  findPluginEntry: mock(() => null),
+  getCachedVersion: mock(() => null),
+  getLatestVersion: mock(async () => null),
+  getLocalDevVersion: mock(() => null),
+  getCurrentRuntimePackageJsonPath: mock(() => null),
+};
+
+const cacheMocks = {
+  preparePackageUpdate: mock(() => '/tmp/opencode'),
+  resolveInstallContext: mock(() => ({ installDir: '/tmp/opencode' })),
+};
+
+const crossSpawnMock = mock((_command: string[]) => ({
+  exited: Promise.resolve(0),
+  exitCode: 0,
+  kill: mock(() => true),
+  stdout: () => Promise.resolve(''),
+  stderr: () => Promise.resolve(''),
+  proc: {} as never,
+}));
+
+mock.module('../../utils/logger', () => ({
+  log: logMock,
+}));
+
+mock.module('./checker', () => checkerMocks);
+
+mock.module('./cache', () => cacheMocks);
+
+mock.module('../../utils/compat', () => ({
+  crossSpawn: crossSpawnMock,
+  crossWrite: mock(() => Promise.resolve()),
+  isBun: false,
+}));
+
+let importCounter = 0;
+
+function createCtx() {
+  const showToast = mock(() => Promise.resolve(undefined));
+
+  return {
+    ctx: {
+      directory: '/test',
+      client: {
+        tui: {
+          showToast,
+        },
+      },
+    },
+    showToast,
+  };
+}
+
+async function waitForCalls(
+  fn: { mock: { calls: unknown[] } },
+  minCalls = 1,
+): Promise<void> {
+  const deadline = Date.now() + 1000;
+
+  while (fn.mock.calls.length < minCalls) {
+    if (Date.now() > deadline) {
+      throw new Error('Timed out waiting for async hook work');
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+
+describe('auto-update-checker/index', () => {
+  beforeEach(() => {
+    logMock.mockClear();
+
+    checkerMocks.extractChannel.mockReset();
+    checkerMocks.extractChannel.mockImplementation(() => 'latest');
+    checkerMocks.findPluginEntry.mockReset();
+    checkerMocks.findPluginEntry.mockImplementation(() => null);
+    checkerMocks.getCachedVersion.mockReset();
+    checkerMocks.getCachedVersion.mockImplementation(() => null);
+    checkerMocks.getLatestVersion.mockReset();
+    checkerMocks.getLatestVersion.mockImplementation(async () => null);
+    checkerMocks.getLocalDevVersion.mockReset();
+    checkerMocks.getLocalDevVersion.mockImplementation(() => null);
+
+    cacheMocks.preparePackageUpdate.mockReset();
+    cacheMocks.preparePackageUpdate.mockImplementation(() => '/tmp/opencode');
+    cacheMocks.resolveInstallContext.mockReset();
+    cacheMocks.resolveInstallContext.mockImplementation(() => ({
+      installDir: '/tmp/opencode',
+    }));
+
+    crossSpawnMock.mockReset();
+    crossSpawnMock.mockImplementation(() => ({
+      exited: Promise.resolve(0),
+      exitCode: 0,
+      kill: mock(() => true),
+      stdout: () => Promise.resolve(''),
+      stderr: () => Promise.resolve(''),
+      proc: {} as never,
+    }));
+  });
+
+  afterEach(() => {
+    // Mocks are automatically cleared by Bun's test runner between tests
+  });
+
+  test('uses resolved install root for auto-update installs', async () => {
+    const { getAutoUpdateInstallDir } = await import(
+      `./index?test=${importCounter++}`
+    );
+
+    expect(getAutoUpdateInstallDir()).toBe('/tmp/opencode');
+  });
+
+  test('skips background update for local dev installs without startup toast', async () => {
+    checkerMocks.getLocalDevVersion.mockImplementation(() => '0.9.11-dev');
+
+    const { createAutoUpdateCheckerHook } = await import(
+      `./index?test=${importCounter++}`
+    );
+    const { ctx, showToast } = createCtx();
+
+    const hook = createAutoUpdateCheckerHook(ctx as never);
+    hook.event({ event: { type: 'session.created', properties: {} } });
+    await waitForCalls(logMock);
+
+    expect(showToast).not.toHaveBeenCalled();
+    expect(checkerMocks.findPluginEntry).not.toHaveBeenCalled();
+    expect(checkerMocks.getLatestVersion).not.toHaveBeenCalled();
+  });
+
+  test('shows success toast after updating the active install root', async () => {
+    checkerMocks.findPluginEntry.mockImplementation(() => ({
+      pinnedVersion: null,
+      isPinned: false,
+    }));
+    checkerMocks.getCachedVersion.mockImplementation(() => '0.9.1');
+    checkerMocks.getLatestVersion.mockImplementation(async () => '0.9.11');
+
+    crossSpawnMock.mockImplementation(() => ({
+      exited: Promise.resolve(0),
+      exitCode: 0,
+      kill: mock(() => true),
+      stdout: () => Promise.resolve(''),
+      stderr: () => Promise.resolve(''),
+      proc: {} as never,
+    }));
+
+    const { createAutoUpdateCheckerHook } = await import(
+      `./index?test=${importCounter++}`
+    );
+    const { ctx, showToast } = createCtx();
+
+    const hook = createAutoUpdateCheckerHook(ctx as never);
+    hook.event({ event: { type: 'session.created', properties: {} } });
+    await waitForCalls(showToast);
+
+    expect(cacheMocks.preparePackageUpdate).toHaveBeenCalledWith(
+      '0.9.11',
+      'opencode-dux',
+    );
+    expect(crossSpawnMock).toHaveBeenCalledWith(
+      ['bun', 'install'],
+      expect.objectContaining({ cwd: '/tmp/opencode' }),
+    );
+    expect(showToast).toHaveBeenCalledWith({
+      body: {
+        title: 'OMO-Slim Updated!',
+        message: 'v0.9.1 → v0.9.11\nRestart OpenCode to apply.',
+        variant: 'success',
+        duration: 8000,
+      },
+    });
+  });
+
+  test('shows notification-only toast when auto-update is disabled', async () => {
+    checkerMocks.findPluginEntry.mockImplementation(() => ({
+      pinnedVersion: null,
+      isPinned: false,
+    }));
+    checkerMocks.getCachedVersion.mockImplementation(() => '0.9.1');
+    checkerMocks.getLatestVersion.mockImplementation(async () => '0.9.11');
+
+    const { createAutoUpdateCheckerHook } = await import(
+      `./index?test=${importCounter++}`
+    );
+    const { ctx, showToast } = createCtx();
+
+    const hook = createAutoUpdateCheckerHook(ctx as never, {
+      autoUpdate: false,
+    });
+    hook.event({ event: { type: 'session.created', properties: {} } });
+    await waitForCalls(showToast);
+
+    expect(showToast).toHaveBeenCalledWith({
+      body: {
+        title: 'OMO-Slim 0.9.11',
+        message: 'v0.9.11 available. Auto-update is disabled.',
+        variant: 'info',
+        duration: 8000,
+      },
+    });
+    expect(cacheMocks.preparePackageUpdate).not.toHaveBeenCalled();
+    expect(crossSpawnMock).not.toHaveBeenCalled();
+  });
+
+  test('shows prepare failure toast and skips installation when active install cannot be resolved', async () => {
+    checkerMocks.findPluginEntry.mockImplementation(() => ({
+      pinnedVersion: null,
+      isPinned: false,
+    }));
+    checkerMocks.getCachedVersion.mockImplementation(() => '0.9.1');
+    checkerMocks.getLatestVersion.mockImplementation(async () => '0.9.11');
+    cacheMocks.preparePackageUpdate.mockImplementation(() => null);
+
+    const { createAutoUpdateCheckerHook } = await import(
+      `./index?test=${importCounter++}`
+    );
+    const { ctx, showToast } = createCtx();
+
+    const hook = createAutoUpdateCheckerHook(ctx as never);
+    hook.event({ event: { type: 'session.created', properties: {} } });
+    await waitForCalls(showToast);
+
+    expect(crossSpawnMock).not.toHaveBeenCalled();
+    expect(showToast).toHaveBeenCalledWith({
+      body: {
+        title: 'OMO-Slim 0.9.11',
+        message:
+          'v0.9.11 available. Auto-update could not prepare the active install.',
+        variant: 'info',
+        duration: 8000,
+      },
+    });
+  });
+
+  test('shows install failure toast without telling users to restart', async () => {
+    checkerMocks.findPluginEntry.mockImplementation(() => ({
+      pinnedVersion: null,
+      isPinned: false,
+    }));
+    checkerMocks.getCachedVersion.mockImplementation(() => '0.9.1');
+    checkerMocks.getLatestVersion.mockImplementation(async () => '0.9.11');
+
+    crossSpawnMock.mockImplementation(() => ({
+      exited: Promise.resolve(1),
+      exitCode: 1,
+      kill: mock(() => true),
+      stdout: () => Promise.resolve(''),
+      stderr: () => Promise.resolve(''),
+      proc: {} as never,
+    }));
+
+    const { createAutoUpdateCheckerHook } = await import(
+      `./index?test=${importCounter++}`
+    );
+    const { ctx, showToast } = createCtx();
+
+    const hook = createAutoUpdateCheckerHook(ctx as never);
+    hook.event({ event: { type: 'session.created', properties: {} } });
+    await waitForCalls(showToast);
+
+    expect(crossSpawnMock).toHaveBeenCalledWith(
+      ['bun', 'install'],
+      expect.objectContaining({ cwd: '/tmp/opencode' }),
+    );
+    expect(showToast).toHaveBeenCalledWith({
+      body: {
+        title: 'OMO-Slim 0.9.11',
+        message:
+          'v0.9.11 available, but auto-update failed to install it. Check logs or retry manually.',
+        variant: 'error',
+        duration: 8000,
+      },
+    });
+  });
+});