vibepulse 0.2.2 → 0.3.1-beta

package/.next/standalone/src/lib/opencodeConfig.ts

@@ -1,6 +1,6 @@
-import { readFile, writeFile } from 'fs/promises';
+import { copyFile, readFile, rm, writeFile } from 'fs/promises';
 import { existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { dirname, join, parse as parsePath } from 'path';
 import { homedir } from 'os';
 import { parse, stringify } from 'comment-json';
 import type { OhMyOpenAgentConfig, OpenEditorTargetMode, VibePulseConfig } from '@/types/opencodeConfig';
@@ -8,11 +8,44 @@ import type { OhMyOpenAgentConfig, OpenEditorTargetMode, VibePulseConfig } from
 export const CONFIG_DIR = join(homedir(), '.config', 'opencode');
 export const CONFIG_PATH = join(CONFIG_DIR, 'oh-my-openagent.jsonc');
 export const LEGACY_CONFIG_PATH = join(CONFIG_DIR, 'oh-my-opencode.jsonc');
-export const OH_MY_OPENAGENT_CONFIG_SCHEMA = 'https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/v3.15.2/assets/oh-my-opencode.schema.json';
+export const PROJECT_CONFIG_DIR = '.opencode';
+export const PROJECT_CONFIG_JSONC = 'oh-my-openagent.jsonc';
+export const PROJECT_CONFIG_JSON = 'oh-my-openagent.json';
+export const LEGACY_PROJECT_CONFIG_JSONC = 'oh-my-opencode.jsonc';
+export const LEGACY_PROJECT_CONFIG_JSON = 'oh-my-opencode.json';
+export const OH_MY_OPENAGENT_CONFIG_SCHEMA = 'https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/master/assets/oh-my-openagent.schema.json';
 export const DEFAULT_OPEN_EDITOR_TARGET_MODE: OpenEditorTargetMode = 'remote';
+const PROJECT_CONFIG_FILENAMES = [
+  PROJECT_CONFIG_JSONC,
+  PROJECT_CONFIG_JSON,
+  LEGACY_PROJECT_CONFIG_JSONC,
+  LEGACY_PROJECT_CONFIG_JSON,
+];
 
 export type OpenCodeConfig = OhMyOpenAgentConfig;
 
+export interface EffectiveConfigOptions {
+  userConfigPath?: string;
+  projectStartDir?: string;
+  projectConfigPath?: string | null;
+}
+
+export interface LegacyMigrationOptions {
+  legacyPath?: string;
+  canonicalPath?: string;
+  backupPath?: string;
+  now?: () => Date;
+  writeCanonicalConfig?: (config: OpenCodeConfig, canonicalPath: string) => Promise<void>;
+}
+
+export interface LegacyMigrationResult {
+  migrated: boolean;
+  legacyPath: string;
+  canonicalPath: string;
+  backupPath?: string;
+  reason?: 'legacy-missing' | 'canonical-exists';
+}
+
 export function normalizeOpenEditorTargetMode(value: unknown): OpenEditorTargetMode {
   return value === 'hub' ? 'hub' : DEFAULT_OPEN_EDITOR_TARGET_MODE;
 }
@@ -28,6 +61,22 @@ export function normalizeVibePulseConfig(value: unknown): VibePulseConfig {
   };
 }
 
