orbital-command 0.1.0

package/server/services/claude-session-service.ts

@@ -0,0 +1,441 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import type Database from 'better-sqlite3';
+import type { ScopeService } from './scope-service.js';
+import { getConfig, getClaudeSessionsDir } from '../config.js';
+
+export interface ClaudeSession {
+  id: string;
+  slug: string;
+  branch: string;
+  startedAt: string;
+  lastActiveAt: string;
+  summary: string | null;
+  fileSize: number;
+}
+
+export interface SessionStats {
+  /** Count of each JSONL line type */
+  typeCounts: Record<string, number>;
+  /** Fields extracted from 'user' lines */
+  user: {
+    totalMessages: number;
+    metaMessages: number;
+    toolResults: number;
+    commands: string[];
+    permissionModes: string[];
+    cwd: string | null;
+    version: string | null;
+  };
+  /** Fields extracted from 'assistant' lines */
+  assistant: {
+    totalMessages: number;
+    models: string[];
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCacheReadTokens: number;
+    totalCacheCreationTokens: number;
+    toolsUsed: Record<string, number>;
+  };
+  /** Fields extracted from 'system' lines */
+  system: {
+    totalMessages: number;
+    subtypes: string[];
+    stopReasons: string[];
+    totalDurationMs: number;
+    hookCount: number;
+    hookErrors: number;
+  };
+  /** Fields extracted from 'progress' lines */
+  progress: {
+    totalLines: number;
+  };
+  /** Timing */
+  timing: {
+    firstTimestamp: string | null;
+    lastTimestamp: string | null;
+    durationMs: number;
+  };
+}
+
+function getSessionsDir(): string {
+  return getClaudeSessionsDir(getConfig().projectRoot);
+}
+
+let cache: { sessions: ClaudeSession[]; expiry: number } | null = null;
+const CACHE_TTL_MS = 60_000;
+
+/**
+ * Extract metadata from a JSONL session file by reading the first few
+ * lines and the last line (avoids parsing the entire file).
+ */
+async function parseSessionFile(filePath: string): Promise<ClaudeSession | null> {
+  const stat = fs.statSync(filePath);
+  const filename = path.basename(filePath, '.jsonl');
+
+  let sessionId = filename;
+  let slug = '';
+  let branch = '';
+  let startedAt = '';
+  let summary: string | null = null;
+
+  // Read first 20 lines for metadata
+  const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  let lineNum = 0;
+
+  for await (const line of rl) {
+    if (lineNum > 20) break;
+    lineNum++;
+
+    try {
+      const data = JSON.parse(line);
+
+      if (data.sessionId && !sessionId) sessionId = data.sessionId;
+      if (data.slug && !slug) slug = data.slug;
+      if (data.gitBranch && !branch) branch = data.gitBranch;
+
+      // Capture the earliest timestamp
+      if (!startedAt) {
+        const ts =
+          data.timestamp ??
+          data.snapshot?.timestamp;
+        if (ts) startedAt = ts;
+      }
+
+      // If we have all fields, stop early
+      if (sessionId && slug && branch && startedAt) break;
+    } catch {
+      // skip unparseable lines
+    }
+  }
+
+  rl.close();
+  stream.destroy();
+
+  if (!sessionId) return null;
+
+  // Read file content for summary extraction
+  try {
+    const fullContent = fs.readFileSync(filePath, 'utf-8');
+    const lines = fullContent.trimEnd().split('\n');
+
+    // Prefer explicit summary line from Claude
+    const lastLine = JSON.parse(lines[lines.length - 1]);
+    if (lastLine.type === 'summary' && lastLine.summary) {
+      summary = lastLine.summary;
+    }
+
+    // Fall back to first user message
+    if (!summary) {
+      summary = extractFirstUserMessage(lines, 120);
+    }
+  } catch {
+    // ignore
+  }
+
+  return {
+    id: sessionId,
+    slug: slug || filename,
+    branch: branch || 'unknown',
+    startedAt: startedAt || stat.birthtime.toISOString(),
+    lastActiveAt: stat.mtime.toISOString(),
+    summary,
+    fileSize: stat.size,
+  };
+}
+
+export async function getClaudeSessions(since?: string): Promise<ClaudeSession[]> {
+  if (cache && Date.now() < cache.expiry) {
+    return filterSince(cache.sessions, since);
+  }
+
+  const sessionsDir = getSessionsDir();
+  if (!fs.existsSync(sessionsDir)) return [];
+
+  const files = fs
+    .readdirSync(sessionsDir)
+    .filter((f) => f.endsWith('.jsonl'))
+    .map((f) => path.join(sessionsDir, f));
+
+  const sessions: ClaudeSession[] = [];
+
+  for (const file of files) {
+    const session = await parseSessionFile(file);
+    if (session) sessions.push(session);
+  }
+
+  // Sort by most recent first
+  sessions.sort(
+    (a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime(),
+  );
+
+  cache = { sessions, expiry: Date.now() + CACHE_TTL_MS };
+  return filterSince(sessions, since);
+}
+
+function filterSince(sessions: ClaudeSession[], since?: string): ClaudeSession[] {
+  if (!since) return sessions;
+  const cutoff = new Date(since).getTime();
+  return sessions.filter((s) => new Date(s.lastActiveAt).getTime() >= cutoff);
+}
+
+/** Truncate text to max length with ellipsis */
+function truncate(text: string | null | undefined, max: number): string {
+  if (!text) return '';
+  return text.length > max ? text.slice(0, max) + '...' : text;
+}
+
+/**
+ * Extract a meaningful session name from JSONL lines.
+ *
+ * Priority:
+ * 1. First non-meta user message (what the user actually typed)
+ * 2. Slash command name from the first command-message (e.g. "/scope review 1")
+ * 3. null if nothing useful found
+ *
+ * Skips isMeta messages (skill prompts injected by the system),
+ * tool_result lines, and raw command XML.
+ */
+function extractFirstUserMessage(lines: string[], max: number): string | null {
+  let slashCommand: string | null = null;
+
+  for (const line of lines) {
+    try {
+      const data = JSON.parse(line);
+      if (data.type !== 'user') continue;
+
+      const content = data.message?.content;
+      let text = '';
+
+      if (typeof content === 'string') {
+        text = content;
+      } else if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block?.type === 'text' && typeof block.text === 'string') {
+            text = block.text;
+            break;
+          }
+        }
+      }
+
+      if (!text) continue;
+
+      // Capture slash command as fallback (e.g. "/scope review 1")
+      if (!slashCommand && text.includes('<command-name>')) {
+        const cmdMatch = text.match(/<command-name>\/?(.+?)<\/command-name>/);
+        const argsMatch = text.match(/<command-args>(.+?)<\/command-args>/);
+        if (cmdMatch) {
+          slashCommand = '/' + cmdMatch[1] + (argsMatch ? ' ' + argsMatch[1] : '');
+        }
+      }
+
+      // Skip system-injected lines: commands, meta/skill prompts, tool results
+      if (text.startsWith('<command') || text.startsWith('<tool_result')) continue;
+      if (data.isMeta) continue;
+
+      return truncate(text.trim(), max);
+    } catch {
+      // skip unparseable lines
+    }
+  }
+
+  return slashCommand ?? null;
+}
+
+/**
+ * Parse a full JSONL file and return detailed stats grouped by line type.
+ * This is heavier than parseSessionFile — only called for the detail view.
+ */
+export function getSessionStats(claudeSessionId: string): SessionStats | null {
+  const filePath = path.join(getSessionsDir(), `${claudeSessionId}.jsonl`);
+  if (!fs.existsSync(filePath)) return null;
+
+  const stats: SessionStats = {
+    typeCounts: {},
+    user: { totalMessages: 0, metaMessages: 0, toolResults: 0, commands: [], permissionModes: [], cwd: null, version: null },
+    assistant: { totalMessages: 0, models: [], totalInputTokens: 0, totalOutputTokens: 0, totalCacheReadTokens: 0, totalCacheCreationTokens: 0, toolsUsed: {} },
+    system: { totalMessages: 0, subtypes: [], stopReasons: [], totalDurationMs: 0, hookCount: 0, hookErrors: 0 },
+    progress: { totalLines: 0 },
+    timing: { firstTimestamp: null, lastTimestamp: null, durationMs: 0 },
+  };
+
+  let content: string;
+  try { content = fs.readFileSync(filePath, 'utf-8'); } catch { return null; }
+
+  const lines = content.trimEnd().split('\n');
+
+  for (const line of lines) {
+    let data: Record<string, unknown>;
+    try { data = JSON.parse(line); } catch { continue; }
+
+    const type = (data.type as string) ?? 'unknown';
+    stats.typeCounts[type] = (stats.typeCounts[type] ?? 0) + 1;
+
+    // Track timestamps
+    const ts = (data.timestamp as string) ?? null;
+    if (ts) {
+      if (!stats.timing.firstTimestamp) stats.timing.firstTimestamp = ts;
+      stats.timing.lastTimestamp = ts;
+    }
+
+    if (type === 'user') {
+      stats.user.totalMessages++;
+      if (data.isMeta) stats.user.metaMessages++;
+      if (data.toolUseResult) stats.user.toolResults++;
+      if (!stats.user.cwd && data.cwd) stats.user.cwd = data.cwd as string;
+      if (!stats.user.version && data.version) stats.user.version = data.version as string;
+
+      const pm = data.permissionMode as string | undefined;
+      if (pm && !stats.user.permissionModes.includes(pm)) stats.user.permissionModes.push(pm);
+
+      // Extract slash commands
+      const content = (data.message as Record<string, unknown>)?.content;
+      const text = typeof content === 'string' ? content : '';
+      const cmdMatch = text.match(/<command-name>\/?(.+?)<\/command-name>/);
+      if (cmdMatch) {
+        const cmd = '/' + cmdMatch[1];
+        if (!stats.user.commands.includes(cmd)) stats.user.commands.push(cmd);
+      }
+    }
+
+    if (type === 'assistant') {
+      stats.assistant.totalMessages++;
+      const msg = data.message as Record<string, unknown> | undefined;
+      if (msg) {
+        const model = msg.model as string | undefined;
+        if (model && !stats.assistant.models.includes(model)) stats.assistant.models.push(model);
+
+        const usage = msg.usage as Record<string, unknown> | undefined;
+        if (usage) {
+          stats.assistant.totalInputTokens += Number(usage.input_tokens) || 0;
+          stats.assistant.totalOutputTokens += Number(usage.output_tokens) || 0;
+          stats.assistant.totalCacheReadTokens += Number(usage.cache_read_input_tokens) || 0;
+          stats.assistant.totalCacheCreationTokens += Number(usage.cache_creation_input_tokens) || 0;
+        }
+
+        // Track tool usage
+        const msgContent = msg.content;
+        if (Array.isArray(msgContent)) {
+          for (const block of msgContent) {
+            if (block?.type === 'tool_use' && block.name) {
+              const name = block.name as string;
+              stats.assistant.toolsUsed[name] = (stats.assistant.toolsUsed[name] ?? 0) + 1;
+            }
+          }
+        }
+      }
+    }
+
+    if (type === 'system') {
+      stats.system.totalMessages++;
+      const subtype = data.subtype as string | undefined;
+      if (subtype && !stats.system.subtypes.includes(subtype)) stats.system.subtypes.push(subtype);
+      const stopReason = data.stopReason as string | undefined;
+      if (stopReason && !stats.system.stopReasons.includes(stopReason)) stats.system.stopReasons.push(stopReason);
+      stats.system.totalDurationMs += Number(data.durationMs) || 0;
+      stats.system.hookCount += Number(data.hookCount) || 0;
+      stats.system.hookErrors += Number(data.hookErrors) || 0;
+    }
+
+    if (type === 'progress') {
+      stats.progress.totalLines++;
+    }
+  }
+
+  // Compute session duration
+  if (stats.timing.firstTimestamp && stats.timing.lastTimestamp) {
+    stats.timing.durationMs = new Date(stats.timing.lastTimestamp).getTime() - new Date(stats.timing.firstTimestamp).getTime();
+  }
+
+  return stats;
+}
+
+/**
+ * Sync sessions into the DB from scope frontmatter.
+ *
+ * Algorithm:
+ * 1. Read scopes with non-empty sessions JSON from DB
+ * 2. For each scope, parse the sessions JSON: Record<phase, uuid[]>
+ * 3. For each (phase, uuid), UPSERT into sessions table with JSONL metadata if available
+ */
+export async function syncClaudeSessionsToDB(db: Database.Database, scopeService: ScopeService): Promise<number> {
+  cache = null; // Force fresh read from filesystem
+
+  const scopeRows = scopeService.getAll()
+    .filter(s => Object.keys(s.sessions).length > 0)
+    .map(s => ({ id: s.id, sessions: s.sessions }));
+
+  const upsert = db.prepare(`
+    INSERT INTO sessions (id, scope_id, claude_session_id, action, started_at, ended_at, summary, handoff_file, discoveries, next_steps)
+    VALUES (?, ?, ?, ?, ?, ?, ?, NULL, '[]', '[]')
+    ON CONFLICT(id) DO UPDATE SET
+      started_at = excluded.started_at,
+      ended_at = excluded.ended_at,
+      summary = excluded.summary,
+      claude_session_id = excluded.claude_session_id,
+      action = excluded.action
+  `);
+
+  let count = 0;
+
+  const insertAll = db.transaction(() => {
+    for (const row of scopeRows) {
+      for (const [phase, uuids] of Object.entries(row.sessions)) {
+        if (!Array.isArray(uuids)) continue;
+
+        for (const uuid of uuids) {
+          if (typeof uuid !== 'string' || !uuid) continue;
+
+          // Check if JSONL file exists for metadata enrichment
+          const jsonlPath = path.join(getSessionsDir(), `${uuid}.jsonl`);
+          let startedAt: string | null = null;
+          let endedAt: string | null = null;
+          let summary: string | null = null;
+
+          if (fs.existsSync(jsonlPath)) {
+            try {
+              const stat = fs.statSync(jsonlPath);
+              startedAt = stat.birthtime.toISOString();
+              endedAt = stat.mtime.toISOString();
+
+              const content = fs.readFileSync(jsonlPath, 'utf-8');
+              const lines = content.trimEnd().split('\n');
+
+              // Prefer explicit summary line from Claude
+              const lastLine = JSON.parse(lines[lines.length - 1]);
+              if (lastLine.type === 'summary' && lastLine.summary) {
+                summary = truncate(lastLine.summary, 200);
+              }
+
+              // Fall back to first user message
+              if (!summary) {
+                summary = extractFirstUserMessage(lines, 200);
+              }
+            } catch {
+              // Metadata unavailable — row still created with nulls
+            }
+          }
+
+          // Composite key includes phase so same UUID under different phases creates distinct rows
+          const compositeId = `${uuid}-scope-${row.id}-${phase}`;
+
+          upsert.run(
+            compositeId,
+            row.id,
+            uuid,
+            phase,
+            startedAt,
+            endedAt,
+            summary,
+          );
+          count++;
+        }
+      }
+    }
+  });
+
+  insertAll();
+  return count;
+}

