gsd-pi 2.28.0-dev.b23c118 → 2.28.0-dev.e19bf89

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

@@ -1,284 +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 } 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;
-
-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);
-  }
-
-  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.
-    const gsdDir = gsdRoot(basePath);
-    mkdirSync(gsdDir, { recursive: true });
-
-    const release = lockfile.lockSync(gsdDir, {
-      realpath: false,
-      stale: 300_000, // 5 minutes — consider lock stale if holder hasn't updated
-      update: 10_000, // Update lock mtime every 10s to prove liveness
-    });
-
-    _releaseFunction = release;
-    _lockedPath = basePath;
-    _lockPid = process.pid;
-
-    // Write the informational lock data
-    atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-
-    return { acquired: true };
-  } catch (err) {
-    // Lock is held by another process
-    const existingData = readExistingLockData(lp);
-    const existingPid = existingData?.pid;
-    const reason = existingPid
-      ? `Another auto-mode session (PID ${existingPid}) is already running on this project.`
-      : `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 {
-  // 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
-  }
-
-  _lockedPath = null;
-  _lockPid = 0;
-}
-
-/**
- * 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/tests/commands-logs.test.ts

@@ -1,241 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, writeFileSync, rmSync, existsSync, utimesSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { handleLogs } from "../commands-logs.ts";
-
-// ─── Test helpers ───────────────────────────────────────────────────────────
-
-function createTestDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-logs-test-"));
-  mkdirSync(join(dir, ".gsd", "activity"), { recursive: true });
-  mkdirSync(join(dir, ".gsd", "debug"), { recursive: true });
-  return dir;
-}
-
-function createMockCtx(): { notifications: Array<{ msg: string; level: string }>; ui: any } {
-  const notifications: Array<{ msg: string; level: string }> = [];
-  return {
-    notifications,
-    ui: {
-      notify(msg: string, level: string) { notifications.push({ msg, level }); },
-      setStatus() {},
-      setWidget() {},
-      setFooter() {},
-    },
-  };
-}
-
-function writeActivityLog(dir: string, seq: number, unitType: string, unitId: string, entries: Record<string, unknown>[]): void {
-  const safeId = unitId.replace(/\//g, "-");
-  const filename = `${String(seq).padStart(3, "0")}-${unitType}-${safeId}.jsonl`;
-  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
-  writeFileSync(join(dir, ".gsd", "activity", filename), content);
-}
-
-function writeDebugLog(dir: string, name: string, entries: Record<string, unknown>[]): void {
-  const content = entries.map(e => JSON.stringify(e)).join("\n") + "\n";
-  writeFileSync(join(dir, ".gsd", "debug", name), content);
-}
-
-// ─── Tests ──────────────────────────────────────────────────────────────────
-
-test("logs shows empty state message when no logs exist", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-  try {
-    await handleLogs("", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    assert.ok(ctx.notifications[0].msg.includes("No logs found"));
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs lists activity logs", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
-    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
-    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
-  ]);
-  writeActivityLog(dir, 2, "complete-slice", "M001/S01", [
-    { role: "assistant", content: "Completing slice S01" },
-  ]);
-
-  try {
-    await handleLogs("", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    const msg = ctx.notifications[0].msg;
-    assert.ok(msg.includes("Activity Logs"), "should show activity logs header");
-    assert.ok(msg.includes("execute-task"), "should show unit type");
-    assert.ok(msg.includes("complete-slice"), "should show second log");
-    assert.ok(msg.includes("/gsd logs <#>"), "should show usage hint");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs <N> shows activity log details", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
-    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
-    { type: "toolCall", name: "write", arguments: { file_path: "/tmp/test.ts" } },
-    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: false },
-    { role: "toolResult", toolCallId: "2", toolName: "write", isError: true },
-    { role: "assistant", content: "I ran the tests and wrote a file" },
-  ]);
-
-  try {
-    await handleLogs("1", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    const msg = ctx.notifications[0].msg;
-    assert.ok(msg.includes("Activity Log #1"), "should show log number");
-    assert.ok(msg.includes("execute-task"), "should show unit type");
-    assert.ok(msg.includes("Tool calls: 2"), "should count tool calls");
-    assert.ok(msg.includes("Errors: 1"), "should count errors");
-    assert.ok(msg.includes("/tmp/test.ts"), "should show files written");
-    assert.ok(msg.includes("npm test"), "should show commands run");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs <N> shows not found for invalid seq", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  try {
-    await handleLogs("999", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    assert.ok(ctx.notifications[0].msg.includes("not found"));
-    assert.equal(ctx.notifications[0].level, "warning");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs debug lists debug logs", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
-    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
-    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
-  ]);
-
-  try {
-    await handleLogs("debug", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    const msg = ctx.notifications[0].msg;
-    assert.ok(msg.includes("Debug Logs"), "should show debug logs header");
-    assert.ok(msg.includes("debug-2026-03-18T10-30-00.log"), "should show filename");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs debug <N> shows debug log summary", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  writeDebugLog(dir, "debug-2026-03-18T10-30-00.log", [
-    { ts: "2026-03-18T10:30:00Z", event: "debug-start", platform: "darwin" },
-    { ts: "2026-03-18T10:30:05Z", event: "dispatch-error", error: "missing plan" },
-    { ts: "2026-03-18T10:35:00Z", event: "debug-summary", dispatches: 5 },
-  ]);
-
-  try {
-    await handleLogs("debug 1", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    const msg = ctx.notifications[0].msg;
-    assert.ok(msg.includes("Debug Log:"), "should show debug log header");
-    assert.ok(msg.includes("Events: 3"), "should count events");
-    assert.ok(msg.includes("Dispatches: 5"), "should show dispatch count");
-    assert.ok(msg.includes("dispatch-error"), "should show errors");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs tail shows recent activity summaries", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [
-    { type: "toolCall", name: "bash", arguments: { command: "npm test" } },
-  ]);
-  writeActivityLog(dir, 2, "execute-task", "M001/S01/T02", [
-    { type: "toolCall", name: "bash", arguments: { command: "npm build" } },
-    { role: "toolResult", toolCallId: "1", toolName: "bash", isError: true },
-  ]);
-
-  try {
-    await handleLogs("tail 2", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    const msg = ctx.notifications[0].msg;
-    assert.ok(msg.includes("Last 2 activity log(s)"), "should show count");
-    assert.ok(msg.includes("#1"), "should show first log");
-    assert.ok(msg.includes("#2"), "should show second log");
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("logs clear removes old logs", async () => {
-  const dir = createTestDir();
-  const ctx = createMockCtx();
-  const origCwd = process.cwd();
-  process.chdir(dir);
-
-  // Create an old activity log (modify mtime to 10 days ago)
-  writeActivityLog(dir, 1, "execute-task", "M001/S01/T01", [{ type: "toolCall" }]);
-  const oldFile = join(dir, ".gsd", "activity", "001-execute-task-M001-S01-T01.jsonl");
-  const oldTime = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
-  utimesSync(oldFile, oldTime, oldTime);
-
-  // Create 6 recent activity logs so the old one is outside the "keep 5" window
-  for (let i = 2; i <= 7; i++) {
-    writeActivityLog(dir, i, "execute-task", `M001/S01/T0${i}`, [{ type: "toolCall" }]);
-  }
-
-  try {
-    await handleLogs("clear", ctx as any);
-    assert.equal(ctx.notifications.length, 1);
-    // Old log should be removed, recent ones kept
-    assert.ok(!existsSync(oldFile), "old log should be removed");
-    assert.ok(
-      existsSync(join(dir, ".gsd", "activity", "007-execute-task-M001-S01-T07.jsonl")),
-      "most recent log should be kept",
-    );
-  } finally {
-    process.chdir(origCwd);
-    rmSync(dir, { recursive: true, force: true });
-  }
-});