@simonfestl/husky-cli 1.14.0 → 1.15.0

package/dist/commands/task.js

@@ -9,6 +9,7 @@ import { execSync } from "child_process";
 import { resolveProject, fetchProjects, formatProjectList } from "../lib/project-resolver.js";
 import { requirePermission } from "../lib/permissions.js";
 import { ErrorHelpers, errorWithHint, ExplainTopic } from "../lib/error-hints.js";
+import { AgentLock, AgentLockError } from "../lib/agent-lock.js";
 export const taskCommand = new Command("task")
     .description("Manage tasks");
 // Helper: Get task ID from --id flag or HUSKY_TASK_ID env var
@@ -245,6 +246,17 @@ taskCommand
             if (worktreeInfo) {
                 console.log(`✓ Created worktree: ${worktreeInfo.path}`);
                 console.log(`  Branch: ${worktreeInfo.branch}`);
+                // Acquire agent lock for the worktree
+                try {
+                    const agentLock = new AgentLock(process.cwd(), worktreeInfo.path, workerId, sessionId);
+                    agentLock.acquire();
+                    console.log(`✓ Acquired agent lock`);
+                }
+                catch (error) {
+                    if (error instanceof AgentLockError) {
+                        console.warn(`⚠ Warning: ${error.message}`);
+                    }
+                }
             }
         }
         const res = await fetch(`${config.apiUrl}/api/tasks/${id}/start`, {

package/dist/commands/worktree.js

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import * as path from "path";
 import { WorktreeManager } from "../lib/worktree.js";
 import { MergeLock, withMergeLock } from "../lib/merge-lock.js";
+import { AgentLock } from "../lib/agent-lock.js";
 import { getConfig } from "./config.js";
 export const worktreeCommand = new Command("worktree")
     .description("Manage Git worktrees for isolated agent workspaces");
@@ -87,13 +88,24 @@ worktreeCommand
     .option("--json", "Output as JSON")
     .action(async (options) => {
     try {
+        const projectDir = getProjectDir(options);
         const manager = getManager(options);
         const worktrees = manager.listWorktrees();
+        const agentLocks = AgentLock.listLocks(projectDir);
+        // Build a map of worktree path to lock info
+        const locksByPath = new Map();
+        for (const lock of agentLocks) {
+            locksByPath.set(lock.worktree, { info: lock.info, isStale: lock.isStale });
+        }
         if (options.json) {
-            console.log(JSON.stringify({ worktrees, baseBranch: manager.getBaseBranch() }, null, 2));
+            const worktreesWithLocks = worktrees.map(wt => ({
+                ...wt,
+                agentLock: locksByPath.get(wt.path) || null,
+            }));
+            console.log(JSON.stringify({ worktrees: worktreesWithLocks, baseBranch: manager.getBaseBranch(), agentLocks }, null, 2));
         }
         else {
-            printWorktreeList(worktrees, manager.getBaseBranch());
+            printWorktreeList(worktrees, manager.getBaseBranch(), locksByPath);
         }
     }
     catch (error) {
@@ -109,6 +121,7 @@ worktreeCommand
     .option("--json", "Output as JSON")
     .action(async (sessionName, options) => {
     try {
+        const projectDir = getProjectDir(options);
         const manager = getManager(options);
         const info = manager.getWorktree(sessionName);
         if (!info) {
@@ -117,11 +130,14 @@ worktreeCommand
         }
         const changedFiles = manager.getChangedFiles(sessionName);
         const hasUncommitted = manager.hasUncommittedChanges(sessionName);
+        // Check for agent lock
+        const agentLocks = AgentLock.listLocks(projectDir);
+        const agentLock = agentLocks.find(l => l.worktree === info.path) || null;
         if (options.json) {
-            console.log(JSON.stringify({ ...info, changedFiles, hasUncommittedChanges: hasUncommitted }, null, 2));
+            console.log(JSON.stringify({ ...info, changedFiles, hasUncommittedChanges: hasUncommitted, agentLock }, null, 2));
         }
         else {
-            printWorktreeDetail(info, changedFiles, hasUncommitted);
+            printWorktreeDetail(info, changedFiles, hasUncommitted, agentLock);
         }
     }
     catch (error) {
@@ -316,14 +332,18 @@ worktreeCommand
         else {
             // Just cleanup stale
             manager.cleanupStale();
-            const staleLocks = MergeLock.cleanupStale(projectDir);
+            const staleMergeLocks = MergeLock.cleanupStale(projectDir);
+            const staleAgentLocks = AgentLock.cleanupStale(projectDir);
             if (options.json) {
-                console.log(JSON.stringify({ staleLocksRemoved: staleLocks, type: "stale" }, null, 2));
+                console.log(JSON.stringify({ staleMergeLocksRemoved: staleMergeLocks, staleAgentLocksRemoved: staleAgentLocks, type: "stale" }, null, 2));
             }
             else {
                 console.log("Cleaned up stale worktrees and locks");
-                if (staleLocks > 0) {
-                    console.log(`  Removed ${staleLocks} stale lock(s)`);
+                if (staleMergeLocks > 0) {
+                    console.log(`  Removed ${staleMergeLocks} stale merge lock(s)`);
+                }
+                if (staleAgentLocks > 0) {
+                    console.log(`  Removed ${staleAgentLocks} stale agent lock(s)`);
                 }
             }
         }
@@ -376,24 +396,34 @@ worktreeCommand
     }
 });
 // Print helpers
-function printWorktreeList(worktrees, baseBranch) {
+function printWorktreeList(worktrees, baseBranch, locksByPath) {
     console.log(`\n  Base branch: ${baseBranch}`);
-    console.log("  " + "-".repeat(80));
+    console.log("  " + "-".repeat(90));
     if (worktrees.length === 0) {
         console.log("  No worktrees found.");
         console.log("  Create one with: husky worktree create <session-name>");
     }
     else {
-        console.log(`  ${"SESSION".padEnd(20)} ${"BRANCH".padEnd(25)} ${"COMMITS".padEnd(8)} ${"CHANGES"}`);
-        console.log("  " + "-".repeat(80));
+        console.log(`  ${"SESSION".padEnd(20)} ${"BRANCH".padEnd(25)} ${"COMMITS".padEnd(8)} ${"CHANGES".padEnd(20)} ${"AGENT"}`);
+        console.log("  " + "-".repeat(90));
         for (const wt of worktrees) {
             const changes = `+${wt.stats.additions}/-${wt.stats.deletions} (${wt.stats.filesChanged} files)`;
-            console.log(`  ${wt.sessionName.padEnd(20)} ${wt.branch.padEnd(25)} ${String(wt.stats.commitCount).padEnd(8)} ${changes}`);
+            const lock = locksByPath.get(wt.path);
+            let agentInfo = "";
+            if (lock) {
+                if (lock.isStale) {
+                    agentInfo = `[stale] ${lock.info.workerId}`;
+                }
+                else {
+                    agentInfo = `${lock.info.workerId} (PID: ${lock.info.pid})`;
+                }
+            }
+            console.log(`  ${wt.sessionName.padEnd(20)} ${wt.branch.padEnd(25)} ${String(wt.stats.commitCount).padEnd(8)} ${changes.padEnd(20)} ${agentInfo}`);
         }
     }
     console.log("");
 }
-function printWorktreeDetail(info, changedFiles, hasUncommitted) {
+function printWorktreeDetail(info, changedFiles, hasUncommitted, agentLock) {
     console.log(`\n  Worktree: ${info.sessionName}`);
     console.log("  " + "-".repeat(60));
     console.log(`  Path:       ${info.path}`);
@@ -405,6 +435,20 @@ function printWorktreeDetail(info, changedFiles, hasUncommitted) {
     console.log(`    Files:    ${info.stats.filesChanged}`);
     console.log(`    Added:    +${info.stats.additions}`);
     console.log(`    Removed:  -${info.stats.deletions}`);
+    if (agentLock) {
+        console.log(`\n  Agent Lock:`);
+        if (agentLock.isStale) {
+            console.log(`    Status:   STALE (process no longer running)`);
+        }
+        else {
+            console.log(`    Status:   ACTIVE`);
+        }
+        console.log(`    Worker:   ${agentLock.info.workerId}`);
+        console.log(`    Session:  ${agentLock.info.sessionId}`);
+        console.log(`    PID:      ${agentLock.info.pid}`);
+        console.log(`    Host:     ${agentLock.info.hostname}`);
+        console.log(`    Since:    ${new Date(agentLock.info.timestamp).toISOString()}`);
+    }
     if (hasUncommitted) {
         console.log(`\n  ⚠ Has uncommitted changes`);
     }

package/dist/lib/agent-lock.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Agent Lock Mechanism for Husky Worktrees
+ *
+ * Prevents multiple agents from working in the same worktree simultaneously.
+ * Tracks agent identity (workerId, sessionId) alongside PID for detection.
+ */
+export declare class AgentLockError extends Error {
+    lockInfo?: AgentLockInfo | undefined;
+    constructor(message: string, lockInfo?: AgentLockInfo | undefined);
+}
+export interface AgentLockInfo {
+    workerId: string;
+    sessionId: string;
+    pid: number;
+    timestamp: number;
+    hostname: string;
+    worktreePath: string;
+    cwd: string;
+}
+export declare class AgentLock {
+    private projectDir;
+    private worktreePath;
+    private lockFile;
+    private lockDir;
+    private isHeldByMe;
+    private workerId;
+    private sessionId;
+    static readonly STALE_TIMEOUT: number;
+    constructor(projectDir: string, worktreePath: string, workerId: string, sessionId: string);
+    /**
+     * Create a simple hash of a path for lock file naming.
+     */
+    private hashPath;
+    /**
+     * Check if another agent is working in this worktree.
+     * Returns the lock info if locked by another agent, null otherwise.
+     */
+    checkForConflict(): AgentLockInfo | null;
+    /**
+     * Acquire the agent lock for this worktree.
+     */
+    acquire(): boolean;
+    /**
+     * Release the agent lock.
+     */
+    release(): void;
+    /**
+     * Update the lock timestamp (heartbeat).
+     */
+    heartbeat(): void;
+    /**
+     * Check if a process exists.
+     */
+    private processExists;
+    /**
+     * Check if a lock is stale.
+     */
+    private isStale;
+    /**
+     * Get the current lock info.
+     */
+    getLockInfo(): AgentLockInfo | null;
+    /**
+     * Check if the lock file exists.
+     */
+    isLocked(): boolean;
+    /**
+     * List all agent locks in a project.
+     */
+    static listLocks(projectDir: string): Array<{
+        worktree: string;
+        info: AgentLockInfo;
+        isStale: boolean;
+    }>;
+    /**
+     * Clean up all stale agent locks.
+     */
+    static cleanupStale(projectDir: string): number;
+}
+/**
+ * Helper to check if a worktree is in use by another agent.
+ */
+export declare function checkWorktreeConflict(projectDir: string, worktreePath: string, workerId: string, sessionId: string): AgentLockInfo | null;
+/**
+ * Helper to acquire an agent lock and run a function.
+ */
+export declare function withAgentLock<T>(projectDir: string, worktreePath: string, workerId: string, sessionId: string, fn: () => Promise<T>): Promise<T>;

package/dist/lib/agent-lock.js

@@ -0,0 +1,332 @@
+/**
+ * Agent Lock Mechanism for Husky Worktrees
+ *
+ * Prevents multiple agents from working in the same worktree simultaneously.
+ * Tracks agent identity (workerId, sessionId) alongside PID for detection.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+export class AgentLockError extends Error {
+    lockInfo;
+    constructor(message, lockInfo) {
+        super(message);
+        this.lockInfo = lockInfo;
+        this.name = "AgentLockError";
+    }
+}
+export class AgentLock {
+    projectDir;
+    worktreePath;
+    lockFile;
+    lockDir;
+    isHeldByMe = false;
+    workerId;
+    sessionId;
+    static STALE_TIMEOUT = 30 * 60 * 1000; // 30 minutes
+    constructor(projectDir, worktreePath, workerId, sessionId) {
+        this.projectDir = path.resolve(projectDir);
+        this.worktreePath = worktreePath;
+        this.workerId = workerId;
+        this.sessionId = sessionId;
+        this.lockDir = path.join(this.projectDir, ".husky", ".locks");
+        // Use worktree path hash to create unique lock file name
+        const worktreeHash = this.hashPath(worktreePath);
+        this.lockFile = path.join(this.lockDir, `agent-${worktreeHash}.lock`);
+    }
+    /**
+     * Create a simple hash of a path for lock file naming.
+     */
+    hashPath(p) {
+        // Simple hash: use last two path segments
+        const parts = p.split(path.sep).filter(Boolean);
+        if (parts.length >= 2) {
+            return `${parts[parts.length - 2]}-${parts[parts.length - 1]}`;
+        }
+        return parts[parts.length - 1] || "default";
+    }
+    /**
+     * Check if another agent is working in this worktree.
+     * Returns the lock info if locked by another agent, null otherwise.
+     */
+    checkForConflict() {
+        if (!fs.existsSync(this.lockFile)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(this.lockFile, "utf-8");
+            const lockInfo = JSON.parse(content);
+            // Same agent, same session - no conflict
+            if (lockInfo.workerId === this.workerId && lockInfo.sessionId === this.sessionId) {
+                return null;
+            }
+            // Check if the locking process is still running
+            if (!this.processExists(lockInfo.pid)) {
+                // Process is dead, lock is stale
+                return null;
+            }
+            // Check if lock is too old
+            if (this.isStale(lockInfo)) {
+                return null;
+            }
+            // Another agent is actively working here
+            return lockInfo;
+        }
+        catch {
+            // Can't read lock file, assume no conflict
+            return null;
+        }
+    }
+    /**
+     * Acquire the agent lock for this worktree.
+     */
+    acquire() {
+        // First check for conflicts
+        const conflict = this.checkForConflict();
+        if (conflict) {
+            throw new AgentLockError(`Worktree is already in use by another agent!\n` +
+                `  Worker: ${conflict.workerId}\n` +
+                `  Session: ${conflict.sessionId}\n` +
+                `  PID: ${conflict.pid}\n` +
+                `  Since: ${new Date(conflict.timestamp).toISOString()}\n` +
+                `  Host: ${conflict.hostname}`, conflict);
+        }
+        // Clean up stale lock if exists
+        if (fs.existsSync(this.lockFile)) {
+            try {
+                const content = fs.readFileSync(this.lockFile, "utf-8");
+                const lockInfo = JSON.parse(content);
+                if (!this.processExists(lockInfo.pid) || this.isStale(lockInfo)) {
+                    fs.unlinkSync(this.lockFile);
+                }
+            }
+            catch {
+                // Ignore errors, try to acquire anyway
+            }
+        }
+        // Create lock directory
+        fs.mkdirSync(this.lockDir, { recursive: true });
+        const lockInfo = {
+            workerId: this.workerId,
+            sessionId: this.sessionId,
+            pid: process.pid,
+            timestamp: Date.now(),
+            hostname: os.hostname(),
+            worktreePath: this.worktreePath,
+            cwd: process.cwd(),
+        };
+        try {
+            // Use exclusive flag for atomic creation
+            const fd = fs.openSync(this.lockFile, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+            fs.writeSync(fd, JSON.stringify(lockInfo, null, 2));
+            fs.closeSync(fd);
+            this.isHeldByMe = true;
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                // File was created between our check and acquire attempt
+                // Re-check for conflict
+                const newConflict = this.checkForConflict();
+                if (newConflict) {
+                    throw new AgentLockError(`Worktree was just locked by another agent!\n` +
+                        `  Worker: ${newConflict.workerId}\n` +
+                        `  Session: ${newConflict.sessionId}`, newConflict);
+                }
+                // Stale lock, try to remove and retry
+                try {
+                    fs.unlinkSync(this.lockFile);
+                    return this.acquire();
+                }
+                catch {
+                    return false;
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Release the agent lock.
+     */
+    release() {
+        if (!this.isHeldByMe) {
+            return;
+        }
+        try {
+            fs.unlinkSync(this.lockFile);
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+        this.isHeldByMe = false;
+    }
+    /**
+     * Update the lock timestamp (heartbeat).
+     */
+    heartbeat() {
+        if (!this.isHeldByMe || !fs.existsSync(this.lockFile)) {
+            return;
+        }
+        try {
+            const content = fs.readFileSync(this.lockFile, "utf-8");
+            const lockInfo = JSON.parse(content);
+            lockInfo.timestamp = Date.now();
+            fs.writeFileSync(this.lockFile, JSON.stringify(lockInfo, null, 2));
+        }
+        catch {
+            // Ignore heartbeat errors
+        }
+    }
+    /**
+     * Check if a process exists.
+     */
+    processExists(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a lock is stale.
+     */
+    isStale(lockInfo) {
+        const age = Date.now() - lockInfo.timestamp;
+        return age > AgentLock.STALE_TIMEOUT;
+    }
+    /**
+     * Get the current lock info.
+     */
+    getLockInfo() {
+        if (!fs.existsSync(this.lockFile)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(this.lockFile, "utf-8");
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if the lock file exists.
+     */
+    isLocked() {
+        return fs.existsSync(this.lockFile);
+    }
+    /**
+     * List all agent locks in a project.
+     */
+    static listLocks(projectDir) {
+        const lockDir = path.join(projectDir, ".husky", ".locks");
+        if (!fs.existsSync(lockDir)) {
+            return [];
+        }
+        const locks = [];
+        const entries = fs.readdirSync(lockDir);
+        for (const entry of entries) {
+            if (!entry.startsWith("agent-") || !entry.endsWith(".lock")) {
+                continue;
+            }
+            const lockFile = path.join(lockDir, entry);
+            try {
+                const content = fs.readFileSync(lockFile, "utf-8");
+                const info = JSON.parse(content);
+                // Check if stale
+                let isStale = false;
+                try {
+                    process.kill(info.pid, 0);
+                    // Process exists, check age
+                    isStale = Date.now() - info.timestamp > AgentLock.STALE_TIMEOUT;
+                }
+                catch {
+                    // Process doesn't exist
+                    isStale = true;
+                }
+                locks.push({
+                    worktree: info.worktreePath,
+                    info,
+                    isStale,
+                });
+            }
+            catch {
+                // Skip invalid lock files
+            }
+        }
+        return locks;
+    }
+    /**
+     * Clean up all stale agent locks.
+     */
+    static cleanupStale(projectDir) {
+        const lockDir = path.join(projectDir, ".husky", ".locks");
+        if (!fs.existsSync(lockDir)) {
+            return 0;
+        }
+        let cleaned = 0;
+        const entries = fs.readdirSync(lockDir);
+        for (const entry of entries) {
+            if (!entry.startsWith("agent-") || !entry.endsWith(".lock")) {
+                continue;
+            }
+            const lockFile = path.join(lockDir, entry);
+            try {
+                const content = fs.readFileSync(lockFile, "utf-8");
+                const info = JSON.parse(content);
+                let isStale = false;
+                try {
+                    process.kill(info.pid, 0);
+                    isStale = Date.now() - info.timestamp > AgentLock.STALE_TIMEOUT;
+                }
+                catch {
+                    isStale = true;
+                }
+                if (isStale) {
+                    fs.unlinkSync(lockFile);
+                    cleaned++;
+                }
+            }
+            catch {
+                // Try to remove invalid lock files
+                try {
+                    fs.unlinkSync(lockFile);
+                    cleaned++;
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+        return cleaned;
+    }
+}
+/**
+ * Helper to check if a worktree is in use by another agent.
+ */
+export function checkWorktreeConflict(projectDir, worktreePath, workerId, sessionId) {
+    const lock = new AgentLock(projectDir, worktreePath, workerId, sessionId);
+    return lock.checkForConflict();
+}
+/**
+ * Helper to acquire an agent lock and run a function.
+ */
+export async function withAgentLock(projectDir, worktreePath, workerId, sessionId, fn) {
+    const lock = new AgentLock(projectDir, worktreePath, workerId, sessionId);
+    if (!lock.acquire()) {
+        throw new AgentLockError(`Could not acquire agent lock for ${worktreePath}`);
+    }
+    // Set up heartbeat interval
+    const heartbeatInterval = setInterval(() => {
+        lock.heartbeat();
+    }, 60000); // Every minute
+    try {
+        return await fn();
+    }
+    finally {
+        clearInterval(heartbeatInterval);
+        lock.release();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simonfestl/husky-cli",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "CLI for Huskyv0 Task Orchestration with Claude Agent SDK",
   "type": "module",
   "bin": {