pushary 1.8.0

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

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

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

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import {
+  readHookInput
+} from "../chunk-KGDWDSNL.js";
+import {
+  announceSubscriptionRequired,
+  isDeferAnswer
+} from "../chunk-5OP5MQI7.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 "../chunk-N6IOSZOE.js";
+import "../chunk-EPCXUP3P.js";
+import {
+  askUser,
+  isDecisionStopped,
+  waitForQuestion
+} from "../chunk-NGDD6TXY.js";
+import "../chunk-CVQYGMSR.js";
+import "../chunk-POFBE6ZY.js";
+import "../chunk-GMXKITVA.js";
+import "../chunk-P7WQEVWA.js";
+import {
+  SubscriptionRequiredError
+} from "../chunk-M5ICYGHT.js";
+import "../chunk-2ABTSGFT.js";
+import "../chunk-2OY3ZZ5N.js";
+import {
+  getMachineId
+} from "../chunk-LXQ5FBBD.js";
+import "../chunk-7QLSKOSU.js";
+import "../chunk-KZERVKTD.js";
+import "../chunk-DB3ONZB4.js";
+import "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import {
+  ELICITATION_ANSWERABLE_MODE,
+  effectiveWaitSeconds,
+  elicitationContent,
+  elicitationContentFromAnswers,
+  hookWaitDeadline,
+  parseAgentQuestionAnswers,
+  planElicitationAsk,
+  readElicitationFields,
+  renderElicitationOutput
+} from "../chunk-NQTHFF4W.js";
+
+// bin/pushary-elicitation-hook.ts
+import { basename } from "path";
+var START_MS = Date.now();
+var answered = (ask, answer) => {
+  if (!answer.answered || isDeferAnswer(answer.value)) return null;
+  if (ask.kind === "questions") {
+    const values = answer.value ? parseAgentQuestionAnswers([...ask.questions], answer.value) : null;
+    return values ? elicitationContentFromAnswers(ask, values) : null;
+  }
+  return answer.value ? elicitationContent(ask, answer.value) : null;
+};
+var main = async () => {
+  const input = await readHookInput("claude", "Elicitation");
+  if (!input || input.hook_event_name !== "Elicitation") return;
+  if (input.mode !== ELICITATION_ANSWERABLE_MODE) return;
+  const message = (input.message ?? "").trim();
+  if (!message) return;
+  const fields = readElicitationFields(input.requested_schema);
+  if (!fields) return;
+  const ask = planElicitationAsk(message, fields);
+  if (!ask) return;
+  const apiKey = getApiKey();
+  if (!apiKey) return;
+  const project = basename(input.cwd ?? process.cwd());
+  const deadline = hookWaitDeadline(START_MS, effectiveWaitSeconds("wait", 0, "claude"), "claude", Date.now());
+  const common = {
+    context: `${input.mcp_server_name ?? "An MCP server"} is asking for input`,
+    agentName: `Claude Code - ${project}`,
+    sessionId: input.session_id,
+    machineId: getMachineId(),
+    toolName: "Elicitation",
+    toolTarget: input.mcp_server_name
+  };
+  const prompts = ask.kind === "questions" ? [...ask.questions.entries()].map(([index, question]) => ({
+    question: question.question,
+    type: "select",
+    options: question.options.map((option) => option.label),
+    questions: [question],
+    toolUseId: input.elicitation_id ? `${input.elicitation_id}:${index}` : void 0
+  })) : [{
+    question: ask.question,
+    type: ask.kind,
+    ...ask.kind === "select" ? { options: [...ask.options] } : {},
+    toolUseId: input.elicitation_id
+  }];
+  let simpleAnswer;
+  const questionAnswers = {};
+  for (const prompt of prompts) {
+    let created;
+    try {
+      created = await askUser(apiKey, { ...common, ...prompt });
+    } catch (error) {
+      if (error instanceof SubscriptionRequiredError) {
+        announceSubscriptionRequired(error.upgradeUrl, input.session_id);
+        return;
+      }
+      process.stdout.write(renderElicitationOutput(input.hook_event_name ?? "Elicitation", "cancel") ?? "");
+      return;
+    }
+    if (isDecisionStopped(created)) {
+      process.stdout.write(renderElicitationOutput(input.hook_event_name ?? "Elicitation", "cancel") ?? "");
+      return;
+    }
+    const answer = await waitForQuestion(apiKey, created, deadline);
+    if (isDecisionStopped(answer)) {
+      process.stdout.write(renderElicitationOutput(input.hook_event_name ?? "Elicitation", "cancel") ?? "");
+      return;
+    }
+    if (ask.kind === "questions") {
+      const question = "questions" in prompt ? prompt.questions[0] : void 0;
+      const parsed = question && answer.answered && answer.value ? parseAgentQuestionAnswers([question], answer.value) : null;
+      if (parsed) Object.assign(questionAnswers, parsed);
+      else {
+        return;
+      }
+    } else {
+      simpleAnswer = answer;
+    }
+  }
+  const content = ask.kind === "questions" ? elicitationContentFromAnswers(ask, questionAnswers) : simpleAnswer ? answered(ask, simpleAnswer) : null;
+  if (!content) {
+    return;
+  }
+  const output = renderElicitationOutput("Elicitation", "accept", content);
+  if (output) process.stdout.write(output);
+};
+main().catch(() => {
+});

