@jlongo78/agent-spaces 0.7.7 → 0.8.0

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

@@ -0,0 +1,111 @@
+import fs from 'fs';
+import crypto from 'crypto';
+import path from 'path';
+
+const HISTORY_FILE = '.aider.chat.history.md';
+const USER_MESSAGE_PREFIX = '#### ';
+
+export interface AiderSessionMeta {
+  projectPath: string;
+  firstPrompt: string;
+  messageCount: number;
+  modified: string;
+  created: string;
+}
+
+/**
+ * Generate a deterministic session ID from a project path.
+ * Returns 'aider-' + first 16 hex chars of sha256(path).
+ */
+export function aiderSessionId(projectPath: string): string {
+  const hash = crypto.createHash('sha256').update(projectPath).digest('hex');
+  return 'aider-' + hash.slice(0, 16);
+}
+
+/**
+ * Generate a deterministic project ID from a project path.
+ * Returns 'aider-proj-' + first 12 hex chars of sha256(path).
+ */
+export function aiderProjectId(projectPath: string): string {
+  const hash = crypto.createHash('sha256').update(projectPath).digest('hex');
+  return 'aider-proj-' + hash.slice(0, 12);
+}
+
+/**
+ * Parse a single .aider.chat.history.md file and extract session metadata.
+ * Returns null if the file doesn't exist or has 0 messages.
+ */
+function parseHistoryFile(projectDir: string): AiderSessionMeta | null {
+  const filePath = path.join(projectDir, HISTORY_FILE);
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  let content: string;
+  try {
+    content = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  let messageCount = 0;
+  let firstPrompt = '';
+
+  for (const line of content.split('\n')) {
+    if (line.startsWith(USER_MESSAGE_PREFIX)) {
+      messageCount++;
+      if (!firstPrompt) {
+        firstPrompt = line.slice(USER_MESSAGE_PREFIX.length).trim().slice(0, 200);
+      }
+    }
+  }
+
+  if (messageCount === 0) {
+    return null;
+  }
+
+  let stat: fs.Stats;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+
+  const modified = stat.mtime.toISOString();
+  // birthtime falls back to ctime on Linux/filesystems that don't track it
+  const created = (stat.birthtime && stat.birthtime.getTime() > 0
+    ? stat.birthtime
+    : stat.ctime
+  ).toISOString();
+
+  return {
+    projectPath: projectDir,
+    firstPrompt,
+    messageCount,
+    modified,
+    created,
+  };
+}
+
+/**
+ * Scan a list of project directories for Aider chat history files.
+ * Deduplicates directories and skips files with 0 messages.
+ */
+export function scanAiderSessions(projectDirs: string[]): AiderSessionMeta[] {
+  const seen = new Set<string>();
+  const results: AiderSessionMeta[] = [];
+
+  for (const dir of projectDirs) {
+    const resolved = path.resolve(dir);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+
+    const meta = parseHistoryFile(resolved);
+    if (meta) {
+      results.push(meta);
+    }
+  }
+
+  return results;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Prefix API paths with basePath and normalize trailing slashes to avoid
+ * 308 redirects (trailingSlash: true in next.config).
+ *
+ * SPACES_BASE_PATH is inlined into the client bundle via next.config.ts `env`.
+ */
+const BASE = process.env.SPACES_BASE_PATH || '';
+
+export const api = (path: string) => {
+  const qIndex = path.indexOf('?');
+  if (qIndex === -1) {
+    const normalized = path.endsWith('/') ? path : `${path}/`;
+    return `${BASE}${normalized}`;
+  }
+  const pathname = path.slice(0, qIndex);
+  const query = path.slice(qIndex);
+  const normalizedPath = pathname.endsWith('/') ? pathname : `${pathname}/`;
+  return `${BASE}${normalizedPath}${query}`;
+};

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

@@ -0,0 +1,47 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { NextRequest } from 'next/server';
+import os from 'os';
+import { HAS_AUTH } from '@/lib/tier';
+
+const userStore = new AsyncLocalStorage<string>();
+
+/**
+ * Extract the authenticated username from SSO headers.
+ * Falls back to the OS user for local development.
+ */
+export function getAuthUser(request: NextRequest): string {
+  // Only trust x-auth-user when auth middleware is active (server/federation mode).
+  // The middleware validates the session and sets this header.
+  // Without auth middleware, a client could spoof this header.
+  if (HAS_AUTH) {
+    return request.headers.get('x-auth-user') || os.userInfo().username;
+  }
+  return os.userInfo().username;
+}
+
+/**
+ * Run a function within a user context, so getDb() and other
+ * user-scoped operations resolve to the correct user.
+ */
+export function withUser<T>(username: string, fn: () => T): T {
+  return userStore.run(username, fn);
+}
+
+/**
+ * Extract the user's role from request headers.
+ * Desktop mode defaults to 'admin'; server mode reads the middleware-set header.
+ */
+export function getAuthRole(request: NextRequest): string {
+  if (!HAS_AUTH) return 'admin';
+  return request.headers.get('x-auth-role') || 'user';
+}
+
+/**
+ * Get the current user from AsyncLocalStorage context.
+ * Falls back to the OS user for local dev or background tasks.
+ */
+export function getCurrentUser(): string {
+  const user = userStore.getStore();
+  if (!user) return os.userInfo().username;
+  return user;
+}

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

@@ -0,0 +1,212 @@
+import fs from 'fs';
+import readline from 'readline';
+import type { SessionIndex, ParsedMessage, ContentBlock } from '@/types/claude';
+
+/**
+ * Parse a sessions-index.json file
+ */
+export function parseSessionIndex(filePath: string): SessionIndex | null {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content) as SessionIndex;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Count conversation messages in a JSONL file (user + assistant only)
+ */
+export function countConversationMessages(filePath: string): number {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    let count = 0;
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === 'user' || parsed.type === 'assistant') {
+          count++;
+        }
+      } catch {
+        // skip malformed lines
+      }
+    }
+    return count;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Stream messages from a JSONL file with pagination
+ * Returns only user/assistant/system messages (conversation messages)
+ */
+export async function readMessages(
+  filePath: string,
+  offset: number = 0,
+  limit: number = 50
+): Promise<{ messages: ParsedMessage[]; total: number; hasMore: boolean }> {
+  return new Promise((resolve, reject) => {
+    const messages: ParsedMessage[] = [];
+    let total = 0;
+    let collected = 0;
+
+    if (!fs.existsSync(filePath)) {
+      resolve({ messages: [], total: 0, hasMore: false });
+      return;
+    }
+
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    rl.on('line', (line: string) => {
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === 'user' || parsed.type === 'assistant' || parsed.type === 'system') {
+          if (total >= offset && collected < limit) {
+            messages.push(parsed as ParsedMessage);
+            collected++;
+          }
+          total++;
+        }
+      } catch {
+        // skip malformed lines
+      }
+    });
+
+    rl.on('close', () => {
+      resolve({ messages, total, hasMore: total > offset + limit });
+    });
+
+    rl.on('error', reject);
+  });
+}
+
+/**
+ * Extract plain text from message content for FTS indexing
+ */
+export function extractTextFromMessage(msg: ParsedMessage): string {
+  if (msg.type === 'user' && 'message' in msg) {
+    const content = msg.message.content;
+    return typeof content === 'string' ? content : '';
+  }
+
+  if (msg.type === 'assistant' && 'message' in msg) {
+    const blocks = msg.message.content;
+    if (!Array.isArray(blocks)) return '';
+    return blocks
+      .filter((b: ContentBlock) => b.type === 'text' && b.text)
+      .map((b: ContentBlock) => b.text!)
+      .join('\n');
+  }
+
+  return '';
+}
+
+/**
+ * Extract text from all messages in a JSONL file for FTS indexing
+ */
+export async function extractAllText(filePath: string): Promise<string> {
+  return new Promise((resolve) => {
+    const texts: string[] = [];
+
+    if (!fs.existsSync(filePath)) {
+      resolve('');
+      return;
+    }
+
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    rl.on('line', (line: string) => {
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === 'user' || parsed.type === 'assistant') {
+          const text = extractTextFromMessage(parsed as ParsedMessage);
+          if (text) texts.push(text);
+        }
+      } catch {
+        // skip
+      }
+    });
+
+    rl.on('close', () => {
+      resolve(texts.join('\n').slice(0, 100000)); // Cap at 100KB per session for FTS
+    });
+  });
+}
+
+/**
+ * Read stats-cache.json
+ */
+export function readStatsCache(statsPath: string) {
+  try {
+    const content = fs.readFileSync(statsPath, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Scan a JSONL file for metadata when no sessions-index.json exists
+ */
+export async function scanJSONLMetadata(filePath: string): Promise<{
+  firstPrompt: string;
+  messageCount: number;
+  created: string;
+  modified: string;
+  gitBranch: string;
+  projectPath: string;
+  model: string;
+} | null> {
+  return new Promise((resolve) => {
+    let firstPrompt = '';
+    let messageCount = 0;
+    let created = '';
+    let modified = '';
+    let gitBranch = '';
+    let projectPath = '';
+    let model = '';
+
+    if (!fs.existsSync(filePath)) {
+      resolve(null);
+      return;
+    }
+
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+    rl.on('line', (line: string) => {
+      if (!line.trim()) return;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === 'user' || parsed.type === 'assistant') {
+          messageCount++;
+          if (parsed.timestamp) {
+            if (!created) created = parsed.timestamp;
+            modified = parsed.timestamp;
+          }
+        }
+        if (parsed.type === 'user' && !firstPrompt) {
+          const content = parsed.message?.content;
+          firstPrompt = typeof content === 'string' ? content.slice(0, 200) : '';
+          gitBranch = parsed.gitBranch || '';
+          projectPath = parsed.cwd || '';
+        }
+        if (parsed.type === 'assistant' && !model) {
+          model = parsed.message?.model || '';
+        }
+      } catch {
+        // skip
+      }
+    });
+
+    rl.on('close', () => {
+      resolve({ firstPrompt, messageCount, created, modified, gitBranch, projectPath, model });
+    });
+  });
+}

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

@@ -0,0 +1,204 @@
+import fs from 'fs';
+import path from 'path';
+import { getUserPaths } from '../config';
+import type { DailyActivity, DailyModelTokens, ModelUsage, StatsCache } from '@/types/claude';
+
+/**
+ * Compute fresh stats by scanning session JSONL files.
+ * Reads from the Spaces-managed cache first; recomputes if stale (>1h).
+ */
+export function getOrComputeStats(username: string): StatsCache | null {
+  const paths = getUserPaths(username);
+  const cachePath = path.join(path.dirname(paths.statsPath), 'spaces-stats-cache.json');
+
+  // Check if our cache is fresh (less than 1 hour old)
+  try {
+    if (fs.existsSync(cachePath)) {
+      const stat = fs.statSync(cachePath);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs < 3600_000) {
+        const cached = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        if (cached?.version === 3) return cached;
+      }
+    }
+  } catch { /* recompute */ }
+
+  // Also try the Claude Code native cache as a fallback data source
+  let nativeCache: StatsCache | null = null;
+  try {
+    if (fs.existsSync(paths.statsPath)) {
+      nativeCache = JSON.parse(fs.readFileSync(paths.statsPath, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+
+  // Compute from JSONL files by scanning the filesystem directly
+  const computed = computeFromJSONL(paths.claudeProjectsDir, nativeCache);
+
+  // Write cache
+  try {
+    const dir = path.dirname(cachePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(cachePath, JSON.stringify(computed, null, 2));
+  } catch { /* non-fatal */ }
+
+  return computed;
+}
+
+function computeFromJSONL(projectsDir: string, nativeCache: StatsCache | null): StatsCache {
+  const dailyActivityMap = new Map<string, DailyActivity>();
+  const dailyTokensMap = new Map<string, Record<string, number>>();
+  const modelUsageMap = new Map<string, ModelUsage>();
+
+  // Scan all JSONL files in all project directories
+  if (fs.existsSync(projectsDir)) {
+    try {
+      const projectDirs = fs.readdirSync(projectsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory());
+
+      for (const dir of projectDirs) {
+        const dirPath = path.join(projectsDir, dir.name);
+        try {
+          const files = fs.readdirSync(dirPath)
+            .filter(f => f.endsWith('.jsonl') && !f.startsWith('.'));
+
+          for (const file of files) {
+            const filePath = path.join(dirPath, file);
+            try {
+              // Skip files older than 90 days for perf
+              const stat = fs.statSync(filePath);
+              const ageMs = Date.now() - stat.mtimeMs;
+              if (ageMs > 90 * 86400_000) continue;
+
+              scanSessionFile(filePath, dailyActivityMap, dailyTokensMap, modelUsageMap);
+            } catch { /* skip unreadable files */ }
+          }
+        } catch { /* skip unreadable dirs */ }
+      }
+    } catch { /* projectsDir unreadable */ }
+  }
+
+  // Merge with native cache data for older dates we skipped
+  if (nativeCache?.dailyActivity) {
+    for (const entry of nativeCache.dailyActivity) {
+      if (!dailyActivityMap.has(entry.date)) {
+        dailyActivityMap.set(entry.date, entry);
+      }
+    }
+  }
+  if (nativeCache?.dailyModelTokens) {
+    for (const entry of nativeCache.dailyModelTokens) {
+      if (!dailyTokensMap.has(entry.date)) {
+        dailyTokensMap.set(entry.date, entry.tokensByModel);
+      }
+    }
+  }
+  if (nativeCache?.modelUsage) {
+    for (const [model, usage] of Object.entries(nativeCache.modelUsage)) {
+      if (!modelUsageMap.has(model)) {
+        modelUsageMap.set(model, usage);
+      }
+    }
+  }
+
+  const dailyActivity = Array.from(dailyActivityMap.entries())
+    .map(([, data]) => data)
+    .sort((a, b) => a.date.localeCompare(b.date));
+
+  const dailyModelTokens: DailyModelTokens[] = Array.from(dailyTokensMap.entries())
+    .map(([date, tokensByModel]) => ({ date, tokensByModel }))
+    .sort((a, b) => a.date.localeCompare(b.date));
+
+  const modelUsage: Record<string, ModelUsage> = {};
+  for (const [model, usage] of modelUsageMap) {
+    modelUsage[model] = usage;
+  }
+
+  return {
+    version: 3 as any,
+    lastComputedDate: new Date().toISOString().slice(0, 10),
+    dailyActivity,
+    dailyModelTokens,
+    modelUsage,
+  };
+}
+
+function scanSessionFile(
+  filePath: string,
+  activityMap: Map<string, DailyActivity>,
+  tokensMap: Map<string, Record<string, number>>,
+  modelUsageMap: Map<string, ModelUsage>,
+) {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const datesInFile = new Set<string>();
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const msg = JSON.parse(line);
+
+      // Track dates for session counting
+      if ((msg.type === 'user' || msg.type === 'assistant') && msg.timestamp) {
+        const date = msg.timestamp.slice(0, 10);
+        if (date.length === 10) datesInFile.add(date);
+      }
+
+      if (msg.type !== 'assistant') continue;
+
+      const ts = msg.timestamp || '';
+      const date = ts.slice(0, 10);
+      if (!date || date.length !== 10) continue;
+
+      const model = msg.message?.model || 'unknown';
+      const usage = msg.message?.usage;
+      const blocks = msg.message?.content;
+
+      // Count tool calls
+      let toolCalls = 0;
+      if (Array.isArray(blocks)) {
+        for (const block of blocks) {
+          if (block.type === 'tool_use') toolCalls++;
+        }
+      }
+
+      // Update daily activity
+      let activity = activityMap.get(date);
+      if (!activity) {
+        activity = { date, messageCount: 0, sessionCount: 0, toolCallCount: 0 };
+        activityMap.set(date, activity);
+      }
+      activity.messageCount++;
+      activity.toolCallCount += toolCalls;
+
+      // Update daily tokens
+      if (usage) {
+        const totalTokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
+        if (!tokensMap.has(date)) tokensMap.set(date, {});
+        const dayTokens = tokensMap.get(date)!;
+        dayTokens[model] = (dayTokens[model] || 0) + totalTokens;
+
+        // Update model usage aggregate
+        if (!modelUsageMap.has(model)) {
+          modelUsageMap.set(model, {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadInputTokens: 0,
+            cacheCreationInputTokens: 0,
+          });
+        }
+        const mu = modelUsageMap.get(model)!;
+        mu.inputTokens += usage.input_tokens || 0;
+        mu.outputTokens += usage.output_tokens || 0;
+        mu.cacheReadInputTokens += usage.cache_read_input_tokens || 0;
+        mu.cacheCreationInputTokens += usage.cache_creation_input_tokens || 0;
+      }
+    } catch {
+      // Skip malformed lines
+    }
+  }
+
+  // Increment sessionCount once per file per date it was active
+  for (const date of datesInFile) {
+    const activity = activityMap.get(date);
+    if (activity) activity.sessionCount++;
+  }
+}