pushary 1.8.0

package/dist/chunk-OKXS7WDZ.js

@@ -0,0 +1,68 @@
+import {
+  guardBinary
+} from "./chunk-A2A2YTMG.js";
+
+// src/bell/install.ts
+import { join } from "path";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var ensureRecord = (parent, key) => {
+  const existing = asRecord(parent[key]);
+  if (existing) return existing;
+  const created = {};
+  parent[key] = created;
+  return created;
+};
+var BELL_HOOK_BINARY = "pushary-bell-hook";
+var isBellHook = (entry) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => String(asRecord(hook)?.command ?? "").includes(BELL_HOOK_BINARY));
+};
+var BELL_TIMEOUT_SECONDS = 5;
+var BELL_NOTIFICATION_MATCHER = "idle_prompt|agent_needs_input|agent_completed";
+var addBellHooks = (settings, binDir) => {
+  const resolve = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = ensureRecord(settings, "hooks");
+  const notification = (Array.isArray(hooks.Notification) ? hooks.Notification : []).filter((entry) => !isBellHook(entry));
+  notification.push({
+    matcher: BELL_NOTIFICATION_MATCHER,
+    hooks: [{ type: "command", command: resolve(BELL_HOOK_BINARY), timeout: BELL_TIMEOUT_SECONDS }]
+  });
+  hooks.Notification = notification;
+  const stop = Array.isArray(hooks.Stop) ? hooks.Stop.filter((entry) => !isBellHook(entry)) : [];
+  if (Array.isArray(hooks.Stop)) {
+    if (stop.length === 0) delete hooks.Stop;
+    else hooks.Stop = stop;
+  }
+};
+var removeBellHooks = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const key of ["Stop", "Notification"]) {
+    const entries = hooks[key];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry) => !isBellHook(entry));
+    if (filtered.length === entries.length) continue;
+    if (filtered.length === 0) delete hooks[key];
+    else hooks[key] = filtered;
+    changed = true;
+  }
+  if (Object.keys(hooks).length === 0) delete settings.hooks;
+  return changed;
+};
+var bellInstalled = (settings) => {
+  const hooks = asRecord(settings.hooks);
+  if (!hooks) return false;
+  return ["Stop", "Notification"].some((key) => {
+    const entries = hooks[key];
+    return Array.isArray(entries) && entries.some(isBellHook);
+  });
+};
+
+export {
+  BELL_HOOK_BINARY,
+  addBellHooks,
+  removeBellHooks,
+  bellInstalled
+};

package/dist/chunk-OLQRRFBX.js

@@ -0,0 +1,21 @@
+import {
+  readTranscriptPreference
+} from "./chunk-P7WQEVWA.js";
+
+// src/transcript-setting.ts
+var transcriptEnvironmentPreference = () => {
+  const value = process.env.PUSHARY_TRANSCRIPTS?.trim().toLowerCase();
+  if (!value) return null;
+  if (["0", "false", "off"].includes(value)) return false;
+  if (["1", "true", "on"].includes(value)) return true;
+  return null;
+};
+var configuredPreference = () => transcriptEnvironmentPreference() ?? readTranscriptPreference();
+var transcriptsEnabled = () => configuredPreference() ?? false;
+var transcriptPreferenceForSetup = (explicit = null) => explicit ?? configuredPreference() ?? true;
+
+export {
+  transcriptEnvironmentPreference,
+  transcriptsEnabled,
+  transcriptPreferenceForSetup
+};

package/dist/chunk-P7WQEVWA.js

