whale-code 6.4.0

package/dist/local-agent/executor.js

@@ -0,0 +1,241 @@
+/**
+ * Local Command Executor — safely runs commands on the user's machine.
+ *
+ * Features:
+ * - Persistent sessions (cwd preserved per session_id)
+ * - Output streaming with truncation
+ * - Timeout enforcement
+ * - Background job support
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+const MAX_OUTPUT_CHARS = 500 * 1024; // 500KB safety cap
+const DEFAULT_TIMEOUT = 30_000;
+// ============================================================================
+// SESSION STATE
+// ============================================================================
+/** Map<sessionId, cwd> — persistent working directory per session */
+const sessions = new Map();
+const backgroundJobs = new Map();
+export async function exec(command, options = {}) {
+    const sessionId = options.session_id || "default";
+    const timeout = Math.min(options.timeout || DEFAULT_TIMEOUT, 600_000);
+    // Get or create session cwd
+    if (!sessions.has(sessionId)) {
+        sessions.set(sessionId, os.homedir());
+    }
+    const cwd = sessions.get(sessionId);
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        let done = false;
+        const shell = process.platform === "win32" ? "cmd.exe" : "/bin/bash";
+        const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
+        const proc = spawn(shell, shellArgs, {
+            cwd,
+            env: { ...process.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const timer = setTimeout(() => {
+            if (!done) {
+                killed = true;
+                proc.kill("SIGKILL");
+            }
+        }, timeout);
+        proc.stdout?.on("data", (data) => {
+            const chunk = data.toString();
+            if (stdout.length < MAX_OUTPUT_CHARS) {
+                stdout += chunk;
+            }
+        });
+        proc.stderr?.on("data", (data) => {
+            const chunk = data.toString();
+            if (stderr.length < MAX_OUTPUT_CHARS) {
+                stderr += chunk;
+            }
+        });
+        proc.on("close", (code) => {
+            done = true;
+            clearTimeout(timer);
+            // Update session cwd if command included cd
+            // Parse the last directory from a subshell approach
+            if (command.includes("cd ")) {
+                try {
+                    const pwdProc = spawn(shell, ["-c", `cd "${cwd}" && ${command} && pwd`], {
+                        cwd,
+                        stdio: ["pipe", "pipe", "pipe"],
+                        timeout: 3000,
+                    });
+                    let newCwd = "";
+                    pwdProc.stdout?.on("data", (d) => { newCwd += d.toString(); });
+                    pwdProc.on("close", () => {
+                        const dir = newCwd.trim().split("\n").pop()?.trim();
+                        if (dir)
+                            sessions.set(sessionId, dir);
+                    });
+                }
+                catch {
+                    // Ignore cwd tracking failures
+                }
+            }
+            // Truncate if needed
+            if (stdout.length > MAX_OUTPUT_CHARS) {
+                stdout = stdout.substring(0, MAX_OUTPUT_CHARS) + `\n...[truncated, ${stdout.length} total chars]`;
+            }
+            if (stderr.length > MAX_OUTPUT_CHARS) {
+                stderr = stderr.substring(0, MAX_OUTPUT_CHARS) + `\n...[truncated, ${stderr.length} total chars]`;
+            }
+            resolve({
+                success: code === 0,
+                stdout,
+                stderr,
+                exit_code: code ?? -1,
+                killed,
+                cwd: sessions.get(sessionId) || cwd,
+                duration_ms: Date.now() - startTime,
+            });
+        });
+        proc.on("error", (err) => {
+            done = true;
+            clearTimeout(timer);
+            resolve({
+                success: false,
+                stdout,
+                stderr: err.message,
+                exit_code: -1,
+                killed: false,
+                cwd,
+                duration_ms: Date.now() - startTime,
+            });
+        });
+    });
+}
+// ============================================================================
+// BACKGROUND JOBS
+// ============================================================================
+export function execBackground(command, sessionId) {
+    const jobId = randomUUID();
+    const cwd = sessions.get(sessionId || "default") || os.homedir();
+    const shell = process.platform === "win32" ? "cmd.exe" : "/bin/bash";
+    const shellArgs = process.platform === "win32" ? ["/c", command] : ["-c", command];
+    const proc = spawn(shell, shellArgs, {
+        cwd,
+        env: { ...process.env },
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: true,
+    });
+    const job = {
+        id: jobId,
+        command,
+        process: proc,
+        stdout: "",
+        stderr: "",
+        startedAt: Date.now(),
+        exitCode: null,
+        killed: false,
+        done: false,
+    };
+    proc.stdout?.on("data", (data) => {
+        if (job.stdout.length < MAX_OUTPUT_CHARS) {
+            job.stdout += data.toString();
+        }
+    });
+    proc.stderr?.on("data", (data) => {
+        if (job.stderr.length < MAX_OUTPUT_CHARS) {
+            job.stderr += data.toString();
+        }
+    });
+    proc.on("close", (code) => {
+        job.exitCode = code;
+        job.done = true;
+    });
+    proc.on("error", (err) => {
+        job.stderr += `\nProcess error: ${err.message}`;
+        job.done = true;
+        job.exitCode = -1;
+    });
+    backgroundJobs.set(jobId, job);
+    return { job_id: jobId };
+}
+export function getJobStatus(jobId, tail) {
+    const job = backgroundJobs.get(jobId);
+    if (!job)
+        return null;
+    let stdout = job.stdout;
+    let stderr = job.stderr;
+    if (tail && tail > 0) {
+        stdout = stdout.slice(-tail);
+        stderr = stderr.slice(-tail);
+    }
+    return {
+        job_id: job.id,
+        command: job.command,
+        running: !job.done,
+        exit_code: job.exitCode,
+        killed: job.killed,
+        stdout,
+        stderr,
+        duration_ms: Date.now() - job.startedAt,
+    };
+}
+export function killJob(jobId) {
+    const job = backgroundJobs.get(jobId);
+    if (!job || job.done)
+        return false;
+    job.killed = true;
+    try {
+        if (job.process.pid) {
+            process.kill(-job.process.pid, "SIGKILL");
+        }
+        else {
+            job.process.kill("SIGKILL");
+        }
+    }
+    catch {
+        job.process.kill("SIGKILL");
+    }
+    return true;
+}
+export function listJobs() {
+    return [...backgroundJobs.values()].map(job => ({
+        job_id: job.id,
+        command: job.command.substring(0, 100),
+        running: !job.done,
+        exit_code: job.exitCode,
+        duration_ms: Date.now() - job.startedAt,
+    }));
+}
+// ============================================================================
+// SESSION MANAGEMENT
+// ============================================================================
+export function listSessions() {
+    return [...sessions.entries()].map(([id, cwd]) => ({ session_id: id, cwd }));
+}
+export function resetSessions() {
+    sessions.clear();
+    for (const [id, job] of backgroundJobs) {
+        if (!job.done) {
+            try {
+                job.process.kill("SIGKILL");
+            }
+            catch { /* */ }
+        }
+    }
+    backgroundJobs.clear();
+}
+export function getSystemInfo() {
+    return {
+        platform: process.platform,
+        arch: process.arch,
+        hostname: os.hostname(),
+        user: os.userInfo().username,
+        home: os.homedir(),
+        cpus: os.cpus().length,
+        memory_gb: Math.round(os.totalmem() / 1024 / 1024 / 1024 * 10) / 10,
+        uptime_hours: Math.round(os.uptime() / 3600 * 10) / 10,
+        node_version: process.version,
+    };
+}

package/dist/local-agent/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * SwagManager Local Agent — CLI entry point.
+ *
+ * Connects to SwagManager cloud via WebSocket, auto-discovers local security tools,
+ * and executes commands from Claude on the user's machine.
+ *
+ * Usage:
+ *   whale agent start --key YOUR_API_KEY
+ *   whale agent start --key YOUR_API_KEY --server wss://custom.server/agent/ws
+ *   whale agent discover                    # list detected tools
+ *   whale agent info                        # system info
+ */
+export {};

package/dist/local-agent/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+/**
+ * SwagManager Local Agent — CLI entry point.
+ *
+ * Connects to SwagManager cloud via WebSocket, auto-discovers local security tools,
+ * and executes commands from Claude on the user's machine.
+ *
+ * Usage:
+ *   whale agent start --key YOUR_API_KEY
+ *   whale agent start --key YOUR_API_KEY --server wss://custom.server/agent/ws
+ *   whale agent discover                    # list detected tools
+ *   whale agent info                        # system info
+ */
+import { LocalAgentConnection } from "./connection.js";
+import { discoverTools } from "./discovery.js";
+import { getSystemInfo } from "./executor.js";
+const args = process.argv.slice(2);
+const command = args[0];
+function getFlag(name) {
+    const idx = args.indexOf(`--${name}`);
+    if (idx >= 0 && idx + 1 < args.length)
+        return args[idx + 1];
+    // Also check -k shorthand for --key
+    if (name === "key") {
+        const shortIdx = args.indexOf("-k");
+        if (shortIdx >= 0 && shortIdx + 1 < args.length)
+            return args[shortIdx + 1];
+    }
+    return undefined;
+}
+// ============================================================================
+// BANNER
+// ============================================================================
+function printBanner() {
+    console.log(`
+  ____                        __  __
+ / ___|_      ____ _  __ _   |  \\/  | __ _ _ __   __ _  __ _  ___ _ __
+ \\___ \\ \\ /\\ / / _\` |/ _\` |  | |\\/| |/ _\` | '_ \\ / _\` |/ _\` |/ _ \\ '__|
+  ___) \\ V  V / (_| | (_| |  | |  | | (_| | | | | (_| | (_| |  __/ |
+ |____/ \\_/\\_/ \\__,_|\\__, |  |_|  |_|\\__,_|_| |_|\\__,_|\\__, |\\___|_|
+                      |___/                              |___/
+  Local Security Agent v1.0
+`);
+}
+// ============================================================================
+// COMMANDS
+// ============================================================================
+async function startAgent() {
+    const apiKey = getFlag("key") || process.env.SWAGMANAGER_API_KEY;
+    if (!apiKey) {
+        console.error("Error: API key required. Use --key YOUR_KEY or set SWAGMANAGER_API_KEY");
+        console.error("");
+        console.error("Generate a key:");
+        console.error("  In Claude Code, run: mcp__swagmanager__api_keys({action: 'generate', name: 'local-agent'})");
+        process.exit(1);
+    }
+    const serverUrl = getFlag("server") || process.env.SWAGMANAGER_SERVER_URL;
+    printBanner();
+    const agentConfig = {
+        apiKey,
+    };
+    if (serverUrl)
+        agentConfig.serverUrl = serverUrl;
+    const agent = new LocalAgentConnection({
+        ...agentConfig,
+        onConnected: () => {
+            console.log("[whale agent] Connected and ready. Waiting for commands from Claude...");
+            console.log("[whale agent] Press Ctrl+C to disconnect.");
+        },
+        onDisconnected: (reason) => {
+            console.log(`[whale agent] Disconnected: ${reason}`);
+        },
+        onError: (err) => {
+            console.error(`[whale agent] Error: ${err.message}`);
+        },
+        onLog: (msg) => {
+            console.log(msg);
+        },
+    });
+    // Graceful shutdown
+    process.on("SIGINT", () => {
+        console.log("\n[whale agent] Shutting down...");
+        agent.disconnect();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        agent.disconnect();
+        process.exit(0);
+    });
+    try {
+        await agent.connect();
+    }
+    catch (err) {
+        console.error(`[whale agent] Failed to connect: ${err.message}`);
+        process.exit(1);
+    }
+    // Keep process alive
+    setInterval(() => { }, 60_000);
+}
+function showDiscover() {
+    printBanner();
+    console.log("Scanning for security tools...\n");
+    const tools = discoverTools();
+    if (tools.length === 0) {
+        console.log("No security tools found.\n");
+        console.log("Install some tools:");
+        console.log("  brew install nmap wireshark hashcat hydra aircrack-ng");
+        console.log("  pip install sqlmap");
+        return;
+    }
+    // Group by category
+    const byCategory = new Map();
+    for (const tool of tools) {
+        const cat = byCategory.get(tool.category) || [];
+        cat.push(tool);
+        byCategory.set(tool.category, cat);
+    }
+    const categoryNames = {
+        network_scanning: "Network Scanning",
+        packet_analysis: "Packet Analysis",
+        web_security: "Web Application Security",
+        exploitation: "Exploitation Frameworks",
+        password_cracking: "Password Cracking",
+        wireless: "Wireless Attacks",
+        recon: "Reconnaissance & OSINT",
+        post_exploitation: "Post-Exploitation",
+        forensics: "Forensics",
+        utility: "Utilities",
+    };
+    for (const [category, categoryTools] of byCategory) {
+        console.log(`\n  ${categoryNames[category] || category}`);
+        console.log("  " + "-".repeat(40));
+        for (const tool of categoryTools) {
+            const version = tool.version ? ` (v${tool.version})` : "";
+            const running = tool.running ? " [RUNNING]" : "";
+            console.log(`    ${tool.name.padEnd(20)} ${tool.path}${version}${running}`);
+        }
+    }
+    console.log(`\n  Total: ${tools.length} tools found\n`);
+}
+function showInfo() {
+    const info = getSystemInfo();
+    console.log("\nSystem Information:");
+    console.log("  " + "-".repeat(40));
+    for (const [key, value] of Object.entries(info)) {
+        console.log(`  ${key.padEnd(20)} ${value}`);
+    }
+    console.log("");
+}
+function showHelp() {
+    printBanner();
+    console.log("Usage:");
+    console.log("  whale agent start --key YOUR_API_KEY     Connect to SwagManager cloud");
+    console.log("  whale agent discover                     List detected security tools");
+    console.log("  whale agent info                         Show system information");
+    console.log("  whale agent help                         Show this help");
+    console.log("");
+    console.log("Options:");
+    console.log("  --key, -k       API key for authentication");
+    console.log("  --server        Custom server URL (default: wss://whale-agent.fly.dev/agent/ws)");
+    console.log("");
+    console.log("Environment Variables:");
+    console.log("  SWAGMANAGER_API_KEY       API key (alternative to --key)");
+    console.log("  SWAGMANAGER_SERVER_URL    Server URL (alternative to --server)");
+    console.log("");
+}
+// ============================================================================
+// MAIN
+// ============================================================================
+switch (command) {
+    case "start":
+    case "connect":
+    case "run":
+        startAgent().catch((err) => {
+            console.error("Fatal:", err.message);
+            process.exit(1);
+        });
+        break;
+    case "discover":
+    case "scan":
+    case "tools":
+        showDiscover();
+        break;
+    case "info":
+    case "status":
+        showInfo();
+        break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+        showHelp();
+        break;
+    default:
+        console.error(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+}

package/dist/node/adapters/base.d.ts

@@ -0,0 +1,35 @@
+export interface MessagePayload {
+    sender_id: string;
+    sender_name?: string;
+    content: string;
+    content_type?: string;
+    metadata?: Record<string, unknown>;
+    conversation_id?: string;
+}
+export interface OutboundMessage {
+    id: string;
+    content: string;
+    sender_id: string;
+    sender_name?: string;
+    conversation_id?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AdapterStats {
+    messages_in: number;
+    messages_out: number;
+    last_message_at?: string;
+    errors: number;
+}
+export declare abstract class BaseAdapter {
+    abstract readonly type: string;
+    abstract readonly name: string;
+    protected stats: AdapterStats;
+    protected running: boolean;
+    abstract start(): Promise<void>;
+    abstract stop(): Promise<void>;
+    abstract sendMessage(msg: OutboundMessage): Promise<boolean>;
+    getStats(): AdapterStats;
+    isRunning(): boolean;
+    protected onInboundMessage?: (msg: MessagePayload) => Promise<void>;
+    setMessageHandler(handler: (msg: MessagePayload) => Promise<void>): void;
+}

package/dist/node/adapters/base.js

@@ -0,0 +1,10 @@
+export class BaseAdapter {
+    stats = { messages_in: 0, messages_out: 0, errors: 0 };
+    running = false;
+    getStats() { return { ...this.stats }; }
+    isRunning() { return this.running; }
+    onInboundMessage;
+    setMessageHandler(handler) {
+        this.onInboundMessage = handler;
+    }
+}

package/dist/node/adapters/discord.d.ts

@@ -0,0 +1,29 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface DiscordConfig {
+    bot_token: string;
+    allowed_channels?: string[];
+    allowed_guilds?: string[];
+    mention_required?: boolean;
+    max_message_length?: number;
+}
+export declare class DiscordAdapter extends BaseAdapter {
+    readonly type = "discord";
+    readonly name: string;
+    private config;
+    private ws;
+    private heartbeatTimer;
+    private sequence;
+    private sessionId;
+    private resumeUrl;
+    private botUserId;
+    private reconnectAttempts;
+    constructor(name: string, config: DiscordConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private connectGateway;
+    private handleGatewayMessage;
+    private handleDispatch;
+    private handleMessage;
+    private scheduleReconnect;
+}