gsd-pi 2.33.0 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/session-lock.ts

@@ -1,362 +0,0 @@
-/**
- * GSD Session Lock — OS-level exclusive locking for auto-mode sessions.
- *
- * Prevents multiple GSD processes from running auto-mode concurrently on
- * the same project. Uses proper-lockfile for OS-level file locking (flock/
- * lockfile) which eliminates the TOCTOU race condition that existed with
- * the old advisory JSON lock approach.
- *
- * The lock file (.gsd/auto.lock) contains JSON metadata (PID, start time,
- * unit info) for diagnostics, but the actual exclusion is enforced by the
- * OS-level lock held via proper-lockfile.
- *
- * Lifecycle:
- *   acquireSessionLock()  — called at the START of bootstrapAutoSession
- *   validateSessionLock() — called periodically during dispatch to detect takeover
- *   releaseSessionLock()  — called on clean stop/pause
- */
-
-import { createRequire } from "node:module";
-import { existsSync, readFileSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { atomicWriteSync } from "./atomic-write.js";
-
-const _require = createRequire(import.meta.url);
-
-// ─── Types ──────────────────────────────────────────────────────────────────
-
-export interface SessionLockData {
-  pid: number;
-  startedAt: string;
-  unitType: string;
-  unitId: string;
-  unitStartedAt: string;
-  completedUnits: number;
-  sessionFile?: string;
-}
-
-export type SessionLockResult =
-  | { acquired: true }
-  | { acquired: false; reason: string; existingPid?: number };
-
-// ─── Module State ───────────────────────────────────────────────────────────
-
-/** Release function from proper-lockfile — calling it releases the OS lock. */
-let _releaseFunction: (() => void) | null = null;
-
-/** The path we currently hold a lock on. */
-let _lockedPath: string | null = null;
-
-/** Our PID at lock acquisition time. */
-let _lockPid: number = 0;
-
-/** Set to true when proper-lockfile fires onCompromised (mtime drift, sleep, etc.). */
-let _lockCompromised: boolean = false;
-
-const LOCK_FILE = "auto.lock";
-
-function lockPath(basePath: string): string {
-  return join(gsdRoot(basePath), LOCK_FILE);
-}
-
-// ─── Public API ─────────────────────────────────────────────────────────────
-
-/**
- * Attempt to acquire an exclusive session lock for the given project.
- *
- * This uses proper-lockfile for OS-level file locking. If another process
- * already holds the lock, this returns { acquired: false } with details.
- *
- * The lock file also contains JSON metadata about the session for
- * diagnostic purposes (PID, unit info, etc.).
- */
-export function acquireSessionLock(basePath: string): SessionLockResult {
-  const lp = lockPath(basePath);
-
-  // Ensure the directory exists
-  mkdirSync(dirname(lp), { recursive: true });
-
-  // Write our lock data first (the content is informational; the OS lock is the real guard)
-  const lockData: SessionLockData = {
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    unitType: "starting",
-    unitId: "bootstrap",
-    unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
-  };
-
-  let lockfile: typeof import("proper-lockfile");
-  try {
-    lockfile = _require("proper-lockfile") as typeof import("proper-lockfile");
-  } catch {
-    // proper-lockfile not available — fall back to PID-based check
-    return acquireFallbackLock(basePath, lp, lockData);
-  }
-
-  const gsdDir = gsdRoot(basePath);
-
-  try {
-    // Try to acquire an exclusive OS-level lock on the lock file.
-    // We lock the directory (gsdRoot) since proper-lockfile works best
-    // on directories, and the lock file itself may not exist yet.
-    mkdirSync(gsdDir, { recursive: true });
-
-    const release = lockfile.lockSync(gsdDir, {
-      realpath: false,
-      stale: 1_800_000, // 30 minutes — safe for laptop sleep / long event loop stalls
-      update: 10_000, // Update lock mtime every 10s to prove liveness
-      onCompromised: () => {
-        // proper-lockfile detected mtime drift (system sleep, event loop stall, etc.).
-        // Default handler throws inside setTimeout — an uncaught exception that crashes
-        // or corrupts process state. Instead, set a flag so validateSessionLock() can
-        // detect the compromise gracefully on the next dispatch cycle.
-        _lockCompromised = true;
-        _releaseFunction = null;
-      },
-    });
-
-    _releaseFunction = release;
-    _lockedPath = basePath;
-    _lockPid = process.pid;
-    _lockCompromised = false;
-
-    // Safety net: clean up lock dir on process exit if _releaseFunction
-    // wasn't called (e.g., normal exit after clean completion) (#1245).
-    const lockDirForCleanup = join(gsdDir + ".lock");
-    process.once("exit", () => {
-      try {
-        if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
-      } catch { /* best-effort */ }
-      try {
-        if (existsSync(lockDirForCleanup)) rmSync(lockDirForCleanup, { recursive: true, force: true });
-      } catch { /* best-effort */ }
-    });
-
-    // Write the informational lock data
-    atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-
-    return { acquired: true };
-  } catch (err) {
-    // Lock is held by another process — or the .gsd.lock/ directory is stranded.
-    // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
-    const existingData = readExistingLockData(lp);
-    const existingPid = existingData?.pid;
-
-    // If no lock file or no alive process, try to clean up and re-acquire (#1245)
-    if (!existingData || (existingPid && !isPidAlive(existingPid))) {
-      try {
-        const lockDir = join(gsdDir + ".lock");
-        if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
-        if (existsSync(lp)) unlinkSync(lp);
-
-        // Retry acquisition after cleanup
-        const release = lockfile.lockSync(gsdDir, {
-          realpath: false,
-          stale: 1_800_000, // 30 minutes — match primary lock settings
-          update: 10_000,
-          onCompromised: () => {
-            _lockCompromised = true;
-          },
-        });
-        _releaseFunction = release;
-        _lockedPath = basePath;
-        _lockPid = process.pid;
-
-        // Safety net for retry path too
-        const retryLockDir = join(gsdDir + ".lock");
-        process.once("exit", () => {
-          try { if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; } } catch {}
-          try { if (existsSync(retryLockDir)) rmSync(retryLockDir, { recursive: true, force: true }); } catch {}
-        });
-
-        atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-        return { acquired: true };
-      } catch {
-        // Retry also failed — fall through to the error path
-      }
-    }
-
-    const reason = existingPid
-      ? `Another auto-mode session (PID ${existingPid}) appears to be running.\nStop it with \`kill ${existingPid}\` before starting a new session.`
-      : `Another auto-mode session is already running on this project.`;
-
-    return { acquired: false, reason, existingPid };
-  }
-}
-
-/**
- * Fallback lock acquisition when proper-lockfile is not available.
- * Uses PID-based liveness checking (the old approach, but with the lock
- * written BEFORE initialization rather than after).
- */
-function acquireFallbackLock(
-  basePath: string,
-  lp: string,
-  lockData: SessionLockData,
-): SessionLockResult {
-  // Check if an existing lock is held by a live process
-  const existing = readExistingLockData(lp);
-  if (existing && existing.pid !== process.pid) {
-    if (isPidAlive(existing.pid)) {
-      return {
-        acquired: false,
-        reason: `Another auto-mode session (PID ${existing.pid}) is already running on this project.`,
-        existingPid: existing.pid,
-      };
-    }
-    // Stale lock from dead process — we can take over
-  }
-
-  // Write our lock data
-  atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-  _lockedPath = basePath;
-  _lockPid = process.pid;
-
-  return { acquired: true };
-}
-
-/**
- * Update the lock file metadata (called on each unit dispatch).
- * Does NOT re-acquire the OS lock — just updates the JSON content.
- */
-export function updateSessionLock(
-  basePath: string,
-  unitType: string,
-  unitId: string,
-  completedUnits: number,
-  sessionFile?: string,
-): void {
-  if (_lockedPath !== basePath && _lockedPath !== null) return;
-
-  const lp = lockPath(basePath);
-  try {
-    const data: SessionLockData = {
-      pid: process.pid,
-      startedAt: new Date().toISOString(),
-      unitType,
-      unitId,
-      unitStartedAt: new Date().toISOString(),
-      completedUnits,
-      sessionFile,
-    };
-    atomicWriteSync(lp, JSON.stringify(data, null, 2));
-  } catch {
-    // Non-fatal: lock update failure
-  }
-}
-
-/**
- * Validate that we still own the session lock.
- *
- * Returns true if we still hold the lock, false if another process
- * has taken over (indicating we should gracefully stop).
- *
- * This is called periodically during the dispatch loop.
- */
-export function validateSessionLock(basePath: string): boolean {
-  // Lock was compromised by proper-lockfile (mtime drift from sleep, stall, etc.)
-  if (_lockCompromised) {
-    return false;
-  }
-
-  // If we have an OS-level lock, we're still the owner
-  if (_releaseFunction && _lockedPath === basePath) {
-    return true;
-  }
-
-  // Fallback: check the lock file PID
-  const lp = lockPath(basePath);
-  const existing = readExistingLockData(lp);
-  if (!existing) {
-    // Lock file was deleted — we lost ownership
-    return false;
-  }
-
-  return existing.pid === process.pid;
-}
-
-/**
- * Release the session lock. Called on clean stop/pause.
- */
-export function releaseSessionLock(basePath: string): void {
-  // Release the OS-level lock
-  if (_releaseFunction) {
-    try {
-      _releaseFunction();
-    } catch {
-      // Lock may already be released
-    }
-    _releaseFunction = null;
-  }
-
-  // Remove the lock file
-  const lp = lockPath(basePath);
-  try {
-    if (existsSync(lp)) unlinkSync(lp);
-  } catch {
-    // Non-fatal
-  }
-
-  // Remove the proper-lockfile directory (.gsd.lock/) if it exists.
-  // proper-lockfile creates this directory as the OS-level lock mechanism.
-  // If the process exits without calling _releaseFunction (SIGKILL, crash),
-  // this directory is stranded and blocks the next session (#1245).
-  try {
-    const lockDir = join(gsdRoot(basePath) + ".lock");
-    if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
-  } catch {
-    // Non-fatal
-  }
-
-  _lockedPath = null;
-  _lockPid = 0;
-  _lockCompromised = false;
-}
-
-/**
- * Check if a session lock exists and return its data (for crash recovery).
- * Does NOT acquire the lock.
- */
-export function readSessionLockData(basePath: string): SessionLockData | null {
-  return readExistingLockData(lockPath(basePath));
-}
-
-/**
- * Check if the process that wrote the lock is still alive.
- */
-export function isSessionLockProcessAlive(data: SessionLockData): boolean {
-  return isPidAlive(data.pid);
-}
-
-/**
- * Returns true if we currently hold a session lock for the given path.
- */
-export function isSessionLockHeld(basePath: string): boolean {
-  return _lockedPath === basePath && _lockPid === process.pid;
-}
-
-// ─── Internal Helpers ───────────────────────────────────────────────────────
-
-function readExistingLockData(lp: string): SessionLockData | null {
-  try {
-    if (!existsSync(lp)) return null;
-    const raw = readFileSync(lp, "utf-8");
-    return JSON.parse(raw) as SessionLockData;
-  } catch {
-    return null;
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  if (pid === process.pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "EPERM") return true;
-    return false;
-  }
-}

