very-happy-cli 0.2.159 → 0.2.160

package/dist/persistence-HGW_ZVs9.mjs

@@ -0,0 +1,372 @@
+import { readFile, open, unlink, stat, rename } from 'node:fs/promises';
+import { existsSync, constants, readFileSync, unlinkSync, renameSync } from 'node:fs';
+import { c as configuration, P as PRIVATE_FILE_MODE, w as writePrivateFileSync, h as hardenPrivateFileSync, e as ensurePrivateDirectory, a as writePrivateFile, b as hardenPrivateFile } from './configuration-RfeNjFmd.mjs';
+import * as z from 'zod';
+import { c as credentialRelayProblem, e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import 'node:os';
+import 'node:path';
+import './package-BhaKlnxz.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import 'chalk';
+import 'node:util';
+
+const SandboxConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  workspaceRoot: z.string().optional(),
+  sessionIsolation: z.enum(["strict", "workspace", "custom"]).default("workspace"),
+  customWritePaths: z.array(z.string()).default([]),
+  denyReadPaths: z.array(z.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
+  extraWritePaths: z.array(z.string()).default(["/tmp"]),
+  denyWritePaths: z.array(z.string()).default([".env"]),
+  networkMode: z.enum(["blocked", "allowed", "custom"]).default("allowed"),
+  allowedDomains: z.array(z.string()).default([]),
+  deniedDomains: z.array(z.string()).default([]),
+  allowLocalBinding: z.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 (!existsSync(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.warn(`Failed to read settings: ${outcome.error}`);
+  }
+  return { ...defaultSettings };
+}
+async function parseSettingsFile() {
+  const content = await readFile(configuration.settingsFile, "utf8");
+  const raw = JSON.parse(content);
+  const schemaVersion = raw.schemaVersion ?? 1;
+  if (schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    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.warn(`\u26A0\uFE0F Invalid sandbox config - skipping. Error: ${error.message}`);
+      migrated.sandboxConfig = void 0;
+    }
+  }
+  return { ...defaultSettings, ...migrated };
+}
+async function writeSettings(settings) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  const settingsWithVersion = {
+    ...settings,
+    schemaVersion: settings.schemaVersion ?? SUPPORTED_SCHEMA_VERSION
+  };
+  await writePrivateFile(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.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 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 stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await 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.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 ensurePrivateDirectory(configuration.happyHomeDir);
+    await writePrivateFile(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    await hardenPrivateFile(configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  token: z.string(),
+  authServerUrl: z.string().optional(),
+  secret: z.string().base64().nullish(),
+  // Legacy
+  encryption: z.object({
+    publicKey: z.string().base64(),
+    machineKey: z.string().base64()
+  }).nullish()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(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 = credentialRelayProblem(credentials.authServerUrl, 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 ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  writePrivateFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2));
+}
+async function clearDaemonState() {
+  if (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+  if (existsSync(configuration.daemonLockFile)) {
+    try {
+      await unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await open(
+        configuration.daemonLockFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+        PRIVATE_FILE_MODE
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              unlinkSync(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 (existsSync(configuration.daemonLockFile)) {
+      unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function readPersistedSessions() {
+  try {
+    if (!existsSync(configuration.sessionsFile)) return {};
+    const data = JSON.parse(readFileSync(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 (!existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(readFileSync(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 (!existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(readFileSync(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.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    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.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    logger.debug(`[PERSISTENCE] Failed to delete persisted sessions:`, error);
+  }
+}
+
+export { SUPPORTED_SCHEMA_VERSION, SandboxConfigSchema, acquireDaemonLock, clearCredentials, clearDaemonState, clearMachineId, deletePersistedSessions, persistSession, readCredentials, readCredentialsForConfiguredRelay, readDaemonState, readPersistedSessions, readSettings, readSettingsOutcome, readTrackedClaudeSessionIds, readTrackedCodexThreadIds, releaseDaemonLock, updateSettings, writeCredentialsDataKey, writeCredentialsLegacy, writeDaemonState, writeSettings };