vibepulse 0.2.0 → 0.2.1

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

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+
+import { getHostAccentTextClass } from './hostAccent';
+
+const PALETTE_SIZE = 5;
+
+function preferredAccentIndex(hostKey: string, hostLabel: string): number {
+  const source = `${hostKey}:${hostLabel}`;
+  let hash = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    hash = (hash * 31 + source.charCodeAt(index)) >>> 0;
+  }
+
+  return hash % PALETTE_SIZE;
+}
+
+function findCollisionPair(): Array<{ hostKey: string; hostLabel: string }> {
+  const byIndex = new Map<number, { hostKey: string; hostLabel: string }>();
+
+  for (let candidate = 1; candidate < 500; candidate += 1) {
+    const entry = { hostKey: `node-${candidate}`, hostLabel: `Node ${candidate}` };
+    const index = preferredAccentIndex(entry.hostKey, entry.hostLabel);
+    const existing = byIndex.get(index);
+    if (existing) {
+      return [existing, entry];
+    }
+
+    byIndex.set(index, entry);
+  }
+
+  throw new Error('Unable to find host accent collision pair for test setup');
+}
+
+describe('host accent assignment', () => {
+  it('returns fallback class when host identity is missing', () => {
+    expect(getHostAccentTextClass(undefined, undefined)).toBe('text-zinc-400 dark:text-zinc-500');
+  });
+
+  it('keeps a stable accent for the same host identity', () => {
+    const accentA = getHostAccentTextClass('node-alpha', 'Node Alpha');
+    const accentB = getHostAccentTextClass('node-alpha', 'Node Alpha');
+
+    expect(accentB).toBe(accentA);
+  });
+
+  it('maps colliding hosts to the same deterministic accent', () => {
+    const [firstHost, secondHost] = findCollisionPair();
+    const firstPreferred = preferredAccentIndex(firstHost.hostKey, firstHost.hostLabel);
+    const secondPreferred = preferredAccentIndex(secondHost.hostKey, secondHost.hostLabel);
+
+    expect(firstPreferred).toBe(secondPreferred);
+
+    const firstAccent = getHostAccentTextClass(firstHost.hostKey, firstHost.hostLabel);
+    const secondAccent = getHostAccentTextClass(secondHost.hostKey, secondHost.hostLabel);
+
+    expect(secondAccent).toBe(firstAccent);
+  });
+});

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

