@simonfestl/husky-cli 1.0.0 → 1.3.0

package/README.md

@@ -174,6 +174,32 @@ husky vm-config update <config-id> --machine-type e2-standard-2
 husky vm-config delete <config-id>
 ```
 
+### Chat / Messaging
+
+```bash
+# Check pending messages
+husky chat pending
+husky chat pending --json
+
+# View inbox (GitHub + Google Chat)
+husky chat inbox
+husky chat inbox --unread
+
+# Reply to any message (auto-detects platform)
+husky chat reply-to <messageId> "Your response"
+
+# Reply in Google Chat thread
+husky chat reply-chat "Message" --thread <threadName>
+
+# Mark message as read
+husky chat mark-read <messageId>
+
+# Watch for messages (inject into tmux)
+husky chat watch-inject --tmux-session supervisor
+```
+
+The `reply-to` command automatically detects whether the message is from GitHub or Google Chat and uses the appropriate API to send the reply.
+
 ### Settings
 
 ```bash
@@ -270,6 +296,17 @@ husky --version
 
 ## Changelog
 
+### v1.1.0 (2026-01-09) - Unified Reply System
+
+**New Features:**
+- `husky chat reply-to` now supports both GitHub and Google Chat
+- Auto-detects platform from message metadata
+- GitHub replies use GitHub App (no PAT required on VM)
+
+**Improvements:**
+- Require 8+ character prefix for messageId matching (prevents misdirected replies)
+- Better error messages for short messageId prefixes
+
 ### v1.0.0 (2026-01-08) - Supervisor Architecture
 
 **BREAKING CHANGES:**

package/dist/commands/agent-msg.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const agentMsgCommand: Command;

package/dist/commands/agent-msg.js