package/dist/resources/extensions/gsd/session-status-io.ts

@@ -1,179 +0,0 @@
-/**
- * GSD Session Status I/O
- *
- * File-based IPC protocol for coordinator-worker communication in
- * parallel milestone orchestration. Each worker writes its status to a
- * file; the coordinator reads all status files to monitor progress.
- *
- * Atomic writes (write to .tmp, then rename) prevent partial reads.
- * Signal files let the coordinator send pause/resume/stop/rebase to workers.
- * Stale detection combines PID liveness checks with heartbeat timeouts.
- */
-
-import {
-  unlinkSync,
-  readdirSync,
-  mkdirSync,
-  existsSync,
-} from "node:fs";
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
-import { loadJsonFileOrNull, writeJsonFileAtomic } from "./json-persistence.js";
-
-// ─── Types ─────────────────────────────────────────────────────────────────
-
-export interface SessionStatus {
-  milestoneId: string;
-  pid: number;
-  state: "running" | "paused" | "stopped" | "error";
-  currentUnit: { type: string; id: string; startedAt: number } | null;
-  completedUnits: number;
-  cost: number;
-  lastHeartbeat: number;
-  startedAt: number;
-  worktreePath: string;
-}
-
-export type SessionSignal = "pause" | "resume" | "stop" | "rebase";
-
-export interface SignalMessage {
-  signal: SessionSignal;
-  sentAt: number;
-  from: "coordinator";
-}
-
-// ─── Constants ─────────────────────────────────────────────────────────────
-
-const PARALLEL_DIR = "parallel";
-const STATUS_SUFFIX = ".status.json";
-const SIGNAL_SUFFIX = ".signal.json";
-const DEFAULT_STALE_TIMEOUT_MS = 30_000;
-
-function isSessionStatus(data: unknown): data is SessionStatus {
-  return data !== null && typeof data === "object" && "milestoneId" in data && "pid" in data;
-}
-
-function isSignalMessage(data: unknown): data is SignalMessage {
-  return data !== null && typeof data === "object" && "signal" in data && "sentAt" in data;
-}
-
-// ─── Helpers ───────────────────────────────────────────────────────────────
-
-function parallelDir(basePath: string): string {
-  return join(gsdRoot(basePath), PARALLEL_DIR);
-}
-
-function statusPath(basePath: string, milestoneId: string): string {
-  return join(parallelDir(basePath), `${milestoneId}${STATUS_SUFFIX}`);
-}
-
-function signalPath(basePath: string, milestoneId: string): string {
-  return join(parallelDir(basePath), `${milestoneId}${SIGNAL_SUFFIX}`);
-}
-
-function ensureParallelDir(basePath: string): void {
-  const dir = parallelDir(basePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ─── Status I/O ────────────────────────────────────────────────────────────
-
-/** Write session status atomically (write to .tmp, then rename). */
-export function writeSessionStatus(basePath: string, status: SessionStatus): void {
-  ensureParallelDir(basePath);
-  writeJsonFileAtomic(statusPath(basePath, status.milestoneId), status);
-}
-
-/** Read a specific milestone's session status. */
-export function readSessionStatus(basePath: string, milestoneId: string): SessionStatus | null {
-  return loadJsonFileOrNull(statusPath(basePath, milestoneId), isSessionStatus);
-}
-
-/** Read all session status files from .gsd/parallel/. */
-export function readAllSessionStatuses(basePath: string): SessionStatus[] {
-  const dir = parallelDir(basePath);
-  if (!existsSync(dir)) return [];
-
-  const results: SessionStatus[] = [];
-  try {
-    for (const entry of readdirSync(dir)) {
-      if (!entry.endsWith(STATUS_SUFFIX)) continue;
-      const status = loadJsonFileOrNull(join(dir, entry), isSessionStatus);
-      if (status) results.push(status);
-    }
-  } catch { /* non-fatal */ }
-  return results;
-}
-
-/** Remove a milestone's session status file. */
-export function removeSessionStatus(basePath: string, milestoneId: string): void {
-  try {
-    const p = statusPath(basePath, milestoneId);
-    if (existsSync(p)) unlinkSync(p);
-  } catch { /* non-fatal */ }
-}
-
-// ─── Signal I/O ────────────────────────────────────────────────────────────
-
-/** Write a signal file for a worker to consume. */
-export function sendSignal(basePath: string, milestoneId: string, signal: SessionSignal): void {
-  ensureParallelDir(basePath);
-  const msg: SignalMessage = { signal, sentAt: Date.now(), from: "coordinator" };
-  writeJsonFileAtomic(signalPath(basePath, milestoneId), msg);
-}
-
-/** Read and delete a signal file (atomic consume). Returns null if no signal pending. */
-export function consumeSignal(basePath: string, milestoneId: string): SignalMessage | null {
-  const p = signalPath(basePath, milestoneId);
-  const msg = loadJsonFileOrNull(p, isSignalMessage);
-  if (msg) {
-    try { unlinkSync(p); } catch { /* non-fatal */ }
-  }
-  return msg;
-}
-
-// ─── Stale Detection ───────────────────────────────────────────────────────
-
-/** Check whether a session is stale (PID dead or heartbeat timed out). */
-export function isSessionStale(
-  status: SessionStatus,
-  timeoutMs: number = DEFAULT_STALE_TIMEOUT_MS,
-): boolean {
-  if (!isPidAlive(status.pid)) return true;
-  const elapsed = Date.now() - status.lastHeartbeat;
-  return elapsed > timeoutMs;
-}
-
-/** Find and remove stale sessions. Returns the milestone IDs that were cleaned up. */
-export function cleanupStaleSessions(
-  basePath: string,
-  timeoutMs: number = DEFAULT_STALE_TIMEOUT_MS,
-): string[] {
-  const removed: string[] = [];
-  const statuses = readAllSessionStatuses(basePath);
-
-  for (const status of statuses) {
-    if (isSessionStale(status, timeoutMs)) {
-      removeSessionStatus(basePath, status.milestoneId);
-      // Also clean up any lingering signal file
-      try {
-        const sig = signalPath(basePath, status.milestoneId);
-        if (existsSync(sig)) unlinkSync(sig);
-      } catch { /* non-fatal */ }
-      removed.push(status.milestoneId);
-    }
-  }
-
-  return removed;
-}

package/dist/resources/extensions/gsd/skill-discovery.ts

@@ -1,139 +0,0 @@
-/**
- * GSD Skill Discovery
- *
- * Detects skills installed during auto-mode by comparing the current
- * skills directory against a snapshot taken at auto-mode start.
- *
- * New skills are injected into the system prompt via before_agent_start,
- * making them visible to all subsequent units without requiring a reload.
- */
-
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
-
-const SKILLS_DIR = join(getAgentDir(), "skills");
-
-export interface DiscoveredSkill {
-  name: string;
-  description: string;
-  location: string;
-}
-
-/** Snapshot of skill names at auto-mode start */
-let baselineSkills: Set<string> | null = null;
-
-/**
- * Snapshot the current skills directory. Call at auto-mode start.
- */
-export function snapshotSkills(): void {
-  baselineSkills = new Set(listSkillDirs());
-}
-
-/**
- * Clear the snapshot. Call when auto-mode stops.
- */
-export function clearSkillSnapshot(): void {
-  baselineSkills = null;
-}
-
-/**
- * Check if a snapshot is active (auto-mode is running with discovery).
- */
-export function hasSkillSnapshot(): boolean {
-  return baselineSkills !== null;
-}
-
-/**
- * Detect skills installed since the snapshot was taken.
- * Returns skill metadata for any new skills found.
- */
-export function detectNewSkills(): DiscoveredSkill[] {
-  if (!baselineSkills) return [];
-
-  const current = listSkillDirs();
-  const newSkills: DiscoveredSkill[] = [];
-
-  for (const dir of current) {
-    if (baselineSkills.has(dir)) continue;
-
-    const skillMdPath = join(SKILLS_DIR, dir, "SKILL.md");
-    if (!existsSync(skillMdPath)) continue;
-
-    const meta = parseSkillFrontmatter(skillMdPath);
-    if (meta) {
-      newSkills.push({
-        name: meta.name || dir,
-        description: meta.description || `Skill: ${dir}`,
-        location: skillMdPath,
-      });
-    }
-  }
-
-  return newSkills;
-}
-
-/**
- * Format discovered skills as an XML block matching pi's <available_skills> format.
- * This can be appended to the system prompt so the LLM sees them naturally.
- */
-export function formatSkillsXml(skills: DiscoveredSkill[]): string {
-  if (skills.length === 0) return "";
-
-  const entries = skills.map(s => `  <skill>
-    <name>${escapeXml(s.name)}</name>
-    <description>${escapeXml(s.description)}</description>
-    <location>${escapeXml(s.location)}</location>
-  </skill>`).join("\n");
-
-  return `\n<newly_discovered_skills>
-The following skills were installed during this auto-mode session.
-Use the read tool to load a skill's file when the task matches its description.
-
-${entries}
-</newly_discovered_skills>`;
-}
-
-// ─── Internals ────────────────────────────────────────────────────────────────
-
-function listSkillDirs(): string[] {
-  if (!existsSync(SKILLS_DIR)) return [];
-  try {
-    return readdirSync(SKILLS_DIR, { withFileTypes: true })
-      .filter(d => d.isDirectory())
-      .map(d => d.name);
-  } catch {
-    return [];
-  }
-}
-
-function parseSkillFrontmatter(path: string): { name?: string; description?: string } | null {
-  try {
-    const content = readFileSync(path, "utf-8");
-    // Use indexOf instead of [\s\S]*? regex to avoid backtracking (#468)
-    if (!content.startsWith('---\n')) return null;
-    const endIdx = content.indexOf('\n---', 4);
-    if (endIdx === -1) return null;
-
-    const fm = content.slice(4, endIdx);
-    const result: { name?: string; description?: string } = {};
-
-    const nameMatch = fm.match(/^name:\s*(.+)$/m);
-    if (nameMatch) result.name = nameMatch[1].trim();
-
-    const descMatch = fm.match(/^description:\s*(.+)$/m);
-    if (descMatch) result.description = descMatch[1].trim();
-
-    return result;
-  } catch {
-    return null;
-  }
-}
-
-function escapeXml(text: string): string {
-  return text
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}