@jlongo78/agent-spaces 0.7.7 → 0.8.0

package/.next/standalone/src/lib/terminal/server.ts

@@ -0,0 +1,128 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import * as pty from 'node-pty';
+import { IncomingMessage } from 'http';
+
+interface TermSession {
+  pty: pty.IPty;
+  ws: WebSocket;
+  id: string;
+}
+
+const sessions = new Map<string, TermSession>();
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+export function startTerminalServer(port = 3458) {
+  const wss = new WebSocketServer({
+    host: '127.0.0.1',
+    port,
+    verifyClient: ({ req }: { req: IncomingMessage }) => {
+      const origin = req.headers.origin;
+      if (!origin) return true;
+      try {
+        const url = new URL(origin);
+        return url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+      } catch {
+        return false;
+      }
+    },
+  });
+
+  wss.on('connection', (ws: WebSocket, req: IncomingMessage) => {
+    const url = new URL(req.url || '/', `http://localhost:${port}`);
+    const paneId = url.searchParams.get('paneId') || crypto.randomUUID();
+    const cwd = url.searchParams.get('cwd') || process.env.HOME || process.env.USERPROFILE || 'C:\\';
+    const rawClaudeSession = url.searchParams.get('claudeSession') || '';
+    const claudeSessionId = (rawClaudeSession === 'new' || UUID_RE.test(rawClaudeSession)) ? rawClaudeSession : '';
+    const cols = parseInt(url.searchParams.get('cols') || '120', 10);
+    const rows = parseInt(url.searchParams.get('rows') || '30', 10);
+
+    // Determine shell and args
+    const isWindows = process.platform === 'win32';
+    let shell: string;
+    let args: string[];
+
+    if (claudeSessionId) {
+      // Resume an agent session
+      shell = isWindows ? 'cmd.exe' : '/bin/bash';
+      const claudeCmd = claudeSessionId === 'new'
+        ? 'claude'
+        : `claude --resume ${claudeSessionId}`;
+      args = isWindows ? ['/c', claudeCmd] : ['-c', claudeCmd];
+    } else {
+      // Plain shell
+      shell = isWindows ? 'cmd.exe' : (process.env.SHELL || '/bin/bash');
+      args = [];
+    }
+
+    // Strip CLAUDECODE to avoid nesting detection
+    const env = { ...process.env } as Record<string, string>;
+    delete env.CLAUDECODE;
+
+    let term: pty.IPty;
+    try {
+      term = pty.spawn(shell, args, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd,
+        env,
+      });
+    } catch (err: any) {
+      ws.send(JSON.stringify({ type: 'error', data: `Failed to spawn terminal: ${err.message}` }));
+      ws.close();
+      return;
+    }
+
+    const session: TermSession = { pty: term, ws, id: paneId };
+    sessions.set(paneId, session);
+
+    // pty -> ws
+    term.onData((data: string) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'data', data }));
+      }
+    });
+
+    term.onExit(({ exitCode }) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'exit', exitCode }));
+      }
+      sessions.delete(paneId);
+    });
+
+    // ws -> pty
+    ws.on('message', (raw: Buffer | string) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === 'data') {
+          term.write(msg.data);
+        } else if (msg.type === 'resize') {
+          term.resize(msg.cols, msg.rows);
+        }
+      } catch {
+        // If not JSON, treat as raw input
+        term.write(raw.toString());
+      }
+    });
+
+    ws.on('close', () => {
+      term.kill();
+      sessions.delete(paneId);
+    });
+
+    // Send ready signal
+    ws.send(JSON.stringify({ type: 'ready', paneId }));
+  });
+
+  wss.on('error', (err) => {
+    console.error('[Terminal Server] Error:', err.message);
+  });
+
+  console.log(`Terminal WebSocket server running on ws://localhost:${port}`);
+  return wss;
+}
+
+// For standalone execution
+if (require.main === module) {
+  startTerminalServer();
+}

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

