opencode-dux 1.0.0

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

@@ -0,0 +1,225 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import { crossSpawn } from '../../utils/compat';
+import { log } from '../../utils/logger';
+import { preparePackageUpdate, resolveInstallContext } from './cache';
+import {
+  extractChannel,
+  findPluginEntry,
+  getCachedVersion,
+  getLatestVersion,
+  getLocalDevVersion,
+} from './checker';
+import { CACHE_DIR, PACKAGE_NAME } from './constants';
+import type { AutoUpdateCheckerOptions } from './types';
+
+/**
+ * Creates an OpenCode hook that checks for plugin updates when a new session is created.
+ * @param ctx The plugin input context.
+ * @param options Configuration options for the update checker.
+ * @returns A hook object for the session.created event.
+ */
+export function createAutoUpdateCheckerHook(
+  ctx: PluginInput,
+  options: AutoUpdateCheckerOptions = {},
+) {
+  const { autoUpdate = true } = options;
+
+  let hasChecked = false;
+
+  return {
+    event: ({ event }: { event: { type: string; properties?: unknown } }) => {
+      if (event.type !== 'session.created') return;
+      if (hasChecked) return;
+
+      const props = event.properties as
+        | { info?: { parentID?: string } }
+        | undefined;
+      if (props?.info?.parentID) return;
+
+      hasChecked = true;
+
+      setTimeout(async () => {
+        const localDevVersion = getLocalDevVersion(ctx.directory);
+
+        if (localDevVersion) {
+          log('[auto-update-checker] Local development mode');
+          return;
+        }
+
+        runBackgroundUpdateCheck(ctx, autoUpdate).catch((err) => {
+          log('[auto-update-checker] Background update check failed:', err);
+        });
+      }, 0);
+    },
+  };
+}
+
+/**
+ * Orchestrates the version comparison and update process in the background.
+ * @param ctx The plugin input context.
+ * @param autoUpdate Whether to automatically install updates.
+ */
+async function runBackgroundUpdateCheck(
+  ctx: PluginInput,
+  autoUpdate: boolean,
+): Promise<void> {
+  const pluginInfo = findPluginEntry(ctx.directory);
+  if (!pluginInfo) {
+    log('[auto-update-checker] Plugin not found in config');
+    return;
+  }
+
+  const cachedVersion = getCachedVersion();
+  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion;
+  if (!currentVersion) {
+    log('[auto-update-checker] No version found (cached or pinned)');
+    return;
+  }
+
+  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
+  const latestVersion = await getLatestVersion(channel);
+  if (!latestVersion) {
+    log(
+      '[auto-update-checker] Failed to fetch latest version for channel:',
+      channel,
+    );
+    return;
+  }
+
+  if (currentVersion === latestVersion) {
+    log(
+      '[auto-update-checker] Already on latest version for channel:',
+      channel,
+    );
+    return;
+  }
+
+  log(
+    `[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`,
+  );
+
+  if (pluginInfo.isPinned) {
+    showToast(
+      ctx,
+      `OMO-Slim ${latestVersion}`,
+      `v${latestVersion} available.\nVersion is pinned. Update your plugin config to apply.`,
+      'info',
+      8000,
+    );
+    log(`[auto-update-checker] Version is pinned; skipping auto-update.`);
+    return;
+  }
+
+  if (!autoUpdate) {
+    showToast(
+      ctx,
+      `OMO-Slim ${latestVersion}`,
+      `v${latestVersion} available. Auto-update is disabled.`,
+      'info',
+      8000,
+    );
+    log('[auto-update-checker] Auto-update disabled, notification only');
+    return;
+  }
+
+  const installDir = preparePackageUpdate(latestVersion, PACKAGE_NAME);
+  if (!installDir) {
+    showToast(
+      ctx,
+      `OMO-Slim ${latestVersion}`,
+      `v${latestVersion} available. Auto-update could not prepare the active install.`,
+      'info',
+      8000,
+    );
+    log('[auto-update-checker] Failed to prepare install root for auto-update');
+    return;
+  }
+
+  const installSuccess = await runBunInstallSafe(installDir);
+
+  if (installSuccess) {
+    showToast(
+      ctx,
+      'OMO-Slim Updated!',
+      `v${currentVersion} → v${latestVersion}\nRestart OpenCode to apply.`,
+      'success',
+      8000,
+    );
+    log(
+      `[auto-update-checker] Update installed: ${currentVersion} → ${latestVersion}`,
+    );
+  } else {
+    showToast(
+      ctx,
+      `OMO-Slim ${latestVersion}`,
+      `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`,
+      'error',
+      8000,
+    );
+    log('[auto-update-checker] bun install failed; update not installed');
+  }
+}
+
+export function getAutoUpdateInstallDir(): string {
+  return resolveInstallContext()?.installDir ?? CACHE_DIR;
+}
+
+/**
+ * Spawns a background process to run 'bun install'.
+ * Includes a 60-second timeout to prevent stalling OpenCode.
+ * @param installDir The directory whose package manager context should be refreshed.
+ * @returns True if the installation succeeded within the timeout.
+ */
+async function runBunInstallSafe(installDir: string): Promise<boolean> {
+  try {
+    const proc = crossSpawn(['bun', 'install'], {
+      cwd: installDir,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    const timeoutPromise = new Promise<'timeout'>((resolve) =>
+      setTimeout(() => resolve('timeout'), 60_000),
+    );
+    const exitPromise = proc.exited.then(() => 'completed' as const);
+    const result = await Promise.race([exitPromise, timeoutPromise]);
+
+    if (result === 'timeout') {
+      try {
+        proc.kill();
+      } catch {
+        /* empty */
+      }
+      return false;
+    }
+
+    return proc.exitCode === 0;
+  } catch (err) {
+    log('[auto-update-checker] bun install error:', err);
+    return false;
+  }
+}
+
+/**
+ * Helper to display a toast notification in the OpenCode TUI.
+ * @param ctx The plugin input context.
+ * @param title The toast title.
+ * @param message The toast message.
+ * @param variant The visual style of the toast.
+ * @param duration How long to show the toast in milliseconds.
+ */
+function showToast(
+  ctx: PluginInput,
+  title: string,
+  message: string,
+  variant: 'info' | 'success' | 'error' = 'info',
+  duration = 3000,
+): void {
+  ctx.client.tui
+    .showToast({
+      body: { title, message, variant, duration },
+    })
+    .catch(() => {});
+}
+
+export type { AutoUpdateCheckerOptions } from './types';

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

@@ -0,0 +1,26 @@
+export interface NpmDistTags {
+  latest: string;
+  [key: string]: string;
+}
+
+export interface OpencodeConfig {
+  plugin?: unknown[];
+  [key: string]: unknown;
+}
+
+export interface PackageJson {
+  version: string;
+  name?: string;
+  [key: string]: unknown;
+}
+
+export interface AutoUpdateCheckerOptions {
+  autoUpdate?: boolean;
+}
+
+export interface PluginEntryInfo {
+  entry: string;
+  isPinned: boolean;
+  pinnedVersion: string | null;
+  configPath: string;
+}

package/src/hooks/chat-headers.test.ts

@@ -0,0 +1,236 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test';
+import type { PluginInput } from '@opencode-ai/plugin';
+import { createInternalAgentTextPart } from '../utils';
+import {
+  __resetInternalMarkerCacheForTesting,
+  createChatHeadersHook,
+} from './chat-headers';
+
+function createMockContext(parts: unknown[] = []) {
+  return {
+    client: {
+      session: {
+        message: mock(async () => ({
+          data: {
+            info: { role: 'user' },
+            parts,
+          },
+        })),
+      },
+    },
+  } as unknown as PluginInput;
+}
+
+function createInput(
+  overrides?: Partial<{
+    sessionID: string;
+    providerID: string;
+    npm: string;
+    messageID: string;
+  }>,
+) {
+  const sessionID = overrides?.sessionID ?? 'session-1';
+  return {
+    sessionID,
+    agent: 'orchestrator',
+    model: {
+      id: 'github-copilot/claude',
+      providerID: overrides?.providerID ?? 'github-copilot',
+      api: {
+        id: 'copilot',
+        url: 'https://example.com',
+        npm: overrides?.npm ?? '@custom/copilot',
+      },
+      name: 'Claude',
+      capabilities: {
+        temperature: true,
+        reasoning: true,
+        attachment: true,
+        toolcall: true,
+        input: {
+          text: true,
+          audio: false,
+          image: false,
+          video: false,
+          pdf: false,
+        },
+        output: {
+          text: true,
+          audio: false,
+          image: false,
+          video: false,
+          pdf: false,
+        },
+      },
+      cost: {
+        input: 0,
+        output: 0,
+        cache: { read: 0, write: 0 },
+      },
+      limit: { context: 0, output: 0 },
+      status: 'active' as const,
+      options: {},
+      headers: {},
+    },
+    provider: {
+      id: overrides?.providerID ?? 'github-copilot',
+      source: 'config' as const,
+      info: {
+        id: overrides?.providerID ?? 'github-copilot',
+      } as never,
+      options: {},
+    },
+    message: {
+      id: overrides?.messageID ?? 'message-1',
+      sessionID,
+      role: 'user' as const,
+      time: { created: Date.now() },
+      agent: 'orchestrator',
+      model: {
+        providerID: 'github-copilot',
+        modelID: 'claude',
+      },
+      tools: {},
+    },
+  };
+}
+
+describe('createChatHeadersHook', () => {
+  beforeEach(() => {
+    __resetInternalMarkerCacheForTesting();
+  });
+
+  test('sets x-initiator for marked Copilot messages', async () => {
+    const ctx = createMockContext([
+      createInternalAgentTextPart('internal notification'),
+    ]);
+    const hook = createChatHeadersHook(ctx);
+    const output = { headers: {} };
+
+    await hook['chat.headers'](createInput(), output);
+
+    expect(output.headers['x-initiator']).toBe('agent');
+  });
+
+  test('skips non-Copilot providers', async () => {
+    const ctx = createMockContext([
+      createInternalAgentTextPart('internal notification'),
+    ]);
+    const hook = createChatHeadersHook(ctx);
+    const output = { headers: {} };
+
+    await hook['chat.headers'](
+      createInput({ providerID: 'anthropic' }),
+      output,
+    );
+
+    expect(output.headers['x-initiator']).toBeUndefined();
+  });
+
+  test('skips requests handled by @ai-sdk/github-copilot', async () => {
+    const ctx = createMockContext([
+      createInternalAgentTextPart('internal notification'),
+    ]);
+    const hook = createChatHeadersHook(ctx);
+    const output = { headers: {} };
+
+    await hook['chat.headers'](
+      createInput({ npm: '@ai-sdk/github-copilot' }),
+      output,
+    );
+
+    expect(output.headers['x-initiator']).toBeUndefined();
+  });
+
+  test('skips normal user messages', async () => {
+    const ctx = createMockContext([{ type: 'text', text: 'normal prompt' }]);
+    const hook = createChatHeadersHook(ctx);
+    const output = { headers: {} };
+
+    await hook['chat.headers'](
+      createInput({ messageID: 'message-normal' }),
+      output,
+    );
+
+    expect(output.headers['x-initiator']).toBeUndefined();
+  });
+
+  test('caches marked internal messages', async () => {
+    const ctx = createMockContext([
+      createInternalAgentTextPart('internal notification'),
+    ]);
+    const hook = createChatHeadersHook(ctx);
+    const firstOutput = { headers: {} };
+    const secondOutput = { headers: {} };
+
+    await hook['chat.headers'](
+      createInput({ messageID: 'message-internal' }),
+      firstOutput,
+    );
+    await hook['chat.headers'](
+      createInput({ messageID: 'message-internal' }),
+      secondOutput,
+    );
+
+    expect(firstOutput.headers['x-initiator']).toBe('agent');
+    expect(secondOutput.headers['x-initiator']).toBe('agent');
+    expect(ctx.client.session.message).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not cache transient message lookup failures', async () => {
+    let calls = 0;
+    const messageMock = mock(async () => {
+      calls += 1;
+      if (calls === 1) {
+        throw new Error('temporary failure');
+      }
+      return {
+        data: {
+          info: { role: 'user' },
+          parts: [createInternalAgentTextPart('internal notification')],
+        },
+      };
+    });
+    const ctx = {
+      client: {
+        session: {
+          message: messageMock,
+        },
+      },
+    } as unknown as PluginInput;
+    const hook = createChatHeadersHook(ctx);
+    const firstOutput = { headers: {} };
+    const secondOutput = { headers: {} };
+
+    await hook['chat.headers'](
+      createInput({ messageID: 'message-retry' }),
+      firstOutput,
+    );
+    await hook['chat.headers'](
+      createInput({ messageID: 'message-retry' }),
+      secondOutput,
+    );
+
+    expect(firstOutput.headers['x-initiator']).toBeUndefined();
+    expect(secondOutput.headers['x-initiator']).toBe('agent');
+    expect(messageMock).toHaveBeenCalledTimes(2);
+  });
+
+  test('caches marked messages by session and message id', async () => {
+    const ctx = createMockContext([
+      createInternalAgentTextPart('internal notification'),
+    ]);
+    const hook = createChatHeadersHook(ctx);
+
+    await hook['chat.headers'](
+      createInput({ sessionID: 'session-a', messageID: 'message-normal' }),
+      { headers: {} },
+    );
+    await hook['chat.headers'](
+      createInput({ sessionID: 'session-b', messageID: 'message-normal' }),
+      { headers: {} },
+    );
+
+    expect(ctx.client.session.message).toHaveBeenCalledTimes(2);
+  });
+});

package/src/hooks/chat-headers.ts

@@ -0,0 +1,97 @@
+import type { PluginInput, ProviderContext } from '@opencode-ai/plugin';
+import type { Model, UserMessage } from '@opencode-ai/sdk';
+import { hasInternalInitiatorMarker } from '../utils';
+
+interface ChatHeadersInput {
+  sessionID: string;
+  model: Model;
+  provider: ProviderContext;
+  message: UserMessage;
+}
+
+interface ChatHeadersOutput {
+  headers: Record<string, string>;
+}
+
+const INTERNAL_MARKER_CACHE_LIMIT = 1000;
+const internalMarkerCache = new Map<string, boolean>();
+
+export function __resetInternalMarkerCacheForTesting(): void {
+  internalMarkerCache.clear();
+}
+
+function getProviderID(input: ChatHeadersInput): string {
+  return input.provider.info?.id || input.model.providerID;
+}
+
+function isCopilotProvider(providerID: string): boolean {
+  return (
+    providerID === 'github-copilot' ||
+    providerID === 'github-copilot-enterprise'
+  );
+}
+
+async function hasInternalMarker(
+  client: PluginInput['client'],
+  sessionID: string,
+  messageID: string,
+): Promise<boolean> {
+  const cacheKey = `${sessionID}:${messageID}`;
+  const cached = internalMarkerCache.get(cacheKey);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID },
+    });
+    const hasMarker = (response.data?.parts ?? []).some(
+      hasInternalInitiatorMarker,
+    );
+
+    if (hasMarker) {
+      if (internalMarkerCache.size >= INTERNAL_MARKER_CACHE_LIMIT) {
+        internalMarkerCache.clear();
+      }
+      internalMarkerCache.set(cacheKey, true);
+    }
+
+    return hasMarker;
+  } catch {
+    return false;
+  }
+}
+
+export function createChatHeadersHook(ctx: PluginInput) {
+  return {
+    'chat.headers': async (
+      input: ChatHeadersInput,
+      output: ChatHeadersOutput,
+    ): Promise<void> => {
+      if (!isCopilotProvider(getProviderID(input))) {
+        return;
+      }
+
+      if (input.model.api.npm === '@ai-sdk/github-copilot') {
+        return;
+      }
+
+      if (!input.message.id || input.message.role !== 'user') {
+        return;
+      }
+
+      if (
+        !(await hasInternalMarker(
+          ctx.client,
+          input.sessionID,
+          input.message.id,
+        ))
+      ) {
+        return;
+      }
+
+      output.headers['x-initiator'] = 'agent';
+    },
+  };
+}