vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,108 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+import { mkdtemp, mkdir, readFile, rm, writeFile, chmod } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { parse } from 'comment-json';
+
+const SCHEMA_URL = 'https://opencode.ai/config.json';
+
+describe('profile storage schema handling', () => {
+  let testHomeDir: string;
+  let originalHome: string | undefined;
+  let storage: typeof import('./storage');
+
+  beforeEach(async () => {
+    vi.resetModules();
+    testHomeDir = await mkdtemp(join(tmpdir(), 'vibepulse-profile-storage-'));
+    originalHome = process.env.HOME;
+    process.env.HOME = testHomeDir;
+
+    storage = await import('./storage');
+  });
+
+  afterEach(async () => {
+    process.env.HOME = originalHome;
+    await rm(testHomeDir, { recursive: true, force: true });
+  });
+
+  it('injects schema when writing profile config', async () => {
+    await storage.writeProfileConfig('custom', {
+      agents: {
+        sisyphus: { model: 'openai/gpt-5.3-codex' },
+      },
+    });
+
+    const configPath = join(storage.PROFILES_DIR, 'custom.json');
+    const persisted = parse(await readFile(configPath, 'utf-8'), null, false) as unknown as {
+      $schema?: string;
+      agents: Record<string, { model?: string }>;
+    };
+
+    expect(persisted.$schema).toBe(SCHEMA_URL);
+    expect(persisted.agents.sisyphus.model).toBe('openai/gpt-5.3-codex');
+  });
+
+  it('backfills schema when reading legacy profile configs', async () => {
+    const profilesDir = storage.PROFILES_DIR;
+    await mkdir(profilesDir, { recursive: true });
+
+    const configPath = join(profilesDir, 'legacy.json');
+    await writeFile(
+      configPath,
+      JSON.stringify({ agents: { oracle: { model: 'openai/gpt-5.4' } } }),
+      'utf-8'
+    );
+
+    const loaded = await storage.readProfileConfig('legacy');
+    expect(loaded.$schema).toBe(SCHEMA_URL);
+    expect(loaded.agents.oracle.model).toBe('openai/gpt-5.4');
+
+    const persisted = parse(await readFile(configPath, 'utf-8'), null, false) as unknown as {
+      $schema?: string;
+    };
+    expect(persisted.$schema).toBe(SCHEMA_URL);
+  });
+
+  it('returns schema-included defaults when profile file is missing', async () => {
+    const loaded = await storage.readProfileConfig('missing');
+
+    expect(loaded).toEqual({
+      $schema: SCHEMA_URL,
+      agents: {},
+    });
+  });
+
+  it('returns parsed config when schema backfill write fails', async () => {
+    const profilesDir = storage.PROFILES_DIR;
+    await mkdir(profilesDir, { recursive: true });
+
+    const configPath = join(profilesDir, 'readonly.json');
+    await writeFile(
+      configPath,
+      JSON.stringify({ agents: { explore: { model: 'anthropic/claude-haiku-4-5' } } }),
+      'utf-8'
+    );
+
+    await chmod(configPath, 0o400);
+
+    try {
+      const loaded = await storage.readProfileConfig('readonly');
+
+      expect(loaded).toEqual({
+        $schema: SCHEMA_URL,
+        agents: {
+          explore: {
+            model: 'anthropic/claude-haiku-4-5',
+          },
+        },
+      });
+
+      const persisted = parse(await readFile(configPath, 'utf-8'), null, false) as unknown as {
+        $schema?: string;
+      };
+      expect(persisted.$schema).toBeUndefined();
+    } finally {
+      await chmod(configPath, 0o600);
+    }
+  });
+});

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

