@clearlysh/beehaven 0.8.16

package/dist/log-redaction.js

@@ -0,0 +1,89 @@
+/**
+ * Log redaction — strip likely-sensitive values before they hit stderr,
+ * log files, or anywhere else a downstream tool might scrape them.
+ *
+ * The logger is the last line of defense. Individual call sites try not
+ * to log tokens in the first place, but the daemon handles a lot of
+ * untrusted input (IPC messages, URLs, SQL, prompts) and it's easy to
+ * accidentally interpolate a token into a format string — especially
+ * during debugging. Every string the logger writes passes through this
+ * function first so a stray secret doesn't land on disk.
+ *
+ * Patterns covered:
+ *   - JWT-like tokens (three base64url segments joined by dots)
+ *   - Firebase/Google access tokens (ya29.xxx, 1//xxx)
+ *   - OpenAI/Anthropic/Vertex API keys (sk-xxx, ak-xxx, xoxb-xxx, etc.)
+ *   - Authorization headers (Bearer, Basic, Digest)
+ *   - key=value/secret=value in JSON, URL query, form bodies
+ *   - AWS access keys (AKIA…)
+ *   - Hex blobs of ≥32 chars (IPC auth tokens are 64-char hex)
+ *   - Email addresses in URL query-param-style contexts (?email=, &user=)
+ *
+ * The patterns are deliberately over-eager — we'd rather show
+ * `[REDACTED]` than leak a credential. False positives in logs are
+ * annoying; false negatives are a breach.
+ */
+export function redactLogText(text) {
+    // Coerce non-strings via String() — log() callers occasionally pass
+    // numbers, errors, or undefined. We return JS-standard string forms
+    // (`'null'`, `'undefined'`, `'123'`) rather than swallowing them so a
+    // future "where did this log come from" search still finds the entry.
+    if (typeof text !== 'string')
+        return String(text);
+    if (text.length === 0)
+        return text;
+    return (text
+        // JWT-like (header.payload.signature) — base64url segments, dots, min lengths
+        .replace(/\beyJ[a-zA-Z0-9_\-]{8,}\.[a-zA-Z0-9_\-]{8,}\.[a-zA-Z0-9_\-]{8,}\b/g, '[REDACTED_JWT]')
+        // Google OAuth2 access tokens (ya29.xxx) and refresh tokens (1//xxx)
+        .replace(/\bya29\.[a-zA-Z0-9_\-]{20,}\b/g, '[REDACTED_GOOGLE_TOKEN]')
+        .replace(/\b1\/\/[a-zA-Z0-9_\-]{40,}\b/g, '[REDACTED_GOOGLE_REFRESH]')
+        // Common API key prefixes: sk-ant-, sk-, ak-, xoxb-, xoxp-, ghp_, ghs_, gho_
+        // sk-ant must come BEFORE sk in alternation so longer prefixes win.
+        .replace(/\b(sk-ant|sk|ak|xoxb|xoxp)-[A-Za-z0-9_\-]{16,}\b/g, '$1-[REDACTED]')
+        .replace(/\bgh[pousr]_[A-Za-z0-9]{30,}\b/g, '[REDACTED_GITHUB_TOKEN]')
+        // Authorization headers
+        .replace(/(Authorization:\s*)(Bearer|Basic|Digest)\s+[A-Za-z0-9._\-/+=]{8,}/gi, (_m, pre, scheme) => `${pre}${scheme} [REDACTED]`)
+        .replace(/\b(Bearer|Basic|Digest)\s+[A-Za-z0-9._\-/+=]{8,}\b/g, '$1 [REDACTED]')
+        // key=value / key: "value" for common secret names
+        .replace(/(\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|token|secret|password|passwd|pwd|auth|authorization|client[_-]?secret)\b)\s*[:=]\s*['"]?[A-Za-z0-9_\-./+=]{8,}['"]?/gi, '$1=[REDACTED]')
+        // Query-string token/secret/key parameters
+        .replace(/([?&](?:token|secret|key|apikey|api_key|access_token|id_token)=)[^&\s"']+/gi, '$1[REDACTED]')
+        // AWS access key IDs
+        .replace(/\b(AKIA[A-Z0-9]{16})\b/g, '[REDACTED_AWS_KEY]')
+        // Long hex blobs (IPC auth tokens are 64-char hex; match ≥32 hex chars when they look standalone)
+        .replace(/\b([a-f0-9]{32,})\b/gi, (m) => (m.length >= 32 ? '[REDACTED_HEX]' : m))
+        // Emails in URL-ish contexts (?email=foo@bar.com, &user=…@…)
+        .replace(/([?&](?:email|user|username|uid)=)[^\s&"']+@[^\s&"']+/gi, '$1[REDACTED_EMAIL]'));
+}
+/**
+ * Redact an arbitrary JSON-safe value. Recursively walks objects/arrays.
+ * Keys whose name matches a sensitive-looking pattern have their value
+ * replaced with `[REDACTED]` wholesale, regardless of content.
+ */
+const SENSITIVE_KEY = /token|secret|password|passwd|pwd|apikey|api[_-]?key|auth|authorization|session|cookie|bearer|refresh|access[_-]?token|id[_-]?token|client[_-]?secret/i;
+export function redactLogObject(value, depth = 0) {
+    if (depth > 6)
+        return '[…too deep…]';
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string')
+        return redactLogText(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => redactLogObject(v, depth + 1));
+    if (typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (SENSITIVE_KEY.test(k)) {
+                out[k] = '[REDACTED]';
+            }
+            else {
+                out[k] = redactLogObject(v, depth + 1);
+            }
+        }
+        return out;
+    }
+    return value;
+}

package/dist/logger.js

@@ -0,0 +1,108 @@
+// ============================================================================
+// Beehaven Daemon — Structured Logger
+// JSON log lines to ~/.beehaven/logs/daemon.log with rotation.
+//
+// All messages + data are passed through log-redaction before being written
+// so a secret accidentally interpolated into a format string (or captured
+// by a catch-and-rethrow) doesn't land on disk verbatim. Keep the redaction
+// layer as the last line of defense — call sites should still try not to
+// log secrets in the first place.
+// ============================================================================
+import { existsSync, mkdirSync, appendFileSync, statSync, renameSync, chmodSync, writeFileSync, } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { redactLogText, redactLogObject } from './log-redaction.js';
+const LOG_DIR = join(homedir(), '.beehaven', 'logs');
+const LOG_FILE = join(LOG_DIR, 'daemon.log');
+const MAX_SIZE = 10 * 1024 * 1024; // 10MB
+const MAX_ROTATIONS = 3;
+let currentLevel = 'info';
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+function ensureLogDir() {
+    // Logs can contain IPC payloads that — despite redactSecrets — may still
+    // leak request shapes, user emails, etc. Restrict to the owning user.
+    if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true, mode: 0o700 });
+    }
+    else {
+        // Existing dir may have been created by an older build without the
+        // mode. Re-apply defensively; chmod is a no-op when already correct.
+        try {
+            chmodSync(LOG_DIR, 0o700);
+        }
+        catch { }
+    }
+    // If the log file exists, make sure it's 0600. We can't pass mode to
+    // appendFileSync directly without creating the file ourselves first.
+    if (!existsSync(LOG_FILE)) {
+        try {
+            writeFileSync(LOG_FILE, '', { mode: 0o600 });
+        }
+        catch { }
+    }
+    else {
+        try {
+            chmodSync(LOG_FILE, 0o600);
+        }
+        catch { }
+    }
+}
+function rotate() {
+    try {
+        if (!existsSync(LOG_FILE))
+            return;
+        const size = statSync(LOG_FILE).size;
+        if (size < MAX_SIZE)
+            return;
+        // Rotate: daemon.log.3 → deleted, daemon.log.2 → .3, daemon.log.1 → .2, daemon.log → .1
+        for (let i = MAX_ROTATIONS; i >= 1; i--) {
+            const from = i === 1 ? LOG_FILE : `${LOG_FILE}.${i - 1}`;
+            const to = `${LOG_FILE}.${i}`;
+            if (existsSync(from))
+                renameSync(from, to);
+        }
+    }
+    catch {
+        /* never crash on rotation failure */
+    }
+}
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+export function log(level, category, message, data) {
+    if (LEVELS[level] < LEVELS[currentLevel])
+        return;
+    // Redact before composing the log entry. Messages get the text-level
+    // regex pass; `data` gets the recursive object walk that additionally
+    // zeros out any key whose name looks sensitive (token, secret, …).
+    const safeMessage = redactLogText(message);
+    const safeData = data !== undefined ? redactLogObject(data) : undefined;
+    const entry = {
+        t: Date.now(),
+        l: level,
+        c: category,
+        m: safeMessage,
+        ...(safeData !== undefined ? { d: safeData } : {}),
+    };
+    const line = JSON.stringify(entry) + '\n';
+    // Always write to stderr for systemd/launchd capture
+    if (level === 'error' || level === 'warn') {
+        process.stderr.write(`[${category}] ${safeMessage}\n`);
+    }
+    // Write to log file
+    try {
+        ensureLogDir();
+        rotate();
+        appendFileSync(LOG_FILE, line);
+    }
+    catch {
+        /* never crash on log failure */
+    }
+}
+// Convenience methods
+export const logger = {
+    debug: (cat, msg, data) => log('debug', cat, msg, data),
+    info: (cat, msg, data) => log('info', cat, msg, data),
+    warn: (cat, msg, data) => log('warn', cat, msg, data),
+    error: (cat, msg, data) => log('error', cat, msg, data),
+};

package/dist/manifest.js

@@ -0,0 +1,143 @@
+/**
+ * Manifest — reads and validates beehaven.json from project directories.
+ *
+ * The manifest is the contract between a local project and the daemon.
+ * It declares tools (shell commands, HTTP endpoints), documentation paths,
+ * and metadata for marketplace publishing.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Load beehaven.json from a directory. Returns null if not found.
+ */
+export function loadManifest(projectDir) {
+    const manifestPath = join(projectDir, 'beehaven.json');
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        const raw = readFileSync(manifestPath, 'utf8');
+        const manifest = JSON.parse(raw);
+        // Basic validation
+        if (!manifest.name || typeof manifest.name !== 'string') {
+            console.warn(`[manifest] beehaven.json in ${projectDir} missing required "name" field`);
+            return null;
+        }
+        return manifest;
+    }
+    catch (err) {
+        console.warn(`[manifest] Failed to parse ${manifestPath}: ${err.message}`);
+        return null;
+    }
+}
+/**
+ * Get all tools from a manifest, with project context attached.
+ */
+export function getManifestTools(manifest, projectDir) {
+    if (!manifest.tools || manifest.tools.length === 0)
+        return [];
+    return manifest.tools.map((tool) => ({
+        ...tool,
+        projectDir,
+        projectName: manifest.name,
+    }));
+}
+/**
+ * Convert a ManifestTool to the tool schema the cloud agent uses.
+ */
+export function toolToSchema(tool, projectName) {
+    const properties = {};
+    const required = [];
+    if (tool.input) {
+        for (const [key, param] of Object.entries(tool.input)) {
+            properties[key] = {
+                type: param.type,
+                description: param.description || key,
+            };
+            if (param.enum)
+                properties[key].enum = param.enum;
+            if (param.default !== undefined)
+                properties[key].default = param.default;
+            if (param.required !== false)
+                required.push(key);
+        }
+    }
+    return {
+        name: `${projectName}:${tool.name}`,
+        description: `[${projectName}] ${tool.description}`,
+        input_schema: {
+            type: 'object',
+            properties,
+            ...(required.length > 0 ? { required } : {}),
+        },
+    };
+}
+/**
+ * Execute a shell command tool.
+ * Substitutes {{param}} placeholders with input values.
+ * Returns stdout as string.
+ */
+export async function executeCommandTool(tool, input) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    if (!tool.command)
+        throw new Error(`Tool ${tool.name} has no command`);
+    // Substitute {{param}} placeholders
+    let cmd = tool.command;
+    for (const [key, value] of Object.entries(input)) {
+        cmd = cmd.replace(new RegExp(`\\{\\{${key}\\}\\}`, 'g'), String(value));
+    }
+    // Split command into executable and args
+    const parts = cmd.split(/\s+/);
+    const executable = parts[0];
+    const args = parts.slice(1);
+    const cwd = tool.cwd ? join(tool.projectDir, tool.cwd) : tool.projectDir;
+    const timeout = tool.timeout ?? 30_000;
+    try {
+        const { stdout, stderr } = await execFileAsync(executable, args, {
+            cwd,
+            timeout,
+            maxBuffer: 10 * 1024 * 1024, // 10MB
+            shell: true,
+        });
+        if (stderr)
+            console.warn(`[tool:${tool.name}] stderr: ${stderr.slice(0, 500)}`);
+        return { result: stdout.trim(), exitCode: 0 };
+    }
+    catch (err) {
+        return { result: err.stderr || err.message, exitCode: err.code ?? 1 };
+    }
+}
+/**
+ * Execute an HTTP endpoint tool.
+ * Sends input as JSON body (POST) or query params (GET).
+ * Returns response body.
+ */
+export async function executeEndpointTool(tool, input, baseEndpoint) {
+    const url = tool.endpoint || baseEndpoint;
+    if (!url)
+        throw new Error(`Tool ${tool.name} has no endpoint`);
+    const method = tool.method ?? 'POST';
+    const timeout = tool.timeout ?? 30_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+        const opts = {
+            method,
+            signal: controller.signal,
+            headers: { 'Content-Type': 'application/json' },
+        };
+        if (method !== 'GET') {
+            opts.body = JSON.stringify(input);
+        }
+        const resp = await fetch(url, opts);
+        clearTimeout(timer);
+        const contentType = resp.headers.get('content-type') || '';
+        const result = contentType.includes('json') ? await resp.json() : await resp.text();
+        return { result, status: resp.status };
+    }
+    catch (err) {
+        clearTimeout(timer);
+        throw new Error(`HTTP ${method} ${url} failed: ${err.message}`);
+    }
+}