@jlongo78/agent-spaces 0.9.7 → 0.9.9

package/.next/standalone/src/hooks/use-claude-usage.ts

@@ -0,0 +1,66 @@
+'use client';
+
+import { useEffect, useRef, useState } from 'react';
+import { api } from '@/lib/api';
+import type { UsageResponse } from '@/types/claude';
+
+const POLL_INTERVAL_MS = 60_000;
+const TRANSIENT_TOLERANCE = 2; // consecutive bad polls before we clobber good data
+
+export function useClaudeUsage(enabled: boolean): UsageResponse | null {
+  const [response, setResponse] = useState<UsageResponse | null>(null);
+  const badPollsRef = useRef(0);
+
+  useEffect(() => {
+    if (!enabled) {
+      badPollsRef.current = 0;
+      return;
+    }
+
+    let cancelled = false;
+
+    async function load() {
+      try {
+        const res = await fetch(api('/api/claude/usage'));
+        if (!res.ok || cancelled) return;
+        const data: UsageResponse = await res.json();
+        if (cancelled) return;
+
+        const isTransient = data.status === 'upstream_error' || data.status === 'expired';
+        if (isTransient) {
+          badPollsRef.current += 1;
+          setResponse(prev => {
+            // If we already have a good response, keep it until the bad state persists.
+            if (prev?.status === 'ok' && badPollsRef.current < TRANSIENT_TOLERANCE) {
+              return prev;
+            }
+            return data;
+          });
+        } else {
+          badPollsRef.current = 0;
+          setResponse(data);
+        }
+      } catch {
+        // Network error — treat as transient.
+        if (cancelled) return;
+        badPollsRef.current += 1;
+        setResponse(prev => {
+          if (prev?.status === 'ok' && badPollsRef.current < TRANSIENT_TOLERANCE) {
+            return prev;
+          }
+          return { status: 'upstream_error' };
+        });
+      }
+    }
+
+    load();
+    const timer = setInterval(load, POLL_INTERVAL_MS);
+
+    return () => {
+      cancelled = true;
+      clearInterval(timer);
+    };
+  }, [enabled]);
+
+  return response;
+}

package/.next/standalone/src/hooks/use-speech-recognition.ts

@@ -63,7 +63,8 @@ export function useSpeechRecognition(): UseSpeechRecognitionReturn {
       }
     };
 
