gsd-pi 2.56.0-dev.b753b00 → 2.57.0-dev.f22a903

package/packages/daemon/src/session-manager.ts

@@ -0,0 +1,394 @@
+/**
+ * SessionManager — manages RpcClient lifecycle for daemon-driven GSD execution.
+ *
+ * Extends EventEmitter to emit typed session lifecycle events.
+ * One active session per projectDir. Tracks events in a ring buffer,
+ * detects blockers, tracks terminal state, and accumulates cost using
+ * the cumulative-max pattern (K004).
+ *
+ * Adapted from packages/mcp-server/src/session-manager.ts with:
+ * - Logger integration for structured logging
+ * - EventEmitter for session lifecycle events
+ * - getAllSessions() for cross-project status (R035)
+ * - projectName field on ManagedSession
+ */
+
+import { execSync } from 'node:child_process';
+import { basename, resolve } from 'node:path';
+import { EventEmitter } from 'node:events';
+import { RpcClient } from '@gsd-build/rpc-client';
+import type { SdkAgentEvent, RpcInitResult, RpcCostUpdateEvent, RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+import type {
+  ManagedSession,
+  StartSessionOptions,
+  PendingBlocker,
+} from './types.js';
+import { MAX_EVENTS, INIT_TIMEOUT_MS } from './types.js';
+import type { Logger } from './logger.js';
+
+// ---------------------------------------------------------------------------
+// Inlined detection logic (from headless-events.ts — no internal package imports)
+// ---------------------------------------------------------------------------
+
+const FIRE_AND_FORGET_METHODS = new Set([
+  'notify', 'setStatus', 'setWidget', 'setTitle', 'set_editor_text',
+]);
+
+const TERMINAL_PREFIXES = ['auto-mode stopped', 'step-mode stopped'];
+
+function isTerminalNotification(event: Record<string, unknown>): boolean {
+  if (event.type !== 'extension_ui_request' || event.method !== 'notify') return false;
+  const message = String(event.message ?? '').toLowerCase();
+  return TERMINAL_PREFIXES.some((prefix) => message.startsWith(prefix));
+}
+
+function isBlockedNotification(event: Record<string, unknown>): boolean {
+  if (event.type !== 'extension_ui_request' || event.method !== 'notify') return false;
+  const message = String(event.message ?? '').toLowerCase();
+  return message.includes('blocked:');
+}
+
+function isBlockingUIRequest(event: Record<string, unknown>): boolean {
+  if (event.type !== 'extension_ui_request') return false;
+  const method = String(event.method ?? '');
+  return !FIRE_AND_FORGET_METHODS.has(method);
+}
+
+// ---------------------------------------------------------------------------
+// SessionManager
+// ---------------------------------------------------------------------------
+
+export class SessionManager extends EventEmitter {
+  /** Sessions keyed by resolved projectDir for duplicate-start prevention */
+  private sessions = new Map<string, ManagedSession>();
+
+  constructor(private readonly logger: Logger) {
+    super();
+  }
+
+  /**
+   * Start a new GSD auto-mode session for the given project directory.
+   *
+   * Rejects if a session already exists for this projectDir.
+   * Creates an RpcClient, starts the process, performs the v2 init handshake,
+   * wires event tracking, and sends '/gsd auto' to begin execution.
+   */
+  async startSession(options: StartSessionOptions): Promise<string> {
+    const { projectDir } = options;
+
+    if (!projectDir || projectDir.trim() === '') {
+      throw new Error('projectDir is required and cannot be empty');
+    }
+
+    const resolvedDir = resolve(projectDir);
+    const projectName = basename(resolvedDir);
+
+    const existing = this.sessions.get(resolvedDir);
+    if (existing) {
+      throw new Error(
+        `Session already active for ${resolvedDir} (sessionId: ${existing.sessionId}, status: ${existing.status})`
+      );
+    }
+
+    const cliPath = options.cliPath ?? SessionManager.resolveCLIPath();
+
+    const args: string[] = ['--mode', 'rpc'];
+    if (options.model) args.push('--model', options.model);
+    if (options.bare) args.push('--bare');
+
+    const client = new RpcClient({
+      cliPath,
+      cwd: resolvedDir,
+      args,
+    });
+
+    // Build the session shell before async operations so we can track state
+    const session: ManagedSession = {
+      sessionId: '', // filled after init
+      projectDir: resolvedDir,
+      projectName,
+      status: 'starting',
+      client,
+      events: [],
+      pendingBlocker: null,
+      cost: { totalCost: 0, tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } },
+      startTime: Date.now(),
+    };
+
+    // Insert into map early (keyed by dir) so concurrent starts are rejected
+    this.sessions.set(resolvedDir, session);
+
+    try {
+      // Start the process with timeout
+      await Promise.race([
+        client.start(),
+        timeout(INIT_TIMEOUT_MS, `RpcClient.start() timed out after ${INIT_TIMEOUT_MS}ms`),
+      ]);
+
+      // Perform v2 init handshake
+      const initResult: RpcInitResult = await Promise.race([
+        client.init(),
+        timeout(INIT_TIMEOUT_MS, `RpcClient.init() timed out after ${INIT_TIMEOUT_MS}ms`),
+      ]) as RpcInitResult;
+
+      session.sessionId = initResult.sessionId;
+      session.status = 'running';
+
+      // Wire event tracking
+      session.unsubscribe = client.onEvent((event: SdkAgentEvent) => {
+        this.handleEvent(session, event);
+      });
+
+      // Kick off auto-mode
+      const command = options.command ?? '/gsd auto';
+      await client.prompt(command);
+
+      this.logger.info('session started', { sessionId: session.sessionId, projectDir: resolvedDir });
+      this.emit('session:started', { sessionId: session.sessionId, projectDir: resolvedDir, projectName });
+
+      return session.sessionId;
+    } catch (err) {
+      session.status = 'error';
+      session.error = err instanceof Error ? err.message : String(err);
+
+      // Attempt cleanup
+      try { await client.stop(); } catch { /* swallow cleanup errors */ }
+
+      this.logger.error('session error', { sessionId: session.sessionId, projectDir: resolvedDir, error: session.error });
+      this.emit('session:error', { sessionId: session.sessionId, projectDir: resolvedDir, projectName, error: session.error });
+
+      // Keep session in map so callers can inspect the error
+      throw new Error(`Failed to start session for ${resolvedDir}: ${session.error}`);
+    }
+  }
+
+  /**
+   * Look up a session by sessionId.
+   * Linear scan is fine — we expect <10 concurrent sessions.
+   */
+  getSession(sessionId: string): ManagedSession | undefined {
+    for (const session of this.sessions.values()) {
+      if (session.sessionId === sessionId) return session;
+    }
+    return undefined;
+  }
+
+  /**
+   * Look up a session by project directory (direct map lookup).
+   */
+  getSessionByDir(projectDir: string): ManagedSession | undefined {
+    return this.sessions.get(resolve(projectDir));
+  }
+
+  /**
+   * Return all tracked sessions (R035 — cross-project status).
+   */
+  getAllSessions(): ManagedSession[] {
+    return Array.from(this.sessions.values());
+  }
+
+  /**
+   * Resolve a pending blocker by sending a UI response.
+   */
+  async resolveBlocker(sessionId: string, response: string): Promise<void> {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    if (!session.pendingBlocker) throw new Error(`No pending blocker for session ${sessionId}`);
+
+    const blocker = session.pendingBlocker;
+    session.client.sendUIResponse(blocker.id, { value: response });
+    session.pendingBlocker = null;
+    if (session.status === 'blocked') {
+      session.status = 'running';
+    }
+
+    this.logger.info('blocker resolved', {
+      sessionId,
+      projectDir: session.projectDir,
+      blockerId: blocker.id,
+      blockerMethod: blocker.method,
+    });
+  }
+
+  /**
+   * Cancel a running session — abort current operation then stop the process.
+   */
+  async cancelSession(sessionId: string): Promise<void> {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+    try {
+      await session.client.abort();
+    } catch { /* may already be stopped */ }
+
+    try {
+      await session.client.stop();
+    } catch { /* swallow */ }
+
+    session.status = 'cancelled';
+    session.unsubscribe?.();
+
+    this.logger.info('session cancelled', { sessionId, projectDir: session.projectDir });
+  }
+
+  /**
+   * Build a HeadlessJsonResult-shaped object from accumulated session state.
+   */
+  getResult(sessionId: string): Record<string, unknown> {
+    const session = this.getSession(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+    const durationMs = Date.now() - session.startTime;
+
+    return {
+      sessionId: session.sessionId,
+      projectDir: session.projectDir,
+      projectName: session.projectName,
+      status: session.status,
+      durationMs,
+      cost: session.cost,
+      recentEvents: session.events.slice(-10),
+      pendingBlocker: session.pendingBlocker
+        ? { id: session.pendingBlocker.id, method: session.pendingBlocker.method, message: session.pendingBlocker.message }
+        : null,
+      error: session.error ?? null,
+    };
+  }
+
+  /**
+   * Stop all active sessions and clean up resources.
+   */
+  async cleanup(): Promise<void> {
+    const stopPromises: Promise<void>[] = [];
+
+    for (const session of this.sessions.values()) {
+      session.unsubscribe?.();
+      if (session.status === 'running' || session.status === 'starting' || session.status === 'blocked') {
+        stopPromises.push(
+          session.client.stop().catch(() => { /* swallow */ })
+        );
+        session.status = 'cancelled';
+      }
+    }
+
+    await Promise.allSettled(stopPromises);
+  }
+
+  /**
+   * Resolve the GSD CLI path.
+   *
+   * 1. GSD_CLI_PATH env var (highest priority)
+   * 2. `which gsd` → resolve to the actual dist/cli.js
+   */
+  static resolveCLIPath(): string {
+    const envPath = process.env['GSD_CLI_PATH'];
+    if (envPath) return resolve(envPath);
+
+    try {
+      const gsdBin = execSync('which gsd', { encoding: 'utf-8' }).trim();
+      if (gsdBin) return resolve(gsdBin);
+    } catch {
+      // which failed
+    }
+
+    throw new Error(
+      'Cannot find GSD CLI. Set GSD_CLI_PATH environment variable or ensure `gsd` is in PATH.'
+    );
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private: Event Handling
+  // ---------------------------------------------------------------------------
+
+  private handleEvent(session: ManagedSession, event: SdkAgentEvent): void {
+    // Ring buffer: push and trim
+    session.events.push(event);
+    if (session.events.length > MAX_EVENTS) {
+      session.events.splice(0, session.events.length - MAX_EVENTS);
+    }
+
+    // Forward event to listeners
+    this.logger.debug('session event', { sessionId: session.sessionId, type: (event as Record<string, unknown>).type as string });
+    this.emit('session:event', { sessionId: session.sessionId, projectDir: session.projectDir, event });
+
+    // Cost tracking (K004 — cumulative-max)
+    if ((event as Record<string, unknown>).type === 'cost_update') {
+      const costEvent = event as unknown as RpcCostUpdateEvent;
+      session.cost.totalCost = Math.max(session.cost.totalCost, costEvent.cumulativeCost ?? 0);
+      if (costEvent.tokens) {
+        session.cost.tokens.input = Math.max(session.cost.tokens.input, costEvent.tokens.input ?? 0);
+        session.cost.tokens.output = Math.max(session.cost.tokens.output, costEvent.tokens.output ?? 0);
+        session.cost.tokens.cacheRead = Math.max(session.cost.tokens.cacheRead, costEvent.tokens.cacheRead ?? 0);
+        session.cost.tokens.cacheWrite = Math.max(session.cost.tokens.cacheWrite, costEvent.tokens.cacheWrite ?? 0);
+      }
+    }
+
+    // Terminal detection — auto-mode/step-mode stopped
+    if (isTerminalNotification(event as Record<string, unknown>)) {
+      if (isBlockedNotification(event as Record<string, unknown>)) {
+        session.status = 'blocked';
+        session.pendingBlocker = extractBlocker(event);
+        this.logger.info('session blocked', {
+          sessionId: session.sessionId,
+          projectDir: session.projectDir,
+          blockerId: session.pendingBlocker.id,
+          blockerMethod: session.pendingBlocker.method,
+        });
+        this.emit('session:blocked', {
+          sessionId: session.sessionId,
+          projectDir: session.projectDir,
+          projectName: session.projectName,
+          blocker: session.pendingBlocker,
+        });
+      } else {
+        session.status = 'completed';
+        session.unsubscribe?.();
+        this.logger.info('session completed', { sessionId: session.sessionId, projectDir: session.projectDir });
+        this.emit('session:completed', {
+          sessionId: session.sessionId,
+          projectDir: session.projectDir,
+          projectName: session.projectName,
+        });
+      }
+      return;
+    }
+
+    // Blocker detection — non-fire-and-forget extension_ui_request
+    if (isBlockingUIRequest(event as Record<string, unknown>)) {
+      session.status = 'blocked';
+      session.pendingBlocker = extractBlocker(event);
+      this.logger.info('session blocked', {
+        sessionId: session.sessionId,
+        projectDir: session.projectDir,
+        blockerId: session.pendingBlocker.id,
+        blockerMethod: session.pendingBlocker.method,
+      });
+      this.emit('session:blocked', {
+        sessionId: session.sessionId,
+        projectDir: session.projectDir,
+        projectName: session.projectName,
+        blocker: session.pendingBlocker,
+      });
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function timeout(ms: number, message: string): Promise<never> {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(message)), ms);
+  });
+}
+
+function extractBlocker(event: SdkAgentEvent): PendingBlocker {
+  const uiEvent = event as unknown as RpcExtensionUIRequest;
+  return {
+    id: String(uiEvent.id ?? ''),
+    method: String(uiEvent.method ?? ''),
+    message: String((uiEvent as Record<string, unknown>).title ?? (uiEvent as Record<string, unknown>).message ?? ''),
+    event: uiEvent,
+  };
+}

package/packages/daemon/src/types.ts

@@ -0,0 +1,199 @@
+import type { RpcClient, SdkAgentEvent, RpcExtensionUIRequest } from '@gsd-build/rpc-client';
+
+/**
+ * Log severity levels, ordered from most to least verbose.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+/**
+ * Per-channel verbosity for Discord event streaming.
+ * - 'default': tool calls, messages, transitions, blockers, errors, completions
+ * - 'verbose': everything including cost_update and status events
+ * - 'quiet': only blockers, errors, completions
+ */
+export type VerbosityLevel = 'default' | 'verbose' | 'quiet';
+
+/**
+ * A single structured log entry written as JSON-lines.
+ */
+export interface LogEntry {
+  /** ISO-8601 timestamp */
+  ts: string;
+  level: LogLevel;
+  msg: string;
+  data?: Record<string, unknown>;
+}
+
+/**
+ * Top-level daemon configuration, loaded from YAML.
+ */
+export interface DaemonConfig {
+  discord?: {
+    token: string;
+    guild_id: string;
+    owner_id: string;
+    /** When true, DM the owner on blocker events in addition to channel messages */
+    dm_on_blocker?: boolean;
+    /** Discord channel ID where the orchestrator listens for natural language commands */
+    control_channel_id?: string;
+    /** LLM orchestrator settings */
+    orchestrator?: {
+      model?: string;
+      max_tokens?: number;
+    };
+  };
+  projects: {
+    scan_roots: string[];
+  };
+  log: {
+    file: string;
+    level: LogLevel;
+    max_size_mb: number;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Session Status
+// ---------------------------------------------------------------------------
+
+export type SessionStatus = 'starting' | 'running' | 'blocked' | 'completed' | 'error' | 'cancelled';
+
+// ---------------------------------------------------------------------------
+// Managed Session
+// ---------------------------------------------------------------------------
+
+/**
+ * A daemon-managed GSD headless session.
+ */
+export interface ManagedSession {
+  /** Unique session ID returned from RpcClient.init() */
+  sessionId: string;
+
+  /** Absolute path to the project directory */
+  projectDir: string;
+
+  /** Human-readable project name (basename of projectDir) */
+  projectName: string;
+
+  /** Current lifecycle status */
+  status: SessionStatus;
+
+  /** The RpcClient instance managing the agent process */
+  client: RpcClient;
+
+  /** Ring buffer of recent events (capped at MAX_EVENTS) */
+  events: SdkAgentEvent[];
+
+  /** Pending blocker requiring user response, if any */
+  pendingBlocker: PendingBlocker | null;
+
+  /** Cumulative cost tracking (max pattern per K004) */
+  cost: CostAccumulator;
+
+  /** Session start timestamp */
+  startTime: number;
+
+  /** Error message if status is 'error' */
+  error?: string;
+
+  /** Cleanup function to unsubscribe from events */
+  unsubscribe?: () => void;
+}
+
+// ---------------------------------------------------------------------------
+// Pending Blocker
+// ---------------------------------------------------------------------------
+
+export interface PendingBlocker {
+  /** The extension_ui_request id */
+  id: string;
+
+  /** The request method (e.g. 'select', 'confirm', 'input') */
+  method: string;
+
+  /** Human-readable message or title */
+  message: string;
+
+  /** Full event payload for inspection */
+  event: RpcExtensionUIRequest;
+}
+
+// ---------------------------------------------------------------------------
+// Cost Accumulator (K004 — cumulative-max)
+// ---------------------------------------------------------------------------
+
+export interface CostAccumulator {
+  totalCost: number;
+  tokens: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Project Info — scanner output
+// ---------------------------------------------------------------------------
+
+/** Marker types detectable by the project scanner */
+export type ProjectMarker = 'git' | 'node' | 'gsd' | 'rust' | 'python' | 'go';
+
+export interface ProjectInfo {
+  /** Directory name (basename) */
+  name: string;
+
+  /** Absolute path to the project directory */
+  path: string;
+
+  /** Detected marker types */
+  markers: ProjectMarker[];
+
+  /** Most recent mtime of detected marker files/dirs (epoch ms) */
+  lastModified: number;
+}
+
+// ---------------------------------------------------------------------------
+// Start Session Options
+// ---------------------------------------------------------------------------
+
+export interface StartSessionOptions {
+  /** Absolute path to the project directory */
+  projectDir: string;
+
+  /** Command to send after '/gsd auto' (default: none) */
+  command?: string;
+
+  /** Model ID override */
+  model?: string;
+
+  /** Run in bare mode (skip user config) */
+  bare?: boolean;
+
+  /** Path to CLI binary (overrides GSD_CLI_PATH and which resolution) */
+  cliPath?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Formatted Event — output of event-formatter.ts
+// ---------------------------------------------------------------------------
+
+/**
+ * Formatted Discord message payload for a GSD event.
+ * content is the plain-text fallback; embeds and components are optional.
+ */
+export interface FormattedEvent {
+  content: string;
+  embed?: import('discord.js').EmbedBuilder;
+  components?: import('discord.js').ActionRowBuilder<import('discord.js').ButtonBuilder>[];
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+/** Maximum number of events kept in the ring buffer (larger than mcp-server's 50 — daemon forwards events to Discord) */
+export const MAX_EVENTS = 100;
+
+/** Timeout for RpcClient initialization (ms) */
+export const INIT_TIMEOUT_MS = 30_000;