@@ -0,0 +1,38 @@
+export type Tier = 'community' | 'team' | 'federation';
+
+// Tier resolution: SPACES_TIER (set by bin/spaces.js launcher) is primary,
+// with NEXT_PUBLIC_TIER and NEXT_PUBLIC_EDITION as backward-compat fallbacks.
+// Auto-detection of @spaces/pro and license verification happen in the launcher,
+// NOT here, because this module is imported by middleware.ts which runs in Edge
+// Runtime where Node.js APIs (crypto, fs, require.resolve) are unavailable.
+export const TIER: Tier = (process.env.SPACES_TIER as Tier)
+  || (process.env.NEXT_PUBLIC_TIER as Tier)
+  || (process.env.NEXT_PUBLIC_EDITION === 'server' ? 'federation' : 'community');
+
+export const IS_TEAM = TIER === 'team' || TIER === 'federation';
+export const IS_FEDERATION = TIER === 'federation';
+export const HAS_AUTH = IS_TEAM;
+export const HAS_MULTIUSER = IS_TEAM;
+export const HAS_ADMIN = IS_TEAM;
+export const HAS_COLLABORATION = IS_TEAM;
+export const HAS_NETWORK = IS_FEDERATION;
+export const HAS_CORTEX = IS_TEAM || process.env.SPACES_HAS_CORTEX === '1';
+export const IS_DESKTOP = !IS_TEAM;
+
+/** Tier flags object for the /api/tier endpoint */
+export function getTierFlags() {
+  let version = '0.0.0';
+  try { version = require('../../package.json').version; } catch {}
+  return {
+    tier: TIER,
+    version,
+    hasAuth: HAS_AUTH,
+    hasAdmin: HAS_ADMIN,
+    hasCollaboration: HAS_COLLABORATION,
+    hasNetwork: HAS_NETWORK,
+    hasMultiuser: HAS_MULTIUSER,
+    hasCortex: HAS_CORTEX,
+    isDesktop: IS_DESKTOP,
+    basePath: process.env.SPACES_BASE_PATH || '',
+  };
+}

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

@@ -0,0 +1,72 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function formatDate(dateStr: string): string {
+  if (!dateStr) return '';
+  try {
+    const date = new Date(dateStr);
+    return date.toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    });
+  } catch {
+    return dateStr;
+  }
+}
+
+export function formatDateTime(dateStr: string): string {
+  if (!dateStr) return '';
+  try {
+    const date = new Date(dateStr);
+    return date.toLocaleString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: '2-digit',
+    });
+  } catch {
+    return dateStr;
+  }
+}
+
+export function formatRelativeTime(dateStr: string): string {
+  if (!dateStr) return '';
+  try {
+    const date = new Date(dateStr);
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMins < 1) return 'just now';
+    if (diffMins < 60) return `${diffMins}m ago`;
+    if (diffHours < 24) return `${diffHours}h ago`;
+    if (diffDays < 7) return `${diffDays}d ago`;
+    return formatDate(dateStr);
+  } catch {
+    return dateStr;
+  }
+}
+
+export function truncate(str: string, length: number): string {
+  if (!str) return '';
+  if (str.length <= length) return str;
+  return str.slice(0, length) + '...';
+}
+
+export function formatNumber(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+  return n.toString();
+}
+
+export function formatCost(cost: number): string {
+  if (cost < 0.01) return '<$0.01';
+  return `$${cost.toFixed(2)}`;
+}

