pushary 1.8.0

package/dist/bin/pushary-logout.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+import {
+  createIo
+} from "../chunk-U4TMAANR.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HZVVNGEW.js";
+import {
+  parseFlags
+} from "../chunk-GMXKITVA.js";
+import {
+  clearKey,
+  readKeySource
+} from "../chunk-P7WQEVWA.js";
+import {
+  UsageError
+} from "../chunk-7QLSKOSU.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import {
+  claudeJson,
+  codexConfigToml,
+  cursorUserMcp,
+  geminiSettings
+} from "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getBaseUrl
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
+
+// bin/pushary-logout.ts
+import { existsSync } from "fs";
+exitOnHelpFlag("logout");
+var parseLogoutOptions = (argv) => {
+  const flags = parseFlags(argv, { bools: ["json", "revoke", "help", "h"], values: [] });
+  if (flags.command !== void 0 && flags.command !== "logout") {
+    throw new UsageError(`logout takes no positional arguments (got ${flags.command})`);
+  }
+  return { json: flags.bools.has("json"), revoke: flags.bools.has("revoke") };
+};
+var options;
+try {
+  options = parseLogoutOptions(process.argv.slice(2));
+} catch (err) {
+  process.stderr.write(`  ! ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(EXIT.USAGE);
+}
+var { bold, dim, green, cyan, yellow } = createIo();
+var say = options.json ? (line) => process.stderr.write(`${line}
+`) : (line) => process.stdout.write(`${line}
+`);
+var AGENT_CONFIGS = [
+  { label: "Claude Code", path: claudeJson() },
+  { label: "Codex", path: codexConfigToml() },
+  { label: "Gemini CLI", path: geminiSettings() },
+  { label: "Cursor", path: cursorUserMcp() }
+];
+var revokeRemotely = async (apiKey) => {
+  try {
+    const res = await fetch(`${getBaseUrl()}/api/v1/server/keys/self/revoke`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.status === 401) return { ok: true, detail: "the server had already stopped accepting it" };
+    if (!res.ok) return { ok: false, detail: `the server answered ${res.status}` };
+    return { ok: true, detail: "revoked server-side" };
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message : "network error" };
+  }
+};
+var main = async () => {
+  const before = readKeySource();
+  let revoked = null;
+  if (options.revoke) {
+    if (before.key) {
+      revoked = await revokeRemotely(before.key);
+    } else {
+      revoked = { ok: false, detail: "no key was stored here, so there was nothing to revoke" };
+    }
+  }
+  const result = clearKey();
+  const remaining = AGENT_CONFIGS.filter((entry) => existsSync(entry.path));
+  say("");
+  if (!result.removedFromConfig && result.rcLinesDisabled === 0 && before.kind !== "env") {
+    say(`  ${dim("No key was stored on this machine. Nothing to remove.")}`);
+  } else {
+    say(`  ${green("\u2713")} ${bold("Signed out.")}`);
+    if (result.removedFromConfig) say(`  ${dim(`Key removed from ${result.configPath}`)}`);
+    if (result.rcLinesDisabled > 0) {
+      say(`  ${dim(`Commented out ${result.rcLinesDisabled} export line in ${result.rcPath}`)}`);
+    }
+  }
+  if (revoked) {
+    say("");
+    if (revoked.ok) {
+      say(`  ${green("\u2713")} Key ${revoked.detail}. It will not work anywhere else either.`);
+    } else {
+      say(`  ${yellow("!")} Could not revoke the key server-side: ${revoked.detail}`);
+      say(`  ${dim("It is still valid. Revoke it at")} ${cyan("pushary.com/dashboard/agent/settings")}`);
+    }
+  }
+  if (before.kind === "env") {
+    say("");
+    say(`  ${yellow("!")} PUSHARY_API_KEY is set in this shell, and a child process cannot unset it.`);
+    say(`  ${dim("Run")} ${cyan("unset PUSHARY_API_KEY")} ${dim("here, or open a new terminal.")}`);
+  }
+  if (remaining.length > 0) {
+    say("");
+    say(`  ${dim("Still holding a copy of the key, untouched by logout:")}`);
+    for (const entry of remaining) say(`  ${dim(`\u2022 ${entry.label}  ${entry.path}`)}`);
+    say(`  ${dim("Run")} ${cyan("pushary clean")} ${dim("to remove Pushary from those too.")}`);
+  }
+  say("");
+  say(`  ${dim("The key itself is still valid server-side. Revoke it at")} ${cyan("pushary.com/dashboard/agent/settings")}`);
+  say("");
+  if (options.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          ok: true,
+          removedFromConfig: result.removedFromConfig,
+          configPath: result.configPath,
+          rcPath: result.rcPath,
+          rcLinesDisabled: result.rcLinesDisabled,
+          envStillSet: before.kind === "env",
+          revoked: revoked === null ? null : revoked.ok,
+          agentConfigsRetainingKey: remaining.map((entry) => entry.path)
+        },
+        null,
+        2
+      )}
+`
+    );
+  }
+  process.exit(EXIT.OK);
+};
+main().catch((err) => {
+  process.stderr.write(`  ! logout failed: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(EXIT.FAILED);
+});

package/dist/bin/pushary-mcp.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/pushary-mcp.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+  MCP_BRIDGE_PATH,
+  bridgeError,
+  createMcpStdioBridge,
+  parseBridgeLine
+} from "../chunk-SLFABHW3.js";
+import "../chunk-M5ICYGHT.js";
+import "../chunk-2ABTSGFT.js";
+import {
+  installNetworkDefaults
+} from "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
+import "../chunk-7QLSKOSU.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
+
+// src/mcp-stdio-stream.ts
+var MCP_MAX_IN_FLIGHT = 16;
+var MCP_CONTROL_RESERVE = 4;
+var MCP_MAX_LINE_BYTES = 1024 * 1024;
+var isControl = (line) => {
+  const parsed = parseBridgeLine(line);
+  if (!parsed.ok || typeof parsed.payload !== "object" || parsed.payload === null || Array.isArray(parsed.payload)) return false;
+  const message = parsed.payload;
+  if (!("method" in message)) return false;
+  if (message.method === "notifications/cancelled") return true;
+  if (message.method !== "tools/call" || !("params" in message)) return false;
+  const params = message.params;
+  return typeof params === "object" && params !== null && "name" in params && params.name === "cancel_question";
+};
+var writeMcpMessage = (output, message) => new Promise((resolve, reject) => {
+  output.write(`${JSON.stringify(message)}
+`, (error) => error ? reject(error) : resolve());
+});
+var runMcpStdioStream = async (input, bridge2, emit) => {
+  const pending = /* @__PURE__ */ new Set();
+  let failure;
+  const line = Buffer.allocUnsafe(MCP_MAX_LINE_BYTES);
+  let lineLength = 0;
+  let discarding = false;
+  const forward = async (text) => {
+    if (!text.trim()) return;
+    const limit = MCP_MAX_IN_FLIGHT + (isControl(text) ? MCP_CONTROL_RESERVE : 0);
+    if (pending.size >= limit) {
+      await bridge2.reject(text, "Pushary MCP bridge is busy. Retry after an outstanding request finishes.");
+      return;
+    }
+    const task = bridge2.forward(text).catch((error) => {
+      failure = error;
+    }).finally(() => pending.delete(task));
+    pending.add(task);
+  };
+  try {
+    for await (const chunk of input) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      let start = 0;
+      while (start < bytes.length) {
+        if (failure) throw failure;
+        const newline = bytes.indexOf(10, start);
+        const end = newline < 0 ? bytes.length : newline;
+        if (!discarding) {
+          if (lineLength + end - start > MCP_MAX_LINE_BYTES) {
+            lineLength = 0;
+            discarding = true;
+            await emit(bridgeError(null, "MCP input line exceeds the 1 MiB limit."));
+          } else {
+            lineLength += bytes.copy(line, lineLength, start, end);
+          }
+        }
+        if (newline >= 0) {
+          if (!discarding) await forward(line.toString("utf8", 0, lineLength));
+          lineLength = 0;
+          discarding = false;
+        }
+        start = end + 1;
+      }
+    }
+    if (!discarding && lineLength > 0) await forward(line.toString("utf8", 0, lineLength));
+  } finally {
+    await Promise.all(pending);
+  }
+  if (failure) throw failure;
+};
+
+// bin/pushary-mcp.ts
+installNetworkDefaults();
+var readApiKey = () => {
+  try {
+    return getApiKey();
+  } catch {
+    return null;
+  }
+};
+var writeMessage = (message) => writeMcpMessage(process.stdout, message);
+var bridge = createMcpStdioBridge({
+  endpoint: `${getBaseUrl()}${MCP_BRIDGE_PATH}`,
+  apiKey: readApiKey,
+  fetchImpl: globalThis.fetch,
+  emit: writeMessage
+});
+runMcpStdioStream(process.stdin, bridge, writeMessage).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = EXIT.FAILED;
+});

package/dist/bin/pushary-mode.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/pushary-mode.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import {
+  exitOnFailedResponse
+} from "../chunk-EX3GAPA4.js";
+import {
+  createIo
+} from "../chunk-U4TMAANR.js";
+import {
+  exitOnHelpFlag
+} from "../chunk-HZVVNGEW.js";
+import {
+  rejectUnknownFlags
+} from "../chunk-GMXKITVA.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
+import {
+  UsageError
+} from "../chunk-7QLSKOSU.js";
+import {
+  EXIT
+} from "../chunk-KZERVKTD.js";
+import "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
+
+// src/cli/mode-request.ts
+var parseDuration = (value) => {
+  const match = value.match(/^(\d+)(m|h)$/);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  return match[2] === "h" ? amount * 3600 : amount * 60;
+};
+var modeRequestBody = (mode, duration) => {
+  if (duration === void 0) return { mode, permanent: true };
+  const ttlSeconds = parseDuration(duration);
+  return ttlSeconds ? { mode, ttlSeconds } : null;
+};
+
+// bin/pushary-mode.ts
+exitOnHelpFlag("mode");
+var VALID_MODES = ["push_only", "push_first", "terminal_only", "notify_only"];
+var { dim, green, cyan, yellow } = createIo();
+{
+  const raw = process.argv.slice(2);
+  const positional = raw[0] === "mode" ? raw.slice(1) : raw;
+  try {
+    rejectUnknownFlags(positional, ["--for"]);
+  } catch (err) {
+    process.stderr.write(`  ! ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(EXIT.USAGE);
+  }
+}
+var main = async () => {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  const rest = process.argv.slice(2);
+  const args = rest[0] === "mode" ? rest.slice(1) : rest;
+  const mode = args[0];
+  const forFlag = args[1];
+  const forValue = args[2];
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  if (!mode || mode === "status") {
+    const res2 = await fetch(`${baseUrl}/api/mcp/mode`, { headers });
+    if (!res2.ok) await exitOnFailedResponse(res2, baseUrl);
+    const data2 = await res2.json();
+    if (!data2.override) {
+      console.log(`  Mode: ${cyan("default")} ${dim("(using per-tool policies)")}`);
+    } else {
+      console.log(`  Mode: ${green(data2.override.mode)}`);
+      if (data2.override.expiresAt) {
+        console.log(`  Expires: ${new Date(data2.override.expiresAt).toLocaleString()}`);
+      } else {
+        console.log(`  ${dim("Sticky (no expiry)")}`);
+      }
+    }
+    return;
+  }
+  if (mode === "clear" || mode === "reset") {
+    const res2 = await fetch(`${baseUrl}/api/mcp/mode`, { method: "DELETE", headers });
+    if (!res2.ok) await exitOnFailedResponse(res2, baseUrl);
+    console.log(`  ${green("\u2713")} Mode override cleared \u2014 using per-tool policies`);
+    return;
+  }
+  if (!VALID_MODES.includes(mode)) {
+    console.log(`  ${yellow("!")} Invalid mode: ${mode}`);
+    console.log(`  Valid modes: ${VALID_MODES.join(", ")}`);
+    console.log(`  ${dim("Usage: pushary mode <mode> [--for <duration>]")}`);
+    console.log(`  ${dim("Example: pushary mode push_only --for 30m")}`);
+    process.exit(EXIT.USAGE);
+  }
+  if (forFlag === "--for" && !forValue) {
+    console.log(`  ${yellow("!")} --for needs a duration ${dim("(use e.g. 30m, 1h)")}`);
+    process.exit(EXIT.USAGE);
+  }
+  const request = modeRequestBody(mode, forFlag === "--for" ? forValue : void 0);
+  if (!request) {
+    console.log(`  ${yellow("!")} Invalid duration: ${forValue} ${dim("(use e.g. 30m, 1h)")}`);
+    process.exit(EXIT.USAGE);
+  }
+  const res = await fetch(`${baseUrl}/api/mcp/mode`, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify(request)
+  });
+  if (!res.ok) await exitOnFailedResponse(res, baseUrl);
+  const data = await res.json();
+  console.log(`  ${green("\u2713")} Mode set to ${cyan(data.override.mode)}${data.permanent ? dim(" (until you change it)") : ""}`);
+  if (data.override.expiresAt) {
+    console.log(`  Expires: ${new Date(data.override.expiresAt).toLocaleString()}`);
+  }
+};
+main().catch((err) => {
+  if (err instanceof UsageError) {
+    process.stderr.write(`  ! ${err.message}
+`);
+    process.exit(EXIT.USAGE);
+  }
+  console.error(`  ${yellow("!")} ${err instanceof Error ? err.message : err}`);
+  process.exit(1);
+});

