@simonfestl/husky-cli 1.6.5 → 1.8.2

package/README.md

@@ -111,6 +111,38 @@ husky vm update <session-id> --status approved
 husky vm delete <session-id>
 ```
 
+### E2E Testing (E2E Agent)
+
+```bash
+# Run E2E tests for a task
+husky e2e run <task-id>
+husky e2e run <task-id> --secret ADMIN_PASSWORD --retries 2
+husky e2e run <task-id> --env TEST_USER=admin --headed
+
+# E2E Inbox (pending test requests)
+husky e2e inbox                          # List all inbox messages
+husky e2e inbox --status pending         # Filter by status
+husky e2e inbox --task <task-id>         # Filter by task
+
+# Watch for new E2E requests (auto-processing)
+husky e2e watch --interval 30
+husky e2e watch --once                   # Process once and exit
+
+# Complete E2E test request (used by e2e-bridge)
+husky e2e done <inbox-id> --passed       # Mark as passed
+husky e2e done <inbox-id> --failed --notes "reason"
+
+# Browser automation utilities
+husky e2e screenshot <url>               # Take screenshot
+husky e2e screenshot <url> --upload      # Upload to GCS
+husky e2e record <url>                   # Record browser session
+
+# Artifact management
+husky e2e upload <file> --task <id>      # Upload to GCS
+husky e2e list --task <id>               # List artifacts
+husky e2e clean --older-than 7           # Clean old artifacts
+```
+
 ### Business Strategy
 
 ```bash
@@ -296,6 +328,20 @@ husky --version
 
 ## Changelog
 
+### v1.7.0 (2026-01-11) - E2E Agent Production Ready
+
+**New Features:**
+- `husky e2e inbox` - List E2E test requests from API
+- `husky e2e watch` - Watch for and auto-process E2E requests
+- `husky e2e run --secret` - Inject secrets from GCP Secret Manager
+- `husky e2e run --env` - Set environment variables for tests
+- `husky e2e run --retries` - Retry failed tests automatically
+
+**Improvements:**
+- All artifact URLs now use HTTPS
+- Better error handling in E2E commands
+- Updated permissions for e2e_agent role
+
 ### v1.1.0 (2026-01-09) - Unified Reply System
 
 **New Features:**

package/dist/commands/agent.js

@@ -376,6 +376,49 @@ agentCommand
         process.exit(1);
     }
 });
+// husky agent qa-review
+agentCommand
+    .command("qa-review <taskId>")
+    .description("Trigger QA review for a task")
+    .option("--pr <url>", "PR URL to review")
+    .option("--json", "Output as JSON")
+    .action(async (taskId, 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 res = await fetch(`${config.apiUrl}/api/tasks/${taskId}/assign-reviewer`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                prUrl: options.pr,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            console.error(`Error assigning reviewer: ${res.status} - ${error}`);
+            process.exit(1);
+        }
+        const data = await res.json();
+        if (options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+        else {
+            console.log(`\n✓ Task ${taskId} assigned to reviewer`);
+            console.log(`  Inbox ID: ${data.inboxId}`);
+            console.log(`  Message:  ${data.message}`);
+        }
+    }
+    catch (error) {
+        console.error("Error triggering QA review:", error);
+        process.exit(1);
+    }
+});
 // husky agent register
 agentCommand
     .command("register")

package/dist/commands/biz/tickets.js

@@ -5,6 +5,7 @@
  */
 import { Command } from "commander";
 import { ZendeskClient } from "../../lib/biz/index.js";
+import { AgentBrain } from "../../lib/biz/agent-brain.js";
 import * as fs from "fs";
 import * as path from "path";
 export const ticketsCommand = new Command("tickets")
@@ -181,9 +182,38 @@ ticketsCommand
 ticketsCommand
     .command("close <id>")
     .description("Close/solve a ticket")