+export function getCanonicalUserConfigPath(): string {
+  return CONFIG_PATH;
+}
+
+export function getLegacyUserConfigPath(): string {
+  return LEGACY_CONFIG_PATH;
+}
+
+export function detectLegacyConfig(legacyPath: string = LEGACY_CONFIG_PATH): boolean {
+  try {
+    return existsSync(legacyPath);
+  } catch {
+    return false;
+  }
+}
+
 export function resolveConfigPath(configPath: string = CONFIG_PATH): string {
   if (configPath !== CONFIG_PATH) {
     return configPath;
@@ -52,6 +101,47 @@ export function detectConfig(configPath: string = CONFIG_PATH): boolean {
   }
 }
 
+export function findProjectConfigPath(startDir: string = process.cwd()): string | null {
+  let currentDir = startDir;
+
+  while (true) {
+    for (const filename of PROJECT_CONFIG_FILENAMES) {
+      const configPath = join(currentDir, PROJECT_CONFIG_DIR, filename);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+
+    currentDir = parentDir;
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function mergeConfig(base: OpenCodeConfig, overlay: OpenCodeConfig): OpenCodeConfig {
+  const merged: Record<string, unknown> = { ...base };
+
+  for (const [key, overlayValue] of Object.entries(overlay)) {
+    const baseValue = merged[key];
+
+    if (isPlainObject(baseValue) && isPlainObject(overlayValue)) {
+      merged[key] = mergeConfig(baseValue as OpenCodeConfig, overlayValue as OpenCodeConfig);
+      continue;
+    }
+
+    merged[key] = overlayValue;
+  }
+
+  return merged as OpenCodeConfig;
+}
+
 export async function readConfig(configPath: string = CONFIG_PATH): Promise<OpenCodeConfig> {
   try {
     const content = await readFile(resolveConfigPath(configPath), 'utf-8');
@@ -62,12 +152,35 @@ export async function readConfig(configPath: string = CONFIG_PATH): Promise<Open
   }
 }
 
+async function readLegacyConfigForMigration(legacyPath: string): Promise<OpenCodeConfig> {
+  try {
+    const content = await readFile(legacyPath, 'utf-8');
+    return parse(content, null, false) as OpenCodeConfig;
+  } catch (error) {
+    throw new Error(`Failed to read legacy config: ${error}`);
+  }
+}
+
+export async function readEffectiveConfig(options: EffectiveConfigOptions = {}): Promise<OpenCodeConfig> {
+  const userConfig = await readConfig(options.userConfigPath);
+  const projectConfigPath = options.projectConfigPath === undefined
+    ? findProjectConfigPath(options.projectStartDir)
+    : options.projectConfigPath;
+
+  if (!projectConfigPath) {
+    return userConfig;
+  }
+
+  const projectConfig = await readConfig(projectConfigPath);
+  return mergeConfig(userConfig, projectConfig);
+}
+
 export async function writeConfig(
   config: OpenCodeConfig, 
   configPath: string = CONFIG_PATH
 ): Promise<void> {
   try {
-    const configDir = join(configPath, '..');
+    const configDir = dirname(configPath);
     if (!existsSync(configDir)) {
       mkdirSync(configDir, { recursive: true });
     }
@@ -86,3 +199,43 @@ export async function writeConfig(
     throw new Error(`Failed to write config: ${error}`);
   }
 }
+
+function formatBackupTimestamp(date: Date): string {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function defaultBackupPath(legacyPath: string, date: Date): string {
+  const parsed = parsePath(legacyPath);
+  return join(parsed.dir, `${parsed.base}.backup-${formatBackupTimestamp(date)}`);
+}
+
+export async function migrateLegacyConfig(options: LegacyMigrationOptions = {}): Promise<LegacyMigrationResult> {
+  const legacyPath = options.legacyPath ?? LEGACY_CONFIG_PATH;
+  const canonicalPath = options.canonicalPath ?? CONFIG_PATH;
+
+  if (!existsSync(legacyPath)) {
+    return { migrated: false, legacyPath, canonicalPath, reason: 'legacy-missing' };
+  }
+
+  if (existsSync(canonicalPath)) {
+    return { migrated: false, legacyPath, canonicalPath, reason: 'canonical-exists' };
+  }
+
+  const backupPath = options.backupPath ?? defaultBackupPath(legacyPath, options.now?.() ?? new Date());
+  const canonicalDir = dirname(canonicalPath);
+  if (!existsSync(canonicalDir)) {
+    mkdirSync(canonicalDir, { recursive: true });
+  }
+
+  await copyFile(legacyPath, backupPath);
+
+  try {
+    const legacyConfig = await readLegacyConfigForMigration(legacyPath);
+    const writeCanonicalConfig = options.writeCanonicalConfig ?? writeConfig;
+    await writeCanonicalConfig(legacyConfig, canonicalPath);
+    return { migrated: true, legacyPath, canonicalPath, backupPath };
+  } catch (error) {
+    await rm(canonicalPath, { force: true });
+    throw error;
+  }
+}

package/.next/standalone/src/lib/opencodeDiscovery.test.ts

@@ -0,0 +1,241 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+type ExecSyncMock = ReturnType<typeof vi.fn>;
+type DiscoveryModule = typeof import('./opencodeDiscovery');
+
+let execSyncMock: ExecSyncMock;
+const originalDiscoveryTimeout = process.env.OPENCODE_DISCOVERY_TIMEOUT_MS;
+
+async function loadDiscovery(): Promise<DiscoveryModule> {
+  vi.resetModules();
+  execSyncMock = vi.fn();
+  vi.doMock('child_process', () => ({
+    execSync: execSyncMock,
+    default: {
+      execSync: execSyncMock,
+    },
+  }));
+
+  return import('./opencodeDiscovery');
+}
+
+function commandText(command: unknown): string {
+  return typeof command === 'string' ? command : '';
+}
+
+function setupCommandOutputs({
+  lsof = '',
+  psCommand = '',
+  probePorts = {},
+  timeoutCommands = [],
+}: {
+  lsof?: string;
+  psCommand?: string;
+  probePorts?: Record<number, { health?: boolean; doc?: boolean; healthBody?: string; docBody?: string }>;
+  timeoutCommands?: string[];
+}): void {
+  execSyncMock.mockImplementation((command: unknown) => {
+    const text = commandText(command);
+
+    if (timeoutCommands.some((pattern) => text.includes(pattern))) {
+      const error = new Error('Command timed out') as Error & { code: string };
+      error.code = 'ETIMEDOUT';
+      throw error;
+    }
+
+    if (text.includes('lsof -nP -iTCP -sTCP:LISTEN')) {
+      return lsof;
+    }
+
+    if (text.includes('ps -axo command')) {
+      return psCommand;
+    }
+
+    if (text.includes('/global/health') || text.includes('/doc')) {
+      const match = text.match(/127\.0\.0\.1:(\d+)\//);
+      const port = match ? Number(match[1]) : NaN;
+      const probe = probePorts[port];
+      const isHealth = text.includes('/global/health');
+      const ok = isHealth ? probe?.health : probe?.doc;
+      if (ok) {
+        return isHealth
+          ? (probe?.healthBody ?? '{"health":"ok","version":"1.14.48"}')
+          : (probe?.docBody ?? '{"openapi":"3.0.0","info":{"title":"OpenCode API","description":"OpenCode docs"}}');
+      }
+      throw new Error(`probe failed for ${port}`);
+    }
+
+    return '';
+  });
+}
+
+function probeUrls(): string[] {
+  return execSyncMock.mock.calls
+    .map((call) => commandText(call[0]))
+    .filter((command) => command.includes('/global/health') || command.includes('/doc'));
+}
+
+describe('opencodeDiscovery', () => {
+  beforeEach(() => {
+    process.env.OPENCODE_DISCOVERY_TIMEOUT_MS = '5000';
+    vi.unstubAllGlobals();
+  });
+
+  afterEach(() => {
+    vi.doUnmock('child_process');
+    vi.unstubAllGlobals();
+    if (originalDiscoveryTimeout === undefined) {
+      delete process.env.OPENCODE_DISCOVERY_TIMEOUT_MS;
+    } else {
+      process.env.OPENCODE_DISCOVERY_TIMEOUT_MS = originalDiscoveryTimeout;
+    }
+  });
+
+  it('includes explicit --port values from both space and equals process args', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: '/usr/local/bin/opencode serve --port 3456\nnode /bin/opencode --port=4567\n',
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [3456, 4567], timedOut: false });
+  });
+
+  it('includes lsof OpenCode listening ports with explicit ports', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      lsof: 'COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME\nopencode 123 user 10u IPv4 0x1 0t0 TCP 127.0.0.1:7777 (LISTEN)\nnode 555 user 12u IPv4 0x2 0t0 TCP 127.0.0.1:9999 (LISTEN)\n',
+      psCommand: 'opencode --port=3456\n',
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [3456, 7777], timedOut: false });
+  });
+
+  it('probes default 4096 when OpenCode is started with --port 0', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: 'opencode serve --port 0\n',
+      probePorts: { 4096: { health: true, healthBody: '{"health":"ok","version":"1.14.48"}' } },
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [4096], timedOut: false });
+    expect(probeUrls()).toEqual(
+      expect.arrayContaining([expect.stringContaining('http://127.0.0.1:4096/global/health')])
+    );
+  });
+
+  it('accepts documented healthy health response for the default candidate', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: 'opencode serve\n',
+      probePorts: { 4096: { health: true, healthBody: '{"healthy":true,"version":"1.14.48"}' } },
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [4096], timedOut: false });
+    expect(probeUrls()).toEqual([
+      expect.stringContaining('http://127.0.0.1:4096/global/health'),
+    ]);
+  });
+
+  it('rejects unhealthy or versionless health responses unless /doc is valid', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: 'opencode serve\n',
+      probePorts: {
+        4096: { health: true, healthBody: '{"healthy":false,"version":"1.14.48"}', doc: false },
+      },
+    });
+
+    expect(discovery.discoverOpencodePortsWithMeta()).toEqual({ ports: [], timedOut: false });
+    expect(probeUrls()).toEqual([
+      expect.stringContaining('http://127.0.0.1:4096/global/health'),
+      expect.stringContaining('http://127.0.0.1:4096/doc'),
+    ]);
+
+    setupCommandOutputs({
+      psCommand: 'opencode serve\n',
+      probePorts: {
+        4096: { health: true, healthBody: '{"healthy":true}', doc: false },
+      },
+    });
+
+    expect(discovery.discoverOpencodePortsWithMeta()).toEqual({ ports: [], timedOut: false });
+  });
+
+  it('accepts default candidate when /doc succeeds after health fails', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: 'opencode serve\n',
+      probePorts: {
+        4096: {
+          health: false,
+          doc: true,
+          docBody: '{"openapi":"3.0.0","info":{"title":"OpenCode API","description":"OpenCode docs"}}',
+        },
+      },
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [4096], timedOut: false });
+    expect(probeUrls()).toEqual([
+      expect.stringContaining('http://127.0.0.1:4096/global/health'),
+      expect.stringContaining('http://127.0.0.1:4096/doc'),
+    ]);
+  });
+
+  it('rejects generic /doc swagger content without an OpenCode signature', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      psCommand: 'opencode serve\n',
+      probePorts: {
+        4096: {
+          health: false,
+          doc: true,
+          docBody: '{"openapi":"3.0.0","info":{"title":"Generic API","description":"Generic docs"}}',
+        },
+      },
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [], timedOut: false });
+    expect(probeUrls()).toEqual([
+      expect.stringContaining('http://127.0.0.1:4096/global/health'),
+      expect.stringContaining('http://127.0.0.1:4096/doc'),
+    ]);
+  });
+
+  it('retains valid known ports and prunes stale known ports after probe failure', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({ psCommand: 'opencode --port=6123\n' });
+
+    expect(discovery.discoverOpencodePortsWithMeta().ports).toEqual([6123]);
+
+    setupCommandOutputs({ probePorts: { 6123: { health: true } } });
+    expect(discovery.discoverOpencodePortsWithMeta().ports).toEqual([6123]);
+
+    setupCommandOutputs({ probePorts: { 6123: { health: false, doc: false } } });
+    expect(discovery.discoverOpencodePortsWithMeta().ports).toEqual([]);
+  });
+
+  it('keeps discovery bounded and reports command timeout', async () => {
+    const discovery = await loadDiscovery();
+    setupCommandOutputs({
+      timeoutCommands: ['lsof -nP -iTCP -sTCP:LISTEN'],
+      psCommand: 'opencode --port=4567\n',
+    });
+
+    const result = discovery.discoverOpencodePortsWithMeta();
+
+    expect(result).toEqual({ ports: [4567], timedOut: true });
+    expect(probeUrls()).toEqual([]);
+  });
+});

