pushary 1.8.0

package/dist/chunk-KVQBWI5T.js

@@ -0,0 +1,99 @@
+import {
+  pusharyHookExecutable
+} from "./chunk-6J2JC2RT.js";
+import {
+  isProtectedByScope,
+  registerHookEntry
+} from "./chunk-A2A2YTMG.js";
+
+// src/skills-cli.ts
+import { execSync } from "child_process";
+var PUSHARY_SKILL_SOURCE = "Pushary/pushary-skill";
+var PUSHARY_SKILL_NAME = "pushary";
+var installSkillViaSkillsCli = (agent) => {
+  try {
+    execSync(`npx -y skills@latest add ${PUSHARY_SKILL_SOURCE}@${PUSHARY_SKILL_NAME} -y -g --agent ${agent}`, {
+      stdio: "pipe",
+      timeout: 9e4
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var installAgentSkill = async (request, effects) => {
+  if (request.skillsCliInUse) {
+    const startedAt = effects.now();
+    if (effects.runSkillsCli(request.agent)) {
+      const modifiedAt = effects.skillModifiedAt(request.agentSkillDir);
+      if (modifiedAt !== null && modifiedAt >= startedAt) return "skills-cli";
+    }
+  }
+  await effects.writePackagedSkill(request.agentSkillDir);
+  return "packaged-copy";
+};
+
+// src/cursor-config.ts
+var hookCommandOf = (entry) => {
+  const command = entry && typeof entry === "object" && !Array.isArray(entry) ? entry.command : void 0;
+  return typeof command === "string" ? command : "";
+};
+var isPusharyCursorEntry = (entry) => pusharyHookExecutable(hookCommandOf(entry)) !== null;
+var registerCursorGate = (existing, entry) => registerHookEntry(existing, isPusharyCursorEntry, entry);
+var withoutPusharyCursorHooks = (hooks, scope) => {
+  let removed = 0;
+  const kept = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) {
+      kept[event] = entries;
+      continue;
+    }
+    const others = entries.filter((entry) => !isPusharyCursorEntry(entry) || isProtectedByScope(hookCommandOf(entry), scope));
+    removed += entries.length - others.length;
+    if (others.length > 0 || entries.length === 0) kept[event] = others;
+  }
+  return { hooks: kept, removed };
+};
+
+// src/cli/dry-run.ts
+import { execFileSync } from "child_process";
+import { rmSync, writeFileSync } from "fs";
+var createGuards = (isDryRun, note) => ({
+  write: (path, contents) => {
+    if (isDryRun()) return note("rewrite", path);
+    writeFileSync(path, contents, "utf-8");
+  },
+  remove: (path, options = {}) => {
+    if (isDryRun()) return note("remove ", path);
+    rmSync(path, { recursive: true, force: options.force ?? false });
+  },
+  execFile: (file, args, options, describe) => {
+    if (isDryRun()) return note("run    ", describe);
+    execFileSync(file, args, options);
+  }
+});
+var describeService = (effects) => {
+  if (effects.controlMode === "off") return "skip     the phone-start background service (--control off)";
+  const where = effects.serviceDefinitionPath ?? "the phone-start service definition";
+  const condition = effects.controlMode === "on" ? "" : ", when a supported agent and a service manager are present";
+  return `write    ${where} and register it with the OS${condition}`;
+};
+var describeSetupSideEffects = (effects) => [
+  `run      npm install -g ${effects.globalPackage}@${effects.version} (the hooks run from the global copy; up to two minutes)`,
+  `write    ${effects.configFile} (the API key, mode 600)`,
+  effects.rcPath ? `edit     ${effects.rcPath} (export PUSHARY_API_KEY)` : "print    the export line for your shell, since no rc file was found",
+  describeService(effects),
+  "ask      Add Pushary instructions to this project's CLAUDE.md/AGENTS.md? (default no)",
+  "ask      Alias claude to pushary claude? (default no)"
+];
+
+export {
+  PUSHARY_SKILL_SOURCE,
+  PUSHARY_SKILL_NAME,
+  installSkillViaSkillsCli,
+  installAgentSkill,
+  registerCursorGate,
+  withoutPusharyCursorHooks,
+  createGuards,
+  describeSetupSideEffects
+};

package/dist/chunk-KZERVKTD.js

@@ -0,0 +1,16 @@
+// src/exit.ts
+var EXIT = {
+  OK: 0,
+  FAILED: 1,
+  USAGE: 2,
+  NOT_CONFIGURED: 3,
+  UNAUTHENTICATED: 4,
+  PROBLEMS_FOUND: 5,
+  NO_DEVICE: 6,
+  INPUT_REQUIRED: 7,
+  UNREACHABLE: 8
+};
+
+export {
+  EXIT
+};

package/dist/chunk-LXQ5FBBD.js

@@ -0,0 +1,47 @@
+import {
+  pusharyDir
+} from "./chunk-A2A2YTMG.js";
+import {
+  writeFileAtomic
+} from "./chunk-T7E75EKA.js";
+
+// src/identity.ts
+import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var readMachineId = (filePath) => {
+  try {
+    const value = readFileSync(filePath, "utf8").trim();
+    return UUID.test(value) ? value : null;
+  } catch {
+    return null;
+  }
+};
+var readExistingMachineId = (options = {}) => readMachineId(options.filePath ?? join(pusharyDir(), "machine-id"));
+var getOrCreateMachineId = (options = {}) => {
+  const filePath = options.filePath ?? join(pusharyDir(), "machine-id");
+  const existing = readMachineId(filePath);
+  if (existing) return existing;
+  const id = (options.randomId ?? randomUUID)();
+  if (!UUID.test(id)) throw new Error("machine id generator returned an invalid UUID");
+  mkdirSync(dirname(filePath), { recursive: true });
+  try {
+    writeFileSync(filePath, `${id}
+`, { flag: "wx", mode: 384 });
+    return id;
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  const winner = readMachineId(filePath);
+  if (winner) return winner;
+  writeFileAtomic(filePath, `${id}
+`, 384);
+  return id;
+};
+var getMachineId = (options = {}) => getOrCreateMachineId(options);
+
+export {
+  readExistingMachineId,
+  getMachineId
+};

package/dist/chunk-M5ICYGHT.js

@@ -0,0 +1,138 @@
+import {
+  keyCheckFromResponse
+} from "./chunk-2ABTSGFT.js";
+import {
+  installNetworkDefaults
+} from "./chunk-2OY3ZZ5N.js";
+import {
+  getBaseUrl
+} from "./chunk-GPEGOGRJ.js";
+
+// src/retry.ts
+var isRetryable = (err) => {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message;
+  return /\b(502|503|429)\b/.test(msg) || /ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed/i.test(msg) || msg.includes("AbortError");
+};
+var withRetry = async (fn, options = {}) => {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 500,
+    maxDelayMs = 5e3,
+    shouldRetry = isRetryable
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt + 1 >= maxAttempts || !shouldRetry(err)) throw err;
+      const jitter = Math.random() * 0.3 + 0.85;
+      const delay = Math.min(baseDelayMs * 2 ** attempt * jitter, maxDelayMs);
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+};
+
+// src/mcp-http.ts
+installNetworkDefaults();
+var SUBSCRIPTION_REQUIRED_MESSAGE = "Pushary MCP error: 403 Subscription required";
+var SubscriptionRequiredError = class extends Error {
+  plan;
+  upgradeUrl;
+  constructor(plan, upgradeUrl) {
+    super(SUBSCRIPTION_REQUIRED_MESSAGE);
+    this.name = "SubscriptionRequiredError";
+    this.plan = plan;
+    this.upgradeUrl = upgradeUrl;
+  }
+};
+var parseSseMessages = (body) => {
+  const messages = [];
+  for (const event of body.split(/\r?\n\r?\n/)) {
+    const data = event.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+    if (!data) continue;
+    try {
+      messages.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  return messages;
+};
+var parseSseJson = (body) => {
+  const message = parseSseMessages(body).at(-1);
+  if (!message) throw new Error("Empty response from Pushary");
+  return message;
+};
+var parseMcpResponse = (body, contentType) => {
+  if (contentType?.includes("text/event-stream")) {
+    return parseSseJson(body);
+  }
+  return JSON.parse(body);
+};
+var sendMcpRequest = async (apiKey, message, options = {}) => {
+  return withRetry(async () => {
+    options.signal?.throwIfAborted();
+    const baseUrl = options.baseUrl ?? getBaseUrl();
+    const fetchFn = options.fetchFn ?? fetch;
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json, text/event-stream",
+      "Authorization": `Bearer ${apiKey}`
+    };
+    if (options.sessionId) {
+      headers["Mcp-Session-Id"] = options.sessionId;
+    }
+    const response = await fetchFn(`${baseUrl}/api/mcp/mcp`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(message),
+      signal: options.timeoutMs ? AbortSignal.any([AbortSignal.timeout(options.timeoutMs), ...options.signal ? [options.signal] : []]) : options.signal
+    });
+    const lock = response.ok ? null : await keyCheckFromResponse(response, baseUrl);
+    if (lock?.kind === "locked") throw new SubscriptionRequiredError(lock.plan, lock.upgradeUrl);
+    const body = await response.text();
+    const contentType = response.headers.get("content-type");
+    let data = null;
+    if (body.trim()) {
+      try {
+        data = parseMcpResponse(body, contentType);
+      } catch (err) {
+        if (response.ok) throw err;
+      }
+    }
+    if (!response.ok) {
+      const msg = data?.error?.message ?? (body.trim() || response.statusText);
+      throw new Error(`Pushary MCP error: ${response.status} ${msg}`);
+    }
+    if (!data) throw new Error("Empty response from Pushary");
+    if (data.error) throw new Error(data.error.message ?? "Pushary MCP error");
+    return {
+      data,
+      sessionId: response.headers.get("mcp-session-id") ?? "",
+      status: response.status,
+      statusText: response.statusText
+    };
+  }, { maxAttempts: options.maxRetries ?? 1 });
+};
+var callMcpTool = async (apiKey, toolName, params, options = {}) => {
+  const { data } = await sendMcpRequest(apiKey, {
+    jsonrpc: "2.0",
+    id: options.id ?? Date.now(),
+    method: "tools/call",
+    params: { name: toolName, arguments: params }
+  }, options);
+  const text = data.result?.content?.[0]?.text;
+  if (!text) throw new Error("Empty response from Pushary");
+  return JSON.parse(text);
+};
+
+export {
+  withRetry,
+  SubscriptionRequiredError,
+  parseSseMessages,
+  sendMcpRequest,
+  callMcpTool
+};