package/.next/standalone/src/middleware.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { HAS_AUTH } from '@/lib/tier';
+
+async function verifyToken(token: string, secretHex: string): Promise<{ sub: string; role: string } | null> {
+  if (!token) return null;
+  const parts = token.split('.');
+  if (parts.length !== 2) return null;
+
+  const [payloadB64, sig] = parts;
+
+  const keyBytes = new Uint8Array(secretHex.length / 2);
+  for (let i = 0; i < secretHex.length; i += 2) {
+    keyBytes[i / 2] = parseInt(secretHex.substring(i, i + 2), 16);
+  }
+  const key = await crypto.subtle.importKey(
+    'raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']
+  );
+
+  const sigBytes = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(payloadB64));
+  const expectedSig = btoa(String.fromCharCode(...new Uint8Array(sigBytes)))
+    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+
+  if (expectedSig !== sig) return null;
+
+  try {
+    const payloadStr = atob(payloadB64.replace(/-/g, '+').replace(/_/g, '/'));
+    const payload = JSON.parse(payloadStr);
+    if (payload.exp < Math.floor(Date.now() / 1000)) return null;
+    return { sub: payload.sub, role: payload.role || 'user' };
+  } catch {
+    return null;
+  }
+}
+
+export async function middleware(request: NextRequest) {
+  if (!HAS_AUTH) {
+    return NextResponse.next();
+  }
+
+  const pathname = request.nextUrl.pathname;
+
+  // Skip auth for login page, specific auth APIs, static assets, and Next.js internals
+  if (
+    pathname === '/login' || pathname === '/login/' ||
+    pathname.startsWith('/api/tier') ||
+    pathname.startsWith('/api/auth/login') ||
+    pathname.startsWith('/api/auth/logout') ||
+    pathname.startsWith('/api/auth/totp/') ||
+    pathname.startsWith('/_next/') ||
+    pathname.startsWith('/favicon') ||
+    pathname.endsWith('.png') ||
+    pathname.endsWith('.ico') ||
+    pathname.endsWith('.svg') ||
+    pathname.endsWith('.jpg') ||
+    pathname.endsWith('.css') ||
+    pathname.endsWith('.js')
+  ) {
+    return NextResponse.next();
+  }
+
+  // Federation API routes authenticate via Bearer token
+  if (pathname.startsWith('/api/network/') && request.headers.get('authorization')?.startsWith('Bearer ')) {
+    return NextResponse.next();
+  }
+
+  // Connection request/callback endpoints are unauthenticated (verified by token in body)
+  if (request.method === 'POST' && (
+    pathname === '/api/network/connect-request' || pathname === '/api/network/connect-request/' ||
+    pathname === '/api/network/connect-callback' || pathname === '/api/network/connect-callback/'
+  )) {
+    return NextResponse.next();
+  }
+
+  // Internal API requests from MCP servers / agent processes / VR client (local network)
+  const internalToken = request.headers.get('x-spaces-internal') || request.nextUrl.searchParams.get('_internal');
+  if (internalToken === (process.env.SPACES_SESSION_SECRET || '').slice(0, 16) &&
+      (request.headers.get('host')?.startsWith('localhost') || request.headers.get('host')?.startsWith('127.0.0.1') || request.headers.get('host')?.startsWith('192.168.'))) {
+    return NextResponse.next();
+  }
+
+  // Validate session cookie
+  const sessionToken = request.cookies.get('spaces-session')?.value;
+  const secretHex = process.env.SPACES_SESSION_SECRET || '';
+
+  if (!secretHex) {
+    const loginUrl = request.nextUrl.clone();
+    loginUrl.pathname = '/login';
+    loginUrl.searchParams.set('error', 'no-secret');
+    return NextResponse.redirect(loginUrl);
+  }
+
+  if (!sessionToken) {
+    const loginUrl = request.nextUrl.clone();
+    loginUrl.pathname = '/login';
+    loginUrl.searchParams.set('redirectTo', pathname);
+    return NextResponse.redirect(loginUrl);
+  }
+
+  const session = await verifyToken(sessionToken, secretHex);
+  if (!session) {
+    const loginUrl = request.nextUrl.clone();
+    loginUrl.pathname = '/login';
+    loginUrl.searchParams.set('redirectTo', pathname);
+    return NextResponse.redirect(loginUrl);
+  }
+
+  // Set auth headers on the forwarded request
+  const requestHeaders = new Headers(request.headers);
+  requestHeaders.set('x-auth-user', session.sub);
+  requestHeaders.set('x-auth-role', session.role);
+
+  // Auto-redirect mobile users
+  if (pathname === '/' || pathname === '') {
+    const ua = request.headers.get('user-agent') || '';
+    const isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(ua);
+    if (isMobile) {
+      const mobileUrl = request.nextUrl.clone();
+      mobileUrl.pathname = '/m/';
+      return NextResponse.redirect(mobileUrl);
+    }
+  }
+
+  return NextResponse.next({
+    request: { headers: requestHeaders },
+  });
+}
+
+export const config = {
+  matcher: [
+    '/',
+    '/((?!_next/static|_next/image).*)',
+  ],
+};

package/.next/standalone/src/types/claude.ts

