very-happy-cli 0.2.159 → 0.2.160

package/dist/lidState-CeEt442o.mjs

@@ -0,0 +1,297 @@
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { e as encodeBase64, g as encrypt, h as decrypt, d as decodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import os from 'os';
+import { execSync } from 'child_process';
+
+function isRateQuotaCode(code) {
+  return typeof code === "string" && code.endsWith("_rate_quota_exceeded");
+}
+const RATE_RETRY_MIN_DELAY_MS = 2e3;
+const RATE_RETRY_MAX_DELAY_MS = 6e4;
+function rateRetryDelayMs(attempt, random = Math.random()) {
+  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
+  const ceiling = Math.min(RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RATE_RETRY_MAX_DELAY_MS);
+  return Math.round(RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RATE_RETRY_MIN_DELAY_MS));
+}
+async function pauseForRateQuota(opts) {
+  const ms = rateRetryDelayMs(opts.attempt);
+  opts.log?.(`[RATE] ${opts.label} write refused (${opts.code}), attempt ${opts.attempt} \u2014 waiting ${ms}ms`);
+  await opts.sleep(ms);
+  return ms;
+}
+
+class RpcHandlerManager {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * B-506: methods whose params/result are PLAINTEXT JSON strings instead of
+   * machine-key ciphertext. The caller is a CLI on another machine of the
+   * same account, which holds neither this machine's key nor the account
+   * content key; the trusted relay sees the payload either way (this fork
+   * is server-trusted, not e2e). Only `registerPlainHandler` puts a method
+   * here; everything else keeps decrypting.
+   */
+  plainMethods = /* @__PURE__ */ new Set();
+  scopePrefix;
+  encryptionKey;
+  encryptionVariant;
+  logger;
+  sockets = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.scopePrefix = config.scopePrefix;
+    this.encryptionKey = config.encryptionKey;
+    this.encryptionVariant = config.encryptionVariant;
+    this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
+  }
+  /**
+   * Register an RPC handler for a specific method
+   * @param method - The method name (without prefix)
+   * @param handler - The handler function
+   */
+  registerHandler(method, handler) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    this.handlers.set(prefixedMethod, handler);
+    for (const socket of this.sockets) socket.emit("rpc-register", { method: prefixedMethod });
+  }
+  unregisterHandler(method) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    this.handlers.delete(prefixedMethod);
+    this.plainMethods.delete(prefixedMethod);
+    for (const socket of this.sockets) socket.emit("rpc-unregister", { method: prefixedMethod });
+  }
+  /**
+   * B-506: register a method whose request is a plaintext JSON string and
+   * whose response is returned as a plaintext JSON string (see
+   * `plainMethods`). The handler receives the parsed params; a throw is
+   * answered with `{ error }` like the encrypted path.
+   */
+  registerPlainHandler(method, handler) {
+    this.plainMethods.add(this.getPrefixedMethod(method));
+    this.registerHandler(method, handler);
+  }
+  isPlainMethod(prefixedMethod) {
+    return this.plainMethods.has(prefixedMethod);
+  }
+  /**
+   * Handle an incoming RPC request
+   * @param request - The RPC request data
+   * @param callback - The response callback
+   */
+  async handleRequest(request) {
+    if (this.plainMethods.has(request.method)) {
+      return this.handlePlainRequest(request);
+    }
+    try {
+      const handler = this.handlers.get(request.method);
+      if (!handler) {
+        this.logger("[RPC] [ERROR] Method not found", { method: request.method });
+        const errorResponse = { error: "Method not found" };
+        const encryptedError = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+        return encryptedError;
+      }
+      const decryptedParams = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(request.params));
+      this.logger("[RPC] Calling handler", { method: request.method });
+      const result = await handler(decryptedParams);
+      this.logger("[RPC] Handler returned", { method: request.method, hasResult: result !== void 0 });
+      const encryptedResponse = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, result));
+      this.logger("[RPC] Sending encrypted response", { method: request.method, responseLength: encryptedResponse.length });
+      return encryptedResponse;
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling request", { error });
+      const errorResponse = {
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      return encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+    }
+  }
+  /** Plaintext variant of handleRequest (B-506). Never throws; never encrypts. */
+  async handlePlainRequest(request) {
+    const handler = this.handlers.get(request.method);
+    if (!handler) return JSON.stringify({ error: "Method not found" });
+    let params;
+    try {
+      params = typeof request.params === "string" && request.params.length > 0 ? JSON.parse(request.params) : {};
+    } catch {
+      return JSON.stringify({ error: "Invalid JSON params" });
+    }
+    try {
+      this.logger("[RPC] Calling plain handler", { method: request.method });
+      const result = await handler(params);
+      return JSON.stringify(result === void 0 ? null : result);
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling plain request", { error });
+      return JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  }
+  onSocketConnect(socket) {
+    this.sockets.add(socket);
+    for (const [prefixedMethod] of this.handlers) {
+      socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  /**
+   * Attach a candidate transport and wait until the server confirms every
+   * method before a release handover closes the old transport.
+   */
+  async onSocketConnectAndWait(socket, timeoutMs = 1e4) {
+    this.sockets.add(socket);
+    const pending = new Set(this.handlers.keys());
+    const acknowledged = /* @__PURE__ */ new Set();
+    await new Promise((resolve, reject) => {
+      let settleTimer = null;
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`RPC registration timed out (${pending.size} pending)`));
+      }, timeoutMs);
+      timer.unref?.();
+      const maybeSettle = () => {
+        if (pending.size > 0 || settleTimer) return;
+        settleTimer = setTimeout(() => {
+          settleTimer = null;
+          for (const prefixedMethod of this.handlers.keys()) {
+            if (acknowledged.has(prefixedMethod) || pending.has(prefixedMethod)) continue;
+            pending.add(prefixedMethod);
+            socket.emit("rpc-register", { method: prefixedMethod });
+          }
+          if (pending.size === 0) {
+            cleanup();
+            resolve();
+          }
+        }, 0);
+        settleTimer.unref?.();
+      };
+      const onRegistered = (data) => {
+        if (typeof data?.method !== "string") return;
+        acknowledged.add(data.method);
+        pending.delete(data.method);
+        maybeSettle();
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (settleTimer) clearTimeout(settleTimer);
+        socket.off("rpc-registered", onRegistered);
+      };
+      socket.on("rpc-registered", onRegistered);
+      for (const prefixedMethod of pending) socket.emit("rpc-register", { method: prefixedMethod });
+      maybeSettle();
+    }).catch((error) => {
+      this.sockets.delete(socket);
+      throw error;
+    });
+  }
+  onSocketDisconnect(socket) {
+    if (socket) this.sockets.delete(socket);
+    else this.sockets.clear();
+  }
+  /**
+   * Get the number of registered handlers
+   */
+  getHandlerCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Check if a handler is registered
+   * @param method - The method name (without prefix)
+   */
+  hasHandler(method) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    return this.handlers.has(prefixedMethod);
+  }
+  /**
+   * Clear all handlers
+   */
+  clearHandlers() {
+    this.handlers.clear();
+    this.logger("Cleared all RPC handlers");
+  }
+  /**
+   * Get the prefixed method name
+   * @param method - The method name
+   */
+  getPrefixedMethod(method) {
+    return `${this.scopePrefix}:${method}`;
+  }
+}
+
+function describeSocketAckDrop(drop) {
+  switch (drop.reason) {
+    case "no-ack":
+      return "no ack callback on the frame (re-delivered after a transport close?); response dropped";
+    case "handler-threw":
+      return `handler threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+    case "ack-threw":
+      return `ack callback threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+  }
+}
+function safeAck(ack, onDrop) {
+  return (value) => {
+    if (typeof ack !== "function") {
+      onDrop({ reason: "no-ack" });
+      return;
+    }
+    try {
+      ack(value);
+    } catch (error) {
+      onDrop({ reason: "ack-threw", error });
+    }
+  };
+}
+async function answerSocketRequest(ack, run, onDrop) {
+  let value;
+  try {
+    value = await run();
+  } catch (error) {
+    onDrop({ reason: "handler-threw", error });
+    return;
+  }
+  safeAck(ack, onDrop)(value);
+}
+
+function hasNetworkConnectivity() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (!iface.internal && iface.family === "IPv4") return true;
+    }
+  }
+  return false;
+}
+function isLidClosed() {
+  if (process.platform !== "darwin") return false;
+  try {
+    const output = execSync("ioreg -r -k AppleClamshellState -d 4", {
+      timeout: 5e3,
+      encoding: "utf-8"
+    });
+    return output.includes('"AppleClamshellState" = Yes');
+  } catch {
+    return false;
+  }
+}
+function hasExternalDisplay() {
+  if (process.platform !== "darwin") return false;
+  try {
+    const output = execSync("system_profiler SPDisplaysDataType -json 2>/dev/null", {
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    const data = JSON.parse(output);
+    const gpus = data.SPDisplaysDataType || [];
+    for (const gpu of gpus) {
+      const displays = gpu.spdisplays_ndrvs || [];
+      for (const display of displays) {
+        const isBuiltIn = display.spdisplays_builtin === "spdisplays_yes" || display.spdisplays_connection_type === "spdisplays_internal";
+        if (!isBuiltIn) return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function shouldReconnect() {
+  if (!hasNetworkConnectivity()) return false;
+  if (isLidClosed() && !hasExternalDisplay()) return false;
+  return true;
+}
+
+export { RpcHandlerManager as R, answerSocketRequest as a, shouldReconnect as b, describeSocketAckDrop as d, isRateQuotaCode as i, pauseForRateQuota as p, safeAck as s };

package/dist/limits-C-a7gr04.cjs

@@ -0,0 +1,43 @@
+'use strict';
+
+const CLIPBOARD_MAX_BYTES = 256 * 1024;
+const CLIPBOARD_HISTORY_MAX_BYTES = 32 * 1024;
+const CLIPBOARD_TOOL_NAME = "copy_to_clipboard";
+const CLIPBOARD_TOOL_TITLE = "Copy to User Clipboard";
+const CLIPBOARD_TOOL_DESCRIPTION = `Copy text to the clipboard of the device the user is currently viewing this session from (their web browser, possibly a phone). Use this whenever the user wants a piece of text handed to them \u2014 not only when they literally say "clipboard". Trigger phrases include: "copy X", "copy that for me", "give me X", "send me X", "I need X on my phone", "\u590D\u5236\u7ED9\u6211", "\u628A X \u590D\u5236\u4E00\u4E0B", "\u53D1\u6211", "\u7ED9\u6211\u4E00\u4EFD", "\u590D\u5236\u5230\u526A\u5207\u677F/\u526A\u8D34\u677F". Typical payloads: command output, code snippets, tokens/keys, URLs, file contents, commit messages. The text is delivered to every device where the user has the web client open. Payloads larger than ${CLIPBOARD_MAX_BYTES / 1024}KB are truncated.`;
+function prepareClipboardText(input, maxBytes = CLIPBOARD_MAX_BYTES) {
+  const totalBytes = Buffer.byteLength(input, "utf8");
+  if (totalBytes <= maxBytes) {
+    return { text: input, truncated: false, totalBytes };
+  }
+  const sliced = Buffer.from(input, "utf8").subarray(0, maxBytes).toString("utf8");
+  let text = sliced;
+  if (text.endsWith("\uFFFD")) {
+    text = text.slice(0, -1);
+  }
+  const lastCode = text.charCodeAt(text.length - 1);
+  if (lastCode >= 55296 && lastCode <= 56319) {
+    text = text.slice(0, -1);
+  }
+  return { text, truncated: true, totalBytes };
+}
+function prepareClipboardHistoryText(input) {
+  const prepared = prepareClipboardText(input, CLIPBOARD_HISTORY_MAX_BYTES);
+  if (Buffer.byteLength(JSON.stringify(prepared.text), "utf8") <= CLIPBOARD_HISTORY_MAX_BYTES + 2) return prepared;
+  let encodedBytes = 0;
+  let text = "";
+  for (const character of prepared.text) {
+    const cost = Buffer.byteLength(JSON.stringify(character), "utf8") - 2;
+    if (encodedBytes + cost > CLIPBOARD_HISTORY_MAX_BYTES) break;
+    encodedBytes += cost;
+    text += character;
+  }
+  return { text, truncated: true, totalBytes: prepared.totalBytes };
+}
+
+exports.CLIPBOARD_MAX_BYTES = CLIPBOARD_MAX_BYTES;
+exports.CLIPBOARD_TOOL_DESCRIPTION = CLIPBOARD_TOOL_DESCRIPTION;
+exports.CLIPBOARD_TOOL_NAME = CLIPBOARD_TOOL_NAME;
+exports.CLIPBOARD_TOOL_TITLE = CLIPBOARD_TOOL_TITLE;
+exports.prepareClipboardHistoryText = prepareClipboardHistoryText;
+exports.prepareClipboardText = prepareClipboardText;

package/dist/limits-DIo7rEBR.mjs

@@ -0,0 +1,36 @@
+const CLIPBOARD_MAX_BYTES = 256 * 1024;
+const CLIPBOARD_HISTORY_MAX_BYTES = 32 * 1024;
+const CLIPBOARD_TOOL_NAME = "copy_to_clipboard";
+const CLIPBOARD_TOOL_TITLE = "Copy to User Clipboard";
+const CLIPBOARD_TOOL_DESCRIPTION = `Copy text to the clipboard of the device the user is currently viewing this session from (their web browser, possibly a phone). Use this whenever the user wants a piece of text handed to them \u2014 not only when they literally say "clipboard". Trigger phrases include: "copy X", "copy that for me", "give me X", "send me X", "I need X on my phone", "\u590D\u5236\u7ED9\u6211", "\u628A X \u590D\u5236\u4E00\u4E0B", "\u53D1\u6211", "\u7ED9\u6211\u4E00\u4EFD", "\u590D\u5236\u5230\u526A\u5207\u677F/\u526A\u8D34\u677F". Typical payloads: command output, code snippets, tokens/keys, URLs, file contents, commit messages. The text is delivered to every device where the user has the web client open. Payloads larger than ${CLIPBOARD_MAX_BYTES / 1024}KB are truncated.`;
+function prepareClipboardText(input, maxBytes = CLIPBOARD_MAX_BYTES) {
+  const totalBytes = Buffer.byteLength(input, "utf8");
+  if (totalBytes <= maxBytes) {
+    return { text: input, truncated: false, totalBytes };
+  }
+  const sliced = Buffer.from(input, "utf8").subarray(0, maxBytes).toString("utf8");
+  let text = sliced;
+  if (text.endsWith("\uFFFD")) {
+    text = text.slice(0, -1);
+  }
+  const lastCode = text.charCodeAt(text.length - 1);
+  if (lastCode >= 55296 && lastCode <= 56319) {
+    text = text.slice(0, -1);
+  }
+  return { text, truncated: true, totalBytes };
+}
+function prepareClipboardHistoryText(input) {
+  const prepared = prepareClipboardText(input, CLIPBOARD_HISTORY_MAX_BYTES);
+  if (Buffer.byteLength(JSON.stringify(prepared.text), "utf8") <= CLIPBOARD_HISTORY_MAX_BYTES + 2) return prepared;
+  let encodedBytes = 0;
+  let text = "";
+  for (const character of prepared.text) {
+    const cost = Buffer.byteLength(JSON.stringify(character), "utf8") - 2;
+    if (encodedBytes + cost > CLIPBOARD_HISTORY_MAX_BYTES) break;
+    encodedBytes += cost;
+    text += character;
+  }
+  return { text, truncated: true, totalBytes: prepared.totalBytes };
+}
+
+export { CLIPBOARD_TOOL_NAME as C, CLIPBOARD_TOOL_TITLE as a, CLIPBOARD_TOOL_DESCRIPTION as b, CLIPBOARD_MAX_BYTES as c, prepareClipboardHistoryText as d, prepareClipboardText as p };

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;