-    .action(async (id) => {
+    .option("--learning", "Capture learning from ticket before closing")
+    .option("-a, --agent <id>", "Agent ID for learning capture")
+    .action(async (id, options) => {
     try {
         const client = ZendeskClient.fromConfig();
+        // Capture learning if flag is set
+        if (options.learning) {
+            const ticketId = parseInt(id, 10);
+            const ticket = await client.getTicket(ticketId);
+            const comments = await client.getTicketComments(ticketId);
+            // Build learning content from ticket and resolution
+            const learningContent = [
+                `Ticket #${ticket.id}: ${ticket.subject}`,
+                `Status: ${ticket.status} → solved`,
+                `Priority: ${ticket.priority}`,
+                `Tags: ${ticket.tags?.join(', ') || 'none'}`,
+                '',
+                'Resolution:',
+                comments.slice(-3).map((c) => `- ${c.body.substring(0, 200)}${c.body.length > 200 ? '...' : ''}`).join('\n')
+            ].join('\n');
+            // Capture to Brain
+            const agentId = options.agent || process.env.HUSKY_AGENT_ID || 'support-agent';
+            const brain = new AgentBrain(agentId, 'support');
+            await brain.remember(learningContent, ['ticket-resolution', 'support', ...(ticket.tags || [])], {
+                ticketId: ticket.id,
+                subject: ticket.subject,
+                priority: ticket.priority,
+                closedAt: new Date().toISOString()
+            }, 'private' // visibility
+            );
+            console.log(`  💡 Captured learning from ticket #${ticket.id}`);
+        }
         const ticket = await client.closeTicket(parseInt(id, 10));
         console.log(`✓ Ticket #${ticket.id} marked as solved`);
     }

package/dist/commands/brain.js

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import { AgentBrain, AGENT_TYPES, isValidAgentType } from "../lib/biz/agent-brain.js";
+import { generateSOP, formatSOPAsMarkdown } from "../lib/biz/sop-generator.js";
 const DEFAULT_AGENT = process.env.HUSKY_AGENT_ID || 'default';
 function createBrain(agentId, agentType) {
     const validAgentType = isValidAgentType(agentType) ? agentType : undefined;
@@ -13,14 +14,21 @@ brainCommand
     .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
     .option("-t, --tags <tags>", "Comma-separated tags")
     .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--visibility <level>", "Visibility level (private, team, public)", "private")
+    .option("--allow-pii", "Skip PII filtering (use only for technical/internal content)")
     .option("--json", "Output as JSON")
     .action(async (content, options) => {
     try {
         const brain = createBrain(options.agent, options.agentType);
         const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+        const visibility = options.visibility;
         const dbInfo = brain.getDatabaseInfo();
+        if (!["private", "team", "public"].includes(visibility)) {
+            console.error("Error: Visibility must be 'private', 'team', or 'public'");
+            process.exit(1);
+        }
         console.log(`  Storing memory for agent: ${options.agent} (db: ${dbInfo.databaseName})...`);
-        const id = await brain.remember(content, tags);
+        const id = await brain.remember(content, tags, undefined, visibility, options.allowPii);
         if (options.json) {
             console.log(JSON.stringify({ success: true, id, agent: options.agent, database: dbInfo.databaseName }));
         }
@@ -40,25 +48,39 @@ brainCommand
     .option("-l, --limit <num>", "Max results", "5")
     .option("-m, --min-score <score>", "Minimum similarity score (0-1)", "0.5")
     .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--shared", "Search shared memories from other agents")
+    .option("--public-only", "Search only public memories (requires --shared)")
     .option("--json", "Output as JSON")
     .action(async (query, options) => {
     try {
         const brain = createBrain(options.agent, options.agentType);
-        const dbInfo = brain.getDatabaseInfo();
-        console.log(`  Searching memories for: "${query}" (db: ${dbInfo.databaseName})...`);
-        const results = await brain.recall(query, parseInt(options.limit, 10), parseFloat(options.minScore));
+        let results;
+        if (options.shared) {
+            // Search shared memories
+            results = await brain.recallShared(query, parseInt(options.limit, 10), parseFloat(options.minScore), options.publicOnly);
+        }
+        else {
+            // Search personal memories
+            const dbInfo = brain.getDatabaseInfo();
+            console.log(`  Searching memories for: "${query}" (db: ${dbInfo.databaseName})...`);
+            results = await brain.recall(query, parseInt(options.limit, 10), parseFloat(options.minScore));
+        }
         if (options.json) {
-            console.log(JSON.stringify({ success: true, query, database: dbInfo.databaseName, results }));
+            const dbInfo = brain.getDatabaseInfo();
+            console.log(JSON.stringify({ success: true, query, database: dbInfo.databaseName, shared: options.shared || false, results }));
             return;
         }
-        console.log(`\n  🧠 Memories for "${query}" (${results.length} found)\n`);
+        const icon = options.shared ? '🌐' : '🧠';
+        const label = options.shared ? 'Shared Memories' : 'Memories';
+        console.log(`\n  ${icon} ${label} for "${query}" (${results.length} found)\n`);
         if (results.length === 0) {
-            console.log("  No relevant memories found.");
+            console.log(`  No relevant ${options.shared ? 'shared ' : ''}memories found.`);
             return;
         }
         for (const r of results) {
             const tags = r.memory.tags.length > 0 ? ` [${r.memory.tags.join(", ")}]` : "";
-            console.log(`  [${(r.score * 100).toFixed(1)}%] ${r.memory.content.slice(0, 80)}${tags}`);
+            const visibility = options.shared && r.memory.visibility ? ` [${r.memory.visibility}]` : "";
+            console.log(`  [${(r.score * 100).toFixed(1)}%]${visibility} ${r.memory.content.slice(0, 80)}${tags}`);
         }
         console.log("");
     }
@@ -212,4 +234,253 @@ brainCommand
         process.exit(1);
     }
 });
+// ============================================================================
+// Phase 2: Cross-Agent Sharing
+// ============================================================================
+brainCommand
+    .command("publish <id>")
+    .description("Publish a memory for sharing")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--visibility <level>", "Visibility level (team, public)", "team")
+    .action(async (memoryId, options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const visibility = options.visibility;
+        if (visibility !== "team" && visibility !== "public") {
+            console.error("Error: Visibility must be 'team' or 'public'");
+            process.exit(1);
+        }
+        await brain.publish(memoryId, visibility);
+        console.log(`  ✓ Memory published as ${visibility}`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("unpublish <id>")
+    .description("Unpublish a memory (set to private)")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .action(async (memoryId, options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        await brain.unpublish(memoryId);
+        console.log(`  ✓ Memory unpublished (set to private)`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("shared")
+    .description("List shared memories")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("-l, --limit <num>", "Max results", "20")
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--public-only", "Show only public memories")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const memories = await brain.listShared(parseInt(options.limit, 10), options.publicOnly);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, memories }));
+            return;
+        }
+        console.log(`\n  🌐 Shared Memories (${memories.length})\n`);
+        if (memories.length === 0) {
+            console.log("  No shared memories found.");
+            return;
+        }
+        for (const m of memories) {
+            const visibility = m.visibility || 'private';
+            const endorsements = m.endorsements || 0;
+            console.log(`  [${visibility}] ${m.content.slice(0, 70)}... (${endorsements} 👍)`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Phase 3: Quality & Decay
+// ============================================================================
+brainCommand
+    .command("boost <id>")
+    .description("Boost a memory (positive feedback)")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .action(async (memoryId, options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        await brain.boost(memoryId);
+        console.log(`  ✓ Memory boosted: ${memoryId}`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("downvote <id>")
+    .description("Downvote a memory (negative feedback)")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .action(async (memoryId, options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        await brain.downvote(memoryId);
+        console.log(`  ✓ Memory downvoted: ${memoryId}`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("quality <id>")
+    .description("Show quality metrics for a memory")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--json", "Output as JSON")
+    .action(async (memoryId, options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const quality = await brain.getQuality(memoryId);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, ...quality }));
+            return;
+        }
+        console.log(`\n  📊 Quality Metrics: ${memoryId}`);
+        console.log(`  ────────────────────────────────`);
+        console.log(`  Recall Count:    ${quality.recallCount}`);
+        console.log(`  Boost Count:     ${quality.boostCount}`);
+        console.log(`  Downvote Count:  ${quality.downvoteCount}`);
+        console.log(`  Quality Score:   ${quality.qualityScore.toFixed(2)}`);
+        console.log(`  Status:          ${quality.status}`);
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("cleanup")
+    .description("Archive low-quality memories")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--dry-run", "Show what would be archived without doing it", true)
+    .option("--execute", "Actually perform the cleanup (removes dry-run)")
+    .option("--threshold <score>", "Quality threshold for archiving", "0.1")
+    .option("--min-age-days <days>", "Minimum age in days", "90")
+    .option("-t, --tag <tags...>", "Filter by tags (for system migrations)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const dryRun = !options.execute;
+        const tags = options.tag;
+        const toArchive = await brain.cleanup(dryRun, parseFloat(options.threshold), parseInt(options.minAgeDays, 10), tags);
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, dryRun, count: toArchive.length, memories: toArchive }));
+            return;
+        }
+        console.log(`\n  🧹 Cleanup ${dryRun ? '(DRY RUN)' : ''}`);
+        console.log(`  ────────────────────────────────`);
+        console.log(`  Memories to archive: ${toArchive.length}`);
+        if (toArchive.length > 0) {
+            console.log(`\n  Memories:`);
+            for (const m of toArchive.slice(0, 10)) {
+                const age = Math.floor((Date.now() - m.createdAt.getTime()) / (1000 * 60 * 60 * 24));
+                console.log(`    ${m.id.slice(0, 8)} │ ${m.content.slice(0, 50)}... (${age}d old, Q: ${m.qualityScore?.toFixed(2)})`);
+            }
+            if (toArchive.length > 10) {
+                console.log(`    ... and ${toArchive.length - 10} more`);
+            }
+        }
+        if (dryRun && toArchive.length > 0) {
+            console.log(`\n  💡 Use --execute to actually perform the cleanup`);
+        }
+        console.log("");
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+brainCommand
+    .command("purge")
+    .description("Permanently delete archived memories")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--retention-days <days>", "Retention period in days", "365")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        const brain = createBrain(options.agent, options.agentType);
+        const count = await brain.purge(parseInt(options.retentionDays, 10));
+        if (options.json) {
+            console.log(JSON.stringify({ success: true, deleted: count }));
+            return;
+        }
+        console.log(`  ✓ Purged ${count} archived memory(ies)`);
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
+// ============================================================================
+// Phase 5: SOP Generation
+// ============================================================================
+brainCommand
+    .command("generate-sop <topic>")
+    .description("Generate SOP from learnings")
+    .option("-a, --agent <id>", "Agent ID", DEFAULT_AGENT)
+    .option("--agent-type <type>", `Agent type for database selection (${AGENT_TYPES.join(", ")})`)
+    .option("--min-memories <num>", "Minimum learnings required", "5")
+    .option("--json", "Output as JSON")
+    .option("-o, --output <file>", "Save SOP to file")
+    .action(async (topic, options) => {
+    try {
+        console.log(`  Generating SOP for topic: ${topic}...`);
+        const sop = await generateSOP(options.agent, {
+            topic,
+            agentType: isValidAgentType(options.agentType) ? options.agentType : undefined,
+            minMemories: parseInt(options.minMemories, 10),
+        });
+        if (options.json) {
+            const output = JSON.stringify(sop, null, 2);
+            if (options.output) {
+                const fs = await import("fs");
+                fs.writeFileSync(options.output, output);
+                console.log(`  ✓ SOP saved to ${options.output}`);
+            }
+            else {
+                console.log(output);
+            }
+            return;
+        }
+        const markdown = formatSOPAsMarkdown(sop);
+        if (options.output) {
+            const fs = await import("fs");
+            fs.writeFileSync(options.output, markdown);
+            console.log(`  ✓ SOP saved to ${options.output}`);
+        }
+        else {
+            console.log(markdown);
+        }
+    }
+    catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+});
 export default brainCommand;

package/dist/commands/chat.js

@@ -377,6 +377,114 @@ chatCommand
         process.exit(1);
     }
 });
+chatCommand
+    .command("send-file <filePath>")
+    .description("Send a file attachment to Google Chat (images auto-compressed)")
+    .option("--space <name>", "Target space (e.g., spaces/ABC123)")
+    .option("--thread <name>", "Reply in thread")
+    .option("--text <message>", "Optional message text to accompany the file")
+    .option("--no-compress", "Skip image compression")
+    .action(async (filePath, options) => {
+    const config = getConfig();
+    const huskyApiUrl = getHuskyApiUrl();
+    if (!huskyApiUrl) {
+        console.error("Error: API URL not configured. Set husky-api-url or api-url.");
+        process.exit(1);
+    }
+    const fs = await import("fs");
+    const path = await import("path");
+    // Check if file exists
+    if (!fs.existsSync(filePath)) {
+        console.error(`Error: File not found: ${filePath}`);
+        process.exit(1);
+    }
+    const fileName = path.basename(filePath);
+    // Determine MIME type from extension
+    const ext = path.extname(filePath).toLowerCase().slice(1);
+    const mimeTypes = {
+        // Images
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+        // Documents
+        pdf: "application/pdf",
+        txt: "text/plain",
+        md: "text/markdown",
+        // Data
+        json: "application/json",
+        xml: "application/xml",
+        csv: "text/csv",
+        yaml: "application/x-yaml",
+        yml: "application/x-yaml",
+        // Code
+        js: "text/javascript",
+        ts: "text/typescript",
+        py: "text/x-python",
+        html: "text/html",
+        css: "text/css",
+        sh: "text/x-sh",
+        sql: "text/x-sql",
+    };
+    const mimeType = mimeTypes[ext] || "application/octet-stream";
+    // Read file
+    let fileBuffer = fs.readFileSync(filePath);
+    const originalSize = fileBuffer.length;
+    console.log(`📤 Preparing ${fileName} (${(originalSize / 1024).toFixed(1)} KB, ${mimeType})...`);
+    // Compress images automatically (unless --no-compress flag is set)
+    const isImage = mimeType.startsWith("image/") && !mimeType.includes("svg");
+    if (isImage && options.compress !== false) {
+        try {
+            const sharp = await import("sharp");
+            console.log(`🔄 Compressing image...`);
+            const compressed = await sharp.default(fileBuffer)
+                .resize(1920, 1920, {
+                fit: "inside",
+                withoutEnlargement: true
+            })
+                .jpeg({ quality: 80 })
+                .toBuffer();
+            fileBuffer = Buffer.from(compressed);
+            const compressedSize = fileBuffer.length;
+            const savedPercent = ((1 - compressedSize / originalSize) * 100).toFixed(0);
+            console.log(`✓ Compressed: ${(originalSize / 1024).toFixed(1)} KB → ${(compressedSize / 1024).toFixed(1)} KB (saved ${savedPercent}%)`);
+        }
+        catch (error) {
+            console.warn(`⚠️  Compression failed, uploading original: ${error.message}`);
+        }
+    }
+    const fileBase64 = fileBuffer.toString("base64");
+    console.log(`📤 Uploading ${fileName} (${(fileBuffer.length / 1024).toFixed(1)} KB)...`);
+    try {
+        const res = await fetch(`${huskyApiUrl}/api/google-chat/send-file`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+            },
+            body: JSON.stringify({
+                fileBase64,
+                fileName,
+                mimeType,
+                text: options.text,
+                spaceName: options.space,
+                threadName: options.thread,
+            }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            throw new Error(`API error: ${res.status} - ${error}`);
+        }
+        const data = await res.json();
+        console.log(`✅ File sent to Google Chat: ${data.fileName}`);
+    }
+    catch (error) {
+        console.error("Error sending file:", error);
+        process.exit(1);
+    }
+});
 chatCommand
     .command("reply-to <messageId> <response>")
     .description("Reply to a specific inbox message in its thread (supports both GitHub and Google Chat)")
@@ -446,7 +554,22 @@ chatCommand
                 method: "POST",
                 headers: config.apiKey ? { "x-api-key": config.apiKey } : {},
             });
-            console.log("✅ Reply sent to Google Chat and message marked as read.");
+            // Add reaction to original message if messageName is available
+            if (msg.messageName) {
+                try {
+                    await fetch(`${huskyApiUrl}/api/google-chat/messages/${encodeURIComponent(msg.messageName)}/react`, {
+                        method: "POST",
+                        headers: {
+                            "Content-Type": "application/json",
+                            ...(config.apiKey ? { "x-api-key": config.apiKey } : {}),
+                        },
+                        body: JSON.stringify({ emoji: "✅" }),
+                    });
+                }
+                catch {
+                    // Reaction is optional - don't fail if it doesn't work
+                }
+            }
         }
     }
     catch (error) {

package/dist/commands/config.d.ts

@@ -24,6 +24,10 @@ interface Config {
     gotessToken?: string;
     gotessBookId?: string;
     agentType?: string;
+    geminiApiKey?: string;
+    nocodbApiToken?: string;
+    nocodbBaseUrl?: string;
+    nocodbWorkspaceId?: string;
 }
 export declare function getConfig(): Config;
 /**

package/dist/commands/config.js

@@ -159,6 +159,12 @@ configCommand
         "gotess-token": "gotessToken",
         "gotess-book-id": "gotessBookId",
         "agent-type": "agentType",
+        // Gemini
+        "gemini-api-key": "geminiApiKey",
+        // NocoDB
+        "nocodb-api-token": "nocodbApiToken",
+        "nocodb-base-url": "nocodbBaseUrl",
+        "nocodb-workspace-id": "nocodbWorkspaceId",
     };
     const configKey = keyMappings[key];
     if (!configKey) {
@@ -171,6 +177,8 @@ configCommand
         console.log("  Qdrant:   qdrant-url, qdrant-api-key");
         console.log("  GCP:      gcp-project-id, gcp-location");
         console.log("  Gotess:   gotess-token, gotess-book-id");
+        console.log("  Gemini:   gemini-api-key");
+        console.log("  NocoDB:   nocodb-api-token, nocodb-base-url, nocodb-workspace-id");
         console.log("  Brain:    agent-type");
         process.exit(1);
     }
@@ -193,7 +201,7 @@ configCommand
     config[configKey] = value;
     saveConfig(config);
     // Mask sensitive values in output
-    const sensitiveKeys = ["api-key", "billbee-api-key", "billbee-password", "zendesk-api-token", "seatable-api-token", "gotess-token"];
+    const sensitiveKeys = ["api-key", "billbee-api-key", "billbee-password", "zendesk-api-token", "seatable-api-token", "gotess-token", "gemini-api-key", "nocodb-api-token"];
     const displayValue = sensitiveKeys.includes(key) ? "***" : value;
     console.log(`✓ Set ${key} = ${displayValue}`);
 });