@@ -0,0 +1,208 @@
+// Types matching agent session data structures
+
+export interface SessionIndex {
+  version: number;
+  entries: SessionEntry[];
+}
+
+export interface SessionEntry {
+  sessionId: string;
+  fullPath: string;
+  fileMtime: number;
+  firstPrompt: string;
+  summary: string;
+  messageCount: number;
+  created: string;
+  modified: string;
+  gitBranch: string;
+  projectPath: string;
+  isSidechain: boolean;
+}
+
+export type MessageType =
+  | 'user'
+  | 'assistant'
+  | 'system'
+  | 'summary'
+  | 'tool_use'
+  | 'tool_result'
+  | 'thinking'
+  | 'progress'
+  | 'bash_progress'
+  | 'file-history-snapshot'
+  | 'queue-operation';
+
+export interface BaseMessage {
+  type: MessageType;
+  uuid: string;
+  parentUuid: string | null;
+  sessionId: string;
+  timestamp: string;
+  isSidechain: boolean;
+}
+
+export interface UserMessage extends BaseMessage {
+  type: 'user';
+  userType: 'external' | 'internal';
+  cwd: string;
+  version: string;
+  gitBranch: string;
+  message: {
+    role: 'user';
+    content: string;
+  };
+}
+
+export interface ContentBlock {
+  type: 'text' | 'thinking' | 'tool_use' | 'tool_result';
+  text?: string;
+  thinking?: string;
+  signature?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  content?: string | ContentBlock[];
+  tool_use_id?: string;
+  is_error?: boolean;
+}
+
+export interface AssistantMessage extends BaseMessage {
+  type: 'assistant';
+  message: {
+    model: string;
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    content: ContentBlock[];
+    stop_reason?: string;
+    usage?: {
+      input_tokens: number;
+      output_tokens: number;
+      cache_creation_input_tokens?: number;
+      cache_read_input_tokens?: number;
+    };
+  };
+  costUSD?: number;
+  durationMs?: number;
+}
+
+export interface SummaryMessage {
+  type: 'summary';
+  summary: string;
+  leafUuid: string;
+}
+
+export interface SystemMessage extends BaseMessage {
+  type: 'system';
+  message: {
+    role: 'system';
+    content: string;
+  };
+}
+
+export type ParsedMessage = UserMessage | AssistantMessage | SystemMessage | SummaryMessage;
+
+// Stats cache format
+export interface StatsCache {
+  version: number;
+  lastComputedDate: string;
+  dailyActivity: DailyActivity[];
+  dailyModelTokens: DailyModelTokens[];
+  modelUsage: Record<string, ModelUsage>;
+}
+
+export interface DailyActivity {
+  date: string;
+  messageCount: number;
+  sessionCount: number;
+  toolCallCount: number;
+}
+
+export interface DailyModelTokens {
+  date: string;
+  tokensByModel: Record<string, number>;
+}
+
+export interface ModelUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadInputTokens: number;
+  cacheCreationInputTokens: number;
+  webSearchRequests?: number;
+}
+
+// Spaces internal types
+export interface Project {
+  id: string;
+  name: string;
+  path: string;
+  claudePath: string;
+  agentType: string;
+  sessionCount: number;
+  lastActivity: string;
+}
+
+export interface SessionWithMeta {
+  id: string;
+  sessionId: string;
+  projectId: string;
+  projectName: string;
+  firstPrompt: string;
+  summary: string;
+  messageCount: number;
+  created: string;
+  modified: string;
+  gitBranch: string;
+  projectPath: string;
+  fullPath: string;
+  starred: boolean;
+  customName: string | null;
+  notes: string | null;
+  tags: string[];
+  workspaces: { id: number; name: string; color: string }[];
+  nodeId?: string;
+  nodeName?: string;
+  agentType: string;
+}
+
+export interface Workspace {
+  id: number;
+  name: string;
+  description: string;
+  color: string;
+  created: string;
+  sessionCount?: number;
+  isActive?: boolean;
+  collaboration?: boolean;
+  paneCount?: number;
+  nodeId?: string;
+  nodeName?: string;
+}
+
+export interface Tag {
+  id: number;
+  name: string;
+  color: string;
+}
+
+export interface SearchResult {
+  sessionId: string;
+  snippet: string;
+  rank: number;
+  projectName: string;
+  firstPrompt: string;
+  created: string;
+  nodeId?: string;
+  nodeName?: string;
+}
+
+export interface AnalyticsOverview {
+  totalSessions: number;
+  totalMessages: number;
+  totalProjects: number;
+  estimatedCost: number;
+  modelUsage: Record<string, ModelUsage>;
+  recentSessions: SessionWithMeta[];
+  dailyActivity: DailyActivity[];
+  dailyModelTokens: DailyModelTokens[];
+}

package/.next/standalone/src/types/network.ts

@@ -0,0 +1,61 @@
+export interface NodeRecord {
+  id: string;
+  name: string;
+  url: string;
+  apiKeyHint: string;
+  status: 'online' | 'offline' | 'error' | 'unknown';
+  lastSeen: string | null;
+  lastError: string | null;
+  sessionCount: number;
+  version: string | null;
+  discoveredVia: 'manual' | 'mdns';
+  created: string;
+  updated: string;
+}
+
+export interface ApiKeyRecord {
+  id: string;
+  name: string;
+  keyPrefix: string;
+  permissions: string;
+  lastUsed: string | null;
+  created: string;
+  expires: string | null;
+  username: string | null;
+}
+
+export interface NodeIdentity {
+  nodeId: string;
+  nodeName: string;
+  version: string;
+  createdAt: string;
+}
+
+export interface DiscoveredNode {
+  nodeId: string;
+  nodeName: string;
+  host: string;
+  port: number;
+  version: string;
+}
+
+export interface HandshakeResponse {
+  nodeId: string;
+  nodeName: string;
+  version: string;
+  sessionCount: number;
+  projectCount: number;
+  workspaceCount: number;
+}
+
+export interface ConnectionRequest {
+  id: string;
+  direction: 'incoming' | 'outgoing';
+  nodeId: string;
+  nodeName: string;
+  nodeUrl: string;
+  requestToken: string;
+  status: 'pending' | 'accepted' | 'denied' | 'expired';
+  created: string;
+  expires: string;
+}

package/.next/standalone/tests/setup.ts

@@ -0,0 +1,8 @@
+import { vi } from 'vitest';
+
+// Mock the auth module for tests - Cortex tests don't need real auth
+vi.mock('@/lib/auth', () => ({
+  getCurrentUser: () => 'test-user',
+  getAuthUser: () => 'test-user',
+  withUser: (_user: string, fn: () => any) => fn(),
+}));