-    recognition.onerror = () => {
+    recognition.onerror = (event: any) => {
+      console.error('[SpeechRecognition] error:', event.error, event.message);
       setIsListening(false);
     };
 

package/.next/standalone/src/lib/claude/credentials.ts

@@ -0,0 +1,36 @@
+import path from 'path';
+import os from 'os';
+import { readFile } from 'fs/promises';
+
+export interface ClaudeAiOAuthTokens {
+  accessToken: string;
+  refreshToken: string | null;
+  expiresAt: number | null; // epoch ms
+  scopes?: string[];
+}
+
+function getCredentialsPath(): string {
+  const home = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  return path.join(home, '.credentials.json');
+}
+
+/**
+ * Reads ~/.claude/.credentials.json and returns the claudeAiOauth block.
+ * Returns null on any read/parse failure or if the block is absent.
+ */
+export async function readClaudeAiOauthTokens(): Promise<ClaudeAiOAuthTokens | null> {
+  try {
+    const raw = await readFile(getCredentialsPath(), 'utf8');
+    const parsed = JSON.parse(raw) as { claudeAiOauth?: ClaudeAiOAuthTokens };
+    const tokens = parsed.claudeAiOauth;
+    if (!tokens?.accessToken) return null;
+    return tokens;
+  } catch {
+    return null;
+  }
+}
+
+export function isTokenExpired(tokens: ClaudeAiOAuthTokens, nowMs = Date.now()): boolean {
+  if (!tokens.expiresAt) return false; // no expiry set → treat as valid
+  return nowMs >= tokens.expiresAt;
+}

package/.next/standalone/src/lib/claude/usage.ts

@@ -0,0 +1,69 @@
+import { createHash } from 'crypto';
+import type { Utilization } from '@/types/claude';
+
+const ANTHROPIC_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const REQUEST_TIMEOUT_MS = 5_000;
+const CACHE_TTL_MS = 30_000;
+
+// UA + anthropic-beta header match Claude Code's. The endpoint requires the
+// beta header; see claude-code/src/utils/http.ts (getAuthHeaders) and
+// claude-code/src/constants/oauth.ts (OAUTH_BETA_HEADER).
+const USER_AGENT = 'claude-code/spaces';
+const OAUTH_BETA_HEADER = 'oauth-2025-04-20';
+
+interface CacheEntry {
+  fetchedAt: number;
+  data: Utilization;
+}
+
+const cache = new Map<string, CacheEntry>();
+
+function cacheKey(accessToken: string): string {
+  // Full SHA-256 of the token so two tokens sharing a prefix cannot collide.
+  return createHash('sha256').update(accessToken).digest('hex');
+}
+
+export type FetchOutcome =
+  | { ok: true; data: Utilization }
+  | { ok: false; reason: 'upstream_error' };
+
+export async function fetchUtilization(accessToken: string): Promise<FetchOutcome> {
+  const key = cacheKey(accessToken);
+  const cached = cache.get(key);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return { ok: true, data: cached.data };
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+  try {
+    const res = await fetch(ANTHROPIC_USAGE_URL, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'anthropic-beta': OAUTH_BETA_HEADER,
+        'Content-Type': 'application/json',
+        'User-Agent': USER_AGENT,
+      },
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      return { ok: false, reason: 'upstream_error' };
+    }
+
+    const data = (await res.json()) as Utilization;
+    cache.set(key, { fetchedAt: Date.now(), data });
+    return { ok: true, data };
+  } catch {
+    return { ok: false, reason: 'upstream_error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** Testing/hot-reload helper. */
+export function __clearUsageCache() {
+  cache.clear();
+}

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

@@ -90,6 +90,7 @@ export interface SpacesConfig {
   installId: string;
   telemetryOptOut: boolean;
   devDirectories: string[];
+  todosEnabled: boolean;
   cortex?: CortexConfig;
   customModels?: CustomModelConfig[];
 }
@@ -103,6 +104,7 @@ export function readConfig(username: string): SpacesConfig {
         installId: raw.installId || crypto.randomUUID(),
         telemetryOptOut: !!raw.telemetryOptOut,
         devDirectories: Array.isArray(raw.devDirectories) ? raw.devDirectories.filter((d: unknown) => typeof d === 'string') : [],
+        todosEnabled: !!raw.todosEnabled,
         ...(raw.cortex && typeof raw.cortex === 'object' ? { cortex: raw.cortex } : {}),
         customModels: Array.isArray(raw.customModels) ? raw.customModels : [],
       };
@@ -117,6 +119,7 @@ export function readConfig(username: string): SpacesConfig {
     installId: crypto.randomUUID(),
     telemetryOptOut: false,
     devDirectories: [],
+    todosEnabled: false,
     customModels: [],
   };
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));

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

@@ -6,6 +6,17 @@ import type { ChildProcess } from 'node:child_process';
 
 let _access: any = null;
 
+/** Resolve the installed @spaces/cortex package root (managed install, symlink, etc.). */
+function resolveCortexPackageDir(): string | null {
+  try {
+    const { createRequire } = require('module') as typeof import('module');
+    const req = createRequire(path.join(process.cwd(), 'package.json'));
+    return path.dirname(req.resolve('@spaces/cortex/package.json'));
+  } catch {
+    return null;
+  }
+}
+
 export function getBenchmarkAccess(): any {
   if (_access) return _access;
 
@@ -14,11 +25,16 @@ export function getBenchmarkAccess(): any {
 
   const user = getCurrentUser();
   const { spacesDir } = getUserPaths(user);
+  const cortexPkgDir = resolveCortexPackageDir();
 
-  // Check candidate paths: user's cortex dir first, then the local dev results dir
+  // Check candidate paths in priority order:
+  //   1. User's cortex dir (where the run route could point --output)
+  //   2. Next standalone sibling — only meaningful in a dev layout
+  //   3. Addon's own results dir — where the CLI writes by default
   const candidates = [
     path.join(spacesDir, 'cortex', 'benchmark.db'),
     path.join(process.cwd(), 'tests', 'benchmark', 'results', 'benchmark.db'),
+    ...(cortexPkgDir ? [path.join(cortexPkgDir, 'tests', 'benchmark', 'results', 'benchmark.db')] : []),
   ];
 
   for (const dbPath of candidates) {

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

@@ -52,5 +52,58 @@ export function hasCortexAddon(): boolean { return loadAddon() !== null; }
 // Re-export engine functions — delegate to addon or return safe fallbacks
 export async function getCortex() { return loadAddon()?.getCortex() ?? null; }
 export function isCortexAvailable(): boolean { return loadAddon()?.isCortexAvailable() ?? false; }
-export function resetCortex(): void { loadAddon()?.resetCortex(); }
+export function resetCortex(): void { _client = null; loadAddon()?.resetCortex(); }
 export type { CortexInstance } from './types';
+
+// --- Cortex Client (multi-server support) ---
+let _client: any = null;
+
+/**
+ * Get a CortexClient that wraps the local embedded engine + any remote connections
+ * from ~/.cortex/connections.json. Use this for search/teach/context operations
+ * that should fan out across all connected Cortex servers.
+ */
+export async function getCortexClient(): Promise<any | null> {
+  if (_client) return _client;
+
+  const addon = loadAddon();
+  if (!addon) return null;
+
+  const engine = await addon.getCortex();
+  if (!engine) return null;
+
+  try {
+    const { createClient, EmbeddedConnection, RemoteConnection, loadConfig } = addon;
+
+    // Build embedded connection from local engine
+    const embeddedConn = new EmbeddedConnection({
+      name: 'local',
+      domains: engine.domainRegistry.list(),
+      writable: true,
+      default: true,
+      primary: true,
+      engine,
+    });
+
+    // Load remote connections from config file
+    const connections: any[] = [embeddedConn];
+    try {
+      const config = loadConfig();
+      for (const c of config.connections) {
+        if (c.type === 'remote') {
+          connections.push(new RemoteConnection(c));
+        }
+        // Skip embedded configs — we already have our local engine
+      }
+    } catch {
+      // No connections.json or invalid — that's fine, just use embedded
+    }
+
+    _client = createClient({ connections });
+    return _client;
+  } catch (err) {
+    // Cortex client not available (old addon version?) — fall back
+    console.warn('[cortex] Client library not available, multi-server disabled:', err);
+    return null;
+  }
+}

package/.next/standalone/src/lib/db/queries.ts

@@ -1,10 +1,6 @@
-import path from 'path';
 import crypto from 'crypto';
 import { getDb } from './schema';
-import { getUserPaths } from '../config';
-import { getCurrentUser } from '../auth';
-import { scanCodexSessions } from '../codex/parser';
-import type { SessionWithMeta, Project, Workspace, Tag, SearchResult } from '@/types/claude';
+import type { SessionWithMeta, Project, Workspace, Tag, SearchResult, WorkspaceTodo } from '@/types/claude';
 
 // ─── Projects ───────────────────────────────────────────────
 
@@ -517,87 +513,8 @@ function mapPane(row: any): PaneData {
   return { ...row, isPopout: !!row.isPopout, isCollaborating: !!row.isCollaborating };
 }
 
-function findLatestSessionIdForPane(db: ReturnType<typeof getDb>, cwd: string, agentType: string): string | null {
-  if (!cwd || !agentType || agentType === 'shell') return null;
-
-  try {
-    const resolved = path.resolve(cwd);
-    const row = db.prepare(`
-      SELECT s.session_id as sessionId
-      FROM sessions s
-      LEFT JOIN projects p ON p.id = s.project_id
-      WHERE s.agent_type = ?
-        AND (
-          s.project_path = ? OR s.project_path = ?
-          OR p.path = ? OR p.path = ?
-        )
-      ORDER BY s.modified DESC
-      LIMIT 1
-    `).get(agentType, cwd, resolved, cwd, resolved) as { sessionId: string } | undefined;
-
-    if (row?.sessionId) return row.sessionId;
-
-    if (agentType === 'codex') {
-      const paths = getUserPaths(getCurrentUser());
-      const latest = scanCodexSessions(paths.codexSessionsDir).find((session) => {
-        try {
-          return path.resolve(session.cwd) === resolved;
-        } catch {
-          return false;
-        }
-      });
-      if (latest?.id) return latest.id;
-    }
-
-    // Pi stores sessions as JSONL in .pi/sessions/ (project) or ~/.pi/agent/sessions/ (global).
-    // Check project-level first, then fall back to global.
-    if (agentType === 'pi') {
-      const fs = require('fs');
-      const dirs = [
-        path.join(resolved, '.pi', 'sessions'),
-        path.join(require('os').homedir(), '.pi', 'agent', 'sessions'),
-      ];
-      for (const dir of dirs) {
-        try {
-          if (!fs.existsSync(dir)) continue;
-          const files: string[] = fs.readdirSync(dir)
-            .filter((f: string) => f.endsWith('.jsonl'))
-            .sort((a: string, b: string) => {
-              // Sort by modification time descending (most recent first)
-              const aStat = fs.statSync(path.join(dir, a));
-              const bStat = fs.statSync(path.join(dir, b));
-              return bStat.mtimeMs - aStat.mtimeMs;
-            });
-          if (files.length > 0) {
-            return path.basename(files[0], '.jsonl');
-          }
-        } catch { /* ignore */ }
-      }
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 function normalizePane(row: any): PaneData {
-  const pane = mapPane(row);
-
-  if (!pane.claudeSessionId || pane.claudeSessionId === 'new') {
-    const db = getDb();
-    const sessionId = findLatestSessionIdForPane(db, pane.cwd, pane.agentType);
-    if (sessionId) {
-      pane.claudeSessionId = sessionId;
-      try {
-        db.prepare('UPDATE panes SET claude_session_id = ? WHERE id = ?').run(sessionId, pane.id);
-      } catch {
-        // Ignore best-effort backfill failures during reads.
-      }
-    }
-  }
-
-  return pane;
+  return mapPane(row);
 }
 
 export function getPanesByWorkspace(workspaceId: number): PaneData[] {
@@ -651,11 +568,7 @@ export function createPane(pane: {
     baselineSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: pane.cwd, encoding: 'utf-8', timeout: 3000 }).trim();
   } catch { /* not a git repo or git not available */ }
 
-  // Automatically find the most recent session for this agent+project if not specified
-  let sessId = pane.claudeSessionId || null;
-  if (!sessId || sessId === 'new') {
-    sessId = findLatestSessionIdForPane(db, pane.cwd, pane.agentType || 'shell');
-  }
+  const sessId = (pane.claudeSessionId && pane.claudeSessionId !== 'new') ? pane.claudeSessionId : null;
 
   db.prepare(`
     INSERT INTO panes (id, title, color, cwd, claude_session_id, agent_type, custom_command, sort_order, workspace_id, node_id, is_collaborating, diff_baseline_sha, custom_model_id)
@@ -825,3 +738,105 @@ export function getDailyActivity(days = 30): { date: string; sessionCount: numbe
   `).all(`-${days} days`) as any[];
 }
 
+// ─── Workspace Todos ───────────────────────────────────────
+
+interface TodoRow {
+  id: number;
+  workspace_id: number;
+  text: string;
+  completed: number;
+  sort_order: number;
+  created: string;
+  completed_at: string | null;
+}
+
+function rowToTodo(r: TodoRow): WorkspaceTodo {
+  return {
+    id: r.id,
+    workspaceId: r.workspace_id,
+    text: r.text,
+    completed: !!r.completed,
+    sortOrder: r.sort_order,
+    created: r.created,
+    completedAt: r.completed_at,
+  };
+}
+
+export function getWorkspaceTodos(workspaceId: number): WorkspaceTodo[] {
+  const db = getDb();
+  const rows = db.prepare(`
+    SELECT id, workspace_id, text, completed, sort_order, created, completed_at
+    FROM workspace_todos
+    WHERE workspace_id = ?
+    ORDER BY completed ASC,
+             CASE WHEN completed = 0 THEN sort_order END ASC,
+             completed_at DESC
+  `).all(workspaceId) as TodoRow[];
+  return rows.map(rowToTodo);
+}
+
+export function addWorkspaceTodo(workspaceId: number, text: string): WorkspaceTodo {
+  const db = getDb();
+  const trimmed = text.trim();
+  if (!trimmed) throw new Error('todo text is required');
+
+  const maxRow = db.prepare(`
+    SELECT COALESCE(MAX(sort_order), -1) AS max_order
+    FROM workspace_todos
+    WHERE workspace_id = ? AND completed = 0
+  `).get(workspaceId) as { max_order: number };
+  const nextOrder = (maxRow?.max_order ?? -1) + 1;
+
+  const info = db.prepare(`
+    INSERT INTO workspace_todos (workspace_id, text, sort_order)
+    VALUES (?, ?, ?)
+  `).run(workspaceId, trimmed, nextOrder);
+
+  const row = db.prepare(`
+    SELECT id, workspace_id, text, completed, sort_order, created, completed_at
+    FROM workspace_todos WHERE id = ?
+  `).get(Number(info.lastInsertRowid)) as TodoRow;
+  return rowToTodo(row);
+}
+
+export function updateWorkspaceTodo(
+  workspaceId: number,
+  todoId: number,
+  data: { text?: string; completed?: boolean }
+): WorkspaceTodo | null {
+  const db = getDb();
+
+  if (data.text !== undefined) {
+    const trimmed = data.text.trim();
+    if (!trimmed) throw new Error('todo text cannot be empty');
+    db.prepare('UPDATE workspace_todos SET text = ? WHERE id = ? AND workspace_id = ?').run(trimmed, todoId, workspaceId);
+  }
+
+  if (data.completed !== undefined) {
+    if (data.completed) {
+      db.prepare(`
+        UPDATE workspace_todos
+        SET completed = 1, completed_at = datetime('now')
+        WHERE id = ? AND workspace_id = ?
+      `).run(todoId, workspaceId);
+    } else {
+      db.prepare(`
+        UPDATE workspace_todos
+        SET completed = 0, completed_at = NULL
+        WHERE id = ? AND workspace_id = ?
+      `).run(todoId, workspaceId);
+    }
+  }
+
+  const row = db.prepare(`
+    SELECT id, workspace_id, text, completed, sort_order, created, completed_at
+    FROM workspace_todos WHERE id = ? AND workspace_id = ?
+  `).get(todoId, workspaceId) as TodoRow | undefined;
+  return row ? rowToTodo(row) : null;
+}
+
+export function deleteWorkspaceTodo(workspaceId: number, todoId: number): void {
+  const db = getDb();
+  db.prepare('DELETE FROM workspace_todos WHERE id = ? AND workspace_id = ?').run(todoId, workspaceId);
+}
+

package/.next/standalone/src/lib/db/schema.ts

@@ -113,6 +113,19 @@ function initSchema(db: Database.Database) {
       enabled INTEGER DEFAULT 0,
       created TEXT DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS workspace_todos (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      text TEXT NOT NULL,
+      completed INTEGER NOT NULL DEFAULT 0,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      created TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workspace_todos_workspace
+      ON workspace_todos(workspace_id);
   `);
 
   // Migrate: add workspace and popout columns to existing tables
@@ -204,3 +217,8 @@ export function closeDb() {
   }
   _dbs.clear();
 }
+
+// Test-only export. Do not use outside of tests.
+export const __testing = {
+  dbs: _dbs,
+};

package/.next/standalone/src/lib/shell-user.ts

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+
+const ADMIN_DB_PATH = path.join(os.homedir(), '.spaces', 'admin.db');
+const SERVICE_KEY = path.join(os.homedir(), '.spaces', 'service_key');
+const KNOWN_HOSTS = path.join(os.homedir(), '.spaces', 'known_hosts');
+
+type AdminDb = {
+  prepare: (sql: string) => { get: (...args: unknown[]) => unknown };
+};
+
+let _adminDb: AdminDb | null = null;
+
+function getAdminDb(): AdminDb | null {
+  if (_adminDb) return _adminDb;
+  if (!fs.existsSync(ADMIN_DB_PATH)) return null;
+  try {
+    const Database = require('better-sqlite3');
+    _adminDb = new Database(ADMIN_DB_PATH, { readonly: true, fileMustExist: true }) as AdminDb;
+    return _adminDb;
+  } catch {
+    return null;
+  }
+}
+
+/** Map an app-level username to the OS shell user (falls back to the same name). */
+export function lookupShellUser(appUsername: string): string {
+  const db = getAdminDb();
+  if (!db) return appUsername;
+  try {
+    const row = db.prepare('SELECT shell_user FROM users WHERE username = ?').get(appUsername) as
+      | { shell_user?: string }
+      | undefined;
+    return row?.shell_user || appUsername;
+  } catch {
+    return appUsername;
+  }
+}
+
+/** Resolve a shell user's home directory via getent; falls back to platform convention. */
+export function resolveHome(shellUser: string): string {
+  if (shellUser === os.userInfo().username) return os.homedir();
+  try {
+    const r = spawnSync('getent', ['passwd', shellUser], { encoding: 'utf-8', timeout: 5000 });
+    const home = (r.stdout || '').split(':')[5];
+    if (home) return home.trim();
+  } catch { /* fall through */ }
+  return process.platform === 'darwin' ? `/Users/${shellUser}` : `/home/${shellUser}`;
+}
+
+function shellQuote(s: string): string {
+  return "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
+export interface ExecResult {
+  status: number;
+  stdout: string;
+  stderr: string;
+}
+
+/**
+ * Run a command as the given shell user.
+ * When the target matches the server process user, spawns directly.
+ * Otherwise SSHes to localhost using the Spaces service key — the same mechanism terminal panes use.
+ */
+export function execAsUser(shellUser: string, argv: string[], opts: { timeoutMs?: number } = {}): ExecResult {
+  const timeout = opts.timeoutMs ?? 10000;
+  const processUser = os.userInfo().username;
+
+  if (shellUser === processUser) {
+    const [cmd, ...rest] = argv;
+    const r = spawnSync(cmd, rest, { encoding: 'utf-8', timeout });
+    return {
+      status: r.status ?? (r.error ? 1 : 0),
+      stdout: r.stdout || '',
+      stderr: r.stderr || (r.error?.message ?? ''),
+    };
+  }
+
+  const remoteCmd = argv.map(shellQuote).join(' ');
+  const r = spawnSync(
+    'ssh',
+    [
+      '-4',
+      '-o', 'StrictHostKeyChecking=accept-new',
+      '-o', `UserKnownHostsFile=${KNOWN_HOSTS}`,
+      '-o', 'BatchMode=yes',
+      '-i', SERVICE_KEY,
+      `${shellUser}@localhost`,
+      remoteCmd,
+    ],
+    { encoding: 'utf-8', timeout },
+  );
+  return {
+    status: r.status ?? (r.error ? 1 : 0),
+    stdout: r.stdout || '',
+    stderr: r.stderr || (r.error?.message ?? ''),
+  };
+}