@@ -0,0 +1,252 @@
+import { Command } from "commander";
+import { getConfig } from "./config.js";
+async function apiCall(path, options = {}) {
+    const config = getConfig();
+    if (!config.apiUrl || !config.apiKey) {
+        console.error("Error: API URL and key required. Run: husky config test");
+        process.exit(1);
+    }
+    const res = await fetch(`${config.apiUrl}${path}`, {
+        ...options,
+        headers: {
+            "Content-Type": "application/json",
+            "x-api-key": config.apiKey,
+            ...options.headers,
+        },
+    });
+    if (!res.ok) {
+        const error = await res.text();
+        throw new Error(`API error ${res.status}: ${error}`);
+    }
+    return res.json();
+}
+export const agentMsgCommand = new Command("agent-msg")
+    .description("Agent-to-agent messaging (worker <-> supervisor)");
+agentMsgCommand
+    .command("send")
+    .description("Send message to supervisor or another agent")
+    .requiredOption("--type <type>", "Message type: approval_request, status_update, error_report, completion, query")
+    .requiredOption("--title <title>", "Message title")
+    .option("--description <desc>", "Message description")
+    .option("--target <id>", "Target agent ID (default: supervisor)")
+    .option("--expires <minutes>", "Expiration in minutes", "60")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const config = getConfig();
+        const sessionId = config.workerId || "unknown";
+        const payload = {
+            sessionId,
+            type: options.type,
+            payload: {
+                title: options.title,
+                description: options.description,
+            },
+            expiresInMinutes: parseInt(options.expires, 10),
+        };
+        if (options.target) {
+            payload.targetId = options.target;
+        }
+        const result = await apiCall("/api/agent-messages", {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`✅ Message sent (ID: ${result.id})`);
+            console.log(`   Type: ${result.type}`);
+            console.log(`   Title: ${result.payload.title}`);
+            if (result.targetId)
+                console.log(`   Target: ${result.targetId}`);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentMsgCommand
+    .command("list")
+    .description("List messages")
+    .option("--status <status>", "Filter by status: pending, responded, expired")
+    .option("--target <id>", "Filter by target agent ID")
+    .option("--limit <n>", "Number of messages", "20")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const params = new URLSearchParams();
+        if (options.status)
+            params.set("status", options.status);
+        if (options.target)
+            params.set("targetId", options.target);
+        if (options.limit)
+            params.set("limit", options.limit);
+        const messages = await apiCall(`/api/agent-messages?${params}`);
+        if (options.json) {
+            console.log(JSON.stringify(messages, null, 2));
+            return;
+        }
+        if (!messages || messages.length === 0) {
+            console.log("No messages found.");
+            return;
+        }
+        console.log("\n  Agent Messages");
+        console.log("  " + "─".repeat(70));
+        for (const msg of messages) {
+            const status = msg.status === "pending" ? "⏳" : msg.status === "responded" ? "✅" : "⌛";
+            console.log(`  ${status} [${msg.type}] ${msg.payload.title}`);
+            console.log(`     ID: ${msg.id} | From: ${msg.sessionId}`);
+            if (msg.response) {
+                console.log(`     Response: ${msg.response.approved ? "Approved" : "Rejected"} - ${msg.response.message || ""}`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentMsgCommand
+    .command("pending")
+    .description("List pending messages (for supervisor)")
+    .option("--target <id>", "Filter by target agent ID")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const params = new URLSearchParams();
+        if (options.target)
+            params.set("targetId", options.target);
+        const messages = await apiCall(`/api/agent-messages/pending?${params}`);
+        if (options.json) {
+            console.log(JSON.stringify(messages, null, 2));
+            return;
+        }
+        if (!messages || messages.length === 0) {
+            console.log("No pending messages.");
+            return;
+        }
+        console.log(`\n  📬 ${messages.length} Pending Message(s)`);
+        console.log("  " + "─".repeat(70));
+        for (const msg of messages) {
+            console.log(`  ⏳ [${msg.type}] ${msg.payload.title}`);
+            console.log(`     ID: ${msg.id} | From: ${msg.sessionId}`);
+            if (msg.payload.description) {
+                console.log(`     ${msg.payload.description.slice(0, 100)}...`);
+            }
+            console.log();
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentMsgCommand
+    .command("respond <messageId>")
+    .description("Respond to a pending message")
+    .requiredOption("--approve", "Approve the request")
+    .requiredOption("--reject", "Reject the request")
+    .option("--message <msg>", "Response message")
+    .action(async (messageId, options) => {
+    try {
+        if (options.approve && options.reject) {
+            console.error("Error: Cannot both approve and reject");
+            process.exit(1);
+        }
+        const approved = !!options.approve;
+        const config = getConfig();
+        const result = await apiCall(`/api/agent-messages/${messageId}/respond`, {
+            method: "POST",
+            body: JSON.stringify({
+                approved,
+                message: options.message,
+                respondedBy: config.workerId || "supervisor",
+            }),
+        });
+        console.log(`✅ Message ${approved ? "approved" : "rejected"}`);
+        if (options.message)
+            console.log(`   Response: ${options.message}`);
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentMsgCommand
+    .command("get <messageId>")
+    .description("Get message details")
+    .option("--json", "Output as JSON")
+    .action(async (messageId, options) => {
+    try {
+        const msg = await apiCall(`/api/agent-messages/${messageId}`);
+        if (options.json) {
+            console.log(JSON.stringify(msg, null, 2));
+            return;
+        }
+        console.log("\n  Message Details");
+        console.log("  " + "─".repeat(50));
+        console.log(`  ID:      ${msg.id}`);
+        console.log(`  Type:    ${msg.type}`);
+        console.log(`  Status:  ${msg.status}`);
+        console.log(`  From:    ${msg.sessionId}`);
+        if (msg.targetId)
+            console.log(`  Target:  ${msg.targetId}`);
+        console.log(`  Title:   ${msg.payload.title}`);
+        if (msg.payload.description) {
+            console.log(`  Desc:    ${msg.payload.description}`);
+        }
+        if (msg.response) {
+            console.log(`  Response: ${msg.response.approved ? "✅ Approved" : "❌ Rejected"}`);
+            if (msg.response.message)
+                console.log(`  Message:  ${msg.response.message}`);
+            console.log(`  By:       ${msg.response.respondedBy}`);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+agentMsgCommand
+    .command("wait <messageId>")
+    .description("Wait for a response to a message (blocking)")
+    .option("--timeout <seconds>", "Timeout in seconds", "300")
+    .option("--json", "Output as JSON")
+    .action(async (messageId, options) => {
+    const timeout = parseInt(options.timeout, 10) * 1000;
+    const start = Date.now();
+    const pollInterval = 2000;
+    process.stdout.write("Waiting for response");
+    while (Date.now() - start < timeout) {
+        try {
+            const msg = await apiCall(`/api/agent-messages/${messageId}`);
+            if (msg.status === "responded") {
+                console.log("\n");
+                if (options.json) {
+                    console.log(JSON.stringify(msg, null, 2));
+                }
+                else {
+                    console.log(`✅ Response received: ${msg.response.approved ? "Approved" : "Rejected"}`);
+                    if (msg.response.message)
+                        console.log(`   Message: ${msg.response.message}`);
+                }
+                process.exit(msg.response.approved ? 0 : 1);
+            }
+            if (msg.status === "expired") {
+                console.log("\n⌛ Message expired without response");
+                process.exit(2);
+            }
+            process.stdout.write(".");
+            await new Promise((r) => setTimeout(r, pollInterval));
+        }
+        catch (error) {
+            console.error("\nError:", error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    }
+    console.log("\n⏱️ Timeout waiting for response");
+    process.exit(2);
+});

package/dist/commands/agent.js

@@ -1,6 +1,7 @@
 import { Command } from "commander";
 import { spawn } from "child_process";
 import { StreamClient, updateSessionStatus, submitPlan, waitForApproval, } from "../lib/streaming.js";
+import { getConfig } from "./config.js";
 // ============================================
 // DEPRECATION NOTICE
 // ============================================
@@ -277,3 +278,272 @@ function parsePlanFromOutput(output) {
         estimatedRuntime: 5, // 5 minutes placeholder
     };
 }
+// ============================================
+// AGENT-TO-AGENT MESSAGING COMMANDS
+// ============================================
+// Role to emoji mapping for formatted messages
+const ROLE_EMOJI = {
+    supervisor: "\uD83D\uDC15", // Dog emoji for supervisor
+    worker: "\uD83D\uDD27", // Wrench emoji for worker
+    reviewer: "\uD83D\uDCDD", // Memo emoji for reviewer
+    support: "\uD83C\uDFA7", // Headphones emoji for support
+};
+// husky agent message
+agentCommand
+    .command("message")
+    .alias("msg")
+    .description("Send message to another agent")
+    .requiredOption("--to <agent>", "Target agent ID (supervisor, worker-1, reviewer, etc.)")
+    .option("--from <agent>", "Sender agent ID (default: from HUSKY_AGENT_ID env)")
+    .argument("<message>", "Message to send")
+    .action(async (message, options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    const senderId = options.from || process.env.HUSKY_AGENT_ID;
+    if (!senderId) {
+        console.error("Error: Sender agent ID not specified.");
+        console.error("  Either use --from <agent-id> or set HUSKY_AGENT_ID environment variable.");
+        process.exit(1);
+    }
+    const targetId = options.to;
+    try {
+        // 1. Lookup sender agent
+        const senderRes = await fetch(`${config.apiUrl}/api/agents/${senderId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!senderRes.ok) {
+            if (senderRes.status === 404) {
+                console.error(`Error: Sender agent '${senderId}' not found.`);
+                console.error("  Register first with: husky agent register --id <id> --name <name> --role <role>");
+            }
+            else {
+                console.error(`Error fetching sender agent: ${senderRes.status}`);
+            }
+            process.exit(1);
+        }
+        const sender = (await senderRes.json());
+        // 2. Lookup target agent
+        const targetRes = await fetch(`${config.apiUrl}/api/agents/${targetId}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!targetRes.ok) {
+            if (targetRes.status === 404) {
+                console.error(`Error: Target agent '${targetId}' not found.`);
+                console.error("  Available agents: husky agent list");
+            }
+            else {
+                console.error(`Error fetching target agent: ${targetRes.status}`);
+            }
+            process.exit(1);
+        }
+        const target = (await targetRes.json());
+        // 3. Format the message with emojis
+        const senderEmoji = sender.emoji || ROLE_EMOJI[sender.role] || "\uD83E\uDD16";
+        const targetEmoji = target.emoji || ROLE_EMOJI[target.role] || "\uD83E\uDD16";
+        const formattedMessage = `[${senderEmoji} ${sender.name} -> ${targetEmoji} ${target.name}]\n${message}`;
+        // 4. Send the message via API
+        const sendRes = await fetch(`${config.apiUrl}/api/agents/${targetId}/message`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                from: senderId,
+                message,
+                formatted: formattedMessage,
+            }),
+        });
+        if (!sendRes.ok) {
+            const error = await sendRes.text();
+            console.error(`Error sending message: ${sendRes.status} - ${error}`);
+            process.exit(1);
+        }
+        const result = (await sendRes.json());
+        if (result.ok) {
+            console.log(`Message queued for ${target.name} (id: ${result.messageId})`);
+            console.log(`  Delivery via supervisor-bridge to tmux session: ${target.tmuxSession || targetId}`);
+        }
+        else {
+            console.log(`Message delivery uncertain for ${target.name}`);
+        }
+    }
+    catch (error) {
+        console.error("Error sending message:", error);
+        process.exit(1);
+    }
+});
+// husky agent register
+agentCommand
+    .command("register")
+    .description("Register this agent with the platform")
+    .requiredOption("--id <id>", "Agent ID")
+    .requiredOption("--name <name>", "Agent display name")
+    .requiredOption("--role <role>", "Agent role (supervisor, worker, reviewer, support)")
+    .option("--emoji <emoji>", "Agent emoji", "\uD83E\uDD16")
+    .option("--tmux <session>", "tmux session name")
+    .option("--vm <vmName>", "VM name")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    // Validate role
+    const validRoles = ["supervisor", "worker", "reviewer", "support"];
+    if (!validRoles.includes(options.role)) {
+        console.error(`Error: Invalid role '${options.role}'.`);
+        console.error(`  Valid roles: ${validRoles.join(", ")}`);
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/agents/register`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                id: options.id,
+                name: options.name,
+                role: options.role,
+                emoji: options.emoji,
+                tmuxSession: options.tmux,
+                vmName: options.vm,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`Error registering agent: ${res.status} - ${error}`);
+            process.exit(1);
+        }
+        const agent = (await res.json());
+        console.log("\n  Agent Registered");
+        console.log("  " + "-".repeat(40));
+        console.log(`  ID:     ${agent.id}`);
+        console.log(`  Name:   ${agent.emoji} ${agent.name}`);
+        console.log(`  Role:   ${agent.role}`);
+        if (agent.tmuxSession) {
+            console.log(`  Tmux:   ${agent.tmuxSession}`);
+        }
+        if (agent.vmName) {
+            console.log(`  VM:     ${agent.vmName}`);
+        }
+        console.log("");
+        console.log("  Set HUSKY_AGENT_ID to use this agent:");
+        console.log(`  export HUSKY_AGENT_ID="${agent.id}"`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error registering agent:", error);
+        process.exit(1);
+    }
+});
+// husky agent list
+agentCommand
+    .command("list")
+    .description("List all registered agents")
+    .option("--status <status>", "Filter by status (online, offline, busy)")
+    .option("--role <role>", "Filter by role (supervisor, worker, reviewer, support)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    try {
+        const params = new URLSearchParams();
+        if (options.status)
+            params.set("status", options.status);
+        if (options.role)
+            params.set("role", options.role);
+        const res = await fetch(`${config.apiUrl}/api/agents?${params}`, {
+            headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
+        });
+        if (!res.ok) {
+            throw new Error(`API error: ${res.status}`);
+        }
+        const data = (await res.json());
+        const agents = data.agents || [];
+        if (options.json) {
+            console.log(JSON.stringify(agents, null, 2));
+            return;
+        }
+        if (agents.length === 0) {
+            console.log("No agents registered.");
+            console.log("\nRegister an agent with:");
+            console.log("  husky agent register --id <id> --name <name> --role <role>");
+            return;
+        }
+        console.log("\n  Registered Agents");
+        console.log("  " + "-".repeat(60));
+        for (const agent of agents) {
+            const statusIcon = agent.status === "online" ? "\u2714" :
+                agent.status === "busy" ? "\u231B" : "\u2717";
+            const lastSeen = agent.lastHeartbeat
+                ? new Date(agent.lastHeartbeat).toLocaleString()
+                : "never";
+            console.log(`  ${statusIcon} ${agent.emoji} ${agent.name} (${agent.id})`);
+            console.log(`      Role: ${agent.role} | Status: ${agent.status} | Last seen: ${lastSeen}`);
+            if (agent.tmuxSession) {
+                console.log(`      Tmux: ${agent.tmuxSession}`);
+            }
+            if (agent.vmName) {
+                console.log(`      VM: ${agent.vmName}`);
+            }
+            console.log("");
+        }
+    }
+    catch (error) {
+        console.error("Error fetching agents:", error);
+        process.exit(1);
+    }
+});
+// husky agent heartbeat
+agentCommand
+    .command("heartbeat")
+    .description("Send heartbeat to mark agent as online")
+    .option("--id <id>", "Agent ID (default: from HUSKY_AGENT_ID env)")
+    .action(async (options) => {
+    const config = getConfig();
+    if (!config.apiUrl) {
+        console.error("Error: API URL not configured. Run: husky config set api-url <url>");
+        process.exit(1);
+    }
+    const agentId = options.id || process.env.HUSKY_AGENT_ID;
+    if (!agentId) {
+        console.error("Error: Agent ID not specified.");
+        console.error("  Either use --id <agent-id> or set HUSKY_AGENT_ID environment variable.");
+        process.exit(1);
+    }
+    try {
+        const res = await fetch(`${config.apiUrl}/api/agents/${agentId}/heartbeat`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+        });
+        if (!res.ok) {
+            if (res.status === 404) {
+                console.error(`Error: Agent '${agentId}' not found.`);
+                console.error("  Register first with: husky agent register --id <id> --name <name> --role <role>");
+            }
+            else {
+                const error = await res.text();
+                console.error(`Error sending heartbeat: ${res.status} - ${error}`);
+            }
+            process.exit(1);
+        }
+        const result = (await res.json());
+        console.log(`Heartbeat sent. Agent '${agentId}' is now ${result.status}.`);
+    }
+    catch (error) {
+        console.error("Error sending heartbeat:", error);
+        process.exit(1);
+    }
+});

package/dist/commands/biz/gotess.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const gotessCommand: Command;
+export default gotessCommand;