@simonfestl/husky-cli 1.13.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/index.js

@@ -89,3 +89,4 @@ if (process.argv.length <= 2) {
 else {
     program.parse();
 }
+// trigger CI

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/dist/lib/biz/wattiz-playwright.js

@@ -115,7 +115,6 @@ export class WattizPlaywrightClient {
             if (!passwordInput) {
                 throw new Error('Could not find password input field');
             }
-            console.log(`Using selectors: email="${emailInput}", password="${passwordInput}"`);
             // Fill in login form
             await page.fill(emailInput, this.config.username);
             await page.fill(passwordInput, this.config.password);
@@ -142,24 +141,13 @@ export class WattizPlaywrightClient {
             await page.waitForLoadState('networkidle', { timeout: 15000 }).catch(() => { });
             // Check if logged in by looking for my-account page or logged-in indicators
             const currentUrl = page.url();
-            console.log('After login, current URL:', currentUrl);
-            // Check for error messages first
-            const errorMsg = await page.locator('.alert-danger, .error-message, .ps-alert-error').textContent().catch(() => '');
-            if (errorMsg) {
-                console.log('Error message on page:', errorMsg.trim());
-            }
             const isLoggedIn = currentUrl.includes('/my-account') ||
                 currentUrl.includes('/mon-compte') ||
                 await page.locator('.account-link').count() > 0 ||
                 await page.locator('[data-link-action="sign-out"]').count() > 0 ||
                 await page.locator('.logout, .sign-out').count() > 0 ||
                 await page.locator('a[href*="logout"]').count() > 0;
-            console.log('Is logged in:', isLoggedIn);
             if (!isLoggedIn) {
-                // Save debug HTML
-                const debugHtml = await page.content();
-                await fs.promises.writeFile('/tmp/wattiz-after-login.html', debugHtml);
-                console.log('Debug HTML saved to /tmp/wattiz-after-login.html');
                 return {
                     success: false,
                     cookies: '',
@@ -200,16 +188,38 @@ export class WattizPlaywrightClient {
         const count = await orderRows.count();
         for (let i = 0; i < count; i++) {
             const row = orderRows.nth(i);
-            // PrestaShop order structure
+            // PrestaShop order structure - get link for order ID
             const orderLinkEl = row.locator('a[href*="order-detail"]').first();
             const orderLink = await orderLinkEl.getAttribute('href').catch(() => '');
             // Extract order ID from PrestaShop controller URL
             const orderIdMatch = orderLink?.match(/id_order=(\d+)/);
             const orderId = orderIdMatch ? orderIdMatch[1] : '';
-            const orderNumber = await orderLinkEl.textContent().catch(() => '') || orderId;
-            const date = (await row.locator('.order-date, td:nth-child(2)').textContent().catch(() => '')) || '';
-            const status = (await row.locator('.order-status, td:nth-child(4), .label').textContent().catch(() => '')) || '';
-            const total = (await row.locator('.order-total, td:nth-child(3)').textContent().catch(() => '')) || '';
+            // Get all table cells
+            const cells = row.locator('td');
+            const cellCount = await cells.count();
+            // Wattiz order-history table structure (customized PrestaShop):
+            // Col 0: Date, Col 1: Total, Col 2: ?, Col 3: ?, Col 4: Status, Col 5: Actions
+            // Order reference is in the link or we use order ID
+            let orderNumber = orderId;
+            let date = '';
+            let total = '';
+            let status = '';
+            if (cellCount >= 2) {
+                // First cell contains Date
+                date = (await cells.nth(0).textContent().catch(() => '')) || '';
+                // Second cell contains Total
+                total = (await cells.nth(1).textContent().catch(() => '')) || '';
+            }
+            if (cellCount >= 5) {
+                // Status is in column 5 (index 4)
+                status = (await cells.nth(4).textContent().catch(() => '')) || '';
+            }
+            // Try to find actual order reference in row text
+            const rowText = await row.textContent().catch(() => '') || '';
+            const refMatch = rowText.match(/WATTIZ[A-Z0-9]+|[A-Z]{2,}[0-9]{6,}/i);
+            if (refMatch) {
+                orderNumber = refMatch[0];
+            }
             if (orderId) {
                 orders.push({
                     id: orderId,
@@ -226,62 +236,202 @@ export class WattizPlaywrightClient {
     async getOrder(orderId) {
         const page = await this.ensureBrowser();
         // PrestaShop controller-based URL
-        await page.goto(`${this.config.baseUrl}/${this.config.language}/index.php?controller=order-detail&id_order=${orderId}`);
-        await page.waitForLoadState('networkidle');
+        await page.goto(`${this.config.baseUrl}/${this.config.language}/index.php?controller=order-detail&id_order=${orderId}`, {
+            waitUntil: 'domcontentloaded',
+            timeout: 30000
+        });
+        await page.waitForLoadState('domcontentloaded').catch(() => { });
         // Check if we need to login
-        const needsLogin = await page.url().includes('/login');
+        const needsLogin = page.url().includes('/login');
         if (needsLogin) {
             await this.login();
-            await page.goto(`${this.config.baseUrl}/${this.config.language}/index.php?controller=order-detail&id_order=${orderId}`);
-            await page.waitForLoadState('networkidle');
+            await page.goto(`${this.config.baseUrl}/${this.config.language}/index.php?controller=order-detail&id_order=${orderId}`, {
+                waitUntil: 'domcontentloaded',
+                timeout: 30000
+            });
+            await page.waitForLoadState('domcontentloaded').catch(() => { });
         }
-        // Extract order information
-        const orderNumber = (await page.locator('.order-reference, h3').first().textContent().catch(() => orderId)) || orderId;
-        const orderDate = (await page.locator('.order-date, .date').first().textContent().catch(() => '')) || '';
-        const orderStatus = (await page.locator('.order-status, .label').first().textContent().catch(() => '')) || '';
-        // Extract customer info
+        // Extract order information from Wattiz order detail page
+        // Use order ID as the order number (Wattiz doesn't display a separate reference)
+        const orderNumber = orderId;
+        let orderDate = '';
+        let orderStatus = '';
+        // Get visible page text for pattern matching
+        const pageText = await page.locator('body').textContent().catch(() => '') || '';
+        // Find date - look for format DD/MM/YYYY or YYYY-MM-DD
+        const dateMatches = pageText.match(/\b(\d{2}[\/\-]\d{2}[\/\-]20\d{2}|20\d{2}[\/\-]\d{2}[\/\-]\d{2})\b/g);
+        if (dateMatches && dateMatches.length > 0 && dateMatches[0]) {
+            orderDate = dateMatches[0];
+        }
+        // Get status - look for common shipping status text
+        const statusPatterns = ['Shipped', 'Delivered', 'Processing', 'Pending', 'Cancelled', 'En cours', 'Expédié', 'Livré'];
+        for (const pattern of statusPatterns) {
+            if (pageText.includes(pattern)) {
+                orderStatus = pattern;
+                break;
+            }
+        }
+        // Also try status elements if no pattern found
+        if (!orderStatus) {
+            const statusSelectors = ['.label.bright', '.badge', '.order-status'];
+            for (const selector of statusSelectors) {
+                const statusText = await page.locator(selector).first().textContent().catch(() => '');
+                if (statusText && statusText.length > 2 && statusText.length < 25 && !statusText.includes('€')) {
+                    orderStatus = statusText.trim();
+                    break;
+                }
+            }
+        }
+        // Extract customer info from address blocks
         let customerName = '';
         let customerAddress = '';
         let customerEmail = '';
         let customerPhone = '';
         try {
-            const addressBlock = page.locator('.address, .delivery-address').first();
-            const addressText = await addressBlock.textContent() || '';
-            const lines = addressText.split('\n').map(l => l.trim()).filter(l => l);
-            if (lines.length > 0)
-                customerName = lines[0];
-            if (lines.length > 1)
-                customerAddress = lines.slice(1).filter(l => !l.includes('@') && !l.startsWith('+')).join(', ');
-            // Try to find email and phone
-            customerEmail = await page.locator('[href^="mailto:"]').first().textContent().catch(() => '') || '';
+            // PrestaShop uses .address class for address blocks
+            const addressBlocks = page.locator('.address, article.address');
+            const blockCount = await addressBlocks.count();
+            for (let i = 0; i < blockCount; i++) {
+                const block = addressBlocks.nth(i);
+                const addressText = await block.textContent() || '';
+                const lines = addressText.split('\n').map(l => l.trim()).filter(l => l && l.length > 1);
+                // First line is usually the name
+                if (lines.length > 0 && !customerName) {
+                    customerName = lines[0];
+                }
+                // Combine address lines (skip name, email, phone)
+                if (lines.length > 1 && !customerAddress) {
+                    customerAddress = lines.slice(1)
+                        .filter(l => !l.includes('@') && !l.match(/^\+?\d[\d\s\-]+$/))
+                        .join(', ');
+                }
+            }
+            // Try to find customer email (exclude wattiz domain)
+            const mailLinks = await page.locator('[href^="mailto:"]').all();
+            for (const link of mailLinks) {
+                const href = await link.getAttribute('href').catch(() => '') || '';
+                const email = href.replace('mailto:', '');
+                if (email && !email.includes('wattiz')) {
+                    customerEmail = email;
+                    break;
+                }
+            }
+            // Fallback: look for email pattern in address blocks (exclude wattiz)
+            if (!customerEmail) {
+                for (let i = 0; i < blockCount; i++) {
+                    const blockText = await addressBlocks.nth(i).textContent().catch(() => '') || '';
+                    const emailMatch = blockText.match(/[\w.+-]+@[\w.-]+\.\w+/);
+                    if (emailMatch && !emailMatch[0].includes('wattiz')) {
+                        customerEmail = emailMatch[0];
+                        break;
+                    }
+                }
+            }
             customerPhone = await page.locator('[href^="tel:"]').first().textContent().catch(() => '') || '';
         }
         catch (error) {
             // Customer details not available
         }
-        // Extract line items
+        // Extract line items from product table
+        // Look for the products section specifically
         const items = [];
-        const itemRows = page.locator('.order-products table tbody tr, .product-line-row');
-        const itemCount = await itemRows.count();
-        for (let i = 0; i < itemCount; i++) {
-            const itemRow = itemRows.nth(i);
-            const name = await itemRow.locator('.product-name, td:first-child').textContent() || '';
-            const qty = await itemRow.locator('.qty, td:nth-child(2)').textContent() || '1';
-            const total = await itemRow.locator('.price, td:last-child').textContent() || '';
-            items.push({
-                sku: '',
-                name: name.trim(),
-                quantity: parseInt(qty.replace(/\D/g, ''), 10) || 1,
-                price: '',
-                total: total.trim(),
-            });
+        // Try different selectors for the product table
+        const productSelectors = [
+            '#order-products table tbody tr',
+            '.order-products tbody tr',
+            '[id*="product"] table tbody tr',
+            'table.table-striped tbody tr'
+        ];
+        let productRows = null;
+        for (const selector of productSelectors) {
+            const rows = page.locator(selector);
+            const count = await rows.count();
+            if (count > 0) {
+                // Check if first row looks like a product (not a date or header)
+                const firstRowText = await rows.first().textContent().catch(() => '') || '';
+                if (!firstRowText.match(/^\d{4}[\/\-]\d{2}/) && firstRowText.length > 10) {
+                    productRows = rows;
+                    break;
+                }
+            }
+        }
+        if (productRows) {
+            const itemCount = await productRows.count();
+            for (let i = 0; i < itemCount; i++) {
+                const itemRow = productRows.nth(i);
+                const rowText = await itemRow.textContent() || '';
+                // Skip rows that look like dates or headers
+                if (rowText.match(/^\s*\d{4}[\/\-]\d{2}/) || rowText.includes('Product') || rowText.trim().length < 5) {
+                    continue;
+                }
+                const cells = itemRow.locator('td');
+                const cellCount = await cells.count();
+                if (cellCount >= 2) {
+                    const nameCell = await cells.nth(0).textContent() || '';
+                    const name = nameCell.replace(/\s+/g, ' ').trim();
+                    let qty = '1';
+                    let total = '';
+                    // Find quantity and price cells
+                    for (let c = 1; c < cellCount; c++) {
+                        const cellText = (await cells.nth(c).textContent() || '').trim();
+                        if (cellText.match(/^\d+$/) && parseInt(cellText, 10) < 1000) {
+                            qty = cellText;
+                        }
+                        else if (cellText.includes('€') || cellText.includes('$')) {
+                            total = cellText;
+                        }
+                    }
+                    // Only add if name looks like a product
+                    if (name && name.length > 5 && !name.match(/^\d{4}[\/\-]/)) {
+                        items.push({
+                            sku: '',
+                            name: name,
+                            quantity: parseInt(qty, 10) || 1,
+                            price: '',
+                            total: total,
+                        });
+                    }
+                }
+            }
         }
         // Look for invoice link
-        const invoiceLink = await page.locator('a[href*="invoice"], a.btn-primary[href*="pdf"]').first().getAttribute('href').catch(() => '');
-        // Extract total
-        const totalText = await page.locator('.order-total, .total-value').last().textContent().catch(() => '');
+        const invoiceLink = await page.locator('a[href*="pdf-invoice"], a[href*="get-invoice"], a[href*="invoice"]').first().getAttribute('href').catch(() => '');
+        // Extract total - look for price patterns in page
+        let totalText = '';
+        // Look for total amount in page text
+        const priceMatches = pageText.match(/€\s*[\d,]+\.?\d*/g) || [];
+        if (priceMatches.length > 0) {
+            // Get the largest price as total (usually the order total)
+            let maxPrice = 0;
+            let maxPriceText = '';
+            for (const priceText of priceMatches) {
+                const value = parseFloat(priceText.replace('€', '').replace(/\s/g, '').replace(',', '.'));
+                if (value > maxPrice) {
+                    maxPrice = value;
+                    maxPriceText = priceText.trim();
+                }
+            }
+            if (maxPriceText) {
+                totalText = maxPriceText;
+            }
+        }
+        // Fallback: try specific selectors
+        if (!totalText) {
+            const totalSelectors = [
+                '.order-totals tr:last-child td:last-child',
+                '.total-value',
+                'table tfoot td:last-child'
+            ];
+            for (const selector of totalSelectors) {
+                const text = await page.locator(selector).last().textContent().catch(() => '');
+                if (text && text.includes('€')) {
+                    totalText = text.trim();
+                    break;
+                }
+            }
+        }
         // Extract tracking number if available
-        const trackingNumber = await page.locator('.tracking-number, [href*="track"]').first().textContent().catch(() => '');
+        const trackingNumber = await page.locator('.tracking-number, [href*="track"], [data-tracking]').first().textContent().catch(() => '');
         return {
             id: orderId,
             orderNumber: orderNumber?.trim() || orderId,

package/package.json

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