gsd-pi 2.55.0-dev.9ec7cdf → 2.56.0-dev.603f970

package/packages/daemon/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../v4/mini/index.cjs"), exports);

package/packages/daemon/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/packages/daemon/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/packages/daemon/node_modules/zod/v4-mini/index.js

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/packages/daemon/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@gsd-build/daemon",
+  "version": "0.1.0",
+  "description": "GSD daemon — background process for project monitoring and Discord integration",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gsd-build/gsd-2.git",
+    "directory": "packages/daemon"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "gsd-daemon": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test dist/daemon.test.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@gsd-build/rpc-client": "^2.52.0",
+    "discord.js": "^14.25.1",
+    "yaml": "^2.8.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*"
+  ]
+}

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

@@ -0,0 +1,223 @@
+/**
+ * ChannelManager — manages per-project Discord text channels under a
+ * 'GSD Projects' category, with archive support.
+ *
+ * Pure helper `sanitizeChannelName` exported separately for testability.
+ */
+
+import {
+  ChannelType,
+  PermissionFlagsBits,
+  type Guild,
+  type CategoryChannel,
+  type TextChannel,
+  type GuildBasedChannel,
+} from 'discord.js';
+import type { Logger } from './logger.js';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CATEGORY_NAME = 'GSD Projects';
+const ARCHIVE_CATEGORY_NAME = 'GSD Archive';
+const CHANNEL_PREFIX = 'gsd-';
+const MAX_CHANNEL_NAME_LENGTH = 100; // Discord's limit
+
+// ---------------------------------------------------------------------------
+// Pure helpers — exported for testability
+// ---------------------------------------------------------------------------
+
+/**
+ * Sanitize a project directory path into a valid Discord channel name.
+ *
+ * - Takes the basename of the path
+ * - Lowercases
+ * - Replaces non-alphanumeric (except hyphens) with hyphens
+ * - Collapses consecutive hyphens
+ * - Trims leading/trailing hyphens
+ * - Prefixes with 'gsd-'
+ * - Caps total length at 100 chars (Discord limit)
+ *
+ * Returns 'gsd-unnamed' for empty/whitespace-only inputs.
+ */
+export function sanitizeChannelName(projectDir: string): string {
+  // Extract basename — handle both forward and back slashes
+  const parts = projectDir.replace(/\\/g, '/').split('/');
+  let basename = parts[parts.length - 1] ?? '';
+
+  // Trim whitespace
+  basename = basename.trim();
+
+  // Fallback for empty basename
+  if (!basename) {
+    return 'gsd-unnamed';
+  }
+
+  // Lowercase
+  let name = basename.toLowerCase();
+
+  // Replace non-alphanumeric (except hyphens) with hyphens
+  name = name.replace(/[^a-z0-9-]/g, '-');
+
+  // Collapse consecutive hyphens
+  name = name.replace(/-{2,}/g, '-');
+
+  // Trim leading/trailing hyphens
+  name = name.replace(/^-+|-+$/g, '');
+
+  // Fallback if nothing remains after sanitization
+  if (!name) {
+    return 'gsd-unnamed';
+  }
+
+  // Prefix
+  const prefixed = `${CHANNEL_PREFIX}${name}`;
+
+  // Cap at max length
+  if (prefixed.length > MAX_CHANNEL_NAME_LENGTH) {
+    // Truncate and remove any trailing hyphen from the cut
+    return prefixed.slice(0, MAX_CHANNEL_NAME_LENGTH).replace(/-+$/, '');
+  }
+
+  return prefixed;
+}
+
+// ---------------------------------------------------------------------------
+// ChannelManager class
+// ---------------------------------------------------------------------------
+
+export interface ChannelManagerOptions {
+  guild: Guild;
+  logger: Logger;
+  categoryName?: string;
+}
+
+export class ChannelManager {
+  private readonly guild: Guild;
+  private readonly logger: Logger;
+  private readonly categoryName: string;
+
+  private categoryCache: CategoryChannel | null = null;
+  private archiveCategoryCache: CategoryChannel | null = null;
+
+  constructor(opts: ChannelManagerOptions) {
+    this.guild = opts.guild;
+    this.logger = opts.logger;
+    this.categoryName = opts.categoryName ?? DEFAULT_CATEGORY_NAME;
+  }
+
+  /**
+   * Find or create the project category channel.
+   * Caches the result — subsequent calls return the cached category.
+   */
+  async resolveCategory(): Promise<CategoryChannel> {
+    if (this.categoryCache) {
+      return this.categoryCache;
+    }
+
+    const existing = this.findCategoryByName(this.categoryName);
+    if (existing) {
+      this.categoryCache = existing;
+      this.logger.debug('category resolved from cache', { name: this.categoryName, id: existing.id });
+      return existing;
+    }
+
+    // Create the category
+    const created = await this.guild.channels.create({
+      name: this.categoryName,
+      type: ChannelType.GuildCategory,
+    });
+
+    this.categoryCache = created as CategoryChannel;
+    this.logger.info('category created', { name: this.categoryName, id: created.id });
+    return this.categoryCache;
+  }
+
+  /**
+   * Create a text channel for a project under the GSD Projects category.
+   * Channel name is derived from the project directory path.
+   */
+  async createProjectChannel(projectDir: string): Promise<TextChannel> {
+    const name = sanitizeChannelName(projectDir);
+    const category = await this.resolveCategory();
+
+    const channel = await this.guild.channels.create({
+      name,
+      type: ChannelType.GuildText,
+      parent: category.id,
+    });
+
+    this.logger.info('project channel created', {
+      name,
+      channelId: channel.id,
+      categoryId: category.id,
+      projectDir,
+    });
+
+    return channel as TextChannel;
+  }
+
+  /**
+   * Archive a channel by moving it to the 'GSD Archive' category and
+   * setting permission overwrite to deny ViewChannel for @everyone.
+   */
+  async archiveChannel(channelId: string): Promise<void> {
+    const archive = await this.resolveArchiveCategory();
+
+    const channel = this.guild.channels.cache.get(channelId);
+    if (!channel) {
+      this.logger.warn('archive target not found', { channelId });
+      return;
+    }
+
+    if (!('edit' in channel) || typeof channel.edit !== 'function') {
+      this.logger.warn('archive target is not editable', { channelId, type: channel.type });
+      return;
+    }
+
+    await channel.edit({
+      parent: archive.id,
+      permissionOverwrites: [
+        {
+          id: this.guild.id, // @everyone role ID matches guild ID
+          deny: [PermissionFlagsBits.ViewChannel],
+        },
+      ],
+    });
+
+    this.logger.info('channel archived', { channelId, archiveCategoryId: archive.id });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  private findCategoryByName(name: string): CategoryChannel | null {
+    const match = this.guild.channels.cache.find(
+      (ch: GuildBasedChannel) => ch.type === ChannelType.GuildCategory && ch.name === name,
+    );
+    return (match as CategoryChannel) ?? null;
+  }
+
+  private async resolveArchiveCategory(): Promise<CategoryChannel> {
+    if (this.archiveCategoryCache) {
+      return this.archiveCategoryCache;
+    }
+
+    const existing = this.findCategoryByName(ARCHIVE_CATEGORY_NAME);
+    if (existing) {
+      this.archiveCategoryCache = existing;
+      return existing;
+    }
+
+    const created = await this.guild.channels.create({
+      name: ARCHIVE_CATEGORY_NAME,
+      type: ChannelType.GuildCategory,
+    });
+
+    this.archiveCategoryCache = created as CategoryChannel;
+    this.logger.info('archive category created', { name: ARCHIVE_CATEGORY_NAME, id: created.id });
+    return this.archiveCategoryCache;
+  }
+}

package/packages/daemon/src/cli.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { resolveConfigPath, loadConfig } from './config.js';
+import { Logger } from './logger.js';
+import { Daemon } from './daemon.js';
+
+const USAGE = `Usage: gsd-daemon [options]
+
+Options:
+  --config <path>  Path to YAML config file (default: ~/.gsd/daemon.yaml)
+  --verbose        Print log entries to stderr in addition to the log file
+  --help           Show this help message and exit
+`;
+
+async function main(): Promise<void> {
+  const { values } = parseArgs({
+    options: {
+      config: { type: 'string', short: 'c' },
+      verbose: { type: 'boolean', short: 'v', default: false },
+      help: { type: 'boolean', short: 'h', default: false },
+    },
+    strict: true,
+  });
+
+  if (values.help) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+
+  const configPath = resolveConfigPath(values.config);
+  const config = loadConfig(configPath);
+
+  const logger = new Logger({
+    filePath: config.log.file,
+    level: config.log.level,
+    verbose: values.verbose,
+  });
+
+  const daemon = new Daemon(config, logger);
+  await daemon.start();
+}
+
+main().catch((err: unknown) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`gsd-daemon: fatal: ${msg}\n`);
+  process.exit(1);
+});

