@jlongo78/agent-spaces 0.7.7 → 0.8.0

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

@@ -0,0 +1,202 @@
+import Database from 'better-sqlite3';
+import { getUserPaths, ensureUserSpacesDir } from '../config';
+import { getCurrentUser } from '../auth';
+
+const _dbs = new Map<string, Database.Database>();
+
+export function getDb(): Database.Database {
+  const username = getCurrentUser();
+
+  const existing = _dbs.get(username);
+  if (existing) return existing;
+
+  ensureUserSpacesDir(username);
+  const { dbPath } = getUserPaths(username);
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = NORMAL');
+  db.pragma('foreign_keys = ON');
+
+  initSchema(db);
+  _dbs.set(username, db);
+  return db;
+}
+
+function initSchema(db: Database.Database) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT NOT NULL,
+      claude_path TEXT NOT NULL,
+      session_count INTEGER DEFAULT 0,
+      last_activity TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      first_prompt TEXT,
+      summary TEXT,
+      message_count INTEGER DEFAULT 0,
+      created TEXT,
+      modified TEXT,
+      git_branch TEXT,
+      project_path TEXT,
+      full_path TEXT NOT NULL,
+      starred INTEGER DEFAULT 0,
+      custom_name TEXT,
+      notes TEXT,
+      FOREIGN KEY (project_id) REFERENCES projects(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_created ON sessions(created);
+    CREATE INDEX IF NOT EXISTS idx_sessions_modified ON sessions(modified);
+    CREATE INDEX IF NOT EXISTS idx_sessions_starred ON sessions(starred);
+
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      description TEXT DEFAULT '',
+      color TEXT DEFAULT '#6366f1',
+      created TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS workspace_sessions (
+      workspace_id INTEGER NOT NULL,
+      session_id TEXT NOT NULL,
+      PRIMARY KEY (workspace_id, session_id),
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS tags (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      color TEXT DEFAULT '#8b5cf6'
+    );
+
+    CREATE TABLE IF NOT EXISTS session_tags (
+      session_id TEXT NOT NULL,
+      tag_id INTEGER NOT NULL,
+      PRIMARY KEY (session_id, tag_id),
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+      FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_state (
+      file_path TEXT PRIMARY KEY,
+      mtime INTEGER,
+      byte_offset INTEGER DEFAULT 0,
+      last_synced TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS panes (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL DEFAULT 'Terminal',
+      color TEXT NOT NULL DEFAULT '#6366f1',
+      cwd TEXT NOT NULL,
+      claude_session_id TEXT,
+      grid_col INTEGER NOT NULL DEFAULT 0,
+      grid_row INTEGER NOT NULL DEFAULT 0,
+      sort_order INTEGER NOT NULL DEFAULT 0,
+      shell TEXT,
+      created TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS totp (
+      username TEXT PRIMARY KEY,
+      secret TEXT NOT NULL,
+      enabled INTEGER DEFAULT 0,
+      created TEXT DEFAULT (datetime('now'))
+    );
+  `);
+
+  // Migrate: add workspace and popout columns to existing tables
+  const addCol = (table: string, col: string, def: string) => {
+    try { db.exec(`ALTER TABLE ${table} ADD COLUMN ${col} ${def}`); } catch { /* already exists */ }
+  };
+
+  // Workspaces: add active tracking
+  addCol('workspaces', 'is_active', 'INTEGER DEFAULT 0');
+  addCol('workspaces', 'updated', 'TEXT');
+  addCol('workspaces', 'lobe_config', "TEXT DEFAULT '{}'")
+
+  // Panes: add workspace ownership, popout tracking, and agent type
+  addCol('panes', 'workspace_id', 'INTEGER');
+  addCol('panes', 'is_popout', 'INTEGER DEFAULT 0');
+  addCol('panes', 'win_x', 'INTEGER');
+  addCol('panes', 'win_y', 'INTEGER');
+  addCol('panes', 'win_width', 'INTEGER DEFAULT 800');
+  addCol('panes', 'win_height', 'INTEGER DEFAULT 600');
+  addCol('panes', 'agent_type', "TEXT DEFAULT 'shell'");
+  addCol('panes', 'custom_command', 'TEXT');
+  addCol('panes', 'node_id', 'TEXT');
+
+  // Multi-agent support: add agent_type to sessions and projects
+  addCol('sessions', 'agent_type', "TEXT DEFAULT 'claude'");
+  addCol('projects', 'agent_type', "TEXT DEFAULT 'claude'");
+  addCol('projects', 'agent_path', 'TEXT');
+
+  // Copy claude_path → agent_path for existing rows that don't have it yet
+  try { db.exec("UPDATE projects SET agent_path = claude_path WHERE agent_path IS NULL AND claude_path IS NOT NULL"); } catch { /* */ }
+
+  // Collaboration toggles
+  addCol('workspaces', 'collaboration', 'INTEGER DEFAULT 0');
+  addCol('panes', 'is_collaborating', 'INTEGER DEFAULT 0');
+
+  // Index for filtering by agent type
+  try { db.exec('CREATE INDEX IF NOT EXISTS idx_sessions_agent_type ON sessions(agent_type)'); } catch { /* */ }
+  try { db.exec('CREATE INDEX IF NOT EXISTS idx_projects_agent_type ON projects(agent_type)'); } catch { /* */ }
+
+  // Ensure a Default workspace exists and orphan panes get assigned to it
+  const defaultWs = db.prepare("SELECT id FROM workspaces WHERE name = 'Default'").get() as { id: number } | undefined;
+  let defaultWsId: number;
+  if (!defaultWs) {
+    const r = db.prepare("INSERT INTO workspaces (name, description, color, is_active) VALUES ('Default', 'Default workspace', '#6366f1', 1)").run();
+    defaultWsId = Number(r.lastInsertRowid);
+  } else {
+    defaultWsId = defaultWs.id;
+    // Ensure at least one workspace is active
+    const anyActive = db.prepare('SELECT id FROM workspaces WHERE is_active = 1').get();
+    if (!anyActive) {
+      db.prepare('UPDATE workspaces SET is_active = 1 WHERE id = ?').run(defaultWsId);
+    }
+  }
+
+  // Assign orphan panes (workspace_id IS NULL) to the active workspace
+  const activeWs = db.prepare('SELECT id FROM workspaces WHERE is_active = 1').get() as { id: number } | undefined;
+  if (activeWs) {
+    db.prepare('UPDATE panes SET workspace_id = ? WHERE workspace_id IS NULL').run(activeWs.id);
+  }
+
+  // Create FTS5 virtual table if it doesn't exist
+  try {
+    db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS sessions_fts USING fts5(
+        session_id,
+        content,
+        content_rowid='rowid'
+      );
+    `);
+  } catch {
+    // FTS5 may already exist
+  }
+
+  // Run @spaces/teams migrations if installed
+  try {
+    const { getTeams } = require('@/lib/teams');
+    const teams = getTeams();
+    if (teams) teams.db.runMigrations(db);
+  } catch { /* @spaces/teams not installed */ }
+}
+
+export function closeDb() {
+  for (const db of _dbs.values()) {
+    db.close();
+  }
+  _dbs.clear();
+}

package/.next/standalone/src/lib/events/sse.ts

@@ -0,0 +1,36 @@
+type SSEClient = {
+  id: string;
+  controller: ReadableStreamDefaultController;
+};
+
+class SSEManager {
+  private clients: SSEClient[] = [];
+
+  addClient(id: string, controller: ReadableStreamDefaultController) {
+    this.clients.push({ id, controller });
+  }
+
+  removeClient(id: string) {
+    this.clients = this.clients.filter(c => c.id !== id);
+  }
+
+  broadcast(event: string, data: unknown) {
+    const message = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(message);
+
+    for (const client of this.clients) {
+      try {
+        client.controller.enqueue(encoded);
+      } catch {
+        this.removeClient(client.id);
+      }
+    }
+  }
+
+  get clientCount() {
+    return this.clients.length;
+  }
+}
+
+export const sseManager = new SSEManager();

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

@@ -0,0 +1,216 @@
+import fs from 'fs';
+import path from 'path';
+
+export interface GeminiSessionMeta {
+  sessionId: string;
+  projectSlug: string;
+  projectPath: string;
+  startTime: string;
+  lastUpdated: string;
+  firstPrompt: string;
+  summary: string;
+  messageCount: number;
+  fullPath: string;
+}
+
+/**
+ * Safely read a directory, returning an empty array on any error.
+ */
+function safeReaddir(dirPath: string): string[] {
+  try {
+    return fs.readdirSync(dirPath);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a path is a directory, returning false on any error.
+ */
+function isDir(filePath: string): boolean {
+  try {
+    return fs.statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read projects.json to build a slug -> project path map.
+ * Returns an empty map if the file doesn't exist or can't be parsed.
+ *
+ * Expected format: an object mapping project paths to objects with an `id` field
+ * (the slug), e.g. { "/home/user/myproject": { "id": "myproject-abc123" } }
+ */
+function loadProjectsRegistry(registryPath: string): Map<string, string> {
+  const slugToPath = new Map<string, string>();
+
+  try {
+    if (!fs.existsSync(registryPath)) {
+      return slugToPath;
+    }
+    const raw = fs.readFileSync(registryPath, 'utf-8');
+    const registry = JSON.parse(raw);
+
+    if (typeof registry !== 'object' || registry === null) {
+      return slugToPath;
+    }
+
+    // The registry maps project paths to { id: slug, ... }
+    for (const [projectPath, entry] of Object.entries(registry)) {
+      if (entry && typeof entry === 'object' && 'id' in entry) {
+        const slug = (entry as { id: string }).id;
+        if (typeof slug === 'string') {
+          slugToPath.set(slug, projectPath);
+        }
+      }
+    }
+  } catch {
+    // Corrupt or unreadable file -- return empty map
+  }
+
+  return slugToPath;
+}
+
+/**
+ * Extract the text from a Gemini message's content field.
+ * Gemini messages may have:
+ *   - content as a plain string
+ *   - content as an object with a `parts` array, each part having a `text` field
+ *   - content as an array of parts directly
+ */
+function extractContentText(content: unknown): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+
+  if (content && typeof content === 'object') {
+    // content.parts array format
+    let parts: unknown[] | undefined;
+
+    if (Array.isArray(content)) {
+      parts = content;
+    } else if ('parts' in content && Array.isArray((content as { parts: unknown }).parts)) {
+      parts = (content as { parts: unknown[] }).parts;
+    }
+
+    if (parts) {
+      const texts: string[] = [];
+      for (const part of parts) {
+        if (part && typeof part === 'object' && 'text' in part) {
+          const text = (part as { text: unknown }).text;
+          if (typeof text === 'string') {
+            texts.push(text);
+          }
+        }
+      }
+      return texts.join('\n');
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Parse a single Gemini session JSON file and extract metadata.
+ * Returns null if the file can't be parsed or has no messages.
+ */
+function parseSessionFile(
+  filePath: string,
+  projectSlug: string,
+  slugToPath: Map<string, string>,
+): GeminiSessionMeta | null {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const record = JSON.parse(raw);
+
+    if (typeof record !== 'object' || record === null) {
+      return null;
+    }
+
+    const sessionId: string = record.sessionId || path.basename(filePath, '.json');
+    const startTime: string = record.startTime || '';
+    const lastUpdated: string = record.lastUpdated || '';
+    const summary: string = record.summary || '';
+    const messages: unknown[] = Array.isArray(record.messages) ? record.messages : [];
+
+    // Count conversation messages and find the first user prompt
+    let messageCount = 0;
+    let firstPrompt = '';
+
+    for (const msg of messages) {
+      if (!msg || typeof msg !== 'object') continue;
+
+      const role = (msg as { role?: string }).role;
+      if (role === 'user' || role === 'model' || role === 'assistant') {
+        messageCount++;
+      }
+
+      if (role === 'user' && !firstPrompt) {
+        const content = (msg as { content?: unknown }).content;
+        const text = extractContentText(content);
+        if (text) {
+          firstPrompt = text.trim().slice(0, 200);
+        }
+      }
+    }
+
+    const projectPath = slugToPath.get(projectSlug) || '';
+
+    return {
+      sessionId,
+      projectSlug,
+      projectPath,
+      startTime,
+      lastUpdated,
+      firstPrompt,
+      summary,
+      messageCount,
+      fullPath: filePath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Scan Gemini CLI session files and return metadata for each session.
+ *
+ * Walks ~/.gemini/tmp/<project-slug>/chats/ for session-*.json files,
+ * optionally enriching project paths from the projects.json registry.
+ *
+ * @param geminiChatsBaseDir  Path to ~/.gemini/tmp/
+ * @param projectsRegistryPath  Path to ~/.gemini/projects.json
+ */
+export function scanGeminiSessions(
+  geminiChatsBaseDir: string,
+  projectsRegistryPath: string,
+): GeminiSessionMeta[] {
+  const slugToPath = loadProjectsRegistry(projectsRegistryPath);
+  const results: GeminiSessionMeta[] = [];
+
+  // Each entry in the base dir is a project slug directory
+  const projectSlugs = safeReaddir(geminiChatsBaseDir);
+
+  for (const slug of projectSlugs) {
+    const projectDir = path.join(geminiChatsBaseDir, slug);
+    if (!isDir(projectDir)) continue;
+
+    const chatsDir = path.join(projectDir, 'chats');
+    if (!isDir(chatsDir)) continue;
+
+    const files = safeReaddir(chatsDir);
+
+    for (const file of files) {
+      if (!file.startsWith('session-') || !file.endsWith('.json')) continue;
+
+      const filePath = path.join(chatsDir, file);
+      const meta = parseSessionFile(filePath, slug, slugToPath);
+      if (meta) {
+        results.push(meta);
+      }
+    }
+  }
+
+  return results;
+}

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

@@ -0,0 +1,56 @@
+import { createPublicKey, verify } from 'crypto';
+
+// Ed25519 public key for license verification (asymmetric — safe to embed)
+// Replace with actual public key from: node scripts/keygen.js
+const PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEApnho5Ufnuut0LbsnVadxr0NKOTYz3ojX0W5n6zfFIUk=
+-----END PUBLIC KEY-----`;
+
+export interface License {
+  tier: 'server' | 'team' | 'federation';
+  sub: string;        // customer email
+  maxUsers?: number;  // for team tier
+  iat: number;
+  exp: number;
+}
+
+/**
+ * Verify an Ed25519-signed JWT license key offline.
+ * Returns the decoded license payload or null if invalid/expired.
+ */
+export function verifyLicense(token: string): License | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) return null;
+
+    const [headerB64, payloadB64, signatureB64] = parts;
+
+    // Verify header declares EdDSA
+    const header = JSON.parse(Buffer.from(headerB64, 'base64url').toString());
+    if (header.alg !== 'EdDSA') return null;
+
+    // Verify signature
+    const publicKey = createPublicKey(PUBLIC_KEY_PEM);
+    const data = Buffer.from(`${headerB64}.${payloadB64}`);
+    const signature = Buffer.from(signatureB64, 'base64url');
+    const valid = verify(null, data, publicKey, signature);
+    if (!valid) return null;
+
+    // Decode payload
+    const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());
+
+    // Check expiration
+    const now = Math.floor(Date.now() / 1000);
+    if (payload.exp && payload.exp < now) return null;
+
+    return {
+      tier: payload.tier,
+      sub: payload.sub,
+      maxUsers: payload.maxUsers,
+      iat: payload.iat,
+      exp: payload.exp,
+    };
+  } catch {
+    return null;
+  }
+}

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

@@ -0,0 +1,31 @@
+import { createRequire } from 'module';
+import path from 'path';
+
+let _pro: any = null;
+let _checked = false;
+
+export function getPro() {
+  if (!_checked) {
+    for (const root of requireRoots()) {
+      try {
+        _pro = createRequire(root)('@spaces/pro');
+        break;
+      } catch {}
+    }
+    _checked = true;
+  }
+  return _pro;
+}
+
+export function hasPro(): boolean {
+  return getPro() !== null;
+}
+
+/** Build a list of require anchors: cwd first, then each NODE_PATH entry. */
+function requireRoots(): string[] {
+  const roots = [path.join(process.cwd(), 'package.json')];
+  for (const dir of (process.env.NODE_PATH || '').split(path.delimiter)) {
+    if (dir) roots.push(path.join(dir, '_anchor.js'));
+  }
+  return roots;
+}