package/server/services/config-service.ts

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import path from 'path';
+import matter from 'gray-matter';
+
+export interface ConfigFileNode {
+  name: string;
+  path: string;      // relative path from base
+  type: 'file' | 'folder';
+  children?: ConfigFileNode[];
+  frontmatter?: Record<string, unknown>;
+}
+
+export type ConfigPrimitiveType = 'agents' | 'skills' | 'hooks';
+
+const VALID_TYPES = new Set<ConfigPrimitiveType>(['agents', 'skills', 'hooks']);
+
+export function isValidPrimitiveType(type: string): type is ConfigPrimitiveType {
+  return VALID_TYPES.has(type as ConfigPrimitiveType);
+}
+
+export class ConfigService {
+  constructor(private projectRoot: string) {}
+
+  /** Resolve the base directory for a primitive type */
+  getBasePath(type: ConfigPrimitiveType): string {
+    switch (type) {
+      case 'agents':  return path.join(this.projectRoot, '.claude', 'agents');
+      case 'skills':  return path.join(this.projectRoot, '.claude', 'skills');
+      case 'hooks':   return path.join(this.projectRoot, '.claude', 'hooks');
+    }
+  }
+
+  /** Scan a directory tree and parse SKILL.md / agent frontmatter */
+  scanDirectory(basePath: string, parseFrontmatter = true): ConfigFileNode[] {
+    if (!fs.existsSync(basePath)) return [];
+    return this.walkDir(basePath, basePath, parseFrontmatter);
+  }
+
+  readFile(basePath: string, relativePath: string): string {
+    const resolved = this.validatePath(basePath, relativePath);
+    return fs.readFileSync(resolved, 'utf-8');
+  }
+
+  writeFile(basePath: string, relativePath: string, content: string): void {
+    const resolved = this.validatePath(basePath, relativePath);
+    if (!fs.existsSync(resolved)) {
+      throw new Error('File not found');
+    }
+    // Atomic write: write to .tmp, then rename
+    const tmpPath = resolved + '.tmp';
+    fs.writeFileSync(tmpPath, content, 'utf-8');
+    fs.renameSync(tmpPath, resolved);
+  }
+
+  createFile(basePath: string, relativePath: string, content: string): void {
+    const resolved = this.validatePath(basePath, relativePath);
+    if (fs.existsSync(resolved)) {
+      throw new Error('File already exists');
+    }
+    const dir = path.dirname(resolved);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(resolved, content, 'utf-8');
+  }
+
+  deleteFile(basePath: string, relativePath: string): void {
+    const resolved = this.validatePath(basePath, relativePath);
+    if (!fs.existsSync(resolved)) {
+      throw new Error('File not found');
+    }
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) {
+      throw new Error('Cannot delete a directory');
+    }
+    fs.unlinkSync(resolved);
+  }
+
+  renameFile(basePath: string, oldPath: string, newPath: string): void {
+    const resolvedOld = this.validatePath(basePath, oldPath);
+    const resolvedNew = this.validatePath(basePath, newPath);
+    if (!fs.existsSync(resolvedOld)) {
+      throw new Error('Source file not found');
+    }
+    if (fs.existsSync(resolvedNew)) {
+      throw new Error('Destination already exists');
+    }
+    const destDir = path.dirname(resolvedNew);
+    if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+    fs.renameSync(resolvedOld, resolvedNew);
+  }
+
+  createFolder(basePath: string, relativePath: string): void {
+    const resolved = this.validatePath(basePath, relativePath);
+    if (fs.existsSync(resolved)) {
+      throw new Error('Folder already exists');
+    }
+    fs.mkdirSync(resolved, { recursive: true });
+  }
+
+  // ─── Private Helpers ────────────────────────────────────
+
+  /** Path traversal validation — ensure resolved path is within basePath */
+  private validatePath(basePath: string, relativePath: string): string {
+    const resolvedBase = path.resolve(basePath);
+    const resolved = path.resolve(basePath, relativePath);
+    if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + path.sep)) {
+      throw new Error('Path traversal detected');
+    }
+    return resolved;
+  }
+
+  /** Recursively walk a directory and build a file tree */
+  private walkDir(currentPath: string, basePath: string, parseFrontmatter: boolean): ConfigFileNode[] {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    const nodes: ConfigFileNode[] = [];
+
+    for (const entry of entries) {
+      // Skip hidden files/dirs (e.g. .DS_Store)
+      if (entry.name.startsWith('.')) continue;
+
+      const fullPath = path.join(currentPath, entry.name);
+      const relPath = path.relative(basePath, fullPath);
+
+      if (entry.isDirectory()) {
+        const children = this.walkDir(fullPath, basePath, parseFrontmatter);
+        nodes.push({ name: entry.name, path: relPath, type: 'folder', children });
+      } else {
+        const node: ConfigFileNode = { name: entry.name, path: relPath, type: 'file' };
+        if (parseFrontmatter && entry.name.endsWith('.md')) {
+          try {
+            const content = fs.readFileSync(fullPath, 'utf-8');
+            const parsed = matter(content);
+            if (Object.keys(parsed.data).length > 0) {
+              node.frontmatter = parsed.data;
+            }
+          } catch {
+            // Skip frontmatter parsing errors
+          }
+        }
+        nodes.push(node);
+      }
+    }
+
+    // Sort: folders first, then files, alphabetical within each group
+    nodes.sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'folder' ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+
+    return nodes;
+  }
+}

