pushary 1.8.0

package/dist/chunk-MPWXGONV.js

@@ -0,0 +1,157 @@
+import {
+  redactSecretsFromContent
+} from "./chunk-NQTHFF4W.js";
+
+// src/crypto.ts
+import nacl from "tweetnacl";
+var EPH_PUB_LEN = nacl.box.publicKeyLength;
+var BOX_NONCE_LEN = nacl.box.nonceLength;
+var SECRETBOX_NONCE_LEN = nacl.secretbox.nonceLength;
+var SESSION_KEY_LEN = nacl.secretbox.keyLength;
+var toBase64 = (bytes) => Buffer.from(bytes).toString("base64");
+var fromBase64 = (value) => new Uint8Array(Buffer.from(value, "base64"));
+var utf8Encode = (text) => new Uint8Array(Buffer.from(text, "utf-8"));
+var decodePublicKey = (value) => fromBase64(value);
+var generateSessionKey = () => nacl.randomBytes(SESSION_KEY_LEN);
+var wrapSessionKey = (sessionKey, accountPublicKey) => {
+  const ephemeral = nacl.box.keyPair();
+  const nonce = nacl.randomBytes(BOX_NONCE_LEN);
+  const box = nacl.box(sessionKey, nonce, accountPublicKey, ephemeral.secretKey);
+  const bundle = new Uint8Array(EPH_PUB_LEN + BOX_NONCE_LEN + box.length);
+  bundle.set(ephemeral.publicKey, 0);
+  bundle.set(nonce, EPH_PUB_LEN);
+  bundle.set(box, EPH_PUB_LEN + BOX_NONCE_LEN);
+  return toBase64(bundle);
+};
+var encryptRecord = (plaintext, sessionKey) => {
+  const nonce = nacl.randomBytes(SECRETBOX_NONCE_LEN);
+  const box = nacl.secretbox(utf8Encode(plaintext), nonce, sessionKey);
+  const bundle = new Uint8Array(SECRETBOX_NONCE_LEN + box.length);
+  bundle.set(nonce, 0);
+  bundle.set(box, SECRETBOX_NONCE_LEN);
+  return toBase64(bundle);
+};
+
+// src/transcript-capture.ts
+import { createHmac } from "crypto";
+
+// src/transcript-budget.ts
+var CIPHERTEXT_BUDGET_CHARS = 64 * 1024;
+var SECRETBOX_OVERHEAD_BYTES = 24 + 16;
+var MAX_PLAINTEXT_BYTES = Math.floor(CIPHERTEXT_BUDGET_CHARS / 4) * 3 - SECRETBOX_OVERHEAD_BYTES;
+var MIN_KEEP_CHARS = 200;
+var note = (dropped) => `
+[Pushary truncated ${dropped} bytes to fit the transcript size limit]`;
+var stringSlots = (value, out = []) => {
+  if (Array.isArray(value)) {
+    value.forEach((inner, index) => {
+      if (typeof inner === "string") {
+        out.push({ get: () => value[index], set: (v) => {
+          value[index] = v;
+        } });
+      } else {
+        stringSlots(inner, out);
+      }
+    });
+  } else if (value && typeof value === "object") {
+    const object = value;
+    for (const key of Object.keys(object)) {
+      const inner = object[key];
+      if (typeof inner === "string") {
+        out.push({ get: () => object[key], set: (v) => {
+          object[key] = v;
+        } });
+      } else {
+        stringSlots(inner, out);
+      }
+    }
+  }
+  return out;
+};
+var jsonBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf-8");
+var fitWithinPlaintextBudget = (record, budget = MAX_PLAINTEXT_BYTES) => {
+  if (jsonBytes(record) <= budget) return false;
+  const slots = stringSlots(record).map((slot) => ({
+    slot,
+    originalBytes: Buffer.byteLength(slot.get(), "utf-8")
+  }));
+  if (slots.length === 0) return false;
+  let truncated = false;
+  for (let pass = 0; pass < 64 && jsonBytes(record) > budget; pass += 1) {
+    let worst = slots[0];
+    for (const candidate of slots) {
+      if (candidate.slot.get().length > worst.slot.get().length) worst = candidate;
+    }
+    const current = worst.slot.get();
+    const keep = Math.max(MIN_KEEP_CHARS, Math.floor(current.length / 2));
+    const kept = current.slice(0, keep);
+    const replacement = kept + note(worst.originalBytes - Buffer.byteLength(kept, "utf-8"));
+    if (replacement.length >= current.length) break;
+    worst.slot.set(replacement);
+    truncated = true;
+  }
+  return truncated;
+};
+
+// src/transcript-capture.ts
+var INTERNAL_TYPES = /* @__PURE__ */ new Set([
+  "file-history-snapshot",
+  "change",
+  "queue-operation",
+  "summary",
+  "last-prompt",
+  "mode",
+  "permission-mode",
+  "atis-latch",
+  "frame-link",
+  "cost-state",
+  "agent-name",
+  "bridge-session",
+  "artifact-autoreact-ledger",
+  "artifact-comment-monitor"
+]);
+var redactDeep = (value) => {
+  if (typeof value === "string") return redactSecretsFromContent(value);
+  if (Array.isArray(value)) return value.map(redactDeep);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) {
+      out[key] = redactDeep(inner);
+    }
+    return out;
+  }
+  return value;
+};
+var localIdFor = (parsed, rawLine, sessionKey) => typeof parsed.uuid === "string" && parsed.uuid.length > 0 ? parsed.uuid : createHmac("sha256", sessionKey).update(rawLine).digest("hex").slice(0, 32);
+var buildTranscriptRecords = (lines, sessionKey, seen = /* @__PURE__ */ new Set()) => {
+  const records = [];
+  const nextSeen = new Set(seen);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const type = typeof parsed.type === "string" ? parsed.type : "";
+    if (INTERNAL_TYPES.has(type)) continue;
+    const localId = localIdFor(parsed, trimmed, sessionKey);
+    if (nextSeen.has(localId)) continue;
+    nextSeen.add(localId);
+    const redacted = redactDeep(parsed);
+    fitWithinPlaintextBudget(redacted);
+    const content = encryptRecord(JSON.stringify(redacted), sessionKey);
+    records.push({ localId, content });
+  }
+  return { records, seen: nextSeen };
+};
+
+export {
+  decodePublicKey,
+  generateSessionKey,
+  wrapSessionKey,
+  encryptRecord,
+  buildTranscriptRecords
+};

