very-happy-cli 0.2.159 → 0.2.161

package/dist/persistence-CBNMzSa8.cjs

@@ -0,0 +1,414 @@
+'use strict';
+
+var promises = require('node:fs/promises');
+var node_fs = require('node:fs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var z = require('zod');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var logger = require('./logger-Bc8-u1w0.cjs');
+require('node:os');
+require('node:path');
+require('./package-Cl5BEP5x.cjs');
+require('node:crypto');
+require('tweetnacl');
+require('chalk');
+require('node:util');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
+
+const SandboxConfigSchema = z__namespace.object({
+  enabled: z__namespace.boolean().default(false),
+  workspaceRoot: z__namespace.string().optional(),
+  sessionIsolation: z__namespace.enum(["strict", "workspace", "custom"]).default("workspace"),
+  customWritePaths: z__namespace.array(z__namespace.string()).default([]),
+  denyReadPaths: z__namespace.array(z__namespace.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
+  extraWritePaths: z__namespace.array(z__namespace.string()).default(["/tmp"]),
+  denyWritePaths: z__namespace.array(z__namespace.string()).default([".env"]),
+  networkMode: z__namespace.enum(["blocked", "allowed", "custom"]).default("allowed"),
+  allowedDomains: z__namespace.array(z__namespace.string()).default([]),
+  deniedDomains: z__namespace.array(z__namespace.string()).default([]),
+  allowLocalBinding: z__namespace.boolean().default(true)
+});
+const SUPPORTED_SCHEMA_VERSION = 2;
+const defaultSettings = {
+  schemaVersion: SUPPORTED_SCHEMA_VERSION,
+  onboardingCompleted: false,
+  sandboxConfig: void 0
+};
+function migrateSettings(raw, fromVersion) {
+  let migrated = { ...raw };
+  return migrated;
+}
+async function readSettingsOutcome() {
+  if (!node_fs.existsSync(configuration.configuration.settingsFile)) {
+    return { kind: "absent" };
+  }
+  try {
+    return { kind: "ok", settings: await parseSettingsFile() };
+  } catch (error) {
+    return { kind: "unreadable", error: error?.message ?? String(error) };
+  }
+}
+async function readSettings() {
+  const outcome = await readSettingsOutcome();
+  if (outcome.kind === "ok") return outcome.settings;
+  if (outcome.kind === "unreadable") {
+    logger.logger.warn(`Failed to read settings: ${outcome.error}`);
+  }
+  return { ...defaultSettings };
+}
+async function parseSettingsFile() {
+  const content = await promises.readFile(configuration.configuration.settingsFile, "utf8");
+  const raw = JSON.parse(content);
+  const schemaVersion = raw.schemaVersion ?? 1;
+  if (schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    logger.logger.warn(
+      `\u26A0\uFE0F Settings schema v${schemaVersion} > supported v${SUPPORTED_SCHEMA_VERSION}. Update happy-cli for full functionality.`
+    );
+  }
+  const migrated = migrateSettings(raw);
+  if (migrated.sandboxConfig !== void 0) {
+    try {
+      migrated.sandboxConfig = SandboxConfigSchema.parse(migrated.sandboxConfig);
+    } catch (error) {
+      logger.logger.warn(`\u26A0\uFE0F Invalid sandbox config - skipping. Error: ${error.message}`);
+      migrated.sandboxConfig = void 0;
+    }
+  }
+  return { ...defaultSettings, ...migrated };
+}
+async function writeSettings(settings) {
+  await configuration.ensurePrivateDirectory(configuration.configuration.happyHomeDir);
+  const settingsWithVersion = {
+    ...settings,
+    schemaVersion: settings.schemaVersion ?? SUPPORTED_SCHEMA_VERSION
+  };
+  await configuration.writePrivateFile(configuration.configuration.settingsFile, JSON.stringify(settingsWithVersion, null, 2));
+}
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.configuration.settingsFile + ".lock";
+  const tmpFile = configuration.configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await promises.open(lockFile, node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY, configuration.PRIVATE_FILE_MODE);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await promises.stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await promises.unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const outcome = await readSettingsOutcome();
+    if (outcome.kind === "unreadable") {
+      throw new Error(
+        `Settings file ${configuration.configuration.settingsFile} exists but could not be read (${outcome.error}). Refusing to overwrite it \u2014 fix or remove the file (a removed file is recreated with defaults).`
+      );
+    }
+    const current = outcome.kind === "ok" ? outcome.settings : { ...defaultSettings };
+    const updated = await updater(current);
+    await configuration.ensurePrivateDirectory(configuration.configuration.happyHomeDir);
+    await configuration.writePrivateFile(tmpFile, JSON.stringify(updated, null, 2));
+    await promises.rename(tmpFile, configuration.configuration.settingsFile);
+    await configuration.hardenPrivateFile(configuration.configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await promises.unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z__namespace.object({
+  token: z__namespace.string(),
+  authServerUrl: z__namespace.string().optional(),
+  secret: z__namespace.string().base64().nullish(),
+  // Legacy
+  encryption: z__namespace.object({
+    publicKey: z__namespace.string().base64(),
+    machineKey: z__namespace.string().base64()
+  }).nullish()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(configuration.configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await promises.readFile(configuration.configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    if (credentials.secret) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "legacy",
+          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
+        }
+      };
+    } else if (credentials.encryption) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "dataKey",
+          publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, "base64")),
+          machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, "base64"))
+        }
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function readCredentialsForConfiguredRelay() {
+  const credentials = await readCredentials();
+  if (!credentials) return null;
+  const relayProblem = authRelay.credentialRelayProblem(credentials.authServerUrl, configuration.configuration.serverUrl);
+  if (relayProblem) {
+    throw new Error(
+      `${relayProblem} Use a separate HAPPY_HOME_DIR for this relay, or run \`very-happy auth login --force\` before making relay requests.`
+    );
+  }
+  return credentials;
+}
+async function writeCredentialsLegacy(credentials) {
+  await configuration.ensurePrivateDirectory(configuration.configuration.happyHomeDir);
+  await configuration.writePrivateFile(configuration.configuration.privateKeyFile, JSON.stringify({
+    secret: authRelay.encodeBase64(credentials.secret),
+    token: credentials.token,
+    authServerUrl: configuration.configuration.serverUrl
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  await configuration.ensurePrivateDirectory(configuration.configuration.happyHomeDir);
+  await configuration.writePrivateFile(configuration.configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: authRelay.encodeBase64(credentials.publicKey), machineKey: authRelay.encodeBase64(credentials.machineKey) },
+    token: credentials.token,
+    authServerUrl: configuration.configuration.serverUrl
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (node_fs.existsSync(configuration.configuration.privateKeyFile)) {
+    await promises.unlink(configuration.configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!node_fs.existsSync(configuration.configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await promises.readFile(configuration.configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  configuration.writePrivateFileSync(configuration.configuration.daemonStateFile, JSON.stringify(state, null, 2));
+}
+async function clearDaemonState() {
+  if (node_fs.existsSync(configuration.configuration.daemonStateFile)) {
+    await promises.unlink(configuration.configuration.daemonStateFile);
+  }
+  if (node_fs.existsSync(configuration.configuration.daemonLockFile)) {
+    try {
+      await promises.unlink(configuration.configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await promises.open(
+        configuration.configuration.daemonLockFile,
+        node_fs.constants.O_CREAT | node_fs.constants.O_EXCL | node_fs.constants.O_WRONLY,
+        configuration.PRIVATE_FILE_MODE
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = node_fs.readFileSync(configuration.configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              node_fs.unlinkSync(configuration.configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch {
+  }
+  try {
+    if (node_fs.existsSync(configuration.configuration.daemonLockFile)) {
+      node_fs.unlinkSync(configuration.configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function readPersistedSessions() {
+  try {
+    if (!node_fs.existsSync(configuration.configuration.sessionsFile)) return {};
+    const data = JSON.parse(node_fs.readFileSync(configuration.configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return {};
+    const now = Date.now();
+    const sessions = {};
+    for (const [id, session] of Object.entries(data.sessions)) {
+      if (now - session.savedAt < SESSION_MAX_AGE_MS) {
+        sessions[id] = session;
+      }
+    }
+    return sessions;
+  } catch {
+    return {};
+  }
+}
+function readTrackedClaudeSessionIds() {
+  try {
+    if (!node_fs.existsSync(configuration.configuration.sessionsFile)) return [];
+    const data = JSON.parse(node_fs.readFileSync(configuration.configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const session of Object.values(data.sessions)) {
+      const metadata = (session ?? {}).metadata;
+      for (const id of [metadata?.claudeSessionId, metadata?.importedFromClaudeSessionId]) {
+        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
+      }
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+function readTrackedCodexThreadIds() {
+  try {
+    if (!node_fs.existsSync(configuration.configuration.sessionsFile)) return [];
+    const data = JSON.parse(node_fs.readFileSync(configuration.configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const session of Object.values(data.sessions)) {
+      const metadata = (session ?? {}).metadata;
+      for (const id of [metadata?.codexThreadId, metadata?.importedFromCodexThreadId]) {
+        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
+      }
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+function persistSession(sessionId, session) {
+  try {
+    const existing = readPersistedSessions();
+    existing[sessionId] = session;
+    const tmpFile = configuration.configuration.sessionsFile + ".tmp";
+    configuration.writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    node_fs.renameSync(tmpFile, configuration.configuration.sessionsFile);
+    configuration.hardenPrivateFileSync(configuration.configuration.sessionsFile);
+  } catch (error) {
+    logger.logger.debug(`[PERSISTENCE] Failed to persist session ${sessionId}:`, error);
+  }
+}
+function deletePersistedSessions(sessionIds) {
+  try {
+    const existing = readPersistedSessions();
+    let changed = false;
+    for (const id of sessionIds) {
+      if (id in existing) {
+        delete existing[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    const tmpFile = configuration.configuration.sessionsFile + ".tmp";
+    configuration.writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    node_fs.renameSync(tmpFile, configuration.configuration.sessionsFile);
+    configuration.hardenPrivateFileSync(configuration.configuration.sessionsFile);
+  } catch (error) {
+    logger.logger.debug(`[PERSISTENCE] Failed to delete persisted sessions:`, error);
+  }
+}
+
+exports.SUPPORTED_SCHEMA_VERSION = SUPPORTED_SCHEMA_VERSION;
+exports.SandboxConfigSchema = SandboxConfigSchema;
+exports.acquireDaemonLock = acquireDaemonLock;
+exports.clearCredentials = clearCredentials;
+exports.clearDaemonState = clearDaemonState;
+exports.clearMachineId = clearMachineId;
+exports.deletePersistedSessions = deletePersistedSessions;
+exports.persistSession = persistSession;
+exports.readCredentials = readCredentials;
+exports.readCredentialsForConfiguredRelay = readCredentialsForConfiguredRelay;
+exports.readDaemonState = readDaemonState;
+exports.readPersistedSessions = readPersistedSessions;
+exports.readSettings = readSettings;
+exports.readSettingsOutcome = readSettingsOutcome;
+exports.readTrackedClaudeSessionIds = readTrackedClaudeSessionIds;
+exports.readTrackedCodexThreadIds = readTrackedCodexThreadIds;
+exports.releaseDaemonLock = releaseDaemonLock;
+exports.updateSettings = updateSettings;
+exports.writeCredentialsDataKey = writeCredentialsDataKey;
+exports.writeCredentialsLegacy = writeCredentialsLegacy;
+exports.writeDaemonState = writeDaemonState;
+exports.writeSettings = writeSettings;