package/server/services/deploy-service.ts

@@ -0,0 +1,98 @@
+import type Database from 'better-sqlite3';
+import type { Server } from 'socket.io';
+import type { DeployStatus, DeployEnvironment } from '../../shared/api-types.js';
+import { createLogger } from '../utils/logger.js';
+
+const log = createLogger('deploy');
+
+export interface DeployRecord {
+  environment: DeployEnvironment;
+  status: DeployStatus;
+  commit_sha: string | null;
+  branch: string | null;
+  pr_number: number | null;
+  health_check_url: string | null;
+  details: Record<string, unknown> | null;
+}
+
+export interface DeployRow {
+  id: number;
+  environment: DeployEnvironment;
+  status: DeployStatus;
+  commit_sha: string | null;
+  branch: string | null;
+  pr_number: number | null;
+  health_check_url: string | null;
+  started_at: string | null;
+  completed_at: string | null;
+  details: string;
+}
+
+export class DeployService {
+  constructor(
+    private db: Database.Database,
+    private io: Server
+  ) {}
+
+  /** Record a deployment event */
+  record(deploy: DeployRecord): number {
+    const now = new Date().toISOString();
+    const result = this.db.prepare(
+      `INSERT INTO deployments (environment, status, commit_sha, branch, pr_number, health_check_url, started_at, details)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      deploy.environment,
+      deploy.status,
+      deploy.commit_sha,
+      deploy.branch,
+      deploy.pr_number,
+      deploy.health_check_url,
+      now,
+      JSON.stringify(deploy.details ?? {})
+    );
+
+    const id = result.lastInsertRowid as number;
+    log.info('Deploy recorded', { id, env: deploy.environment, status: deploy.status, commit_sha: deploy.commit_sha, branch: deploy.branch });
+    const inserted = this.db.prepare('SELECT * FROM deployments WHERE id = ?').get(id);
+    if (inserted) {
+      this.io.emit('deploy:updated', inserted);
+    }
+
+    return id;
+  }
+
+  /** Update deployment status */
+  updateStatus(id: number, status: DeployStatus, details?: string): void {
+    const completedAt = (status === 'healthy' || status === 'failed' || status === 'rolled-back')
+      ? new Date().toISOString()
+      : null;
+
+    this.db.prepare(
+      `UPDATE deployments SET status = ?, completed_at = COALESCE(?, completed_at), details = COALESCE(?, details) WHERE id = ?`
+    ).run(status, completedAt, details, id);
+
+    log.info('Deploy status updated', { id, status });
+    const updated = this.db.prepare('SELECT * FROM deployments WHERE id = ?').get(id);
+    if (updated) {
+      this.io.emit('deploy:updated', updated);
+    }
+  }
+
+  /** Get recent deployments */
+  getRecent(limit: number = 20): DeployRow[] {
+    return this.db
+      .prepare('SELECT * FROM deployments ORDER BY started_at DESC LIMIT ?')
+      .all(limit) as DeployRow[];
+  }
+
+  /** Get latest deployment per environment */
+  getLatestPerEnv(): DeployRow[] {
+    return this.db.prepare(`
+      SELECT * FROM deployments
+      WHERE id IN (
+        SELECT MAX(id) FROM deployments GROUP BY environment
+      )
+      ORDER BY environment
+    `).all() as DeployRow[];
+  }
+}