vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { normalizeVibePulseConfig, readConfig, writeConfig } from './opencodeConfig';
+import { writeFile, unlink, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+const TEST_CONFIG_DIR = join(tmpdir(), 'vibepulse-test-' + Date.now());
+const TEST_CONFIG_PATH = join(TEST_CONFIG_DIR, 'oh-my-opencode.jsonc');
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+async function cleanup() {
+  try {
+    if (existsSync(TEST_CONFIG_PATH)) {
+      await unlink(TEST_CONFIG_PATH);
+    }
+  } catch {}
+}
+
+describe('opencodeConfig', () => {
+  beforeEach(cleanup);
+  afterEach(cleanup);
+
+  describe('config echo bug fixes', () => {
+    it('should correctly read config immediately after saving', async () => {
+      const originalConfig = {
+        agents: {
+          sisyphus: {
+            model: 'claude-sonnet-4-20250514',
+            variant: 'high',
+            temperature: 0.2,
+            top_p: 0.9,
+          },
+        },
+        categories: {
+          coding: { model: 'gpt-4', variant: 'high' },
+        },
+      };
+
+      await writeConfig(originalConfig, TEST_CONFIG_PATH);
+      const echoed = await readConfig(TEST_CONFIG_PATH);
+
+      expect(echoed).toEqual(originalConfig);
+    });
+
+    it('should not lose other fields during partial update', async () => {
+      await writeConfig({
+        agents: {
+          sisyphus: { model: 'claude', temperature: 0.5 },
+          prometheus: { model: 'gpt-4', temperature: 0.7 },
+        },
+      }, TEST_CONFIG_PATH);
+
+      const loaded = await readConfig(TEST_CONFIG_PATH);
+      const existingAgents = isRecord(loaded.agents) ? loaded.agents : {};
+      const existingSisyphus = isRecord(existingAgents.sisyphus) ? existingAgents.sisyphus : {};
+      const updated = {
+        ...loaded,
+        agents: {
+          ...existingAgents,
+          sisyphus: { ...existingSisyphus, temperature: 0.9 },
+        },
+      };
+
+      await writeConfig(updated, TEST_CONFIG_PATH);
+      const final = await readConfig(TEST_CONFIG_PATH);
+
+      expect(final.agents?.prometheus).toEqual({ model: 'gpt-4', temperature: 0.7 });
+    });
+
+    it('should return empty object when file does not exist', async () => {
+      const config = await readConfig(TEST_CONFIG_PATH);
+      expect(config).toEqual({});
+    });
+
+    it('should return empty object for invalid JSON', async () => {
+      await mkdir(TEST_CONFIG_DIR, { recursive: true });
+      await writeFile(TEST_CONFIG_PATH, 'invalid {{{ json');
+
+      const config = await readConfig(TEST_CONFIG_PATH);
+      expect(config).toEqual({});
+    });
+
+    it('normalizes missing openEditorTargetMode to remote', () => {
+      expect(normalizeVibePulseConfig({ stickyBusyDelayMs: 1000 })).toEqual({
+        stickyBusyDelayMs: 1000,
+        openEditorTargetMode: 'remote',
+      });
+    });
+
+    it('preserves hub openEditorTargetMode when configured', () => {
+      expect(normalizeVibePulseConfig({ openEditorTargetMode: 'hub' })).toEqual({
+        openEditorTargetMode: 'hub',
+      });
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+import { readFile, writeFile } from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse, stringify } from 'comment-json';
+import type { OpenEditorTargetMode, VibePulseConfig } from '@/types/opencodeConfig';
+
+export const CONFIG_DIR = join(homedir(), '.config', 'opencode');
+export const CONFIG_PATH = join(CONFIG_DIR, 'oh-my-opencode.jsonc');
+export const OPEN_CODE_CONFIG_SCHEMA = 'https://opencode.ai/config.json';
+export const DEFAULT_OPEN_EDITOR_TARGET_MODE: OpenEditorTargetMode = 'remote';
+
+export type OpenCodeConfig = {
+  $schema?: string;
+  agents?: Record<string, unknown>;
+  vibepulse?: VibePulseConfig;
+  [key: string]: unknown;
+};
+
+export function normalizeOpenEditorTargetMode(value: unknown): OpenEditorTargetMode {
+  return value === 'hub' ? 'hub' : DEFAULT_OPEN_EDITOR_TARGET_MODE;
+}
+
+export function normalizeVibePulseConfig(value: unknown): VibePulseConfig {
+  const vibepulse = typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? { ...(value as Record<string, unknown>) }
+    : {};
+
+  return {
+    ...vibepulse,
+    openEditorTargetMode: normalizeOpenEditorTargetMode(vibepulse.openEditorTargetMode),
+  };
+}
+
+export function detectConfig(configPath: string = CONFIG_PATH): boolean {
+  try {
+    return existsSync(configPath);
+  } catch {
+    return false;
+  }
+}
+
+export async function readConfig(configPath: string = CONFIG_PATH): Promise<OpenCodeConfig> {
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const config = parse(content, null, false) as OpenCodeConfig;
+    return config;
+  } catch {
+    return {};
+  }
+}
+
+export async function writeConfig(
+  config: OpenCodeConfig, 
+  configPath: string = CONFIG_PATH
+): Promise<void> {
+  try {
+    const configDir = join(configPath, '..');
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    const shouldEnforceSchema = configPath === CONFIG_PATH;
+    const configWithSchema: OpenCodeConfig = shouldEnforceSchema
+      ? {
+          ...config,
+          $schema: config.$schema || OPEN_CODE_CONFIG_SCHEMA,
+        }
+      : config;
+
+    const content = stringify(configWithSchema, null, 2);
+    await writeFile(configPath, content, 'utf-8');
+  } catch (error) {
+    throw new Error(`Failed to write config: ${error}`);
+  }
+}

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

@@ -0,0 +1,275 @@
+import { execSync } from 'child_process';
+
+const DEFAULT_DISCOVERY_COMMAND_TIMEOUT_MS = 5000;
+const knownPorts = new Set<number>();
+
+export type OpencodeProcessCwd = {
+  pid: number;
+  cwd: string;
+};
+
+export type OpencodePortDiscoveryResult = {
+  ports: number[];
+  timedOut: boolean;
+};
+
+export type OpencodeProcessCwdDiscoveryResult = {
+  processes: OpencodeProcessCwd[];
+  timedOut: boolean;
+};
+
+type DiscoveryState = {
+  timedOut: boolean;
+  timeoutMs: number;
+  deadlineMs: number;
+};
+
+function getDiscoveryCommandTimeoutMs(): number {
+  const parsedTimeout = Number(process.env.OPENCODE_DISCOVERY_TIMEOUT_MS);
+  return Number.isFinite(parsedTimeout) && parsedTimeout > 0
+    ? parsedTimeout
+    : DEFAULT_DISCOVERY_COMMAND_TIMEOUT_MS;
+}
+
+function isCommandTimeoutError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  type TimeoutLikeError = Error & {
+    code?: string;
+    signal?: string;
+    killed?: boolean;
+  };
+
+  const timeoutError = error as TimeoutLikeError;
+  const message = timeoutError.message.toLowerCase();
+  return timeoutError.code === 'ETIMEDOUT' || message.includes('timed out') || message.includes('etimedout');
+}
+
+function getRemainingTimeoutMs(state: DiscoveryState): number | null {
+  const remainingMs = state.deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    state.timedOut = true;
+    return null;
+  }
+
+  return Math.max(1, Math.min(state.timeoutMs, remainingMs));
+}
+
+function toUniqueSortedPorts(ports: number[]): number[] {
+  return Array.from(
+    new Set(ports.filter((port) => Number.isInteger(port) && port > 0 && port <= 65535))
+  ).sort((a, b) => a - b);
+}
+
+function getPortsFromLsof(state: DiscoveryState): number[] {
+  try {
+    const timeoutMs = getRemainingTimeoutMs(state);
+    if (timeoutMs === null) {
+      return [];
+    }
+
+    const output = execSync('lsof -nP -iTCP -sTCP:LISTEN', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: timeoutMs,
+    });
+    const lines = output.split('\n');
+    const ports: number[] = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('COMMAND')) {
+        continue;
+      }
+
+      const parts = trimmed.split(/\s+/);
+      const command = parts[0]?.toLowerCase();
+      if (command !== 'opencode') {
+        continue;
+      }
+
+      const match = trimmed.match(/:(\d+)\s+\(LISTEN\)/);
+      if (!match) {
+        continue;
+      }
+
+      const port = parseInt(match[1], 10);
+      if (Number.isFinite(port)) {
+        ports.push(port);
+      }
+    }
+
+    return ports;
+  } catch (error) {
+    if (isCommandTimeoutError(error)) {
+      state.timedOut = true;
+    }
+    return [];
+  }
+}
+
+function getPortsFromProcessArgs(state: DiscoveryState): number[] {
+  try {
+    const timeoutMs = getRemainingTimeoutMs(state);
+    if (timeoutMs === null) {
+      return [];
+    }
+
+    const output = execSync('ps -axo command', {
+      encoding: 'utf-8',
+      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));
+  } catch (error) {
+    if (isCommandTimeoutError(error)) {
+      state.timedOut = true;
+    }
+    return [];
+  }
+}
+
+export function discoverOpencodePorts(): number[] {
+  return discoverOpencodePortsWithMeta().ports;
+}
+
+export function discoverOpencodePortsWithMeta(): OpencodePortDiscoveryResult {
+  const timeoutMs = getDiscoveryCommandTimeoutMs();
+  const state: DiscoveryState = {
+    timedOut: false,
+    timeoutMs,
+    deadlineMs: Date.now() + timeoutMs,
+  };
+
+  const discoveredPorts = toUniqueSortedPorts([
+    ...getPortsFromLsof(state),
+    ...getPortsFromProcessArgs(state),
+  ]);
+
+  for (const port of discoveredPorts) {
+    knownPorts.add(port);
+  }
+
+  const ports = toUniqueSortedPorts([
+    ...discoveredPorts,
+    ...Array.from(knownPorts),
+  ]);
+
+  return {
+    ports,
+    timedOut: state.timedOut,
+  };
+}
+
+function getOpencodePidsWithoutPortFlag(state: DiscoveryState): number[] {
+  try {
+    const timeoutMs = getRemainingTimeoutMs(state);
+    if (timeoutMs === null) {
+      return [];
+    }
+
+    const output = execSync('ps -axo pid=,command=', {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: timeoutMs,
+    });
+
+    const pids: number[] = [];
+    const lines = output.split('\n');
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      const match = trimmed.match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+
+      const pid = parseInt(match[1], 10);
+      const command = match[2];
+
+      if (!Number.isFinite(pid)) continue;
+      if (!/\bopencode\b/.test(command)) continue;
+      if (/\b--port(?:=|\s+)\d+\b/.test(command)) continue;
+
+      pids.push(pid);
+    }
+
+    return Array.from(new Set(pids));
+  } catch (error) {
+    if (isCommandTimeoutError(error)) {
+      state.timedOut = true;
+    }
+    return [];
+  }
+}
+
+function getCwdForPid(pid: number, state: DiscoveryState): string | null {
+  try {
+    const timeoutMs = getRemainingTimeoutMs(state);
+    if (timeoutMs === null) {
+      return null;
+    }
+
+    const output = execSync(`lsof -nP -a -p ${pid} -d cwd -Fn`, {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: timeoutMs,
+    });
+
+    const cwdLine = output
+      .split('\n')
+      .find((line) => line.startsWith('n') && line.length > 1);
+
+    if (!cwdLine) return null;
+    return cwdLine.slice(1);
+  } catch (error) {
+    if (isCommandTimeoutError(error)) {
+      state.timedOut = true;
+    }
+    return null;
+  }
+}
+
+export function discoverOpencodeProcessCwdsWithoutPort(): OpencodeProcessCwd[] {
+  return discoverOpencodeProcessCwdsWithoutPortWithMeta().processes;
+}
+
+export function discoverOpencodeProcessCwdsWithoutPortWithMeta(): OpencodeProcessCwdDiscoveryResult {
+  const timeoutMs = getDiscoveryCommandTimeoutMs();
+  const state: DiscoveryState = {
+    timedOut: false,
+    timeoutMs,
+    deadlineMs: Date.now() + timeoutMs,
+  };
+
+  const pids = getOpencodePidsWithoutPortFlag(state);
+  if (!pids.length) {
+    return {
+      processes: [],
+      timedOut: state.timedOut,
+    };
+  }
+
+  const processes: OpencodeProcessCwd[] = [];
+  const seen = new Set<string>();
+
+  for (const pid of pids) {
+    const cwd = getCwdForPid(pid, state);
+    if (!cwd) continue;
+
+    const key = `${pid}:${cwd}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    processes.push({ pid, cwd });
+  }
+
+  return {
+    processes,
+    timedOut: state.timedOut,
+  };
+}

package/.next/standalone/src/lib/profiles/share.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { createExportedProfileFile, parseImportedProfileFile } from './share';
+
+describe('profile share helpers', () => {
+  it('creates an exported profile file payload', () => {
+    const result = createExportedProfileFile(
+      {
+        id: 'team-sync',
+        name: 'Team Sync',
+        emoji: '🤝',
+        description: 'Shared team profile',
+        createdAt: '2026-03-18T00:00:00.000Z',
+        updatedAt: '2026-03-18T00:00:00.000Z',
+      },
+      {
+        agents: {
+          sisyphus: { model: 'openai/gpt-5.4' },
+        },
+        categories: {
+          deep: { model: 'openai/gpt-5.3-codex', variant: 'medium' },
+        },
+      }
+    );
+
+    expect(result).toMatchObject({
+      version: 1,
+      source: 'vibepulse',
+      profile: {
+        id: 'team-sync',
+        name: 'Team Sync',
+        emoji: '🤝',
+        description: 'Shared team profile',
+      },
+      config: {
+        agents: {
+          sisyphus: { model: 'openai/gpt-5.4' },
+        },
+        categories: {
+          deep: { model: 'openai/gpt-5.3-codex', variant: 'medium' },
+        },
+      },
+    });
+    expect(result.exportedAt).toBeTypeOf('string');
+  });
+
+  it('parses a valid imported profile payload', () => {
+    const result = parseImportedProfileFile({
+      version: 1,
+      source: 'vibepulse',
+      exportedAt: '2026-03-18T00:00:00.000Z',
+      profile: {
+        id: 'team-sync',
+        name: 'Team Sync',
+        emoji: '🤝',
+      },
+      config: {
+        agents: {
+          sisyphus: { model: 'openai/gpt-5.4' },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      profile: {
+        id: 'team-sync',
+        name: 'Team Sync',
+        emoji: '🤝',
+        description: undefined,
+      },
+      config: {
+        agents: {
+          sisyphus: { model: 'openai/gpt-5.4' },
+        },
+        categories: undefined,
+      },
+    });
+  });
+
+  it('rejects an imported profile with an invalid id', () => {
+    expect(() =>
+      parseImportedProfileFile({
+        profile: {
+          id: 'team sync',
+          name: 'Team Sync',
+          emoji: '🤝',
+        },
+        config: { agents: {} },
+      })
+    ).toThrow('Imported profile id must contain only letters, numbers, hyphens, and underscores');
+  });
+});

package/.next/standalone/src/lib/profiles/share.ts

@@ -0,0 +1,93 @@
+import type { Profile, ProfileConfig } from '@/types/opencodeConfig';
+
+export interface ExportedProfileFile {
+  version: 1;
+  source: 'vibepulse';
+  exportedAt: string;
+  profile: {
+    id: string;
+    name: string;
+    emoji: string;
+    description?: string;
+  };
+  config: ProfileConfig;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function normalizeConfig(value: unknown): ProfileConfig {
+  if (!isRecord(value)) {
+    return { agents: {} };
+  }
+
+  return {
+    agents: isRecord(value.agents) ? (value.agents as ProfileConfig['agents']) : {},
+    categories: isRecord(value.categories)
+      ? (value.categories as NonNullable<ProfileConfig['categories']>)
+      : undefined,
+  };
+}
+
+export function createExportedProfileFile(
+  profile: Profile,
+  config: ProfileConfig
+): ExportedProfileFile {
+  return {
+    version: 1,
+    source: 'vibepulse',
+    exportedAt: new Date().toISOString(),
+    profile: {
+      id: profile.id,
+      name: profile.name,
+      emoji: profile.emoji,
+      description: profile.description,
+    },
+    config: normalizeConfig(config),
+  };
+}
+
+export function parseImportedProfileFile(value: unknown): {
+  profile: ExportedProfileFile['profile'];
+  config: ProfileConfig;
+} {
+  if (!isRecord(value)) {
+    throw new Error('Imported profile file must be a JSON object');
+  }
+
+  const profileValue = value.profile;
+  if (!isRecord(profileValue)) {
+    throw new Error('Imported profile file is missing a valid profile block');
+  }
+
+  const id = profileValue.id;
+  if (typeof id !== 'string' || id.trim() === '') {
+    throw new Error('Imported profile id is required');
+  }
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(id.trim())) {
+    throw new Error('Imported profile id must contain only letters, numbers, hyphens, and underscores');
+  }
+
+  const name = profileValue.name;
+  if (typeof name !== 'string' || name.trim() === '') {
+    throw new Error('Imported profile name is required');
+  }
+
+  const emojiValue = profileValue.emoji;
+  const descriptionValue = profileValue.description;
+
+  return {
+    profile: {
+      id: id.trim(),
+      name: name.trim(),
+      emoji: typeof emojiValue === 'string' && emojiValue.trim() ? emojiValue : '⚙️',
+      description:
+        typeof descriptionValue === 'string' && descriptionValue.trim()
+          ? descriptionValue.trim()
+          : undefined,
+    },
+    config: normalizeConfig(value.config),
+  };
+}