package/.next/standalone/src/lib/opencodeDiscovery.ts

@@ -1,6 +1,8 @@
 import { execSync } from 'child_process';
 
 const DEFAULT_DISCOVERY_COMMAND_TIMEOUT_MS = 5000;
+const DEFAULT_OPENCODE_PORT = 4096;
+const OPENCODE_PROBE_ENDPOINTS = ['/global/health', '/doc'] as const;
 const knownPorts = new Set<number>();
 
 export type OpencodeProcessCwd = {
@@ -24,6 +26,58 @@ type DiscoveryState = {
   deadlineMs: number;
 };
 
+type ProcessPortDiscovery = {
+  ports: number[];
+  shouldProbeDefaultPort: boolean;
+};
+
+type ProbeResult = 'ok' | 'failed' | 'timedOut';
+
+function parseJsonResponse(body: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(body) as unknown;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return null;
+    }
+
+    return parsed as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+function isOpenCodeHealthResponse(body: string): boolean {
+  const parsed = parseJsonResponse(body);
+  if (!parsed) {
+    return false;
+  }
+
+  const health = parsed.health;
+  const healthy = parsed.healthy;
+  const version = parsed.version;
+  return (
+    (health === 'ok' || healthy === true) &&
+    typeof version === 'string' &&
+    /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)
+  );
+}
+
+function isOpenCodeDocsResponse(body: string): boolean {
+  const parsed = parseJsonResponse(body);
+  if (!parsed || typeof parsed.openapi !== 'string' || !/^3(?:\.\d+)?/.test(parsed.openapi)) {
+    return false;
+  }
+
+  const info = parsed.info;
+  const infoRecord = info && typeof info === 'object' && !Array.isArray(info) ? info as Record<string, unknown> : null;
+  const title = typeof infoRecord?.title === 'string' ? infoRecord.title : '';
+  const description = typeof infoRecord?.description === 'string' ? infoRecord.description : '';
+  const rootTitle = typeof parsed.title === 'string' ? parsed.title : '';
+  const rootDescription = typeof parsed.description === 'string' ? parsed.description : '';
+
+  return [title, description, rootTitle, rootDescription].some((value) => /opencode/i.test(value));
+}
+
 function getDiscoveryCommandTimeoutMs(): number {
   const parsedTimeout = Number(process.env.OPENCODE_DISCOVERY_TIMEOUT_MS);
   return Number.isFinite(parsedTimeout) && parsedTimeout > 0
@@ -110,11 +164,31 @@ function getPortsFromLsof(state: DiscoveryState): number[] {
   }
 }
 
