very-happy-cli 0.2.158 → 0.2.160

package/dist/sessionLock-D-EG2CfG.mjs

@@ -0,0 +1,197 @@
+import { existsSync, readFileSync, unlinkSync, mkdirSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { c as configuration, w as writePrivateFileSync } from './configuration-RfeNjFmd.mjs';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+
+const PROCESS_IDENTITY_FIELDS = [
+  "hostPid",
+  "version",
+  "startedBy",
+  "startedFromDaemon",
+  "happyHomeDir",
+  "happyLibDir",
+  "happyToolsDir",
+  "capabilities",
+  "attachmentKinds",
+  "queueCancellation",
+  "sandbox",
+  "dangerouslySkipPermissions",
+  "os",
+  "host",
+  "homeDir",
+  "permissionMode"
+];
+function processIdentityFields(local) {
+  const out = {};
+  for (const key of PROCESS_IDENTITY_FIELDS) {
+    const value = local[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function mergeReconnectMetadata(server, local, now) {
+  return {
+    ...server,
+    ...processIdentityFields(local),
+    lifecycleState: "running",
+    lifecycleStateSince: now,
+    archivedBy: void 0,
+    archiveReason: void 0
+  };
+}
+function applyServerSnapshot(response, snapshot) {
+  return {
+    ...response,
+    seq: snapshot.seq,
+    metadata: snapshot.metadata,
+    metadataVersion: snapshot.metadataVersion,
+    agentState: snapshot.agentState,
+    agentStateVersion: snapshot.agentStateVersion
+  };
+}
+function withoutServerSnapshot(response) {
+  return { ...response, metadataVersion: 0, agentStateVersion: 0 };
+}
+
+const runtime = {
+  signal: (pid, signal) => process.kill(pid, signal),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  schedule: (callback, delayMs) => {
+    setTimeout(callback, delayMs);
+  }
+};
+function terminateProcess(pid, onSettled, impl = runtime, graceMs = 2e3) {
+  if (!impl.isAlive(pid)) {
+    onSettled(true);
+    return true;
+  }
+  try {
+    impl.signal(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  impl.schedule(() => {
+    if (impl.isAlive(pid)) {
+      try {
+        impl.signal(pid, "SIGKILL");
+      } catch {
+        onSettled(!impl.isAlive(pid));
+        return;
+      }
+    }
+    impl.schedule(() => onSettled(!impl.isAlive(pid)), 100);
+  }, graceMs);
+  return true;
+}
+
+const SESSION_LOCK_DIR = "session-locks";
+const defaultRuntime = () => ({
+  dir: join(configuration.happyHomeDir, SESSION_LOCK_DIR),
+  selfPid: process.pid,
+  now: () => Date.now(),
+  signal: (pid, signal) => process.kill(pid, signal),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  schedule: (callback, delayMs) => {
+    setTimeout(callback, delayMs);
+  }
+});
+function sessionLockPath(happySessionId, dir = join(configuration.happyHomeDir, SESSION_LOCK_DIR)) {
+  return join(dir, `${happySessionId}.json`);
+}
+function readSessionLock(happySessionId, dir) {
+  try {
+    const path = sessionLockPath(happySessionId, dir);
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (typeof parsed?.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    return {
+      pid: parsed.pid,
+      startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0,
+      version: typeof parsed.version === "string" ? parsed.version : "",
+      ...typeof parsed.flavor === "string" ? { flavor: parsed.flavor } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function liveSessionLockHolder(happySessionId, runtime = defaultRuntime()) {
+  const record = readSessionLock(happySessionId, runtime.dir);
+  if (!record || record.pid === runtime.selfPid) return null;
+  return runtime.isAlive(record.pid) ? record : null;
+}
+function writeSessionLock(happySessionId, record, dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = sessionLockPath(happySessionId, dir);
+  const tmp = `${path}.${record.pid}.tmp`;
+  writePrivateFileSync(tmp, JSON.stringify(record));
+  renameSync(tmp, path);
+}
+function acquireSessionLock(happySessionId, options, runtime = defaultRuntime()) {
+  const record = () => ({
+    pid: runtime.selfPid,
+    startedAt: runtime.now(),
+    version: options.version,
+    ...options.flavor ? { flavor: options.flavor } : {}
+  });
+  const holder = liveSessionLockHolder(happySessionId, runtime);
+  if (!holder) {
+    writeSessionLock(happySessionId, record(), runtime.dir);
+    return Promise.resolve({ ok: true, replaced: null });
+  }
+  if (!options.takeover) {
+    return Promise.resolve({ ok: false, holder });
+  }
+  return new Promise((resolve) => {
+    const requested = terminateProcess(holder.pid, (stopped) => {
+      if (!stopped) {
+        resolve({ ok: false, holder });
+        return;
+      }
+      writeSessionLock(happySessionId, record(), runtime.dir);
+      resolve({ ok: true, replaced: holder });
+    }, runtime, options.graceMs ?? 2e3);
+    if (!requested) resolve({ ok: false, holder });
+  });
+}
+function releaseSessionLock(happySessionId, runtime = defaultRuntime()) {
+  try {
+    const record = readSessionLock(happySessionId, runtime.dir);
+    if (record && record.pid === runtime.selfPid) {
+      unlinkSync(sessionLockPath(happySessionId, runtime.dir));
+    }
+  } catch {
+  }
+}
+async function claimSessionOrExit(happySessionId, options) {
+  const result = await acquireSessionLock(happySessionId, {
+    takeover: options.takeover,
+    version: configuration.currentCliVersion,
+    flavor: options.flavor
+  });
+  if (!result.ok) {
+    const message = `Session ${happySessionId} is already run by very-happy pid ${result.holder.pid} (v${result.holder.version || "?"}); this process yields.`;
+    logger.debug(`[SESSION LOCK] ${message}`);
+    console.error(message);
+    process.exit(0);
+  }
+  if (result.replaced) {
+    logger.debug(`[SESSION LOCK] Took over session ${happySessionId} from pid ${result.replaced.pid} (v${result.replaced.version || "?"})`);
+  }
+  process.on("exit", () => releaseSessionLock(happySessionId));
+}
+
+export { applyServerSnapshot as a, claimSessionOrExit as c, mergeReconnectMetadata as m, processIdentityFields as p, readSessionLock as r, terminateProcess as t, withoutServerSnapshot as w };

package/dist/sessionModeFile-DMl3dw3r.mjs

@@ -0,0 +1,32 @@
+import { mkdirSync, renameSync, existsSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { w as writePrivateFileSync, c as configuration } from './configuration-RfeNjFmd.mjs';
+
+const SESSION_MODE_DIR = "session-modes";
+const ACP_PERMISSION_MODES = ["default", "acceptEdits", "plan", "bypassPermissions"];
+function normalizeAcpPermissionMode(value) {
+  if (typeof value !== "string") return null;
+  if (value === "yolo") return "bypassPermissions";
+  return ACP_PERMISSION_MODES.includes(value) ? value : null;
+}
+function sessionModeFilePath(happySessionId, dir = join(configuration.happyHomeDir, SESSION_MODE_DIR)) {
+  return join(dir, `${happySessionId}.json`);
+}
+function sessionModeFilePayload(permissionMode, now = Date.now()) {
+  return { permissionMode, updatedAt: now };
+}
+function writeSessionModeFile(happySessionId, permissionMode, opts = {}) {
+  const path = sessionModeFilePath(happySessionId, opts.dir);
+  mkdirSync(join(path, ".."), { recursive: true, mode: 448 });
+  const payload = sessionModeFilePayload(permissionMode, opts.now);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writePrivateFileSync(tmp, JSON.stringify(payload));
+  renameSync(tmp, path);
+  return payload;
+}
+function removeSessionModeFile(happySessionId, dir) {
+  const path = sessionModeFilePath(happySessionId, dir);
+  if (existsSync(path)) unlinkSync(path);
+}
+
+export { normalizeAcpPermissionMode as n, removeSessionModeFile as r, writeSessionModeFile as w };

package/dist/sessionModeFile-RSm0NQkH.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var path = require('node:path');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+
+const SESSION_MODE_DIR = "session-modes";
+const ACP_PERMISSION_MODES = ["default", "acceptEdits", "plan", "bypassPermissions"];
+function normalizeAcpPermissionMode(value) {
+  if (typeof value !== "string") return null;
+  if (value === "yolo") return "bypassPermissions";
+  return ACP_PERMISSION_MODES.includes(value) ? value : null;
+}
+function sessionModeFilePath(happySessionId, dir = path.join(configuration.configuration.happyHomeDir, SESSION_MODE_DIR)) {
+  return path.join(dir, `${happySessionId}.json`);
+}
+function sessionModeFilePayload(permissionMode, now = Date.now()) {
+  return { permissionMode, updatedAt: now };
+}
+function writeSessionModeFile(happySessionId, permissionMode, opts = {}) {
+  const path$1 = sessionModeFilePath(happySessionId, opts.dir);
+  node_fs.mkdirSync(path.join(path$1, ".."), { recursive: true, mode: 448 });
+  const payload = sessionModeFilePayload(permissionMode, opts.now);
+  const tmp = `${path$1}.${process.pid}.tmp`;
+  configuration.writePrivateFileSync(tmp, JSON.stringify(payload));
+  node_fs.renameSync(tmp, path$1);
+  return payload;
+}
+function removeSessionModeFile(happySessionId, dir) {
+  const path = sessionModeFilePath(happySessionId, dir);
+  if (node_fs.existsSync(path)) node_fs.unlinkSync(path);
+}
+
+exports.normalizeAcpPermissionMode = normalizeAcpPermissionMode;
+exports.removeSessionModeFile = removeSessionModeFile;
+exports.writeSessionModeFile = writeSessionModeFile;