package/dist/chunk-N6IOSZOE.js

@@ -0,0 +1,185 @@
+// src/pending.ts
+import { join } from "path";
+import { homedir, tmpdir } from "os";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, rmSync, statSync } from "fs";
+var PENDING_DIR = join(tmpdir(), "pushary-pending");
+var commandRoot = () => process.env.PUSHARY_COMMAND_DIR?.trim() || join(homedir(), ".pushary", "run", "commands");
+var DEFAULT_SESSION = "_no_session";
+var GRACE_MS = 10 * 60 * 1e3;
+var sanitize = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
+var dirFor = (sessionId) => join(PENDING_DIR, sanitize(sessionId));
+var commandDirFor = (sessionId, namespace = "") => join(
+  commandRoot(),
+  createHash("sha256").update(namespace).digest("hex").slice(0, 16),
+  sanitize(sessionId)
+);
+var legacyCommandFile = (sessionId, namespace = "") => join(commandDirFor(sessionId, namespace), "command.json");
+var commandFile = (sessionId, id, namespace = "") => join(commandDirFor(sessionId, namespace), `${createHash("sha256").update(id).digest("hex")}.json`);
+var readCommandFile = (file) => {
+  try {
+    const value = JSON.parse(readFileSync(file, "utf-8"));
+    if (typeof value.id !== "string" || typeof value.text !== "string" || typeof value.expiresAtMs !== "number") return null;
+    if (value.expiresAtMs <= Date.now()) {
+      unlinkSync(file);
+      return null;
+    }
+    return {
+      ...value,
+      delivered: value.delivered === true,
+      ...value.failed === true ? { failed: true } : {}
+    };
+  } catch {
+    return null;
+  }
+};
+var readPendingCommandById = (sessionId, id, namespace = "") => {
+  const current = readCommandFile(commandFile(sessionId, id, namespace));
+  if (current?.id === id) return current;
+  const legacy = readCommandFile(legacyCommandFile(sessionId, namespace));
+  return legacy?.id === id ? legacy : null;
+};
+var pruneExpiredCommands = (dir) => {
+  let files;
+  try {
+    files = readdirSync(dir).filter((file) => file.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return files.flatMap((file) => {
+    const command = readCommandFile(join(dir, file));
+    return command ? [command] : [];
+  });
+};
+var pruneExpiredCommandStore = () => {
+  let namespaces;
+  try {
+    namespaces = readdirSync(commandRoot(), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const namespace of namespaces.filter((entry) => entry.isDirectory())) {
+    const namespaceDir = join(commandRoot(), namespace.name);
+    let sessions;
+    try {
+      sessions = readdirSync(namespaceDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const session of sessions.filter((entry) => entry.isDirectory())) {
+      pruneExpiredCommands(join(namespaceDir, session.name));
+    }
+  }
+};
+var readPendingCommand = (sessionId, namespace = "") => {
+  const commands = pruneExpiredCommands(commandDirFor(sessionId, namespace));
+  return commands.find((command) => !command.delivered && !command.failed) ?? commands[0] ?? null;
+};
+var savePendingCommand = (sessionId, command, namespace = "") => {
+  const dir = commandDirFor(sessionId, namespace);
+  try {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    pruneExpiredCommandStore();
+    if (readPendingCommandById(sessionId, command.id, namespace)) return false;
+    writeFileSync(commandFile(sessionId, command.id, namespace), JSON.stringify(command), { encoding: "utf-8", mode: 384, flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var updatePendingCommand = (sessionId, id, update, namespace = "") => {
+  const command = readPendingCommandById(sessionId, id, namespace);
+  if (!command) return false;
+  const currentFile = commandFile(sessionId, id, namespace);
+  const file = existsSync(currentFile) ? currentFile : legacyCommandFile(sessionId, namespace);
+  const temporary = `${file}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temporary, JSON.stringify({ ...command, ...update, text: "" }), { encoding: "utf-8", mode: 384 });
+    renameSync(temporary, file);
+    return true;
+  } catch {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    return false;
+  }
+};
+var markPendingCommandDelivered = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: true, failed: void 0 }, namespace);
+var markPendingCommandFailed = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: false, failed: true }, namespace);
+var removePendingCommand = (sessionId, id, namespace = "") => {
+  if (!readPendingCommandById(sessionId, id, namespace)) return;
+  try {
+    unlinkSync(commandFile(sessionId, id, namespace));
+  } catch {
+  }
+  try {
+    if (readCommandFile(legacyCommandFile(sessionId, namespace))?.id === id) {
+      unlinkSync(legacyCommandFile(sessionId, namespace));
+    }
+  } catch {
+  }
+};
+var isDefaultSession = (sessionId) => sanitize(sessionId) === DEFAULT_SESSION;
+var listPendingQuestionsForToolUse = (sessionId, toolUseId) => {
+  if (!toolUseId) return [];
+  const dir = dirFor(sessionId);
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return files.filter((name) => {
+    try {
+      return readFileSync(join(dir, name), "utf-8") === toolUseId;
+    } catch {
+      return false;
+    }
+  });
+};
+var listPendingQuestions = (sessionId) => {
+  const dir = dirFor(sessionId);
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  if (!isDefaultSession(sessionId)) return files;
+  const cutoff = Date.now() - GRACE_MS;
+  return files.filter((name) => {
+    try {
+      return statSync(join(dir, name)).mtimeMs < cutoff;
+    } catch {
+      return false;
+    }
+  });
+};
+var removePendingQuestion = (sessionId, correlationId) => {
+  try {
+    unlinkSync(join(dirFor(sessionId), correlationId));
+  } catch {
+  }
+};
+var removePendingSession = (sessionId) => {
+  try {
+    rmSync(dirFor(sessionId), { recursive: true, force: true });
+  } catch {
+  }
+};
+
+export {
+  DEFAULT_SESSION,
+  readPendingCommandById,
+  readPendingCommand,
+  savePendingCommand,
+  markPendingCommandDelivered,
+  markPendingCommandFailed,
+  removePendingCommand,
+  isDefaultSession,
+  listPendingQuestionsForToolUse,
+  listPendingQuestions,
+  removePendingQuestion,
+  removePendingSession
+};

package/dist/chunk-NGDD6TXY.js

@@ -0,0 +1,192 @@
+import {
+  clientErrorKindOf,
+  reportClientError
+} from "./chunk-CVQYGMSR.js";
+import {
+  SubscriptionRequiredError,
+  callMcpTool
+} from "./chunk-M5ICYGHT.js";
+import {
+  installNetworkDefaults
+} from "./chunk-2OY3ZZ5N.js";
+import {
+  getBaseUrl
+} from "./chunk-GPEGOGRJ.js";
+import {
+  ASK_AGENT_NAME_MAX,
+  ASK_QUESTION_MAX,
+  DECISION_LINE_MAX,
+  truncateLine
+} from "./chunk-NQTHFF4W.js";
+
+// src/api.ts
+import { randomUUID } from "crypto";
+
+// src/validate.ts
+var isPolicyConfig = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return (d.resolvedAgent === void 0 || typeof d.resolvedAgent === "string") && Array.isArray(d.policies) && typeof d.defaultTimeoutSeconds === "number" && typeof d.defaultTimeoutAction === "string";
+};
+var isAskUserResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.correlationId === "string" && typeof d.status === "string" && (d.answered === void 0 || typeof d.answered === "boolean") && (d.value === void 0 || typeof d.value === "string") && (d.note === void 0 || typeof d.note === "string") && (d.waitEndsAt === void 0 || typeof d.waitEndsAt === "string");
+};
+var isWaitForAnswerResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.answered === "boolean";
+};
+var GATE_REPLY_KINDS = ["kill", "allow", "deny", "ask", "no_opinion"];
+var isSettlementOutputs = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const outputs = value;
+  return (outputs.approve === void 0 || typeof outputs.approve === "string") && (outputs.deny === void 0 || typeof outputs.deny === "string");
+};
+var isGateReply = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return GATE_REPLY_KINDS.includes(d.kind) && (d.output === void 0 || typeof d.output === "string") && (d.correlationId === void 0 || typeof d.correlationId === "string") && (d.deadlineSeconds === void 0 || typeof d.deadlineSeconds === "number") && (d.noDevices === void 0 || typeof d.noDevices === "boolean") && (d.suppressed === void 0 || typeof d.suppressed === "boolean") && (d.settlementOutputs === void 0 || isSettlementOutputs(d.settlementOutputs));
+};
+var isBlockedActionClaim = (data) => {
+  if (!data || typeof data !== "object") return false;
+  return typeof data.granted === "boolean";
+};
+
+// src/api.ts
+installNetworkDefaults();
+var DECISION_STOP_REASON = "Approval was cancelled or became unavailable. Retry only after resolving it.";
+var isDecisionStopped = (result) => result.handoffAction === "stop" || ["cancelled", "unavailable", "stopped", "missing"].includes(result.status ?? "");
+var isLocalQuestionHandoff = (result) => result.suppressed === true || result.noDevices === true || result.status === "terminal" || result.status === "notified";
+var STOPPED = { answered: false, handoffAction: "stop" };
+var UNVERIFIABLE_APPROVAL_REASON = "Pushary could not create a verifiable approval. Retry the action.";
+var unavailableQuestionUnlessSubscriptionRequired = (error) => {
+  if (error instanceof SubscriptionRequiredError) throw error;
+  return { correlationId: "", status: "unavailable" };
+};
+var truncateOptional = (text, max) => text === void 0 ? void 0 : truncateLine(text, max);
+var withinAskUserLimits = (params) => ({
+  ...params,
+  question: truncateLine(params.question, ASK_QUESTION_MAX),
+  agentName: truncateOptional(params.agentName, ASK_AGENT_NAME_MAX),
+  intent: truncateOptional(params.intent, DECISION_LINE_MAX),
+  action: truncateOptional(params.action, DECISION_LINE_MAX),
+  blocker: truncateOptional(params.blocker, DECISION_LINE_MAX)
+});
+var askUser = async (apiKey, params, timeoutMs = 15e3) => {
+  const identified = params.toolUseId || params.requestId ? params : { ...params, requestId: randomUUID() };
+  const result = await callMcpTool(apiKey, "ask_user", { ...withinAskUserLimits(identified), wait: false }, { maxRetries: 3, timeoutMs });
+  if (!isAskUserResponse(result)) throw new Error("Invalid ask_user response");
+  return result;
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4, signal) => {
+  const result = await callMcpTool(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  }, { timeoutMs: timeoutMs + 1e4, signal });
+  if (!isWaitForAnswerResponse(result)) throw new Error("Invalid wait_for_answer response");
+  return result;
+};
+var WAIT_RESPONSE_GRACE_MS = 2e3;
+var MIN_LONG_POLL_MS = 1e3;
+var MAX_LONG_POLL_MS = 3e4;
+var nextLongPollMs = (deadlineMs, nowMs) => {
+  const hold = Math.min(deadlineMs - nowMs - WAIT_RESPONSE_GRACE_MS, MAX_LONG_POLL_MS);
+  return hold >= MIN_LONG_POLL_MS ? hold : null;
+};
+var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  while (Date.now() < deadlineMs) {
+    const hold = nextLongPollMs(deadlineMs, Date.now());
+    if (hold === null) {
+      await sleep(Math.max(0, deadlineMs - Date.now()));
+      continue;
+    }
+    let answer;
+    try {
+      answer = await waitForAnswer(apiKey, correlationId, hold, AbortSignal.timeout(Math.max(1, deadlineMs - Date.now())));
+    } catch {
+      const late = await withdrawQuestion(apiKey, correlationId);
+      return late.answered ? late : STOPPED;
+    }
+    if (isDecisionStopped(answer) || answer.answered) return answer;
+    if (answer.status === "expired") return STOPPED;
+    await sleep(Math.min(pollInterval, Math.max(0, deadlineMs - Date.now())));
+  }
+  return withdrawQuestion(apiKey, correlationId);
+};
+var cancelQuestion = async (apiKey, correlationId, signal) => {
+  return callMcpTool(apiKey, "cancel_question", { correlationId }, { signal, timeoutMs: 4e3, maxRetries: 1 });
+};
+var withdrawQuestion = async (apiKey, correlationId, transport = { cancelQuestion, waitForAnswer }) => {
+  try {
+    const cancelled = await transport.cancelQuestion(apiKey, correlationId, AbortSignal.timeout(4e3));
+    if (!cancelled || isDecisionStopped(cancelled)) return STOPPED;
+    if (cancelled.cancelled === true) return { answered: false, status: "withdrawn" };
+    const late = await transport.waitForAnswer(apiKey, correlationId, 1e3, AbortSignal.timeout(2e3));
+    if (late.answered || isDecisionStopped(late)) return late;
+    return late.status === "expired" ? { answered: false, status: "withdrawn" } : STOPPED;
+  } catch {
+    return STOPPED;
+  }
+};
+var waitForQuestion = async (apiKey, question, deadlineMs, pollInterval = 2e3) => {
+  if (isDecisionStopped(question) || question.answered) return { ...question, answered: !!question.answered };
+  if (question.status === "expired") return STOPPED;
+  return isLocalQuestionHandoff(question) ? withdrawQuestion(apiKey, question.correlationId) : pollForAnswer(apiKey, question.correlationId, deadlineMs, pollInterval);
+};
+var sendNotification = async (apiKey, params, timeoutMs = 15e3, signal) => {
+  await callMcpTool(apiKey, "send_notification", { ...params }, { maxRetries: signal ? 1 : 3, timeoutMs, signal });
+};
+var GATE_PATH = "/api/agent/gate";
+var BLOCKED_ACTION_CLAIM_PATH = "/api/agent/blocked-action/claim";
+var postAgentRequest = async (apiKey, path, body, timeoutMs) => {
+  const response = await fetch(`${getBaseUrl()}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) throw new Error(`${path} rejected (${response.status})`);
+  return response.json();
+};
+var requestGate = async (apiKey, request, timeoutMs = 15e3) => {
+  try {
+    const reply = await postAgentRequest(apiKey, GATE_PATH, request, timeoutMs);
+    return isGateReply(reply) ? reply : null;
+  } catch (error) {
+    void reportClientError({ kind: clientErrorKindOf(error), code: "gate_request_failed" });
+    return null;
+  }
+};
+var claimBlockedAction = async (apiKey, request, timeoutMs) => {
+  try {
+    const reply = await postAgentRequest(apiKey, BLOCKED_ACTION_CLAIM_PATH, request, timeoutMs);
+    return isBlockedActionClaim(reply) ? reply.granted : null;
+  } catch (error) {
+    void reportClientError({ kind: clientErrorKindOf(error), code: "blocked_action_claim_failed" });
+    return null;
+  }
+};
+
+export {
+  isPolicyConfig,
+  isAskUserResponse,
+  isWaitForAnswerResponse,
+  DECISION_STOP_REASON,
+  isDecisionStopped,
+  isLocalQuestionHandoff,
+  UNVERIFIABLE_APPROVAL_REASON,
+  unavailableQuestionUnlessSubscriptionRequired,
+  askUser,
+  waitForAnswer,
+  nextLongPollMs,
+  pollForAnswer,
+  cancelQuestion,
+  withdrawQuestion,
+  waitForQuestion,
+  sendNotification,
+  requestGate,
+  claimBlockedAction
+};