package/dist/bin/pushary-notification-hook.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/pushary-notification-hook.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  activeHookSource,
+  activeIdentity
+} from "../chunk-J5TIV3J6.js";
+import "../chunk-AXPCESYO.js";
+import {
+  readHookInput
+} from "../chunk-KGDWDSNL.js";
+import "../chunk-JZTHGAPA.js";
+import "../chunk-SGZJ5LYH.js";
+import "../chunk-EYK3GSRH.js";
+import "../chunk-ZVSKMPBZ.js";
+import "../chunk-C2WCPBF7.js";
+import "../chunk-6J2JC2RT.js";
+import "../chunk-WE2J62NC.js";
+import "../chunk-3EVPNIBE.js";
+import "../chunk-OKXS7WDZ.js";
+import "../chunk-MPWXGONV.js";
+import "../chunk-SAXBC4AZ.js";
+import "../chunk-OLQRRFBX.js";
+import "../chunk-XHKBHWLX.js";
+import {
+  handleNotification
+} from "../chunk-CULUZTWQ.js";
+import "../chunk-N6IOSZOE.js";
+import "../chunk-EPCXUP3P.js";
+import "../chunk-NGDD6TXY.js";
+import "../chunk-CVQYGMSR.js";
+import "../chunk-POFBE6ZY.js";
+import "../chunk-GMXKITVA.js";
+import "../chunk-P7WQEVWA.js";
+import "../chunk-M5ICYGHT.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import "../chunk-LXQ5FBBD.js";
+import "../chunk-7QLSKOSU.js";
+import "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
+
+// bin/pushary-notification-hook.ts
+var AGENT = activeIdentity(process.argv);
+var main = async () => {
+  const input = await readHookInput(activeHookSource(process.argv), "Notification");
+  if (!input) return;
+  try {
+    await handleNotification(input, AGENT);
+  } catch {
+  }
+};
+main();

package/dist/bin/pushary-opencode-hook.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node