@pushary/agent-hooks 0.60.0 → 0.61.0

package/dist/chunk-B26DNXCA.js

@@ -0,0 +1,235 @@
+import {
+  resolveShellRc
+} from "./chunk-BC3VCZ3E.js";
+import {
+  configFilePath
+} from "./chunk-2UMNXADU.js";
+
+// src/cli/fsx.ts
+import { copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var readJsonSafe = (filePath) => {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT") return { kind: "missing" };
+    return { kind: "unreadable", error };
+  }
+  if (raw.trim() === "") return { kind: "ok", value: {} };
+  try {
+    return { kind: "ok", value: JSON.parse(raw) };
+  } catch (err) {
+    return { kind: "unparseable", error: err, raw };
+  }
+};
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+var backupFile = (filePath) => {
+  const target = `${filePath}.pushary-backup-${stamp()}`;
+  copyFileSync(filePath, target);
+  return target;
+};
+var writeFileAtomic = (filePath, contents, mode) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const temp = join(dir, `.${process.pid}-${stamp()}.pushary-tmp`);
+  try {
+    writeFileSync(temp, contents, mode === void 0 ? "utf-8" : { encoding: "utf-8", mode });
+    const handle = openSync(temp, "r+");
+    try {
+      fsyncSync(handle);
+    } finally {
+      closeSync(handle);
+    }
+    renameSync(temp, filePath);
+  } catch (err) {
+    try {
+      if (existsSync(temp)) unlinkSync(temp);
+    } catch {
+    }
+    throw err;
+  }
+};
+var writeJsonAtomic = (filePath, data, mode) => writeFileAtomic(filePath, `${JSON.stringify(data, null, 2)}
+`, mode);
+
+// src/keystore.ts
+import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var KEY_FILE_MODE = 384;
+var FALLBACK_RCS = [".zshrc", ".zprofile", ".bashrc", ".bash_profile"];
+var OUR_EXPORT = /^[ \t]*export[ \t]+PUSHARY_API_KEY=(['"]?)(pk_[a-f0-9]+\.[a-f0-9]+)\1[ \t]*$/;
+var MENTIONS_KEY = /PUSHARY_API_KEY/;
+var isComment = (line) => line.trimStart().startsWith("#");
+var exportLine = (apiKey) => `export PUSHARY_API_KEY='${apiKey}'`;
+var keyPrefix = (key) => key.split(".")[0] ?? key;
+var rcResult = (kind, over = {}) => ({
+  kind,
+  path: null,
+  shell: null,
+  previousKeyPrefix: null,
+  declinedLine: null,
+  backupPath: null,
+  detail: null,
+  ...over
+});
+var realPathOf = (filePath) => {
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return filePath;
+  }
+};
+var rewriteRcExport = (rcPath, apiKey, shell = null) => {
+  const target = realPathOf(rcPath);
+  let content = "";
+  try {
+    content = readFileSync2(target, "utf-8");
+  } catch (err) {
+    const error = err;
+    if (error.code !== "ENOENT") {
+      return rcResult("unavailable", { path: target, shell, detail: error.message });
+    }
+  }
+  const lines = content.split("\n");
+  const foreign = lines.findIndex((line) => !isComment(line) && MENTIONS_KEY.test(line) && !OUR_EXPORT.test(line));
+  if (foreign >= 0) {
+    const match = /pk_[a-f0-9]+/.exec(lines[foreign] ?? "");
+    return rcResult("declined", {
+      path: target,
+      shell,
+      declinedLine: foreign + 1,
+      previousKeyPrefix: match?.[0] ?? null
+    });
+  }
+  const ours = lines.map((line, index) => ({ line, index })).filter((entry) => OUR_EXPORT.test(entry.line));
+  if (ours.length > 0) {
+    const previous = OUR_EXPORT.exec(ours[ours.length - 1].line)?.[2] ?? null;
+    if (ours.every((entry) => OUR_EXPORT.exec(entry.line)?.[2] === apiKey)) {
+      return rcResult("unchanged", {
+        path: target,
+        shell,
+        previousKeyPrefix: previous ? keyPrefix(previous) : null
+      });
+    }
+    const next = [...lines];
+    for (const entry of ours) next[entry.index] = exportLine(apiKey);
+    try {
+      const backupPath = backupFile(target);
+      writeFileAtomic(target, next.join("\n"), KEY_FILE_MODE);
+      return rcResult("updated", {
+        path: target,
+        shell,
+        previousKeyPrefix: previous ? keyPrefix(previous) : null,
+        backupPath
+      });
+    } catch (err) {
+      return rcResult("unavailable", { path: target, shell, detail: err.message });
+    }
+  }
+  const gap = content.length === 0 ? "" : content.endsWith("\n") ? "" : "\n";
+  try {
+    writeFileAtomic(target, `${content}${gap}${exportLine(apiKey)}
+`, KEY_FILE_MODE);
+  } catch (err) {
+    return rcResult("unavailable", { path: target, shell, detail: err.message });
+  }
+  return rcResult("written", { path: target, shell });
+};
+var resolveRcTarget = () => {
+  const resolved = resolveShellRc();
+  if (resolved) return { path: resolved.path, shell: resolved.shell };
+  const fallback = FALLBACK_RCS.map((name) => join2(homedir(), name)).find(existsSync2);
+  return fallback ? { path: fallback, shell: null } : null;
+};
+var writeKey = (apiKey, options = {}) => {
+  const configPath = configFilePath();
+  const existing = readJsonSafe(configPath);
+  let current = {};
+  let configBackupPath = null;
+  if (existing.kind === "unreadable") {
+    throw new Error(
+      `${configPath} exists but could not be read (${existing.error.message}). Fix its permissions or remove it, then re-run setup. Nothing was changed.`
+    );
+  }
+  if (existing.kind === "ok") {
+    current = existing.value;
+  } else if (existing.kind === "unparseable") {
+    configBackupPath = backupFile(configPath);
+  }
+  writeJsonAtomic(configPath, { ...current, apiKey }, KEY_FILE_MODE);
+  restrictFile(configPath);
+  const target = (options.resolveRc ?? resolveRcTarget)();
+  const rc = target ? rewriteRcExport(target.path, apiKey, target.shell) : rcResult("no-rc");
+  process.env.PUSHARY_API_KEY = apiKey;
+  return { configPath, rc, configBackupPath };
+};
+var clearKey = (options = {}) => {
+  const configPath = configFilePath();
+  const existing = readJsonSafe(configPath);
+  let removedFromConfig = false;
+  if (existing.kind === "ok" && typeof existing.value.apiKey === "string") {
+    const { apiKey: _dropped, ...rest } = existing.value;
+    writeJsonAtomic(configPath, rest, KEY_FILE_MODE);
+    restrictFile(configPath);
+    removedFromConfig = true;
+  }
+  const target = (options.resolveRc ?? resolveRcTarget)();
+  let rcLinesDisabled = 0;
+  if (target) {
+    try {
+      const real = realpathSync(target.path);
+      const lines = readFileSync2(real, "utf8").split("\n");
+      const next = lines.map((line) => {
+        if (!OUR_EXPORT.test(line)) return line;
+        rcLinesDisabled += 1;
+        return `# ${line.trim()}   # removed by pushary logout`;
+      });
+      if (rcLinesDisabled > 0) writeFileSync2(real, next.join("\n"));
+    } catch {
+      rcLinesDisabled = 0;
+    }
+  }
+  delete process.env.PUSHARY_API_KEY;
+  return {
+    removedFromConfig,
+    configPath,
+    rcPath: target?.path ?? null,
+    rcLinesDisabled
+  };
+};
+var restrictFile = (filePath) => {
+  try {
+    chmodSync(filePath, KEY_FILE_MODE);
+  } catch {
+  }
+};
+var readConfigKey = (configPath) => {
+  const result = readJsonSafe(configPath);
+  if (result.kind !== "ok") return null;
+  const key = typeof result.value.apiKey === "string" ? result.value.apiKey.trim() : "";
+  return key || null;
+};
+var readKeySource = () => {
+  const configPath = configFilePath();
+  const envKey = process.env.PUSHARY_API_KEY?.trim() || null;
+  const fileKey = readConfigKey(configPath);
+  const drift = envKey && fileKey && envKey !== fileKey ? { envPrefix: keyPrefix(envKey), configPrefix: keyPrefix(fileKey), configPath } : null;
+  if (envKey) return { kind: "env", key: envKey, origin: "PUSHARY_API_KEY", drift };
+  if (fileKey) return { kind: "config", key: fileKey, origin: configPath, drift: null };
+  return { kind: "none", key: null, origin: null, drift: null };
+};
+
+export {
+  readJsonSafe,
+  backupFile,
+  writeFileAtomic,
+  writeJsonAtomic,
+  KEY_FILE_MODE,
+  exportLine,
+  writeKey,
+  clearKey,
+  readKeySource
+};