package/packages/daemon/src/commands.ts

@@ -0,0 +1,110 @@
+/**
+ * Slash command definitions, guild-scoped registration, and status formatting.
+ *
+ * Commands are registered per-guild (not globally) for instant availability.
+ * Registration failures are non-fatal — the bot continues without slash commands.
+ */
+
+import {
+  SlashCommandBuilder,
+  REST,
+  Routes,
+  type RESTPostAPIChatInputApplicationCommandsJSONBody,
+} from 'discord.js';
+import type { ManagedSession } from './types.js';
+import type { Logger } from './logger.js';
+
+// ---------------------------------------------------------------------------
+// Command definitions
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the array of slash command JSON payloads for guild registration.
+ */
+export function buildCommands(): RESTPostAPIChatInputApplicationCommandsJSONBody[] {
+  return [
+    new SlashCommandBuilder()
+      .setName('gsd-status')
+      .setDescription('Show status of all active GSD sessions')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('gsd-start')
+      .setDescription('Start a new GSD session')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('gsd-stop')
+      .setDescription('Stop a running GSD session')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('gsd-verbose')
+      .setDescription('Set event verbosity level for this channel')
+      .addStringOption((option) =>
+        option
+          .setName('level')
+          .setDescription('Verbosity level')
+          .setRequired(false)
+          .addChoices(
+            { name: 'default', value: 'default' },
+            { name: 'verbose', value: 'verbose' },
+            { name: 'quiet', value: 'quiet' },
+          ),
+      )
+      .toJSON(),
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Guild-scoped registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register slash commands for a specific guild via PUT.
+ * Non-fatal: logs errors and returns false on failure.
+ */
+export async function registerGuildCommands(
+  rest: REST,
+  clientId: string,
+  guildId: string,
+  commands: RESTPostAPIChatInputApplicationCommandsJSONBody[],
+  logger?: Logger,
+): Promise<boolean> {
+  try {
+    await rest.put(
+      Routes.applicationGuildCommands(clientId, guildId),
+      { body: commands },
+    );
+    logger?.info('commands registered', { count: commands.length, guildId });
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger?.warn('command registration failed', {
+      guildId,
+      error: message,
+    });
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Status formatting
+// ---------------------------------------------------------------------------
+
+/**
+ * Format session list for /gsd-status reply.
+ * Shows projectName, status, duration, and cost for each session.
+ * Returns 'No active sessions.' if the array is empty.
+ */
+export function formatSessionStatus(sessions: ManagedSession[]): string {
+  if (sessions.length === 0) {
+    return 'No active sessions.';
+  }
+
+  const lines = sessions.map((s) => {
+    const durationMs = Date.now() - s.startTime;
+    const durationMin = Math.floor(durationMs / 60_000);
+    const cost = s.cost.totalCost.toFixed(4);
+    return `• **${s.projectName}** — ${s.status} (${durationMin}m, $${cost})`;
+  });
+
+  return lines.join('\n');
+}

package/packages/daemon/src/config.ts

@@ -0,0 +1,137 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import type { DaemonConfig, LogLevel } from './types.js';
+
+const VALID_LOG_LEVELS: ReadonlySet<string> = new Set(['debug', 'info', 'warn', 'error']);
+
+/** Expand leading ~ to the user's home directory. */
+function expandTilde(p: string): string {
+  if (p.startsWith('~/') || p === '~') {
+    return resolve(homedir(), p.slice(2) || '.');
+  }
+  return p;
+}
+
+/** Default config values when no file is present or fields are missing. */
+function defaults(): DaemonConfig {
+  return {
+    discord: undefined,
+    projects: { scan_roots: [] },
+    log: {
+      file: resolve(homedir(), '.gsd', 'daemon.log'),
+      level: 'info',
+      max_size_mb: 50,
+    },
+  };
+}
+
+/**
+ * Resolve the config file path.
+ * Priority: explicit CLI arg → GSD_DAEMON_CONFIG env → ~/.gsd/daemon.yaml
+ */
+export function resolveConfigPath(cliPath?: string): string {
+  if (cliPath) return expandTilde(cliPath);
+  const envPath = process.env['GSD_DAEMON_CONFIG'];
+  if (envPath) return expandTilde(envPath);
+  return resolve(homedir(), '.gsd', 'daemon.yaml');
+}
+
+/**
+ * Validate and normalise a raw parsed object into a DaemonConfig.
+ * Missing/invalid fields are filled with defaults. Invalid log level falls back to 'info'.
+ */
+export function validateConfig(raw: unknown): DaemonConfig {
+  const def = defaults();
+
+  if (raw == null || typeof raw !== 'object') return def;
+  const obj = raw as Record<string, unknown>;
+
+  // --- discord ---
+  let discord: DaemonConfig['discord'] = undefined;
+  if (obj['discord'] != null && typeof obj['discord'] === 'object') {
+    const d = obj['discord'] as Record<string, unknown>;
+    discord = {
+      token: typeof d['token'] === 'string' ? d['token'] : '',
+      guild_id: typeof d['guild_id'] === 'string' ? d['guild_id'] : '',
+      owner_id: typeof d['owner_id'] === 'string' ? d['owner_id'] : '',
+      ...(typeof d['dm_on_blocker'] === 'boolean' ? { dm_on_blocker: d['dm_on_blocker'] } : {}),
+      ...(typeof d['control_channel_id'] === 'string' ? { control_channel_id: d['control_channel_id'] } : {}),
+    };
+
+    // Parse orchestrator sub-block
+    if (d['orchestrator'] != null && typeof d['orchestrator'] === 'object') {
+      const orc = d['orchestrator'] as Record<string, unknown>;
+      discord.orchestrator = {
+        ...(typeof orc['model'] === 'string' ? { model: orc['model'] } : {}),
+        ...(typeof orc['max_tokens'] === 'number' && orc['max_tokens'] > 0 ? { max_tokens: orc['max_tokens'] } : {}),
+      };
+    }
+  }
+
+  // --- projects ---
+  let scanRoots: string[] = [];
+  if (obj['projects'] != null && typeof obj['projects'] === 'object') {
+    const p = obj['projects'] as Record<string, unknown>;
+    if (Array.isArray(p['scan_roots'])) {
+      scanRoots = (p['scan_roots'] as unknown[])
+        .filter((s): s is string => typeof s === 'string')
+        .map(expandTilde);
+    }
+  }
+
+  // --- log ---
+  let logFile = def.log.file;
+  let logLevel: LogLevel = def.log.level;
+  let maxSizeMb = def.log.max_size_mb;
+
+  if (obj['log'] != null && typeof obj['log'] === 'object') {
+    const l = obj['log'] as Record<string, unknown>;
+    if (typeof l['file'] === 'string') logFile = expandTilde(l['file']);
+    if (typeof l['level'] === 'string') {
+      logLevel = VALID_LOG_LEVELS.has(l['level']) ? (l['level'] as LogLevel) : 'info';
+    }
+    if (typeof l['max_size_mb'] === 'number' && l['max_size_mb'] > 0) {
+      maxSizeMb = l['max_size_mb'];
+    }
+  }
+
+  // --- env override: DISCORD_BOT_TOKEN ---
+  const envToken = process.env['DISCORD_BOT_TOKEN'];
+  if (envToken) {
+    if (!discord) {
+      discord = { token: envToken, guild_id: '', owner_id: '' };
+    } else {
+      discord = { ...discord, token: envToken };
+    }
+  }
+
+  return {
+    discord,
+    projects: { scan_roots: scanRoots },
+    log: { file: logFile, level: logLevel, max_size_mb: maxSizeMb },
+  };
+}
+
+/**
+ * Load and validate a DaemonConfig from a YAML file.
+ * If the file doesn't exist, returns defaults. If the file is malformed YAML, throws.
+ */
+export function loadConfig(configPath: string): DaemonConfig {
+  if (!existsSync(configPath)) {
+    // Still apply env-var overrides even when file is missing
+    return validateConfig(null);
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  let parsed: unknown;
+  try {
+    parsed = parseYaml(raw);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse YAML config at ${configPath}: ${msg}`);
+  }
+
+  return validateConfig(parsed);
+}