@@ -0,0 +1,46 @@
+type HostAccentPaletteItem = {
+  textClass: string;
+};
+
+const HOST_ACCENT_PALETTE: HostAccentPaletteItem[] = [
+  {
+    textClass: 'text-blue-500 dark:text-blue-400',
+  },
+  {
+    textClass: 'text-emerald-500 dark:text-emerald-400',
+  },
+  {
+    textClass: 'text-amber-500 dark:text-amber-400',
+  },
+  {
+    textClass: 'text-violet-500 dark:text-violet-400',
+  },
+  {
+    textClass: 'text-cyan-500 dark:text-cyan-400',
+  },
+];
+
+const DEFAULT_TEXT_CLASS = 'text-zinc-400 dark:text-zinc-500';
+
+function toHostAccentKey(hostKey?: string, hostLabel?: string): string {
+  return `${hostKey ?? ''}:${hostLabel ?? ''}`;
+}
+
+function getHostAccentIndex(hostKey?: string, hostLabel?: string): number {
+  const source = toHostAccentKey(hostKey, hostLabel);
+  let hash = 0;
+
+  for (let index = 0; index < source.length; index += 1) {
+    hash = (hash * 31 + source.charCodeAt(index)) >>> 0;
+  }
+
+  return hash % HOST_ACCENT_PALETTE.length;
+}
+
+export function getHostAccentTextClass(hostKey?: string, hostLabel?: string): string {
+  if (!hostKey && !hostLabel) {
+    return DEFAULT_TEXT_CLASS;
+  }
+
+  return HOST_ACCENT_PALETTE[getHostAccentIndex(hostKey, hostLabel)].textClass;
+}

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

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import {
+  composeSourceKey,
+  parseSourceKey,
+  getHostIdFromSourceKey,
+  getSessionIdFromSourceKey,
+  buildSourceKey,
+  isFromHost,
+  parseActionSessionReference,
+  resolveLocalActionSessionId,
+} from './hostIdentity';
+
+describe('composeSourceKey', () => {
+  it('creates valid composite key', () => {
+    expect(composeSourceKey('host-1', 'session-123')).toBe('host-1:session-123');
+  });
+
+  it('throws on empty hostId', () => {
+    expect(() => composeSourceKey('', 'session-123')).toThrow('Invalid hostId: cannot be empty');
+  });
+
+  it('throws on empty sessionId', () => {
+    expect(() => composeSourceKey('host-1', '')).toThrow('Invalid sessionId: cannot be empty');
+  });
+
+  it('throws on whitespace-only hostId', () => {
+    expect(() => composeSourceKey('   ', 'session-123')).toThrow('Invalid hostId: cannot be empty');
+  });
+
+  it('throws on whitespace-only sessionId', () => {
+    expect(() => composeSourceKey('host-1', '   ')).toThrow('Invalid sessionId: cannot be empty');
+  });
+
+  it('throws if hostId contains colon', () => {
+    expect(() => composeSourceKey('host:1', 'session-123')).toThrow('colon character not allowed');
+  });
+
+  it('throws if sessionId contains colon', () => {
+    expect(() => composeSourceKey('host-1', 'session:123')).toThrow('colon character not allowed');
+  });
+});
+
+describe('parseSourceKey', () => {
+  it('parses valid composite key', () => {
+    expect(parseSourceKey('host-1:session-123')).toEqual({ hostId: 'host-1', sessionId: 'session-123' });
+  });
+
+  it('parses keys with special characters in parts', () => {
+    expect(parseSourceKey('my-host_123:session-456_abc')).toEqual({
+      hostId: 'my-host_123',
+      sessionId: 'session-456_abc',
+    });
+  });
+
+  it('throws on non-string input', () => {
+    // @ts-expect-error testing invalid input
+    expect(() => parseSourceKey(null)).toThrow('must be a string');
+  });
+
+  it('throws on missing colon', () => {
+    expect(() => parseSourceKey('host-1session-123')).toThrow('exactly one colon separator');
+  });
+
+  it('throws on multiple colons', () => {
+    expect(() => parseSourceKey('host:1:session:123')).toThrow('exactly one colon separator');
+  });
+
+  it('throws on empty hostId part', () => {
+    expect(() => parseSourceKey(':session-123')).toThrow('cannot be empty');
+  });
+
+  it('throws on empty sessionId part', () => {
+    expect(() => parseSourceKey('host-1:')).toThrow('cannot be empty');
+  });
+
+  it('throws on both parts empty', () => {
+    expect(() => parseSourceKey(':')).toThrow('cannot be empty');
+  });
+
+  it('trims whitespace from parts', () => {
+    expect(parseSourceKey(' host-1 : session-123 ')).toEqual({ hostId: 'host-1', sessionId: 'session-123' });
+  });
+});
+
+describe('getHostIdFromSourceKey', () => {
+  it('returns hostId for valid key', () => {
+    expect(getHostIdFromSourceKey('host-1:session-123')).toBe('host-1');
+  });
+
+  it('returns null for invalid key', () => {
+    expect(getHostIdFromSourceKey('invalid-key')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(getHostIdFromSourceKey('')).toBeNull();
+  });
+});
+
+describe('getSessionIdFromSourceKey', () => {
+  it('returns sessionId for valid key', () => {
+    expect(getSessionIdFromSourceKey('host-1:session-123')).toBe('session-123');
+  });
+
+  it('returns null for invalid key', () => {
+    expect(getSessionIdFromSourceKey('invalid-key')).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(getSessionIdFromSourceKey('')).toBeNull();
+  });
+});
+
+describe('buildSourceKey', () => {
+  it('builds key from hostId and sessionId', () => {
+    expect(buildSourceKey('my-host', 'session-123')).toBe('my-host:session-123');
+  });
+
+  it('works with any hostId string', () => {
+    expect(buildSourceKey('remote-alpha', 'abc-123')).toBe('remote-alpha:abc-123');
+  });
+});
+
+describe('isFromHost', () => {
+  it('returns true when hostId matches', () => {
+    expect(isFromHost('host-1:session-123', 'host-1')).toBe(true);
+  });
+
+  it('returns false when hostId does not match', () => {
+    expect(isFromHost('host-1:session-123', 'host-2')).toBe(false);
+  });
+
+  it('returns false for invalid sourceKey', () => {
+    expect(isFromHost('invalid-key', 'host-1')).toBe(false);
+  });
+});
+
+describe('parseActionSessionReference', () => {
+  it('treats a raw session id as local', () => {
+    expect(parseActionSessionReference('ses_local_123')).toEqual({
+      hostId: 'local',
+      sessionId: 'ses_local_123',
+      isRemote: false,
+    });
+  });
+
+  it('parses a composite local session id', () => {
+    expect(parseActionSessionReference('local:ses_local_123')).toEqual({
+      hostId: 'local',
+      sessionId: 'ses_local_123',
+      isRemote: false,
+    });
+  });
+
+  it('parses a composite remote session id', () => {
+    expect(parseActionSessionReference('node-1:ses_123')).toEqual({
+      hostId: 'node-1',
+      sessionId: 'ses_123',
+      isRemote: true,
+    });
+  });
+
+  it('rejects empty values', () => {
+    expect(() => parseActionSessionReference('   ')).toThrow('cannot be empty');
+  });
+
+  it('rejects malformed composite ids', () => {
+    expect(() => parseActionSessionReference('node-1:')).toThrow('cannot be empty');
+  });
+});
+
+describe('resolveLocalActionSessionId', () => {
+  it('returns the raw id for local sessions', () => {
+    expect(resolveLocalActionSessionId('ses_local_123')).toBe('ses_local_123');
+  });
+
+  it('returns the session id for composite local sessions', () => {
+    expect(resolveLocalActionSessionId('local:ses_local_123')).toBe('ses_local_123');
+  });
+
+  it('returns null for remote sessions', () => {
+    expect(resolveLocalActionSessionId('node-1:ses_123')).toBeNull();
+  });
+
+  it('returns null for malformed action ids', () => {
+    expect(resolveLocalActionSessionId('node-1:')).toBeNull();
+  });
+});

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

@@ -0,0 +1,122 @@
+/**
+ * Composes a composite source key from host ID and session ID.
+ * Format: "hostId:sessionId"
+ */
+export function composeSourceKey(hostId: string, sessionId: string): string {
+  if (!hostId || hostId.trim() === '') {
+    throw new Error('Invalid hostId: cannot be empty');
+  }
+  if (!sessionId || sessionId.trim() === '') {
+    throw new Error('Invalid sessionId: cannot be empty');
+  }
+  if (hostId.includes(':') || sessionId.includes(':')) {
+    throw new Error('Invalid hostId or sessionId: colon character not allowed');
+  }
+  return `${hostId}:${sessionId}`;
+}
+
+/**
+ * Parses a composite source key into host ID and session ID.
+ * Throws if the key is not in the format "hostId:sessionId".
+ */
+export function parseSourceKey(sourceKey: string): { hostId: string; sessionId: string } {
+  if (typeof sourceKey !== 'string') {
+    throw new Error('Invalid sourceKey: must be a string');
+  }
+
+  const parts = sourceKey.split(':');
+  if (parts.length !== 2) {
+    throw new Error('Invalid sourceKey: must contain exactly one colon separator');
+  }
+
+  const [hostId, sessionId] = parts;
+  const trimmedHostId = hostId.trim();
+  const trimmedSessionId = sessionId.trim();
+  if (trimmedHostId === '' || trimmedSessionId === '') {
+    throw new Error('Invalid sourceKey: hostId and sessionId cannot be empty');
+  }
+
+  return { hostId: trimmedHostId, sessionId: trimmedSessionId };
+}
+
+/**
+ * Extracts the host ID from a composite source key.
+ * Returns null if the key is invalid.
+ */
+export function getHostIdFromSourceKey(sourceKey: string): string | null {
+  try {
+    const { hostId } = parseSourceKey(sourceKey);
+    return hostId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extracts the session ID from a composite source key.
+ * Returns null if the key is invalid.
+ */
+export function getSessionIdFromSourceKey(sourceKey: string): string | null {
+  try {
+    const { sessionId } = parseSourceKey(sourceKey);
+    return sessionId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Builds a composite source key from a host ID and session ID.
+ */
+export function buildSourceKey(hostId: string, sessionId: string): string {
+  return composeSourceKey(hostId, sessionId);
+}
+
+/**
+ * Checks if a source key matches a given host ID.
+ */
+export function isFromHost(sourceKey: string, hostId: string): boolean {
+  const parsedHostId = getHostIdFromSourceKey(sourceKey);
+  return parsedHostId === hostId;
+}
+
+export interface ActionSessionReference {
+  hostId: string;
+  sessionId: string;
+  isRemote: boolean;
+}
+
+export function parseActionSessionReference(value: string): ActionSessionReference {
+  if (typeof value !== 'string') {
+    throw new Error('Invalid action session id: must be a string');
+  }
+
+  const trimmedValue = value.trim();
+  if (trimmedValue === '') {
+    throw new Error('Invalid action session id: cannot be empty');
+  }
+
+  if (!trimmedValue.includes(':')) {
+    return {
+      hostId: 'local',
+      sessionId: trimmedValue,
+      isRemote: false,
+    };
+  }
+
+  const { hostId, sessionId } = parseSourceKey(trimmedValue);
+  return {
+    hostId,
+    sessionId,
+    isRemote: hostId !== 'local',
+  };
+}
+
+export function resolveLocalActionSessionId(value: string): string | null {
+  try {
+    const reference = parseActionSessionReference(value);
+    return reference.isRemote ? null : reference.sessionId;
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+const STORAGE_KEY_FILTER = 'vibepulse:host-filter:v1';
+
+describe('hostSourcesStorage', () => {
+  let mockLocalStorage: Record<string, string> = {};
+
+  beforeEach(() => {
+    mockLocalStorage = {};
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => mockLocalStorage[key] || null,
+      setItem: (key: string, value: string) => {
+        mockLocalStorage[key] = value;
+      },
+      removeItem: (key: string) => {
+        delete mockLocalStorage[key];
+      },
+      clear: () => {
+        Object.keys(mockLocalStorage).forEach((key) => {
+          delete mockLocalStorage[key];
+        });
+      },
+    });
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  describe('validateNodeUrl', () => {
+    it('normalizes valid http/https URLs', async () => {
+      const { validateNodeUrl } = await import('./hostSourcesStorage');
+
+      expect(validateNodeUrl('  http://example.com///  ')).toEqual({
+        ok: true,
+        normalizedBaseUrl: 'http://example.com',
+      });
+      expect(validateNodeUrl('https://example.com/path/')).toEqual({
+        ok: true,
+        normalizedBaseUrl: 'https://example.com/path',
+      });
+      expect(validateNodeUrl('https://example.com/path/?tenant=acme#hash')).toEqual({
+        ok: true,
+        normalizedBaseUrl: 'https://example.com/path',
+      });
+    });
+
+    it('rejects unsupported protocols and credentialed URLs', async () => {
+      const { validateNodeUrl } = await import('./hostSourcesStorage');
+
+      expect(validateNodeUrl('ftp://example.com')).toEqual({
+        ok: false,
+        error: 'unsupported_protocol',
+      });
+      expect(validateNodeUrl('https://user:pass@example.com')).toEqual({
+        ok: false,
+        error: 'credentials_not_allowed',
+      });
+    });
+
+    it('rejects empty or invalid URLs', async () => {
+      const { validateNodeUrl } = await import('./hostSourcesStorage');
+
+      expect(validateNodeUrl('   ')).toEqual({ ok: false, error: 'empty' });
+      expect(validateNodeUrl('not-a-url')).toEqual({ ok: false, error: 'invalid' });
+    });
+  });
+
+  describe('getHostFilter', () => {
+    it('returns all by default and for malformed values', async () => {
+      const { getHostFilter } = await import('./hostSourcesStorage');
+
+      expect(getHostFilter()).toBe('all');
+      mockLocalStorage[STORAGE_KEY_FILTER] = 'not json';
+      expect(getHostFilter()).toBe('all');
+      mockLocalStorage[STORAGE_KEY_FILTER] = JSON.stringify(123);
+      expect(getHostFilter()).toBe('all');
+      mockLocalStorage[STORAGE_KEY_FILTER] = JSON.stringify('');
+      expect(getHostFilter()).toBe('all');
+    });
+
+    it('returns normalized local and remote filter values', async () => {
+      const { getHostFilter } = await import('./hostSourcesStorage');
+
+      mockLocalStorage[STORAGE_KEY_FILTER] = JSON.stringify('local');
+      expect(getHostFilter()).toBe('local');
+
+      mockLocalStorage[STORAGE_KEY_FILTER] = JSON.stringify('  remote-1  ');
+      expect(getHostFilter()).toBe('remote-1');
+    });
+
+    it('returns all in SSR environment', async () => {
+      vi.unstubAllGlobals();
+      vi.stubGlobal('window', undefined);
+      const { getHostFilter } = await import('./hostSourcesStorage');
+
+      expect(getHostFilter()).toBe('all');
+    });
+  });
+
+  describe('saveHostFilter', () => {
+    it('saves all/local/remote filters with normalization', async () => {
+      const { saveHostFilter } = await import('./hostSourcesStorage');
+
+      saveHostFilter('all');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('all'));
+
+      saveHostFilter('local');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('local'));
+
+      saveHostFilter('  remote-1  ');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('remote-1'));
+    });
+
+    it('falls back to all for invalid values', async () => {
+      const { saveHostFilter } = await import('./hostSourcesStorage');
+
+      // @ts-expect-error testing invalid input type
+      saveHostFilter(123);
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('all'));
+
+      saveHostFilter('');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('all'));
+
+      saveHostFilter('local');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('local'));
+
+      saveHostFilter('local');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBe(JSON.stringify('local'));
+    });
+
+    it('does not write in SSR environment', async () => {
+      vi.unstubAllGlobals();
+      vi.stubGlobal('window', undefined);
+      const { saveHostFilter } = await import('./hostSourcesStorage');
+
+      saveHostFilter('remote-1');
+      expect(mockLocalStorage[STORAGE_KEY_FILTER]).toBeUndefined();
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+const HOST_FILTER_KEY = 'vibepulse:host-filter:v1';
+
+const BUILTIN_LOCAL_ID = 'local';
+
+function isSSR(): boolean {
+  return typeof window === 'undefined';
+}
+
+export type NodeUrlValidationError = 'empty' | 'invalid' | 'unsupported_protocol' | 'credentials_not_allowed';
+
+type NodeUrlValidationResult =
+  | { ok: true; normalizedBaseUrl: string }
+  | { ok: false; error: NodeUrlValidationError };
+
+function normalizeParsedBaseUrl(url: URL): string {
+  url.search = '';
+  url.hash = '';
+  return url.toString().replace(/\/+$/, '');
+}
+
+export function validateNodeUrl(url: string): NodeUrlValidationResult {
+  const trimmedUrl = url.trim();
+  if (!trimmedUrl) {
+    return { ok: false, error: 'empty' };
+  }
+
+  try {
+    const parsed = new URL(trimmedUrl);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      return { ok: false, error: 'unsupported_protocol' };
+    }
+
+    if (parsed.username || parsed.password) {
+      return { ok: false, error: 'credentials_not_allowed' };
+    }
+
+    return { ok: true, normalizedBaseUrl: normalizeParsedBaseUrl(parsed) };
+  } catch {
+    return { ok: false, error: 'invalid' };
+  }
+}
+
+export function getHostFilter(): 'all' | 'local' | string {
+  if (isSSR()) return 'all';
+
+  try {
+    const raw = localStorage.getItem(HOST_FILTER_KEY);
+    if (!raw) return 'all';
+
+    const value = JSON.parse(raw);
+    if (typeof value === 'string' && value.trim() !== '') {
+      const trimmed = value.trim();
+      if (trimmed === BUILTIN_LOCAL_ID) return 'local';
+      return trimmed;
+    }
+    return 'all';
+  } catch {
+    return 'all';
+  }
+}
+
+export function saveHostFilter(filter: 'all' | 'local' | string): void {
+  if (isSSR()) return;
+
+  if (filter === 'all' || filter === 'local') {
+    localStorage.setItem(HOST_FILTER_KEY, JSON.stringify(filter));
+  } else if (typeof filter === 'string' && filter.trim() !== '' && filter !== BUILTIN_LOCAL_ID) {
+    localStorage.setItem(HOST_FILTER_KEY, JSON.stringify(filter.trim()));
+  } else {
+    localStorage.setItem(HOST_FILTER_KEY, JSON.stringify('all'));
+  }
+}