package/dist/bin/pushary-gemini-bridge.d.ts

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

package/dist/bin/pushary-gemini-bridge.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+import {
+  LiveTranscriptRelay,
+  liveSessionSleep,
+  postLiveSession,
+  postLiveSessionUntilAccepted,
+  startLiveSessionHeartbeat
+} from "../chunk-R7437YI3.js";
+import {
+  SESSION_IDLE_TIMEOUT_MS,
+  describeIdleWindow,
+  idleDeadlinePassed,
+  startProcessOwnership,
+  withSpawnProcessOwnership
+} from "../chunk-ZSZSSJCV.js";
+import "../chunk-MPWXGONV.js";
+import "../chunk-SAXBC4AZ.js";
+import {
+  transcriptsEnabled
+} from "../chunk-OLQRRFBX.js";
+import {
+  spawnClaude
+} from "../chunk-XHKBHWLX.js";
+import "../chunk-P7WQEVWA.js";
+import {
+  getMachineId
+} from "../chunk-LXQ5FBBD.js";
+import "../chunk-DB3ONZB4.js";
+import {
+  resolveBinary
+} from "../chunk-A2A2YTMG.js";
+import "../chunk-T7E75EKA.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "../chunk-GPEGOGRJ.js";
+import "../chunk-E4FJTUH4.js";
+import "../chunk-NQTHFF4W.js";
+
+// bin/pushary-gemini-bridge.ts
+import { existsSync } from "fs";
+
+// src/gemini-bridge.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { basename } from "path";
+var MAX_STREAM_LINE = 1024 * 1024;
+var MAX_TRANSCRIPT_TEXT = 32 * 1024;
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var string = (value) => typeof value === "string" && value.length > 0 ? value : null;
+var geminiArgs = (options) => [
+  ...options.bridge.command.args ?? [],
+  ...options.bridge.model ? ["--model", options.bridge.model] : [],
+  options.startNew ? "--session-id" : "--resume",
+  options.sessionId,
+  "--output-format",
+  "stream-json",
+  "--prompt",
+  options.text
+];
+var runGeminiTurn = (options) => new Promise((resolve, reject) => {
+  const spawnOptions = {
+    cwd: options.bridge.cwd,
+    env: { ...process.env, PUSHARY_GEMINI_BRIDGE: "1" },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  };
+  const child = process.platform === "win32" ? spawnClaude(options.bridge.command.command, geminiArgs(options), spawnOptions) : spawn(options.bridge.command.command, geminiArgs(options), spawnOptions);
+  let buffer = "";
+  let assistant = "";
+  let initialized = false;
+  let successful = false;
+  let resultError = null;
+  let linkError;
+  let linking = null;
+  let settled = false;
+  const stop2 = () => {
+    if (child.exitCode == null) child.kill();
+  };
+  const fail = (error) => {
+    if (settled) return;
+    settled = true;
+    options.bridge.signal.removeEventListener("abort", stop2);
+    stop2();
+    reject(error instanceof Error ? error : new Error(String(error)));
+  };
+  const handle = (line) => {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (event.type === "init") {
+      if (event.session_id !== options.sessionId) {
+        fail(new Error("Gemini returned a different session id"));
+        return;
+      }
+      initialized = true;
+      linking ??= options.onSession().catch((error) => {
+        linkError = error;
+        stop2();
+      });
+    }
+    if (event.type === "message" && event.role === "assistant") {
+      const content = string(event.content);
+      if (content) assistant = `${assistant}${content}`.slice(0, MAX_TRANSCRIPT_TEXT);
+    }
+    if (event.type === "result") {
+      successful = event.status === "success";
+      resultError = string(object(event.error)?.message);
+    }
+  };
+  const read = (chunk) => {
+    buffer += chunk;
+    if (buffer.length > MAX_STREAM_LINE && !buffer.includes("\n")) {
+      fail(new Error("Gemini sent an oversized stream event"));
+      return;
+    }
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (line.length > MAX_STREAM_LINE) {
+        fail(new Error("Gemini sent an oversized stream event"));
+        return;
+      }
+      handle(line);
+      newline = buffer.indexOf("\n");
+    }
+  };
+  options.bridge.signal.addEventListener("abort", stop2, { once: true });
+  child.stdout?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => read(String(chunk)));
+  child.stderr?.resume();
+  child.once("error", fail);
+  child.once("close", async (code) => {
+    if (settled) return;
+    await linking;
+    if (linkError) return fail(linkError);
+    settled = true;
+    options.bridge.signal.removeEventListener("abort", stop2);
+    if (options.bridge.signal.aborted) return resolve("aborted");
+    if (!initialized) return reject(new Error("Gemini did not initialize a session"));
+    if (code !== 0 || !successful) return reject(new Error(resultError ?? `Gemini exited with code ${code ?? "unknown"}`));
+    options.relay?.add({
+      type: "user",
+      uuid: `${options.commandId}-user`,
+      message: { role: "user", content: options.text }
+    });
+    if (assistant) {
+      options.relay?.add({
+        type: "assistant",
+        uuid: `${options.commandId}-assistant`,
+        message: { role: "assistant", content: assistant }
+      });
+    }
+    resolve("delivered");
+  });
+});
+var runGeminiBridge = async (options) => {
+  const sessionId = options.resumeSessionId ?? randomUUID();
+  const now = options.now ?? Date.now;
+  const idleTimeoutMs = options.idleTimeoutMs ?? SESSION_IDLE_TIMEOUT_MS;
+  const ownership = startProcessOwnership({ sessionId, pid: process.pid, spawnId: options.spawnId });
+  let linked = false;
+  let stopHeartbeat = () => {
+  };
+  let firstTurn = !options.resumeSessionId;
+  let idleSince = now();
+  let idledOut = false;
+  const relay = options.transcripts === false ? null : new LiveTranscriptRelay(options, sessionId);
+  const reportBody = (event, action) => ({
+    event,
+    action,
+    agentType: "gemini_cli",
+    agentName: `Gemini - ${basename(options.cwd)}`,
+    sessionId,
+    geminiSessionId: sessionId,
+    spawnId: options.spawnId,
+    machineId: options.machineId,
+    pid: process.pid,
+    cwd: options.cwd
+  });
+  const report = (event, action) => postLiveSession(options, "/api/agent/event", reportBody(event, action));
+  const link = async () => {
+    if (linked) return;
+    await postLiveSessionUntilAccepted(
+      options,
+      "/api/agent/event",
+      reportBody("session_start", options.resumeSessionId ? "Session resumed" : "Session started")
+    );
+    linked = true;
+    stopHeartbeat = startLiveSessionHeartbeat(
+      options,
+      reportBody("heartbeat", "Session online"),
+      void 0,
+      () => ownership.touch()
+    );
+  };
+  const turn = (text, commandId) => {
+    const result = runGeminiTurn({
+      bridge: options,
+      sessionId,
+      text,
+      commandId,
+      startNew: firstTurn,
+      relay,
+      onSession: link
+    });
+    firstTurn = false;
+    return result;
+  };
+  try {
+    await ownership.ready;
+    if (options.resumeSessionId && !options.prompt) await link();
+    if (options.prompt) {
+      try {
+        await turn(options.prompt, `spawn-${options.spawnId}`);
+      } catch (error) {
+        if (!linked) throw error;
+        await report("turn_error", "Gemini turn failed").catch(() => null);
+      }
+      idleSince = now();
+    }
+    let pendingAck = null;
+    while (!options.signal.aborted) {
+      if (idleDeadlinePassed(idleSince, now(), idleTimeoutMs)) {
+        idledOut = true;
+        break;
+      }
+      try {
+        if (pendingAck) {
+          const acknowledged = await postLiveSession(options, "/api/agent/command/ack", pendingAck);
+          if (acknowledged.ok) pendingAck = null;
+        }
+        if (pendingAck) {
+          await liveSessionSleep(options.pollIntervalMs ?? 2e3, options.signal);
+          continue;
+        }
+        const response = await postLiveSession(options, "/api/agent/command/drain", {
+          sessionId,
+          machineId: options.machineId,
+          ackMode: true
+        });
+        if (response.ok) {
+          const command = object((await response.json()).command);
+          const commandId = string(command?.id);
+          const text = string(command?.text);
+          if (commandId && text) {
+            idleSince = now();
+            try {
+              const outcome2 = await turn(text, commandId);
+              idleSince = now();
+              if (outcome2 === "aborted") break;
+              void report("stop", "Turn completed").catch(() => null);
+              pendingAck = {
+                commandId,
+                sessionId,
+                machineId: options.machineId,
+                state: "delivered"
+              };
+            } catch (error) {
+              pendingAck = {
+                commandId,
+                sessionId,
+                machineId: options.machineId,
+                state: "failed",
+                failureCode: "gemini_rejected",
+                failureMessage: (error instanceof Error ? error.message : String(error)).slice(0, 240)
+              };
+            }
+          }
+        }
+      } catch {
+      }
+      await relay?.flush();
+      await liveSessionSleep(options.pollIntervalMs ?? 2e3, options.signal);
+    }
+    await relay?.flush();
+    await report(
+      "session_closed",
+      idledOut ? `Session ended after ${describeIdleWindow(idleTimeoutMs)} idle` : "Session stopped"
+    ).catch(() => null);
+    return "stopped";
+  } catch (error) {
+    if (!linked && options.claimId) {
+      const message = error instanceof Error ? error.message : String(error);
+      for (let attempt = 0; attempt < 3; attempt++) {
+        const acknowledged = await postLiveSession(options, "/api/agent/spawn/ack", {
+          spawnId: options.spawnId,
+          claimId: options.claimId,
+          machineId: options.machineId,
+          state: "failed",
+          failure: {
+            code: "bridge_failed",
+            message: message.slice(0, 240),
+            retryable: false
+          }
+        }).catch(() => null);
+        if (acknowledged?.ok) break;
+        await liveSessionSleep(200 * (attempt + 1), options.signal);
+      }
+    }
+    await report("error", "Live bridge failed").catch(() => null);
+    return "failed";
+  } finally {
+    stopHeartbeat();
+    ownership.stop();
+  }
+};
+
+// bin/pushary-gemini-bridge.ts
+var spawnId = process.env.PUSHARY_SPAWN_ID?.trim();
+var requestedCwd = process.env.PUSHARY_BRIDGE_CWD?.trim();
+if (!spawnId || !requestedCwd || !existsSync(requestedCwd)) {
+  process.stderr.write("[pushary] Gemini bridge received an invalid launch request\n");
+  process.exit(1);
+}
+var abort = new AbortController();
+var signals = process.platform === "win32" ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+var stop = () => abort.abort();
+for (const signal of signals) process.on(signal, stop);
+var outcome = await withSpawnProcessOwnership(spawnId, () => runGeminiBridge({
+  apiKey: getApiKey(),
+  baseUrl: getBaseUrl(),
+  machineId: getMachineId(),
+  spawnId,
+  claimId: process.env.PUSHARY_SPAWN_CLAIM_ID?.trim() || void 0,
+  cwd: requestedCwd,
+  prompt: process.env.PUSHARY_BRIDGE_PROMPT?.trim() || void 0,
+  model: process.env.PUSHARY_BRIDGE_MODEL?.trim() || void 0,
+  resumeSessionId: process.env.PUSHARY_BRIDGE_RESUME_SESSION_ID?.trim() || void 0,
+  command: { command: process.env.PUSHARY_GEMINI_COMMAND?.trim() || resolveBinary("gemini") || "gemini" },
+  signal: abort.signal,
+  transcripts: transcriptsEnabled()
+}));
+for (const signal of signals) process.off(signal, stop);
+process.exit(outcome === "stopped" ? 0 : 1);

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

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