very-happy-cli 0.2.158 → 0.2.160

package/dist/localHappyAgentAuth-C-HQyiv6.mjs

@@ -0,0 +1,82 @@
+import { createHash, createHmac } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import tweetnacl from 'tweetnacl';
+import { z } from 'zod';
+import { c as credentialRelayProblem, d as decodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+
+const AgentCredentialsSchema = z.object({
+  token: z.string().min(1),
+  secret: z.string().min(1),
+  authServerUrl: z.string().optional()
+});
+function hmacSha512(key, data) {
+  const hmac = createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+function deriveKey(master, usage, path) {
+  const root = hmacSha512(new TextEncoder().encode(`${usage} Master Seed`), master);
+  let state = {
+    key: root.slice(0, 32),
+    chainCode: root.slice(32)
+  };
+  for (const index of path) {
+    const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+    const derived = hmacSha512(state.chainCode, data);
+    state = {
+      key: derived.slice(0, 32),
+      chainCode: derived.slice(32)
+    };
+  }
+  return state.key;
+}
+function deriveContentKeyPair(secret) {
+  const seed = deriveKey(secret, "Happy EnCoder", ["content"]);
+  const hashedSeed = new Uint8Array(createHash("sha512").update(seed).digest());
+  const secretKey = hashedSeed.slice(0, 32);
+  const keyPair = tweetnacl.box.keyPair.fromSecretKey(secretKey);
+  return {
+    publicKey: keyPair.publicKey,
+    secretKey: keyPair.secretKey
+  };
+}
+function getLocalHappyAgentCredentialPath(happyHomeDir = configuration.happyHomeDir) {
+  return join(happyHomeDir, "agent.key");
+}
+function readLocalHappyAgentCredentials(happyHomeDir = configuration.happyHomeDir, serverUrl = configuration.serverUrl) {
+  const credentialPath = getLocalHappyAgentCredentialPath(happyHomeDir);
+  if (!existsSync(credentialPath)) {
+    return null;
+  }
+  try {
+    const parsed = AgentCredentialsSchema.parse(JSON.parse(readFileSync(credentialPath, "utf8")));
+    if (!parsed.authServerUrl) return null;
+    if (credentialRelayProblem(parsed.authServerUrl, serverUrl)) return null;
+    const secret = decodeBase64(parsed.secret);
+    return {
+      token: parsed.token,
+      authServerUrl: parsed.authServerUrl,
+      secret,
+      contentKeyPair: deriveContentKeyPair(secret)
+    };
+  } catch {
+    return null;
+  }
+}
+function hasLocalHappyAgentAuth(happyHomeDir = configuration.happyHomeDir) {
+  return readLocalHappyAgentCredentials(happyHomeDir) !== null;
+}
+function detectResumeSupport(happyHomeDir = configuration.happyHomeDir) {
+  const happyAgentAuthenticated = hasLocalHappyAgentAuth(happyHomeDir);
+  return {
+    rpcAvailable: happyAgentAuthenticated,
+    requiresSameMachine: true,
+    requiresHappyAgentAuth: true,
+    happyAgentAuthenticated,
+    detectedAt: Date.now()
+  };
+}
+
+export { detectResumeSupport as d, getLocalHappyAgentCredentialPath as g, readLocalHappyAgentCredentials as r };

package/dist/localHappyAgentAuth-D6rFhaoc.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var tweetnacl = require('tweetnacl');
+var z = require('zod');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+
+const AgentCredentialsSchema = z.z.object({
+  token: z.z.string().min(1),
+  secret: z.z.string().min(1),
+  authServerUrl: z.z.string().optional()
+});
+function hmacSha512(key, data) {
+  const hmac = node_crypto.createHmac("sha512", key);
+  hmac.update(data);
+  return new Uint8Array(hmac.digest());
+}
+function deriveKey(master, usage, path) {
+  const root = hmacSha512(new TextEncoder().encode(`${usage} Master Seed`), master);
+  let state = {
+    key: root.slice(0, 32),
+    chainCode: root.slice(32)
+  };
+  for (const index of path) {
+    const data = new Uint8Array([0, ...new TextEncoder().encode(index)]);
+    const derived = hmacSha512(state.chainCode, data);
+    state = {
+      key: derived.slice(0, 32),
+      chainCode: derived.slice(32)
+    };
+  }
+  return state.key;
+}
+function deriveContentKeyPair(secret) {
+  const seed = deriveKey(secret, "Happy EnCoder", ["content"]);
+  const hashedSeed = new Uint8Array(node_crypto.createHash("sha512").update(seed).digest());
+  const secretKey = hashedSeed.slice(0, 32);
+  const keyPair = tweetnacl.box.keyPair.fromSecretKey(secretKey);
+  return {
+    publicKey: keyPair.publicKey,
+    secretKey: keyPair.secretKey
+  };
+}
+function getLocalHappyAgentCredentialPath(happyHomeDir = configuration.configuration.happyHomeDir) {
+  return path.join(happyHomeDir, "agent.key");
+}
+function readLocalHappyAgentCredentials(happyHomeDir = configuration.configuration.happyHomeDir, serverUrl = configuration.configuration.serverUrl) {
+  const credentialPath = getLocalHappyAgentCredentialPath(happyHomeDir);
+  if (!node_fs.existsSync(credentialPath)) {
+    return null;
+  }
+  try {
+    const parsed = AgentCredentialsSchema.parse(JSON.parse(node_fs.readFileSync(credentialPath, "utf8")));
+    if (!parsed.authServerUrl) return null;
+    if (authRelay.credentialRelayProblem(parsed.authServerUrl, serverUrl)) return null;
+    const secret = authRelay.decodeBase64(parsed.secret);
+    return {
+      token: parsed.token,
+      authServerUrl: parsed.authServerUrl,
+      secret,
+      contentKeyPair: deriveContentKeyPair(secret)
+    };
+  } catch {
+    return null;
+  }
+}
+function hasLocalHappyAgentAuth(happyHomeDir = configuration.configuration.happyHomeDir) {
+  return readLocalHappyAgentCredentials(happyHomeDir) !== null;
+}
+function detectResumeSupport(happyHomeDir = configuration.configuration.happyHomeDir) {
+  const happyAgentAuthenticated = hasLocalHappyAgentAuth(happyHomeDir);
+  return {
+    rpcAvailable: happyAgentAuthenticated,
+    requiresSameMachine: true,
+    requiresHappyAgentAuth: true,
+    happyAgentAuthenticated,
+    detectedAt: Date.now()
+  };
+}
+
+exports.detectResumeSupport = detectResumeSupport;
+exports.getLocalHappyAgentCredentialPath = getLocalHappyAgentCredentialPath;
+exports.readLocalHappyAgentCredentials = readLocalHappyAgentCredentials;

package/dist/logger-6HYUEXNk.mjs

@@ -0,0 +1,271 @@
+import chalk from 'chalk';
+import { inspect } from 'node:util';
+import { d as appendPrivateFileSync, c as configuration } from './configuration-RfeNjFmd.mjs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+function sensitiveKey(key) {
+  const normalized = key.toLowerCase().replace(/[_\-\s]/g, "");
+  return /(token|secret|password|authorization|cookie|credential|apikey|privatekey|encryptionkey|accesskey|claimsecret)/.test(normalized);
+}
+function redactLogString(value) {
+  return value.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]").replace(/([?&](?:token|secret|password|api[_-]?key)=)[^&#\s]+/gi, "$1[REDACTED]").replace(/((?:token|secret|password|api[_-]?key)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
+}
+function redactLogValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") return redactLogString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 6) return "[TRUNCATED]";
+  if (seen.has(value)) return "[CIRCULAR]";
+  seen.add(value);
+  if (value instanceof Error) {
+    const error = value;
+    return {
+      name: error.name,
+      message: redactLogString(error.message),
+      ...typeof error.code === "string" || typeof error.code === "number" ? { code: error.code } : {},
+      ...typeof (error.status ?? error.response?.status) === "number" ? { status: error.status ?? error.response?.status } : {}
+    };
+  }
+  if (Array.isArray(value)) return value.map((item) => redactLogValue(item, depth + 1, seen));
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (sensitiveKey(key)) {
+      result[key] = "[REDACTED]";
+    } else if (key === "environmentVariables" && child && typeof child === "object") {
+      result[key] = { names: Object.keys(child).sort() };
+    } else {
+      result[key] = redactLogValue(child, depth + 1, seen);
+    }
+  }
+  return result;
+}
+
+function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
+}
+function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleTimeString("en-US", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
+function getSessionLogPath() {
+  const timestamp = createTimestampForFilename();
+  const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
+  return join(configuration.logsDir, filename);
+}
+function safeRemoteLogUrl(raw) {
+  if (!raw) return void 0;
+  try {
+    const url = new URL(raw);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) return void 0;
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    const remoteUrl = safeRemoteLogUrl(process.env.HAPPY_SERVER_URL);
+    const remoteToken = process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING_TOKEN;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && remoteUrl && remoteToken && Buffer.byteLength(remoteToken) >= 32) {
+      this.dangerouslyUnencryptedServerLoggingUrl = remoteUrl;
+      this.dangerouslyUnencryptedServerLoggingToken = remoteToken;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  dangerouslyUnencryptedServerLoggingToken;
+  // Use local timezone for simplicity of locating the logs,
+  // in practice you will not need absolute timestamps
+  localTimezoneTimestamp() {
+    return createTimestampForLogEntry();
+  }
+  debug(message, ...args) {
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
+  }
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+      return;
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(redactLogValue(object));
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, redactLogString(message), "\n", json);
+  }
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
+  }
+  infoDeveloper(message, ...args) {
+    this.debug(message, ...args);
+    if (process.env.DEBUG) {
+      this.logToConsole("info", "[DEV]", message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    this.logToConsole("warn", "", message, ...args);
+    this.debug(`[WARN] ${message}`, ...args);
+  }
+  getLogPath() {
+    return this.logFilePath;
+  }
+  logToConsole(level, prefix, message, ...args) {
+    message = redactLogString(message);
+    args = args.map((arg) => redactLogValue(arg));
+    switch (level) {
+      case "debug": {
+        console.log(chalk.gray(prefix), message, ...args);
+        break;
+      }
+      case "error": {
+        console.error(chalk.red(prefix), message, ...args);
+        break;
+      }
+      case "info": {
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+      case "warn": {
+        console.log(chalk.yellow(prefix), message, ...args);
+        break;
+      }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+    }
+  }
+  async sendToRemoteServer(level, message, ...args) {
+    if (!this.dangerouslyUnencryptedServerLoggingUrl) return;
+    try {
+      await fetch(this.dangerouslyUnencryptedServerLoggingUrl + "/logs-combined-from-cli-and-mobile-for-simple-ai-debugging", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.dangerouslyUnencryptedServerLoggingToken}`
+        },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          message: `${redactLogString(message)} ${args.map((raw) => {
+            const safe = redactLogValue(raw);
+            return typeof safe === "object" ? JSON.stringify(safe, null, 2) : String(safe);
+          }).join(" ")}`,
+          source: "cli",
+          platform: process.platform
+        })
+      });
+    } catch (error) {
+    }
+  }
+  logToFile(prefix, message, ...args) {
+    const safeMessage = redactLogString(message);
+    const safeArgs = args.map((arg) => redactLogValue(arg));
+    const logLine = `${prefix} ${safeMessage} ${safeArgs.map(
+      (arg) => typeof arg === "string" ? arg : inspect(arg, { depth: 5, breakLength: 120 })
+    ).join(" ")}
+`;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, safeMessage, ...safeArgs).catch(() => {
+      });
+    }
+    try {
+      appendPrivateFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
+      if (process.env.DEBUG) {
+        console.error("[DEV MODE ONLY THROWING] Failed to append to log file:", appendError);
+        throw appendError;
+      }
+    }
+  }
+}
+let logger = new Logger();
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.logsDir;
+    if (!existsSync(logsDir)) {
+      return [];
+    }
+    const logs = readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = join(logsDir, file);
+      const stats = statSync(fullPath);
+      return { file, path: fullPath, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    try {
+      const { readDaemonState } = await import('./persistence-HGW_ZVs9.mjs');
+      const state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && existsSync(state.daemonLogPath)) {
+        const stats = statSync(state.daemonLogPath);
+        const persisted = {
+          file: basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
+
+export { getLatestDaemonLog as g, logger as l, redactLogValue as r };