gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/packages/daemon/src/daemon.test.ts

@@ -417,7 +417,110 @@ describe('Daemon', () => {
   });
 });
 
-// ---------- CLI integration ----------
+// ---------- Health heartbeat ----------
+
+describe('Health heartbeat', () => {
+  it('logs health entry with expected fields after interval tick', async () => {
+    const dir = tmpDir();
+    cleanupDirs.push(dir);
+    const logPath = join(dir, 'health.log');
+
+    const config: DaemonConfig = {
+      discord: undefined,
+      projects: { scan_roots: [] },
+      log: { file: logPath, level: 'info', max_size_mb: 50 },
+    };
+
+    const logger = new Logger({ filePath: logPath, level: 'info' });
+    // Use 50ms interval for fast test
+    const daemon = new Daemon(config, logger, 50);
+
+    await daemon.start();
+
+    // Wait for at least one health tick
+    await new Promise((r) => setTimeout(r, 120));
+
+    const origExit = process.exit;
+    // @ts-expect-error — overriding process.exit for test
+    process.exit = () => {};
+    try {
+      await daemon.shutdown();
+    } finally {
+      process.exit = origExit;
+    }
+
+    const content = readFileSync(logPath, 'utf-8');
+    const lines = content.trim().split('\n');
+    const healthLines = lines.filter((l) => {
+      const e: LogEntry = JSON.parse(l);
+      return e.msg === 'health';
+    });
+
+    assert.ok(healthLines.length >= 1, 'should have at least one health log entry');
+
+    const entry: LogEntry = JSON.parse(healthLines[0]!);
+    assert.equal(entry.msg, 'health');
+    assert.equal(typeof entry.data?.uptime_s, 'number');
+    assert.equal(typeof entry.data?.active_sessions, 'number');
+    assert.equal(typeof entry.data?.discord_connected, 'boolean');
+    assert.equal(typeof entry.data?.memory_rss_mb, 'number');
+    assert.equal(entry.data?.discord_connected, false); // no discord configured
+    assert.equal(entry.data?.active_sessions, 0); // no sessions
+  });
+
+  it('health timer is cleared on shutdown — no lingering intervals', async () => {
+    const dir = tmpDir();
+    cleanupDirs.push(dir);
+    const logPath = join(dir, 'health-cleanup.log');
+
+    const config: DaemonConfig = {
+      discord: undefined,
+      projects: { scan_roots: [] },
+      log: { file: logPath, level: 'info', max_size_mb: 50 },
+    };
+
+    const logger = new Logger({ filePath: logPath, level: 'info' });
+    // Use 50ms interval
+    const daemon = new Daemon(config, logger, 50);
+
+    await daemon.start();
+
+    // Wait for one tick
+    await new Promise((r) => setTimeout(r, 80));
+
+    const origExit = process.exit;
+    // @ts-expect-error — overriding process.exit for test
+    process.exit = () => {};
+    try {
+      await daemon.shutdown();
+    } finally {
+      process.exit = origExit;
+    }
+
+    // Count health entries at shutdown
+    const contentAtShutdown = readFileSync(logPath, 'utf-8');
+    const healthCountAtShutdown = contentAtShutdown
+      .trim()
+      .split('\n')
+      .filter((l) => JSON.parse(l).msg === 'health').length;
+
+    // Wait another interval — no new health entries should appear
+    await new Promise((r) => setTimeout(r, 120));
+
+    // Re-read (logger is closed, so file shouldn't change)
+    const contentAfterWait = readFileSync(logPath, 'utf-8');
+    const healthCountAfterWait = contentAfterWait
+      .trim()
+      .split('\n')
+      .filter((l) => JSON.parse(l).msg === 'health').length;
+
+    assert.equal(
+      healthCountAfterWait,
+      healthCountAtShutdown,
+      'no new health entries should appear after shutdown',
+    );
+  });
+});
 
 describe('CLI integration', () => {
   it('--help prints usage and exits 0', () => {

package/packages/daemon/src/daemon.ts

@@ -13,6 +13,7 @@ import { Orchestrator } from './orchestrator.js';
 export class Daemon {
   private shuttingDown = false;
   private keepaliveTimer: ReturnType<typeof setInterval> | undefined;
+  private healthTimer: ReturnType<typeof setInterval> | undefined;
   private readonly onSigterm: () => void;
   private readonly onSigint: () => void;
   private sessionManager: SessionManager | undefined;
@@ -23,6 +24,7 @@ export class Daemon {
   constructor(
     private readonly config: DaemonConfig,
     private readonly logger: Logger,
+    private readonly healthIntervalMs: number = 300_000,
   ) {
     this.onSigterm = () => void this.shutdown();
     this.onSigint = () => void this.shutdown();
@@ -80,7 +82,7 @@ export class Daemon {
               channelManager,
               scanProjects: () => this.scanProjects(),
               config: {
-                model: this.config.discord.orchestrator?.model ?? 'claude-sonnet-4-5-20250929',
+                model: this.config.discord.orchestrator?.model ?? 'claude-haiku-4-5-20251001',
                 max_tokens: this.config.discord.orchestrator?.max_tokens ?? 1024,
                 control_channel_id: this.config.discord.control_channel_id,
               },
@@ -105,6 +107,21 @@ export class Daemon {
         this.discordBot = undefined;
       }
     }
+
+    // Health heartbeat — logs uptime, session count, Discord status, memory
+    const startTime = Date.now();
+    this.healthTimer = setInterval(() => {
+      const sessions = this.sessionManager?.getAllSessions() ?? [];
+      const activeSessions = sessions.filter(
+        (s) => s.status === 'running' || s.status === 'blocked',
+      ).length;
+      this.logger.info('health', {
+        uptime_s: Math.floor((Date.now() - startTime) / 1000),
+        active_sessions: activeSessions,
+        discord_connected: !!this.discordBot?.getClient()?.isReady(),
+        memory_rss_mb: Math.round(process.memoryUsage().rss / 1024 / 1024),
+      });
+    }, this.healthIntervalMs);
   }
 
   /** Scan configured project roots for project directories. */
@@ -141,6 +158,12 @@ export class Daemon {
     process.removeListener('SIGTERM', this.onSigterm);
     process.removeListener('SIGINT', this.onSigint);
 
+    // Clear health heartbeat timer
+    if (this.healthTimer) {
+      clearInterval(this.healthTimer);
+      this.healthTimer = undefined;
+    }
+
     // Clear keepalive so the event loop can drain
     if (this.keepaliveTimer) {
       clearInterval(this.keepaliveTimer);

package/packages/daemon/src/discord-bot.ts

@@ -129,7 +129,73 @@ export class DiscordBot {
       this.handleInteraction(interaction);
     });
 
-    await client.login(this.config.token);
+    // Debug: log all incoming messages at debug level
+    client.on('messageCreate', (msg) => {
+      this.logger.debug('raw messageCreate', {
+        authorId: msg.author.id,
+        authorBot: msg.author.bot,
+        channelId: msg.channelId,
+        contentLength: msg.content.length,
+        hasContent: msg.content.length > 0,
+      });
+    });
+
+    // Reconnection observability — structured logging for all shard lifecycle events (R027)
+    client.on('shardError', (error) => {
+      this.logger.error('discord shard error', { error: error.message });
+    });
+    client.on('shardDisconnect', (event, shardId) => {
+      this.logger.warn('discord shard disconnected', { shardId, code: event.code });
+    });
+    client.on('shardReconnecting', (shardId) => {
+      this.logger.info('discord shard reconnecting', { shardId });
+    });
+    client.on('shardResume', (shardId, replayedEvents) => {
+      this.logger.info('discord shard resumed', { shardId, replayedEvents });
+    });
+    client.on('warn', (message) => {
+      this.logger.warn('discord warning', { message });
+    });
+    client.on('error', (error) => {
+      this.logger.error('discord error', { error: error.message });
+    });
+
+    // Wait for both login AND the 'ready' event.
+    // client.login() resolves on WebSocket auth, but the 'ready' event fires
+    // asynchronously later. We need 'ready' before getChannelManager() works.
+    let readyTimeout: ReturnType<typeof setTimeout> | undefined;
+    let readySettled = false;
+    const readyPromise = new Promise<void>((resolve, reject) => {
+      readyTimeout = setTimeout(() => {
+        if (!readySettled) { readySettled = true; reject(new Error('Discord ready timeout (30s)')); }
+      }, 30_000);
+      const cleanup = () => {
+        if (readyTimeout) { clearTimeout(readyTimeout); readyTimeout = undefined; }
+      };
+      client.once('ready', () => {
+        cleanup();
+        if (!readySettled) { readySettled = true; resolve(); }
+      });
+      client.once('error', (err) => {
+        cleanup();
+        if (!readySettled) { readySettled = true; reject(err); }
+      });
+      // shardDisconnect fires on fatal gateway errors (e.g. 4014 disallowed intents)
+      client.once('shardDisconnect', (event) => {
+        cleanup();
+        if (!readySettled) { readySettled = true; reject(new Error(`Shard disconnected: ${event.code}`)); }
+      });
+    });
+
+    try {
+      await client.login(this.config.token);
+    } catch (err) {
+      // Login itself failed — clean up the ready timer so it doesn't fire as unhandled rejection
+      if (readyTimeout) { clearTimeout(readyTimeout); readyTimeout = undefined; }
+      readySettled = true;
+      throw err;
+    }
+    await readyPromise;
     this.client = client;
     this.destroyed = false;
   }
@@ -331,16 +397,20 @@ export class DiscordBot {
       const projectPath = collected.values[0];
       this.logger.info('gsd-start: project selected', { projectPath });
 
+      // Defer the update immediately — startSession can take 10-30s to spawn the GSD process,
+      // and Discord's component interaction token expires in 3 seconds without deferral.
+      await collected.deferUpdate();
+
       try {
         const sessionId = await this.sessionManager.startSession({ projectDir: projectPath });
-        await collected.update({
+        await interaction.editReply({
           content: `✅ Session started for **${projectPath}** (ID: \`${sessionId}\`)`,
           components: [],
         });
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
         this.logger.error('gsd-start: startSession failed', { error: errMsg, projectPath });
-        await collected.update({
+        await interaction.editReply({
           content: `❌ Failed to start session: ${errMsg}`,
           components: [],
         });

package/packages/daemon/src/event-bridge.ts

@@ -417,17 +417,23 @@ export class EventBridge {
       return;
     }
 
-    // Otherwise, steer the session with the message content
-    if (session.status === 'running') {
-      try {
+    // Otherwise, relay the message to the GSD session
+    // Use steer() when running (injects mid-turn), prompt() otherwise (starts new turn)
+    try {
+      if (session.status === 'running') {
         await session.client.steer(message.content);
-        await message.react('📨').catch(() => {});
-        this.logger.info('bridge: message relayed to session', { sessionId });
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        this.logger.error('bridge: steer failed', { sessionId, error: errMsg });
-        await message.reply(`❌ Failed to relay message: ${errMsg}`).catch(() => {});
+      } else {
+        await session.client.prompt(message.content);
       }
+      await message.react('📨').catch(() => {});
+      this.logger.info('bridge: message relayed to session', {
+        sessionId,
+        method: session.status === 'running' ? 'steer' : 'prompt',
+      });
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      this.logger.error('bridge: relay failed', { sessionId, error: errMsg });
+      await message.reply(`❌ Failed to relay message: ${errMsg}`).catch(() => {});
     }
   }
 

package/packages/daemon/src/event-formatter.ts

@@ -102,14 +102,42 @@ export function formatToolEnd(event: SdkAgentEvent): FormattedEvent {
 export function formatMessage(event: SdkAgentEvent): FormattedEvent {
   // Extract text from content blocks or message field
   let text = '';
+
+  // Try content array first (most common for agent messages)
   if (Array.isArray(event.content)) {
     const blocks = event.content as Array<{ type?: string; text?: string }>;
     text = blocks
       .filter((b) => b.type === 'text' && typeof b.text === 'string')
       .map((b) => b.text!)
       .join('\n');
-  } else {
-    text = str(event.message || event.text || event.content);
+  }
+
+  // Try message field — could be string, object with content array, or object with text
+  if (!text && event.message != null) {
+    if (typeof event.message === 'string') {
+      text = event.message;
+    } else if (typeof event.message === 'object') {
+      const msg = event.message as Record<string, unknown>;
+      if (Array.isArray(msg.content)) {
+        const blocks = msg.content as Array<{ type?: string; text?: string }>;
+        text = blocks
+          .filter((b) => b.type === 'text' && typeof b.text === 'string')
+          .map((b) => b.text!)
+          .join('\n');
+      } else if (typeof msg.text === 'string') {
+        text = msg.text;
+      } else if (typeof msg.content === 'string') {
+        text = msg.content;
+      }
+    }
+  }
+
+  // Fallback to text or content as plain strings
+  if (!text) {
+    text = typeof event.text === 'string' ? event.text : '';
+  }
+  if (!text && typeof event.content === 'string') {
+    text = event.content;
   }
 
   if (!text) {

package/packages/daemon/src/index.ts

@@ -44,3 +44,12 @@ export {
   formatGenericEvent,
   formatEvent,
 } from './event-formatter.js';
+export {
+  escapeXml,
+  generatePlist,
+  getPlistPath,
+  install as installLaunchAgent,
+  uninstall as uninstallLaunchAgent,
+  status as launchAgentStatus,
+} from './launchd.js';
+export type { PlistOptions, LaunchdStatus, RunCommandFn } from './launchd.js';