@@ -0,0 +1,370 @@
+import { readFile, writeFile, unlink } from 'fs/promises';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse, stringify } from 'comment-json';
+import { OPEN_CODE_CONFIG_SCHEMA } from '../opencodeConfig';
+import type { AgentConfig, CategoryConfig } from '@/types/opencodeConfig';
+
+export const PROFILES_DIR = join(homedir(), '.config', 'opencode', 'profiles');
+export const PROFILE_INDEX_PATH = join(PROFILES_DIR, 'index.json');
+
+export interface Profile {
+  id: string;
+  name: string;
+  emoji: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+  isDefault?: boolean;
+  isBuiltIn?: boolean;
+}
+
+export interface ProfileIndex {
+  version: number;
+  profiles: Profile[];
+  activeProfileId: string | null;
+  lastModified: string;
+}
+
+export interface ProfileConfig {
+  $schema?: string;
+  agents: Record<string, AgentConfig>;
+  categories?: Record<string, CategoryConfig>;
+}
+
+const BUILTIN_PROFILES: Profile[] = [
+  {
+    id: 'balanced',
+    name: 'Balanced',
+    emoji: '⚖️',
+    description: 'Balanced multi-model orchestration optimized for general coding tasks',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    isBuiltIn: true,
+  },
+];
+
+const BUILTIN_PROFILE_CONFIGS: Record<string, ProfileConfig> = {
+  balanced: {
+    agents: {
+      sisyphus: {
+        model: 'anthropic/claude-opus-4-6',
+        variant: 'max',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      oracle: {
+        model: 'openai/gpt-5.4',
+        variant: 'high',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      prometheus: {
+        model: 'anthropic/claude-opus-4-6',
+        variant: 'max',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      metis: {
+        model: 'anthropic/claude-opus-4-6',
+        variant: 'max',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      momus: {
+        model: 'openai/gpt-5.4',
+        variant: 'medium',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      atlas: {
+        model: 'anthropic/claude-sonnet-4-6',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      hepheastus: {
+        model: 'openai/gpt-5.3-codex',
+        variant: 'xhigh',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      librarian: {
+        model: 'anthropic/claude-sonnet-4-6',
+        temperature: 0.3,
+        top_p: 0.9,
+      },
+      explore: {
+        model: 'anthropic/claude-haiku-4-5',
+        temperature: 0.1,
+        top_p: 0.9,
+      },
+      'multimodal-looker': {
+        model: 'google/gemini-3.1-pro',
+        variant: 'high',
+        temperature: 0.2,
+        top_p: 0.9,
+      },
+      'frontend-ui-ux': {
+        model: 'google/gemini-3.1-pro',
+        variant: 'high',
+        temperature: 0.3,
+        top_p: 0.9,
+      },
+    },
+    categories: {
+      'visual-engineering': {
+        model: 'google/gemini-3.1-pro',
+        variant: 'high',
+      },
+      ultrabrain: {
+        model: 'openai/gpt-5.3-codex',
+        variant: 'xhigh',
+      },
+      deep: {
+        model: 'openai/gpt-5.3-codex',
+        variant: 'medium',
+      },
+      artistry: {
+        model: 'google/gemini-3.1-pro',
+        variant: 'high',
+      },
+      quick: {
+        model: 'anthropic/claude-haiku-4-5',
+        temperature: 0.1,
+      },
+      'unspecified-low': {
+        model: 'anthropic/claude-sonnet-4-6',
+        temperature: 0.2,
+      },
+      'unspecified-high': {
+        model: 'openai/gpt-5.4',
+        variant: 'high',
+        temperature: 0.2,
+      },
+      writing: {
+        model: 'google/gemini-3-flash',
+        temperature: 0.3,
+      },
+    },
+  },
+};
+
+export function ensureProfilesDir(): void {
+  if (!existsSync(PROFILES_DIR)) {
+    mkdirSync(PROFILES_DIR, { recursive: true });
+  }
+}
+
+function getProfileConfigPath(id: string): string {
+  return join(PROFILES_DIR, `${id}.json`);
+}
+
+function normalizeProfileConfig(config: unknown): ProfileConfig {
+  if (!config || typeof config !== 'object') {
+    return {
+      $schema: OPEN_CODE_CONFIG_SCHEMA,
+      agents: {},
+    };
+  }
+
+  const candidate = config as Record<string, unknown>;
+  const agents =
+    candidate.agents && typeof candidate.agents === 'object'
+      ? (candidate.agents as Record<string, AgentConfig>)
+      : {};
+
+  const categories =
+    candidate.categories && typeof candidate.categories === 'object'
+      ? (candidate.categories as Record<string, CategoryConfig>)
+      : undefined;
+
+  const schema =
+    typeof candidate.$schema === 'string' && candidate.$schema.trim().length > 0
+      ? candidate.$schema
+      : OPEN_CODE_CONFIG_SCHEMA;
+
+  return {
+    $schema: schema,
+    agents,
+    categories,
+  };
+}
+
+function createDefaultProfileIndex(): ProfileIndex {
+  return {
+    version: 1,
+    profiles: [...BUILTIN_PROFILES],
+    activeProfileId: null,
+    lastModified: new Date().toISOString(),
+  };
+}
+
+async function createBuiltinProfileConfigs(): Promise<void> {
+  const validBuiltinIds = new Set(BUILTIN_PROFILES.map(p => p.id));
+  const deprecatedBuiltinIds = ['coding', 'writing', 'debug', 'minimal'];
+
+  for (const deprecatedId of deprecatedBuiltinIds) {
+    if (!validBuiltinIds.has(deprecatedId)) {
+      const deprecatedConfigPath = getProfileConfigPath(deprecatedId);
+      if (existsSync(deprecatedConfigPath)) {
+        await unlink(deprecatedConfigPath);
+      }
+    }
+  }
+
+  for (const profile of BUILTIN_PROFILES) {
+    const config = BUILTIN_PROFILE_CONFIGS[profile.id] || { agents: {} };
+    await writeProfileConfig(profile.id, config);
+  }
+}
+
+export async function readProfileIndex(): Promise<ProfileIndex> {
+  return readProfileIndexInternal(true);
+}
+
+export async function readProfileIndexStrict(): Promise<ProfileIndex> {
+  return readProfileIndexInternal(false);
+}
+
+async function readProfileIndexInternal(fallbackOnError: boolean): Promise<ProfileIndex> {
+  try {
+    ensureProfilesDir();
+
+    if (!existsSync(PROFILE_INDEX_PATH)) {
+      const defaultIndex = createDefaultProfileIndex();
+      await writeProfileIndex(defaultIndex);
+      await createBuiltinProfileConfigs();
+      return defaultIndex;
+    }
+
+    const content = await readFile(PROFILE_INDEX_PATH, 'utf-8');
+    const index = parse(content, null, false) as unknown as ProfileIndex;
+    
+    // Ensure all built-in profiles exist in the index
+    let modified = false;
+    for (const builtinProfile of BUILTIN_PROFILES) {
+      const exists = index.profiles.some(p => p.id === builtinProfile.id);
+      if (!exists) {
+        index.profiles.push(builtinProfile);
+        modified = true;
+      }
+    }
+    
+    // Remove built-in profiles that are no longer in BUILTIN_PROFILES
+    const builtinIds = new Set(BUILTIN_PROFILES.map(p => p.id));
+    const oldLength = index.profiles.length;
+    index.profiles = index.profiles.filter(p => !p.isBuiltIn || builtinIds.has(p.id));
+    if (index.profiles.length !== oldLength) {
+      modified = true;
+    }
+    
+    await createBuiltinProfileConfigs();
+    
+    if (modified) {
+      index.lastModified = new Date().toISOString();
+      await writeProfileIndex(index);
+    }
+    
+    return index;
+  } catch (error) {
+    if (!fallbackOnError) {
+      throw error;
+    }
+    return createDefaultProfileIndex();
+  }
+}
+
+export async function writeProfileIndex(index: ProfileIndex): Promise<void> {
+  ensureProfilesDir();
+  
+  index.lastModified = new Date().toISOString();
+  const content = stringify(index, null, 2);
+  
+  await writeFile(PROFILE_INDEX_PATH, content, 'utf-8');
+}
+
+
+export async function readProfileConfig(id: string): Promise<ProfileConfig> {
+  try {
+    const configPath = getProfileConfigPath(id);
+    
+    if (!existsSync(configPath)) {
+      return {
+        $schema: OPEN_CODE_CONFIG_SCHEMA,
+        agents: {},
+      };
+    }
+
+    const content = await readFile(configPath, 'utf-8');
+    const parsedConfig = parse(content, null, false) as unknown;
+    const normalizedConfig = normalizeProfileConfig(parsedConfig);
+
+    if (
+      !parsedConfig ||
+      typeof parsedConfig !== 'object' ||
+      typeof (parsedConfig as { $schema?: unknown }).$schema !== 'string'
+    ) {
+      try {
+        await writeProfileConfig(id, normalizedConfig);
+      } catch {
+        return normalizedConfig;
+      }
+    }
+
+    return normalizedConfig;
+  } catch {
+    return {
+      $schema: OPEN_CODE_CONFIG_SCHEMA,
+      agents: {},
+    };
+  }
+}
+
+export async function writeProfileConfig(
+  id: string, 
+  config: ProfileConfig
+): Promise<void> {
+  ensureProfilesDir();
+
+  const configPath = getProfileConfigPath(id);
+  const content = stringify(normalizeProfileConfig(config), null, 2);
+
+  await writeFile(configPath, content, 'utf-8');
+}
+
+export async function deleteProfileConfig(id: string): Promise<boolean> {
+  const index = await readProfileIndex();
+  const profile = index.profiles.find(p => p.id === id);
+  
+  if (profile?.isBuiltIn) {
+    const defaultConfig = BUILTIN_PROFILE_CONFIGS[id] || { agents: {} };
+    await writeProfileConfig(id, defaultConfig);
+    return true;
+  }
+  
+  const configPath = getProfileConfigPath(id);
+  
+  if (!existsSync(configPath)) {
+    return false;
+  }
+  
+  await unlink(configPath);
+  return true;
+}
+
+export async function getProfileById(id: string): Promise<Profile | undefined> {
+  const index = await readProfileIndex();
+  return index.profiles.find(p => p.id === id);
+}
+
+export async function getActiveProfileId(): Promise<string | null> {
+  const index = await readProfileIndex();
+  return index.activeProfileId;
+}
+
+export async function setActiveProfileId(id: string | null): Promise<void> {
+  const index = await readProfileIndex();
+  index.activeProfileId = id;
+  await writeProfileIndex(index);
+}

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import { NODE_RUNTIME_FLAG, RUNTIME_ROLE_ENV_VAR, resolveRuntimeMode } from './runtimeMode';
+
+describe('resolveRuntimeMode', () => {
+  it('resolves hub mode by default', () => {
+    expect(resolveRuntimeMode([])).toEqual({ role: 'hub' });
+  });
+
+  it('resolves node mode from --serve', () => {
+    expect(resolveRuntimeMode([NODE_RUNTIME_FLAG])).toEqual({ role: 'node' });
+  });
+
+  it('exposes the runtime role env variable name', () => {
+    expect(RUNTIME_ROLE_ENV_VAR).toBe('VIBEPULSE_RUNTIME_ROLE');
+  });
+
+  it('fails deterministically for unsupported flags', () => {
+    expect(() => resolveRuntimeMode(['--unknown'])).toThrow(
+      'Unsupported arguments: --unknown. Usage: vibepulse [--serve]'
+    );
+  });
+
+  it('fails deterministically for extra flags after --serve', () => {
+    expect(() => resolveRuntimeMode([NODE_RUNTIME_FLAG, '--unknown'])).toThrow(
+      'Unsupported arguments: --serve --unknown. Usage: vibepulse [--serve]'
+    );
+  });
+});

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

@@ -0,0 +1,29 @@
+export const NODE_RUNTIME_FLAG = '--serve';
+export const RUNTIME_ROLE_ENV_VAR = 'VIBEPULSE_RUNTIME_ROLE';
+
+export type RuntimeRole = 'hub' | 'node';
+
+export interface RuntimeMode {
+  role: RuntimeRole;
+}
+
+function formatUsage(args: string[]): string {
+  const renderedArgs = args.length > 0 ? args.join(' ') : '(none)';
+  return `Unsupported arguments: ${renderedArgs}. Usage: vibepulse [${NODE_RUNTIME_FLAG}]`;
+}
+
+export function resolveRuntimeMode(argv: string[]): RuntimeMode {
+  if (!Array.isArray(argv)) {
+    throw new TypeError('Runtime arguments must be provided as an array.');
+  }
+
+  if (argv.length === 0) {
+    return { role: 'hub' };
+  }
+
+  if (argv.length === 1 && argv[0] === NODE_RUNTIME_FLAG) {
+    return { role: 'node' };
+  }
+
+  throw new Error(formatUsage(argv));
+}

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

@@ -0,0 +1,37 @@
+type SessionActionErrorPayload = {
+  error?: unknown;
+  reason?: unknown;
+  message?: unknown;
+};
+
+function readString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value : null;
+}
+
+export function mapSessionActionError(payload: SessionActionErrorPayload | null | undefined, fallback: string): string {
+  const reason = readString(payload?.reason);
+
+  switch (reason) {
+    case 'unauthorized':
+      return 'Remote node rejected the request. Check node access token settings.';
+    case 'session_not_found':
+      return 'Session was not found.';
+    case 'forbidden':
+    case 'node_request_failed_403':
+      return 'Remote node denied the request.';
+    case 'unsupported_node_version':
+    case 'node_request_failed_404':
+    case 'node_request_failed_501':
+      return 'Remote node does not support this action yet.';
+    case 'upstream_timeout':
+      return 'Remote node did not respond in time.';
+    case 'upstream_unreachable':
+      return 'Remote node is offline or unreachable.';
+    case 'editor_unavailable':
+      return 'Remote node could not open the editor on that machine.';
+    case 'invalid_action_session_id':
+      return 'The selected session id is invalid.';
+    default:
+      return readString(payload?.error) ?? readString(payload?.message) ?? fallback;
+  }
+}

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

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import {
+  clearSessionForceUnarchived,
+  clearSessionStickyStatusBlocked,
+  markSessionForceUnarchived,
+  markSessionStickyStatusBlocked,
+  shouldForceSessionUnarchived,
+  takeSessionStickyStatusBlocked,
+} from './sessionArchiveOverrides';
+
+describe('sessionArchiveOverrides', () => {
+  it('consumes sticky-status block exactly once', () => {
+    const sessionId = `sticky-once-${Date.now()}-${Math.random()}`;
+
+    markSessionStickyStatusBlocked(sessionId, 1_000);
+
+    expect(takeSessionStickyStatusBlocked(sessionId, 1_001)).toBe(true);
+    expect(takeSessionStickyStatusBlocked(sessionId, 1_002)).toBe(false);
+  });
+
+  it('expires sticky-status block after retention window', () => {
+    const sessionId = `sticky-expire-${Date.now()}-${Math.random()}`;
+    const markedAt = 5_000;
+    const beyondRetention = markedAt + 10 * 60 * 1000 + 1;
+
+    markSessionStickyStatusBlocked(sessionId, markedAt);
+
+    expect(takeSessionStickyStatusBlocked(sessionId, beyondRetention)).toBe(false);
+  });
+
+  it('force-unarchive entries can be cleared explicitly', () => {
+    const sessionId = `force-clear-${Date.now()}-${Math.random()}`;
+
+    markSessionForceUnarchived(sessionId, 8_000);
+    expect(shouldForceSessionUnarchived(sessionId, 8_001)).toBe(true);
+
+    clearSessionForceUnarchived(sessionId);
+    clearSessionStickyStatusBlocked(sessionId);
+
+    expect(shouldForceSessionUnarchived(sessionId, 8_002)).toBe(false);
+    expect(takeSessionStickyStatusBlocked(sessionId, 8_002)).toBe(false);
+  });
+});