-function getPortsFromProcessArgs(state: DiscoveryState): number[] {
+function isOpencodeCommand(command: string): boolean {
+  return /\bopencode\b/.test(command);
+}
+
+function extractPortFlags(command: string): number[] {
+  const ports: number[] = [];
+  const matches = command.matchAll(/--port(?:=(\d+)|\s+(\d+))\b/g);
+
+  for (const match of matches) {
+    const parsedPort = parseInt(match[1] ?? match[2] ?? '', 10);
+    if (Number.isFinite(parsedPort)) {
+      ports.push(parsedPort);
+    }
+  }
+
+  return ports;
+}
+
+function getPortsFromProcessArgs(state: DiscoveryState): ProcessPortDiscovery {
+  const result: ProcessPortDiscovery = { ports: [], shouldProbeDefaultPort: false };
+
   try {
     const timeoutMs = getRemainingTimeoutMs(state);
     if (timeoutMs === null) {
-      return [];
+      return result;
     }
 
     const output = execSync('ps -axo command', {
@@ -122,16 +196,73 @@ function getPortsFromProcessArgs(state: DiscoveryState): number[] {
       stdio: ['ignore', 'pipe', 'ignore'],
       timeout: timeoutMs,
     });
-    const matches = [...output.matchAll(/\bopencode\b[^\n]*\b--port(?:=|\s+)(\d+)\b/g)];
-    return matches
-      .map((match) => parseInt(match[1], 10))
-      .filter((port) => Number.isFinite(port));
+
+    for (const line of output.split('\n')) {
+      const command = line.trim();
+      if (!command || !isOpencodeCommand(command)) {
+        continue;
+      }
+
+      const ports = extractPortFlags(command);
+      if (ports.length === 0) {
+        result.shouldProbeDefaultPort = true;
+        continue;
+      }
+
+      for (const port of ports) {
+        if (port === 0) {
+          result.shouldProbeDefaultPort = true;
+        } else {
+          result.ports.push(port);
+        }
+      }
+    }
+
+    return result;
   } catch (error) {
     if (isCommandTimeoutError(error)) {
       state.timedOut = true;
     }
-    return [];
+    return result;
+  }
+}
+
+function probeOpencodePort(port: number, state: DiscoveryState): ProbeResult {
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    return 'failed';
+  }
+
+  for (const endpoint of OPENCODE_PROBE_ENDPOINTS) {
+    const timeoutMs = getRemainingTimeoutMs(state);
+    if (timeoutMs === null) {
+      return 'timedOut';
+    }
+
+    try {
+      const timeoutSeconds = Math.max(0.001, timeoutMs / 1000).toFixed(3);
+      const response = execSync(`curl -fsS --max-time ${timeoutSeconds} http://127.0.0.1:${port}${endpoint}`, {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: timeoutMs,
+      });
+
+      const body = typeof response === 'string' ? response : String(response);
+      const isValidProbe = endpoint === '/global/health'
+        ? isOpenCodeHealthResponse(body)
+        : isOpenCodeDocsResponse(body);
+
+      if (isValidProbe) {
+        return 'ok';
+      }
+    } catch (error) {
+      if (isCommandTimeoutError(error)) {
+        state.timedOut = true;
+        return 'timedOut';
+      }
+    }
   }
+
+  return 'failed';
 }
 
 export function discoverOpencodePorts(): number[] {
@@ -146,17 +277,41 @@ export function discoverOpencodePortsWithMeta(): OpencodePortDiscoveryResult {
     deadlineMs: Date.now() + timeoutMs,
   };
 
+  const processDiscovery = getPortsFromProcessArgs(state);
   const discoveredPorts = toUniqueSortedPorts([
     ...getPortsFromLsof(state),
-    ...getPortsFromProcessArgs(state),
+    ...processDiscovery.ports,
   ]);
 
   for (const port of discoveredPorts) {
     knownPorts.add(port);
   }
 
+  const probeCandidates = new Set<number>();
+  if (processDiscovery.shouldProbeDefaultPort && !discoveredPorts.includes(DEFAULT_OPENCODE_PORT)) {
+    probeCandidates.add(DEFAULT_OPENCODE_PORT);
+  }
+
+  for (const port of knownPorts) {
+    if (!discoveredPorts.includes(port)) {
+      probeCandidates.add(port);
+    }
+  }
+
+  const probedPorts: number[] = [];
+  for (const port of probeCandidates) {
+    const probeResult = probeOpencodePort(port, state);
+    if (probeResult === 'ok') {
+      knownPorts.add(port);
+      probedPorts.push(port);
+    } else if (probeResult === 'failed' && knownPorts.has(port)) {
+      knownPorts.delete(port);
+    }
+  }
+
   const ports = toUniqueSortedPorts([
     ...discoveredPorts,
+    ...probedPorts,
     ...Array.from(knownPorts),
   ]);
 
@@ -194,7 +349,7 @@ function getOpencodePidsWithoutPortFlag(state: DiscoveryState): number[] {
 
       if (!Number.isFinite(pid)) continue;
       if (!/\bopencode\b/.test(command)) continue;
-      if (/\b--port(?:=|\s+)\d+\b/.test(command)) continue;
+      if (extractPortFlags(command).length > 0) continue;
 
       pids.push(pid);
     }