@@ -0,0 +1,307 @@
+import {
+  resolveInstallSourceFor
+} from "./chunk-DB3ONZB4.js";
+import {
+  backupFile,
+  readJsonSafe,
+  writeFileAtomic,
+  writeJsonAtomic
+} from "./chunk-T7E75EKA.js";
+import {
+  configFilePath
+} from "./chunk-GPEGOGRJ.js";
+
+// src/shell-alias.ts
+import { homedir } from "os";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var MARKER_START = "# >>> pushary >>>";
+var MARKER_END = "# <<< pushary <<<";
+var CANDIDATE_RCS = [".zshrc", ".zprofile", ".bashrc", ".bash_profile"];
+var aliasBlock = () => `${MARKER_START}
+# Make \`claude\` reachable from your phone when idle (runs it through Pushary).
+# Remove this block, or run \`pushary clean\`, to undo.
+alias claude='pushary claude'
+${MARKER_END}
+`;
+var hasClaudeAlias = (content) => content.includes(MARKER_START) || /alias\s+claude=['"]?pushary claude/.test(content);
+var stripPusharyBlock = (content) => {
+  const lines = content.split("\n");
+  const out = [];
+  let inBlock = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === MARKER_START) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === MARKER_END) {
+      inBlock = false;
+      continue;
+    }
+    if (!inBlock) out.push(line);
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n");
+};
+var resolveShellRc = () => {
+  if (process.platform === "win32") return null;
+  const shell = (process.env.SHELL ?? "").split("/").pop() ?? "";
+  const home = homedir();
+  if (shell === "zsh") return { path: join(home, ".zshrc"), shell };
+  if (shell === "bash") {
+    const bashrc = join(home, ".bashrc");
+    const profile = join(home, ".bash_profile");
+    if (process.platform === "darwin") return { path: profile, shell };
+    return { path: existsSync(bashrc) ? bashrc : profile, shell };
+  }
+  return null;
+};
+var installClaudeAlias = () => {
+  const rc = resolveShellRc();
+  if (!rc) return { installed: false, reason: "unsupported-shell" };
+  let content = "";
+  try {
+    content = readFileSync(rc.path, "utf-8");
+  } catch {
+  }
+  if (hasClaudeAlias(content)) return { installed: false, path: rc.path, reason: "exists" };
+  const gap = content.length > 0 && !content.endsWith("\n") ? "\n\n" : content.length > 0 ? "\n" : "";
+  appendFileSync(rc.path, `${gap}${aliasBlock()}`, "utf-8");
+  return { installed: true, path: rc.path };
+};
+var removeClaudeAlias = () => {
+  const removed = [];
+  for (const name of CANDIDATE_RCS) {
+    const path = join(homedir(), name);
+    if (!existsSync(path)) continue;
+    let content;
+    try {
+      content = readFileSync(path, "utf-8");
+    } catch {
+      continue;
+    }
+    const stripped = stripPusharyBlock(content);
+    if (stripped !== content) {
+      try {
+        writeFileSync(path, stripped, "utf-8");
+        removed.push(path);
+      } catch {
+      }
+    }
+  }
+  return removed;
+};
+
+// src/keystore.ts
+import { chmodSync, existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } 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 LOGOUT_MARK = "# removed by pushary logout";
+var disabledExportLine = (line) => `# ${line.trim()}   ${LOGOUT_MARK}`;
+var isDisabledExport = (line) => {
+  const trimmed = line.trim();
+  if (!isComment(trimmed) || !trimmed.endsWith(LOGOUT_MARK)) return false;
+  return OUR_EXPORT.test(trimmed.slice(1, -LOGOUT_MARK.length).trim());
+};
+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(homedir2(), 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,
+      installSource: resolveInstallSourceFor(current),
+      ...options.controlMode ? { controlMode: options.controlMode } : {},
+      ...options.transcriptsEnabled === void 0 ? {} : { transcriptsEnabled: options.transcriptsEnabled }
+    },
+    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 disabledExportLine(line);
+      });
+      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 readConfigFileKey = () => readConfigKey(configFilePath());
+var readControlMode = (configPath = configFilePath()) => {
+  const result = readJsonSafe(configPath);
+  if (result.kind !== "ok") return null;
+  const value = result.value.controlMode;
+  return value === "auto" || value === "on" || value === "off" ? value : null;
+};
+var readTranscriptPreference = () => {
+  const result = readJsonSafe(configFilePath());
+  if (result.kind !== "ok") return null;
+  return typeof result.value.transcriptsEnabled === "boolean" ? result.value.transcriptsEnabled : 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 {
+  CANDIDATE_RCS,
+  resolveShellRc,
+  installClaudeAlias,
+  removeClaudeAlias,
+  KEY_FILE_MODE,
+  exportLine,
+  isDisabledExport,
+  keyPrefix,
+  writeKey,
+  clearKey,
+  readConfigFileKey,
+  readControlMode,
+  readTranscriptPreference,
+  readKeySource
+};

package/dist/chunk-POFBE6ZY.js

@@ -0,0 +1,12 @@
+// src/cli/env-switch.ts
+var CLIENT_REPORT_DISABLE_ENV = "PUSHARY_DISABLE_CLIENT_REPORTS";
+var NOT_DISABLED_VALUES = /* @__PURE__ */ new Set(["", "0"]);
+var isDisabledByEnv = (env, name) => {
+  const value = env[name];
+  return value !== void 0 && !NOT_DISABLED_VALUES.has(value.trim());
+};
+
+export {
+  CLIENT_REPORT_DISABLE_ENV,
+  isDisabledByEnv
+};

package/dist/chunk-PQ4K74WL.js

@@ -0,0 +1,30 @@
+// src/wrapper/claudeBinary.ts
+import { statSync } from "fs";
+import { join, delimiter } from "path";
+var WRAPPER_ACTIVE_ENV = "PUSHARY_WRAPPER_ACTIVE";
+var isFile = (path) => {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+};
+var findClaudeBinary = () => {
+  const override = process.env.PUSHARY_CLAUDE_BIN?.trim();
+  if (override) return isFile(override) ? override : null;
+  const pathVar = process.env.PATH ?? "";
+  const exts = process.platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
+  for (const dir of pathVar.split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      const candidate = join(dir, `claude${ext}`);
+      if (isFile(candidate)) return candidate;
+    }
+  }
+  return null;
+};
+
+export {
+  WRAPPER_ACTIVE_ENV,
+  findClaudeBinary
+};

package/dist/chunk-PUZZELE6.js

@@ -0,0 +1,37 @@
+// src/cli/browser.ts
+import { spawn } from "child_process";
+var command = () => {
+  if (process.platform === "darwin") return { bin: "open", args: [] };
+  if (process.platform === "win32") return { bin: "cmd", args: ["/c", "start", ""] };
+  if (process.platform === "linux") return { bin: "xdg-open", args: [] };
+  return null;
+};
+var canOpenBrowser = () => {
+  if (process.env.PUSHARY_NO_BROWSER === "1") return false;
+  if (process.env.CI) return false;
+  if (process.env.SSH_TTY) return false;
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  return command() !== null;
+};
+var openInBrowser = (url) => {
+  const resolved = command();
+  if (!resolved) return false;
+  try {
+    const child = spawn(resolved.bin, [...resolved.args, url], {
+      stdio: "ignore",
+      detached: true,
+      windowsHide: true
+    });
+    child.unref();
+    child.on("error", () => {
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export {
+  canOpenBrowser,
+  openInBrowser
+};