@jlongo78/agent-spaces 0.7.7 → 0.8.0

package/.next/standalone/src/lib/codex/parser.ts

@@ -0,0 +1,265 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Metadata extracted from a Codex CLI session rollout file.
+ */
+export interface CodexSessionMeta {
+  id: string;
+  cwd: string;
+  timestamp: string;
+  firstPrompt: string;
+  messageCount: number;
+  modified: string;
+}
+
+/**
+ * Read the first `bytes` of a file and return the content as a UTF-8 string.
+ * Uses low-level fs.openSync/readSync so we never load the entire file.
+ */
+function readHead(filePath: string, bytes: number): string {
+  let fd: number | null = null;
+  try {
+    fd = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(bytes);
+    const bytesRead = fs.readSync(fd, buf, 0, bytes, 0);
+    return buf.toString('utf-8', 0, bytesRead);
+  } finally {
+    if (fd !== null) fs.closeSync(fd);
+  }
+}
+
+/**
+ * Extract the session UUID from a rollout filename.
+ * Expected format: rollout-<timestamp>-<session-uuid>.jsonl
+ * The session UUID is the last hyphen-separated segment before .jsonl,
+ * which itself is a standard UUID (8-4-4-4-12 hex).
+ */
+function sessionIdFromFilename(filename: string): string {
+  // Strip extension
+  const base = filename.replace(/\.jsonl$/, '');
+  // Match a UUID at the end: 8-4-4-4-12 hex pattern
+  const uuidMatch = base.match(
+    /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i
+  );
+  if (uuidMatch) return uuidMatch[1];
+  // Fallback: everything after "rollout-"
+  return base.replace(/^rollout-/, '');
+}
+
+/**
+ * Try to extract a user message string from a parsed JSONL event.
+ *
+ * Codex CLI uses several shapes depending on version:
+ *   - { payload: { type: "user_message", text: "..." } }
+ *   - { payload: { type: "UserMessage", text: "..." } }
+ *   - { type: "user_message", text: "..." }
+ *   - { type: "UserMessage", text: "..." }
+ *   - { payload: { type: "user_message", content: "..." } }
+ *   - { payload: { type: "user_message", message: { content: "..." } } }
+ */
+function extractUserMessage(obj: Record<string, unknown>): string | null {
+  const candidates = [obj.payload as Record<string, unknown> | undefined, obj];
+  for (const c of candidates) {
+    if (!c || typeof c !== 'object') continue;
+    const t = c.type;
+    if (t === 'user_message' || t === 'UserMessage') {
+      // Direct text field
+      if (typeof c.text === 'string') return c.text;
+      // Content field
+      if (typeof c.content === 'string') return c.content;
+      // Nested message.content
+      const msg = c.message as Record<string, unknown> | undefined;
+      if (msg && typeof msg.content === 'string') return msg.content;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check if a parsed JSONL line looks like a conversation event
+ * (something we should count toward messageCount).
+ */
+function isConversationEvent(obj: Record<string, unknown>): boolean {
+  const payload = obj.payload as Record<string, unknown> | undefined;
+  const t = (payload?.type ?? obj.type) as string | undefined;
+  if (!t) return false;
+  // Count user messages, assistant messages, and tool outputs
+  const eventTypes = new Set([
+    'user_message', 'UserMessage',
+    'assistant_message', 'AssistantMessage',
+    'message', 'response',
+    'tool_call', 'ToolCall',
+    'tool_result', 'ToolResult',
+  ]);
+  return eventTypes.has(t);
+}
+
+/**
+ * Parse a single rollout JSONL file into session metadata.
+ * Only reads the first ~8KB for efficiency; counts events in that window
+ * to produce an approximate message count.
+ */
+function parseRolloutFile(filePath: string, filename: string): CodexSessionMeta | null {
+  try {
+    const head = readHead(filePath, 8192);
+    const stat = fs.statSync(filePath);
+    const lines = head.split('\n').filter(l => l.trim().length > 0);
+
+    if (lines.length === 0) return null;
+
+    let id = '';
+    let cwd = '';
+    let timestamp = '';
+    let firstPrompt = '';
+    let messageCount = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      let parsed: Record<string, unknown>;
+      try {
+        parsed = JSON.parse(lines[i]);
+      } catch {
+        continue;
+      }
+
+      // First valid JSON line: extract session metadata
+      if (i === 0 || (!id && !cwd && !timestamp)) {
+        // Session ID: try item.id, id, session_id
+        const item = parsed.item as Record<string, unknown> | undefined;
+        id = (
+          (item?.id as string) ||
+          (parsed.id as string) ||
+          (parsed.session_id as string) ||
+          ''
+        );
+        // CWD: try item.cwd, cwd
+        cwd = (
+          (item?.cwd as string) ||
+          (parsed.cwd as string) ||
+          ''
+        );
+        // Timestamp: try item.timestamp, timestamp, created_at, created
+        timestamp = (
+          (item?.timestamp as string) ||
+          (parsed.timestamp as string) ||
+          (item?.created_at as string) ||
+          (parsed.created_at as string) ||
+          (parsed.created as string) ||
+          ''
+        );
+      }
+
+      // Count conversation events
+      if (isConversationEvent(parsed)) {
+        messageCount++;
+      }
+
+      // Extract first user message
+      if (!firstPrompt) {
+        const msg = extractUserMessage(parsed);
+        if (msg) {
+          firstPrompt = msg.slice(0, 500);
+        }
+      }
+    }
+
+    // Fallback: extract session ID from filename
+    if (!id) {
+      id = sessionIdFromFilename(filename);
+    }
+
+    // Derive timestamp from filename if not found in content
+    // Filename format: rollout-<timestamp>-<uuid>.jsonl
+    if (!timestamp) {
+      const tsMatch = filename.match(/^rollout-(\d+)/);
+      if (tsMatch) {
+        const epochMs = parseInt(tsMatch[1], 10);
+        // Codex uses millisecond timestamps typically
+        const date = new Date(epochMs > 1e12 ? epochMs : epochMs * 1000);
+        if (!isNaN(date.getTime())) {
+          timestamp = date.toISOString();
+        }
+      }
+    }
+
+    // Last resort: use file mtime for timestamp
+    if (!timestamp) {
+      timestamp = stat.mtime.toISOString();
+    }
+
+    return {
+      id,
+      cwd,
+      timestamp,
+      firstPrompt,
+      messageCount,
+      modified: stat.mtime.toISOString(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively collect all `rollout-*.jsonl` files under the YYYY/MM/DD
+ * directory tree inside the Codex sessions directory.
+ */
+function collectRolloutFiles(dir: string): { filePath: string; filename: string }[] {
+  const results: { filePath: string; filename: string }[] = [];
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        // Recurse into YYYY, MM, DD subdirectories
+        results.push(...collectRolloutFiles(fullPath));
+      } else if (
+        entry.isFile() &&
+        entry.name.startsWith('rollout-') &&
+        entry.name.endsWith('.jsonl')
+      ) {
+        results.push({ filePath: fullPath, filename: entry.name });
+      }
+    }
+  } catch {
+    // Directory unreadable or doesn't exist
+  }
+
+  return results;
+}
+
+/**
+ * Scan the Codex sessions directory (~/.codex/sessions/) for all rollout
+ * files and return metadata for each session.
+ *
+ * The directory structure is: YYYY/MM/DD/rollout-<timestamp>-<session-uuid>.jsonl
+ *
+ * Each file is read only partially (first 8KB) for efficiency.
+ * Bad or unreadable files are silently skipped.
+ */
+export function scanCodexSessions(sessionsDir: string): CodexSessionMeta[] {
+  if (!sessionsDir || !fs.existsSync(sessionsDir)) {
+    return [];
+  }
+
+  const files = collectRolloutFiles(sessionsDir);
+  const sessions: CodexSessionMeta[] = [];
+
+  for (const { filePath, filename } of files) {
+    const meta = parseRolloutFile(filePath, filename);
+    if (meta) {
+      sessions.push(meta);
+    }
+  }
+
+  // Sort by timestamp descending (most recent first)
+  sessions.sort((a, b) => {
+    if (a.timestamp && b.timestamp) {
+      return b.timestamp.localeCompare(a.timestamp);
+    }
+    return b.modified.localeCompare(a.modified);
+  });
+
+  return sessions;
+}

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

@@ -0,0 +1,115 @@
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import crypto from 'crypto';
+import { HAS_MULTIUSER } from '@/lib/tier';
+import { getTeams } from '@/lib/teams';
+import type { CortexConfig } from './cortex/config';
+
+export const config = {
+  // Server
+  port: parseInt(process.env.SPACES_PORT || '3457', 10),
+
+  // Cost rates ($ per 1M tokens)
+  costRates: {
+    'claude-opus-4-5-20251101': { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    'claude-opus-4-6': { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    'claude-sonnet-4-5-20250929': { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    'claude-haiku-4-5-20251001': { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  } as Record<string, { input: number; output: number; cacheRead: number; cacheWrite: number }>,
+};
+
+export function getUserPaths(username: string) {
+  // In server mode, resolve the app username to the OS shell user
+  let resolvedUser = username;
+  if (HAS_MULTIUSER) {
+    try {
+      const teams = getTeams();
+      if (teams) resolvedUser = teams.admin.resolveShellUser(username);
+    } catch {
+      // @spaces/teams not available or admin DB not ready
+    }
+  }
+
+  // Agent session data lives in the shell user's home (read-only access via group perms)
+  let homeDir: string;
+  if (resolvedUser === os.userInfo().username) {
+    homeDir = os.homedir();
+  } else if (process.platform === 'win32') {
+    const usersDir = path.dirname(os.homedir());
+    const candidate = path.join(usersDir, resolvedUser);
+    homeDir = fs.existsSync(candidate) ? candidate : os.homedir();
+  } else {
+    homeDir = `/home/${resolvedUser}`;
+  }
+
+  // Spaces writable data is centralized under the app process owner's home
+  // so we don't need write access to other users' home directories
+  const isLocalUser = resolvedUser === os.userInfo().username;
+  const spacesDir = isLocalUser
+    ? path.join(os.homedir(), '.spaces')
+    : path.join(os.homedir(), '.spaces', 'users', username);
+
+  return {
+    claudeDir: path.join(homeDir, '.claude'),
+    claudeProjectsDir: path.join(homeDir, '.claude', 'projects'),
+    statsPath: path.join(homeDir, '.claude', 'stats-cache.json'),
+    codexDir: path.join(homeDir, '.codex'),
+    codexSessionsDir: path.join(homeDir, '.codex', 'sessions'),
+    geminiDir: path.join(homeDir, '.gemini'),
+    geminiChatsBaseDir: path.join(homeDir, '.gemini', 'tmp'),
+    geminiProjectsRegistry: path.join(homeDir, '.gemini', 'projects.json'),
+    spacesDir,
+    dbPath: path.join(spacesDir, 'spaces.db'),
+    configPath: path.join(spacesDir, 'config.json'),
+  };
+}
+
+export function ensureUserSpacesDir(username: string) {
+  const { spacesDir } = getUserPaths(username);
+  if (!fs.existsSync(spacesDir)) {
+    fs.mkdirSync(spacesDir, { recursive: true });
+  }
+}
+
+export interface SpacesConfig {
+  installId: string;
+  telemetryOptOut: boolean;
+  devDirectories: string[];
+  cortex?: CortexConfig;
+}
+
+export function readConfig(username: string): SpacesConfig {
+  const { configPath, spacesDir } = getUserPaths(username);
+  try {
+    if (fs.existsSync(configPath)) {
+      const raw = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      return {
+        installId: raw.installId || crypto.randomUUID(),
+        telemetryOptOut: !!raw.telemetryOptOut,
+        devDirectories: Array.isArray(raw.devDirectories) ? raw.devDirectories.filter((d: unknown) => typeof d === 'string') : [],
+        ...(raw.cortex && typeof raw.cortex === 'object' ? { cortex: raw.cortex } : {}),
+      };
+    }
+  } catch { /* corrupt file, recreate */ }
+
+  // Create fresh config
+  if (!fs.existsSync(spacesDir)) {
+    fs.mkdirSync(spacesDir, { recursive: true });
+  }
+  const config: SpacesConfig = {
+    installId: crypto.randomUUID(),
+    telemetryOptOut: false,
+    devDirectories: [],
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  return config;
+}
+
+export function writeConfig(username: string, updates: Partial<SpacesConfig>) {
+  const current = readConfig(username);
+  const merged = { ...current, ...updates };
+  const { configPath } = getUserPaths(username);
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2));
+  return merged;
+}

package/.next/standalone/src/lib/cortex/benchmark.ts

@@ -0,0 +1,67 @@
+import { getCortexAddon } from './index';
+import { getUserPaths } from '../config';
+import { getCurrentUser } from '../auth';
+import path from 'path';
+import type { ChildProcess } from 'node:child_process';
+
+let _access: any = null;
+
+export function getBenchmarkAccess(): any {
+  if (_access) return _access;
+
+  const addon = getCortexAddon();
+  if (!addon?.BenchmarkDataAccess) return null;
+
+  const user = getCurrentUser();
+  const { spacesDir } = getUserPaths(user);
+
+  // Check candidate paths: user's cortex dir first, then the local dev results dir
+  const candidates = [
+    path.join(spacesDir, 'cortex', 'benchmark.db'),
+    path.join(process.cwd(), 'tests', 'benchmark', 'results', 'benchmark.db'),
+  ];
+
+  for (const dbPath of candidates) {
+    const access = new addon.BenchmarkDataAccess(dbPath);
+    if (access.isAvailable()) {
+      _access = access;
+      return _access;
+    }
+    access.close();
+  }
+
+  return null;
+}
+
+export function resetBenchmarkAccess(): void {
+  if (_access) {
+    _access.close();
+    _access = null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Benchmark process tracking
+// ---------------------------------------------------------------------------
+
+interface BenchmarkProcessInfo {
+  process: ChildProcess;
+  pid: number;
+  startedAt: string;
+  preset: string;
+  categories: string;
+  model: string;
+  noJudge: boolean;
+  getOutput: () => string;
+  getErrors: () => string;
+}
+
+let _benchmarkProcess: BenchmarkProcessInfo | null = null;
+
+export function getBenchmarkProcess(): BenchmarkProcessInfo | null {
+  return _benchmarkProcess;
+}
+
+export function setBenchmarkProcess(info: BenchmarkProcessInfo): void {
+  _benchmarkProcess = info;
+}

package/.next/standalone/src/lib/cortex/config.ts

@@ -1,40 +1,40 @@
-/** Stub — delegates to @spaces/cortex addon */
-import { getCortexAddon } from './index';
-
-export interface CortexConfig {
-  enabled: boolean;
-  debug: boolean;
-  anthropic_api_key?: string;
-  openai_api_key?: string;
-  embedding: any;
-  injection: any;
-  ingestion: any;
-  layers: any;
-  staleness: any;
-  federation: any;
-  storage: any;
-  policies?: any[];
-}
-
-export const DEFAULT_CORTEX_CONFIG: CortexConfig = {
-  enabled: false,
-  debug: false,
-  anthropic_api_key: '',
-  openai_api_key: '',
-  embedding: { provider: 'auto', model: null, fallback: 'local', dimensions: null },
-  injection: { enabled: true, max_tokens: 5000, max_results: 10, min_confidence: 0.3 },
-  ingestion: { auto_ingest: true, distillation: true, distillation_model: 'auto' },
-  layers: { personal: true, workspace: true, team: true },
-  staleness: { decision_halflife_days: 180, pattern_halflife_days: 90, context_halflife_days: 30, conversation_halflife_days: 14 },
-  federation: { sync_mode: 'query-only', sync_interval_minutes: 5, query_timeout_ms: 500 },
-  storage: { max_size_mb: 2048, warning_threshold_mb: 500 },
-  policies: [],
-};
-
-export function readCortexConfig(configPath: string): CortexConfig {
-  return getCortexAddon()?.readCortexConfig(configPath) ?? { ...DEFAULT_CORTEX_CONFIG };
-}
-
-export function writeCortexConfig(configPath: string, updates: Partial<CortexConfig>): void {
-  getCortexAddon()?.writeCortexConfig(configPath, updates);
-}
+/** Stub — delegates to @spaces/cortex addon */
+import { getCortexAddon } from './index';
+
+export interface CortexConfig {
+  enabled: boolean;
+  debug: boolean;
+  anthropic_api_key?: string;
+  openai_api_key?: string;
+  embedding: any;
+  injection: any;
+  ingestion: any;
+  layers: any;
+  staleness: any;
+  federation: any;
+  storage: any;
+  policies?: any[];
+}
+
+export const DEFAULT_CORTEX_CONFIG: CortexConfig = {
+  enabled: false,
+  debug: false,
+  anthropic_api_key: '',
+  openai_api_key: '',
+  embedding: { provider: 'auto', model: null, fallback: 'local', dimensions: null },
+  injection: { enabled: true, max_tokens: 5000, max_results: 10, min_confidence: 0.3 },
+  ingestion: { auto_ingest: true, distillation: true, distillation_model: 'auto' },
+  layers: { personal: true, workspace: true, team: true },
+  staleness: { decision_halflife_days: 180, pattern_halflife_days: 90, context_halflife_days: 30, conversation_halflife_days: 14 },
+  federation: { sync_mode: 'query-only', sync_interval_minutes: 5, query_timeout_ms: 500 },
+  storage: { max_size_mb: 2048, warning_threshold_mb: 500 },
+  policies: [],
+};
+
+export function readCortexConfig(configPath: string): CortexConfig {
+  return getCortexAddon()?.readCortexConfig(configPath) ?? { ...DEFAULT_CORTEX_CONFIG };
+}
+
+export function writeCortexConfig(configPath: string, updates: Partial<CortexConfig>): void {
+  getCortexAddon()?.writeCortexConfig(configPath, updates);
+}

package/.next/standalone/src/lib/cortex/debug.ts

@@ -1,10 +1,10 @@
-/** Stub — delegates to @spaces/cortex addon */
-import { getCortexAddon } from './index';
-
-export function cortexDebug(...args: unknown[]): void {
-  getCortexAddon()?.cortexDebug(...args);
-}
-
-export function setCortexDebug(enabled: boolean): void {
-  getCortexAddon()?.setCortexDebug(enabled);
-}
+/** Stub — delegates to @spaces/cortex addon */
+import { getCortexAddon } from './index';
+
+export function cortexDebug(...args: unknown[]): void {
+  getCortexAddon()?.cortexDebug(...args);
+}
+
+export function setCortexDebug(enabled: boolean): void {
+  getCortexAddon()?.setCortexDebug(enabled);
+}

package/.next/standalone/src/lib/cortex/distillation/usage-store.ts

@@ -1,18 +1,18 @@
-/** Stub — delegates to @spaces/cortex addon */
-import { getCortexAddon } from '../index';
-
-export interface UsageRecord { input_tokens: number; output_tokens: number; calls: number; estimated_cost_usd: number; last_updated: string; }
-export interface CortexUsage { distillation: UsageRecord; by_model: Record<string, UsageRecord>; }
-
-const EMPTY: CortexUsage = {
-  distillation: { input_tokens: 0, output_tokens: 0, calls: 0, estimated_cost_usd: 0, last_updated: '' },
-  by_model: {},
-};
-
-export function readUsage(usagePath: string): CortexUsage {
-  return getCortexAddon()?.readUsage?.(usagePath) ?? EMPTY;
-}
-
-export function recordUsage(usagePath: string, usage: any): void {
-  getCortexAddon()?.recordUsage?.(usagePath, usage);
-}
+/** Stub — delegates to @spaces/cortex addon */
+import { getCortexAddon } from '../index';
+
+export interface UsageRecord { input_tokens: number; output_tokens: number; calls: number; estimated_cost_usd: number; last_updated: string; }
+export interface CortexUsage { distillation: UsageRecord; by_model: Record<string, UsageRecord>; }
+
+const EMPTY: CortexUsage = {
+  distillation: { input_tokens: 0, output_tokens: 0, calls: 0, estimated_cost_usd: 0, last_updated: '' },
+  by_model: {},
+};
+
+export function readUsage(usagePath: string): CortexUsage {
+  return getCortexAddon()?.readUsage?.(usagePath) ?? EMPTY;
+}
+
+export function recordUsage(usagePath: string, usage: any): void {
+  getCortexAddon()?.recordUsage?.(usagePath, usage);
+}

package/.next/standalone/src/lib/cortex/graph/resolver.ts

@@ -1,10 +1,10 @@
-/** Stub — delegates to @spaces/cortex addon */
-import { getCortexAddon } from '../index';
-
-export class EntityResolver {
-  constructor(graph: any) {
-    const addon = getCortexAddon();
-    if (addon?.EntityResolver) return new addon.EntityResolver(graph) as any;
-  }
-  resolve(...args: any[]): any { return null; }
-}
+/** Stub — delegates to @spaces/cortex addon */
+import { getCortexAddon } from '../index';
+
+export class EntityResolver {
+  constructor(graph: any) {
+    const addon = getCortexAddon();
+    if (addon?.EntityResolver) return new addon.EntityResolver(graph) as any;
+  }
+  resolve(...args: any[]): any { return null; }
+}

package/.next/standalone/src/lib/cortex/graph/types.ts

@@ -1,22 +1,22 @@
-/** Stub — type definitions for build-time compatibility */
-export const ENTITY_TYPES = ['person', 'team', 'project', 'system', 'module', 'topic', 'department', 'organization'] as const;
-export type EntityType = typeof ENTITY_TYPES[number];
-
-export const EDGE_RELATIONS = ['owns', 'works_on', 'part_of', 'contains', 'depends_on', 'relates_to', 'expert_in'] as const;
-export type EdgeRelation = typeof EDGE_RELATIONS[number];
-
-export function isValidEntityType(t: string): t is EntityType {
-  return ENTITY_TYPES.includes(t as any);
-}
-
-export function isValidEdgeRelation(r: string): r is EdgeRelation {
-  return EDGE_RELATIONS.includes(r as any);
-}
-
-export function slugify(s: string): string {
-  return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-}
-
-export function entityId(type: EntityType, slug: string): string {
-  return `${type}-${slug}`;
-}
+/** Stub — type definitions for build-time compatibility */
+export const ENTITY_TYPES = ['person', 'team', 'project', 'system', 'module', 'topic', 'department', 'organization'] as const;
+export type EntityType = typeof ENTITY_TYPES[number];
+
+export const EDGE_RELATIONS = ['owns', 'works_on', 'part_of', 'contains', 'depends_on', 'relates_to', 'expert_in'] as const;
+export type EdgeRelation = typeof EDGE_RELATIONS[number];
+
+export function isValidEntityType(t: string): t is EntityType {
+  return ENTITY_TYPES.includes(t as any);
+}
+
+export function isValidEdgeRelation(r: string): r is EdgeRelation {
+  return EDGE_RELATIONS.includes(r as any);
+}
+
+export function slugify(s: string): string {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+export function entityId(type: EntityType, slug: string): string {
+  return `${type}-${slug}`;
+}