@pushary/agent-hooks 0.66.0 → 0.67.1

package/dist/bin/pushary-setup.js

@@ -10,13 +10,15 @@ import {
 import {
   describeDetection,
   detectAllAgents,
-  isDetected
-} from "../chunk-6G2BC4ET.js";
-import {
+  isDetected,
+  pluginLocationSnippet,
+  registerPluginLocation,
   renderAgentInstructions,
   renderProjectAgentInstructions,
+  shortenHome,
+  vscodeSettingsTargets,
   writeInstructionBlock
-} from "../chunk-N7XJ4L2W.js";
+} from "../chunk-KB4ODLGB.js";
 import {
   GEMINI_HOOK_BINARY,
   addGeminiHooks,
@@ -37,15 +39,16 @@ import {
   cursorUserHooks,
   geminiMd,
   geminiSettings,
-  pusharyConfigFile
-} from "../chunk-RU3CIBXY.js";
+  pusharyConfigFile,
+  vscodePluginDir
+} from "../chunk-7HG4WUIE.js";
 import {
   confirmAppConnection,
   connectDevice,
   connectViaAppPairing,
   printConnectInstructions,
   setHumanStream
-} from "../chunk-QTC7SR6A.js";
+} from "../chunk-V6OA4VPU.js";
 import "../chunk-3EGEA4KH.js";
 import {
   KEY_FILE_MODE,
@@ -262,7 +265,7 @@ var reportSetupAbortWith = async (deps, reason, exitCode, keyCheck = "unknown")
 var reportSetupAbort = (reason, exitCode, keyCheck) => reportSetupAbortWith(defaultDeps, reason, exitCode, keyCheck);
 
 // src/setup/options.ts
-var AGENT_CHOICES = ["claude_code", "codex", "gemini_cli", "hermes", "cursor", "custom"];
+var AGENT_CHOICES = ["claude_code", "codex", "gemini_cli", "hermes", "cursor", "vscode", "custom"];
 var CONNECT_MODES = ["app", "browser", "web", "none"];
 var CONNECT_ALIASES = { auto: "app", pwa: "web" };
 var parseConnectMode = (raw) => {
@@ -340,6 +343,7 @@ var CLAUDE_SETTINGS = claudeSettings();
 var CLAUDE_JSON = claudeJson();
 var CURSOR_PLUGIN_DIR = cursorPluginDir();
 var CURSOR_USER_HOOKS = cursorUserHooks();
+var VSCODE_PLUGIN_DIR = vscodePluginDir();
 var CLAUDE_SKILL_DIR = claudeSkillDir();
 var CODEX_HOME = codexHome();
 var CODEX_SKILL_DIR = codexSkillDir();
@@ -849,6 +853,120 @@ var setupCursor = async (apiKey) => {
   console.log(`  ${dim("\u2022")} Fully quit and reopen Cursor to load it (a Reload Window may not be enough)`);
   noteManual("Fully quit and reopen Cursor. A Reload Window may not be enough.");
 };
+var resolveBundledVsCodePlugin = () => {
+  const dir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(dir, "..", "..", "data", "vscode-plugin"),
+    join(dir, "..", "data", "vscode-plugin"),
+    join(dir, "..", "..", "..", "vscode-plugin"),
+    join(dir, "..", "..", "vscode-plugin")
+  ];
+  return candidates.find((p) => existsSync(join(p, ".claude-plugin", "plugin.json"))) ?? null;
+};
+var pinVsCodeGatePath = (pluginDir) => {
+  const hooksPath = join(pluginDir, "hooks", "hooks.json");
+  const data = readJson(hooksPath);
+  const entries = data.hooks?.PreToolUse;
+  if (!Array.isArray(entries) || entries.length === 0) {
+    throw new Error("bundled VS Code hooks.json is missing a PreToolUse entry");
+  }
+  const gate = join(pluginDir, "scripts", "pushary-gate.mjs");
+  data.hooks.PreToolUse = entries.map((entry) => ({ ...entry, command: `node "${gate}"` }));
+  writeJson(hooksPath, data);
+};
+var registerVsCodePlugin = (pluginDir) => {
+  const written = [];
+  const manual = [];
+  for (const settingsPath of vscodeSettingsTargets(existsSync)) {
+    const current = existsSync(settingsPath) ? readFileSync(settingsPath, "utf-8") : null;
+    const result = registerPluginLocation(current, pluginDir);
+    if (result.kind === "already") continue;
+    if (result.kind === "manual") {
+      manual.push(settingsPath);
+      continue;
+    }
+    if (current !== null) backupFile(settingsPath);
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileAtomic(settingsPath, result.content);
+    written.push(settingsPath);
+  }
+  return { written, manual };
+};
+var setupVsCode = async (apiKey) => {
+  console.log(`
+  ${bold("Setting up VS Code")}
+`);
+  const source = resolveBundledVsCodePlugin();
+  if (!source) throw new Error("bundled VS Code plugin not found in this package");
+  await spinner("Installing Pushary plugin", async () => {
+    const staging = join(dirname(VSCODE_PLUGIN_DIR), `.pushary-staging-vscode-${process.pid}`);
+    const backup = `${VSCODE_PLUGIN_DIR}.pushary-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+    mkdirSync(dirname(VSCODE_PLUGIN_DIR), { recursive: true });
+    rmSync(staging, { recursive: true, force: true });
+    try {
+      cpSync(source, staging, {
+        recursive: true,
+        filter: (p) => !["tools", "node_modules", ".git", ".DS_Store"].includes(basename(p))
+      });
+      const staged = readJsonSafe(join(staging, ".claude-plugin", "plugin.json"));
+      if (staged.kind !== "ok") {
+        throw new Error("staged VS Code plugin is missing or has an unreadable plugin.json");
+      }
+      const hadExisting = existsSync(VSCODE_PLUGIN_DIR);
+      if (hadExisting) renameSync(VSCODE_PLUGIN_DIR, backup);
+      try {
+        renameSync(staging, VSCODE_PLUGIN_DIR);
+      } catch (err) {
+        if (hadExisting) renameSync(backup, VSCODE_PLUGIN_DIR);
+        throw err;
+      }
+      if (hadExisting) rmSync(backup, { recursive: true, force: true });
+    } finally {
+      rmSync(staging, { recursive: true, force: true });
+    }
+  });
+  await spinner("Linking your API key", async () => {
+    const mcpPath = join(VSCODE_PLUGIN_DIR, ".mcp.json");
+    const mcp = readAgentJson(mcpPath);
+    const servers = mcp.mcpServers ?? {};
+    if (servers.pushary) {
+      servers.pushary.headers = { ...servers.pushary.headers, Authorization: `Bearer ${apiKey}` };
+      mcp.mcpServers = servers;
+      writeJsonAtomic(mcpPath, mcp, KEY_FILE_MODE);
+    }
+    pinVsCodeGatePath(VSCODE_PLUGIN_DIR);
+  });
+  let registration = { written: [], manual: [] };
+  await spinner("Registering the plugin with VS Code", async () => {
+    registration = registerVsCodePlugin(VSCODE_PLUGIN_DIR);
+  });
+  console.log();
+  console.log(`  ${dim("What this configured:")}`);
+  console.log(`  ${dim("\u2022")} Plugin installed to ${shortenHome(VSCODE_PLUGIN_DIR)} (MCP tools, skill, commands)`);
+  for (const path of registration.written) {
+    console.log(`  ${dim("\u2022")} Registered in ${shortenHome(path)} under chat.pluginLocations`);
+  }
+  console.log(`  ${dim("\u2022")} Risky shell commands route to push approval before they run`);
+  if (registration.manual.length > 0) {
+    console.log();
+    console.log(`  ${yellow("!")} ${bold("One step left, by hand")}`);
+    console.log(`  ${dim("These settings files already have a chat.pluginLocations block, and")}`);
+    console.log(`  ${dim("they contain comments, so they were left untouched rather than rewritten.")}`);
+    console.log(`  ${dim("Add this entry inside that block:")}`);
+    console.log();
+    console.log(`  ${cyan(`${JSON.stringify(VSCODE_PLUGIN_DIR)}: true`)}`);
+    console.log();
+    for (const path of registration.manual) {
+      console.log(`  ${dim("in")} ${path}`);
+    }
+    noteManual(
+      `Add ${JSON.stringify(VSCODE_PLUGIN_DIR)}: true to the chat.pluginLocations block in ${registration.manual.join(" and ")}. Full snippet:
+${pluginLocationSnippet(VSCODE_PLUGIN_DIR)}`
+    );
+  }
+  console.log(`  ${dim("\u2022")} Fully quit and reopen VS Code to load the plugin`);
+  noteManual("Fully quit and reopen VS Code. A Reload Window may not pick up a new plugin location.");
+};
 var saveApiKey = async (apiKey) => {
   let result;
   await spinner("Saving your API key", async () => {
@@ -941,6 +1059,7 @@ var AGENT_SETUP = {
   gemini_cli: setupGemini,
   hermes: setupHermes,
   cursor: setupCursor,
+  vscode: setupVsCode,
   custom: setupCustom
 };
 var PROJECT_INSTRUCTION_TARGETS = {
@@ -1042,6 +1161,7 @@ var AGENT_NAMES = {
   gemini_cli: "Gemini CLI",
   hermes: "Hermes",
   cursor: "Cursor",
+  vscode: "VS Code",
   custom: "Other"
 };
 var AGENT_CAPABILITIES = {
@@ -1050,6 +1170,7 @@ var AGENT_CAPABILITIES = {
   gemini_cli: "MCP + native hooks + auto-allowed tools",
   hermes: "native plugin + auto-error notifications",
   cursor: "plugin + permission gate",
+  vscode: "agent plugin + permission gate",
   custom: "any MCP or HTTP agent (Windsurf, n8n, custom)"
 };
 var NAME_COLUMN = Math.max(...Object.values(AGENT_NAMES).map((name) => name.length)) + 2;
@@ -1111,6 +1232,7 @@ var AGENT_TARGETS = {
   gemini_cli: [GEMINI_SETTINGS, GEMINI_MD],
   hermes: ["the Hermes virtualenv (pip install pushary-hermes)"],
   cursor: [join(CURSOR_PLUGIN_DIR, "mcp.json"), CURSOR_USER_HOOKS],
+  vscode: [join(VSCODE_PLUGIN_DIR, ".mcp.json"), ...vscodeSettingsTargets(existsSync)],
   custom: ["nothing (prints connection details only)"]
 };
 var reportDryRun = (apiKey, agents, keyCheck) => {

package/dist/bin/pushary-status.js

@@ -7,7 +7,7 @@ import {
   describeReach,
   fetchChannels,
   reachVerdict
-} from "../chunk-QTC7SR6A.js";
+} from "../chunk-V6OA4VPU.js";
 import "../chunk-3EGEA4KH.js";
 import {
   readKeySource

package/dist/bin/pushary-upgrade.js

@@ -20,8 +20,10 @@ import {
   codexHooksJson,
   cursorPluginDir,
   geminiSettings,
-  hasCodexHooks
-} from "../chunk-RU3CIBXY.js";
+  hasCodexHooks,
+  vscodePluginDir,
+  vscodePluginMcp
+} from "../chunk-7HG4WUIE.js";
 import {
   readJsonSafe
 } from "../chunk-6MTNS63X.js";
@@ -160,8 +162,7 @@ var reapplyGeminiSettings = (apiKey, paths = {}) => {
   }
   return { reapplied: hooks || mcp, hooks, mcp };
 };
-var reapplyCursorPlugin = (apiKey, paths = {}) => {
-  const mcpPath = paths.pluginMcpPath ?? join(homedir(), ".cursor", "plugins", "local", "pushary", "mcp.json");
+var reapplyPluginMcp = (mcpPath, apiKey) => {
   if (!apiKey) return { reapplied: false, hooks: false, mcp: false };
   const mcpConfig = readJson(mcpPath);
   if (mcpConfig == null) return { reapplied: false, hooks: false, mcp: false };
@@ -175,12 +176,18 @@ var reapplyCursorPlugin = (apiKey, paths = {}) => {
     return { reapplied: false, hooks: false, mcp: false };
   }
 };
+var reapplyCursorPlugin = (apiKey, paths = {}) => reapplyPluginMcp(
+  paths.pluginMcpPath ?? join(homedir(), ".cursor", "plugins", "local", "pushary", "mcp.json"),
+  apiKey
+);
+var reapplyVsCodePlugin = (apiKey, paths = {}) => reapplyPluginMcp(paths.pluginMcpPath ?? vscodePluginMcp(), apiKey);
 var reapplyAllAgents = (apiKey) => {
   const runners = [
     { label: "Claude Code", run: () => reapplyClaudeSettings(apiKey) },
     { label: "Codex", run: () => reapplyCodexSettings(apiKey) },
     { label: "Gemini CLI", run: () => reapplyGeminiSettings(apiKey) },
-    { label: "Cursor", run: () => reapplyCursorPlugin(apiKey) }
+    { label: "Cursor", run: () => reapplyCursorPlugin(apiKey) },
+    { label: "VS Code", run: () => reapplyVsCodePlugin(apiKey) }
   ];
   const done = [];
   for (const runner of runners) {
@@ -202,6 +209,11 @@ var detectInstallModes = () => {
       upgrade: "updates itself through Cursor",
       present: existsSync2(cursorPluginDir())
     },
+    {
+      label: "VS Code plugin",
+      upgrade: "npx @pushary/agent-hooks@latest setup --agents vscode",
+      present: existsSync2(vscodePluginDir())
+    },
     {
       label: "Codex config",
       upgrade: "npx @pushary/agent-hooks@latest setup --agents codex",

package/dist/{chunk-RU3CIBXY.js → chunk-7HG4WUIE.js}

@@ -158,6 +158,8 @@ var claudeSkillDir = () => join2(homedir2(), ".claude", "skills", "pushary");
 var cursorPluginDir = () => join2(homedir2(), ".cursor", "plugins", "local", "pushary");
 var cursorUserHooks = () => join2(homedir2(), ".cursor", "hooks.json");
 var cursorUserMcp = () => join2(homedir2(), ".cursor", "mcp.json");
+var vscodePluginDir = () => join2(homedir2(), ".pushary", "plugins", "vscode");
+var vscodePluginMcp = () => join2(vscodePluginDir(), ".mcp.json");
 var claudeSettingsLocal = () => join2(homedir2(), ".claude", "settings.local.json");
 var pusharyDir = () => join2(homedir2(), ".pushary");
 var codexSkillDir2 = () => join2(codexHome(), "skills", "pushary");
@@ -188,6 +190,8 @@ export {
   cursorPluginDir,
   cursorUserHooks,
   cursorUserMcp,
+  vscodePluginDir,
+  vscodePluginMcp,
   claudeSettingsLocal,
   pusharyDir,
   codexSkillDir2,

package/dist/chunk-KB4ODLGB.js

@@ -0,0 +1,332 @@
+import {
+  codexHomeFrom
+} from "./chunk-7HG4WUIE.js";
+
+// src/vscode-config.ts
+import { homedir } from "os";
+import { join } from "path";
+var PLUGIN_LOCATIONS_KEY = "chat.pluginLocations";
+var blankJsonComments = (text) => {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  let escaped = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") {
+        out += " ";
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      const stop = end === -1 ? text.length : end + 2;
+      while (i < stop) {
+        out += text[i] === "\n" ? "\n" : " ";
+        i += 1;
+      }
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+};
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var parseJsonc = (text) => {
+  const blanked = blankJsonComments(text);
+  const withoutTrailingCommas = blanked.replace(/,(\s*[}\]])/g, "$1");
+  try {
+    return asRecord(JSON.parse(withoutTrailingCommas));
+  } catch {
+    return void 0;
+  }
+};
+var rootBraceIndex = (text) => blankJsonComments(text).indexOf("{");
+var detectIndent = (text) => {
+  const match = /\n([ \t]+)"/.exec(text);
+  return match?.[1] ?? "  ";
+};
+var freshDocument = (pluginDir, indent = "  ") => `${JSON.stringify({ [PLUGIN_LOCATIONS_KEY]: { [pluginDir]: true } }, null, indent)}
+`;
+var registerPluginLocation = (existing, pluginDir) => {
+  if (existing === null || existing.trim() === "") {
+    return { kind: "created", content: freshDocument(pluginDir) };
+  }
+  const indent = detectIndent(existing);
+  try {
+    const parsed2 = asRecord(JSON.parse(existing));
+    if (parsed2) {
+      const locations2 = asRecord(parsed2[PLUGIN_LOCATIONS_KEY]) ?? {};
+      if (locations2[pluginDir] === true) return { kind: "already" };
+      parsed2[PLUGIN_LOCATIONS_KEY] = { ...locations2, [pluginDir]: true };
+      return { kind: "merged", content: `${JSON.stringify(parsed2, null, indent)}
+` };
+    }
+  } catch {
+  }
+  const parsed = parseJsonc(existing);
+  if (!parsed) return { kind: "manual" };
+  const locations = asRecord(parsed[PLUGIN_LOCATIONS_KEY]);
+  if (locations?.[pluginDir] === true) return { kind: "already" };
+  if (parsed[PLUGIN_LOCATIONS_KEY] !== void 0) return { kind: "manual" };
+  const brace = rootBraceIndex(existing);
+  if (brace === -1) return { kind: "manual" };
+  const needsComma = Object.keys(parsed).length > 0;
+  const line = `
+${indent}${JSON.stringify(PLUGIN_LOCATIONS_KEY)}: { ${JSON.stringify(pluginDir)}: true }${needsComma ? "," : ""}`;
+  return {
+    kind: "inserted",
+    content: `${existing.slice(0, brace + 1)}${line}${existing.slice(brace + 1)}`
+  };
+};
+var unregisterPluginLocation = (existing, pluginDir) => {
+  if (existing === null || existing.trim() === "") return { kind: "absent" };
+  const indent = detectIndent(existing);
+  try {
+    const parsed2 = asRecord(JSON.parse(existing));
+    if (parsed2) {
+      const locations2 = asRecord(parsed2[PLUGIN_LOCATIONS_KEY]);
+      if (!locations2 || !(pluginDir in locations2)) return { kind: "absent" };
+      const remaining = { ...locations2 };
+      delete remaining[pluginDir];
+      if (Object.keys(remaining).length === 0) delete parsed2[PLUGIN_LOCATIONS_KEY];
+      else parsed2[PLUGIN_LOCATIONS_KEY] = remaining;
+      return { kind: "removed", content: `${JSON.stringify(parsed2, null, indent)}
+` };
+    }
+  } catch {
+  }
+  const parsed = parseJsonc(existing);
+  if (!parsed) return { kind: "manual" };
+  const locations = asRecord(parsed[PLUGIN_LOCATIONS_KEY]);
+  if (!locations || !(pluginDir in locations)) return { kind: "absent" };
+  const line = new RegExp(
+    `\\n[ \\t]*${escapeRegExp(JSON.stringify(PLUGIN_LOCATIONS_KEY))}\\s*:\\s*\\{\\s*${escapeRegExp(JSON.stringify(pluginDir))}\\s*:\\s*true\\s*\\},?`
+  );
+  if (!line.test(existing)) return { kind: "manual" };
+  return { kind: "removed", content: existing.replace(line, "") };
+};
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var isPluginRegistered = (existing, pluginDir) => {
+  if (!existing) return false;
+  const parsed = parseJsonc(existing);
+  return asRecord(parsed?.[PLUGIN_LOCATIONS_KEY])?.[pluginDir] === true;
+};
+var pluginLocationSnippet = (pluginDir) => `"${PLUGIN_LOCATIONS_KEY}": {
+  ${JSON.stringify(pluginDir)}: true
+}`;
+var VSCODE_PRODUCTS = ["Code", "Code - Insiders"];
+var settingsRoot = (home, platform) => {
+  if (platform === "darwin") return join(home, "Library", "Application Support");
+  if (platform === "win32") return process.env.APPDATA?.trim() || join(home, "AppData", "Roaming");
+  return process.env.XDG_CONFIG_HOME?.trim() || join(home, ".config");
+};
+var vscodeSettingsCandidates = (home = homedir(), platform = process.platform) => {
+  const root = settingsRoot(home, platform);
+  return VSCODE_PRODUCTS.map((product) => join(root, product, "User", "settings.json"));
+};
+var vscodeSettingsTargets = (exists, home, platform) => {
+  const candidates = vscodeSettingsCandidates(home, platform);
+  const present = candidates.filter((path) => exists(path));
+  return present.length > 0 ? present : candidates.slice(0, 1);
+};
+
+// src/setup/detect.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var whichCommand = () => process.platform === "win32" ? "where" : "which";
+var binaryOnPath = (binary) => {
+  try {
+    execSync(`${whichCommand()} ${binary}`, { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultDeps = { onPath: binaryOnPath, exists: existsSync };
+var detectAgent = (probe, deps = defaultDeps) => {
+  const checked = [];
+  if (probe.binary) {
+    checked.push(`${whichCommand()} ${probe.binary}`);
+    if (deps.onPath(probe.binary)) {
+      return { kind: "installed", evidence: `${probe.binary} on PATH`, strong: true };
+    }
+  }
+  for (const path of probe.paths) {
+    checked.push(path);
+    if (deps.exists(path)) return { kind: "installed", evidence: path, strong: true };
+  }
+  for (const marker of probe.configMarkers) {
+    checked.push(marker);
+    if (deps.exists(marker)) return { kind: "installed", evidence: marker, strong: false };
+  }
+  if (probe.binary === null && probe.paths.length === 0 && probe.configMarkers.length === 0) {
+    return { kind: "unknown" };
+  }
+  return { kind: "not-found", checked };
+};
+var agentProbes = (home = homedir2()) => ({
+  claude_code: {
+    binary: "claude",
+    // The native installer puts it here, outside a default non-login PATH.
+    paths: [join2(home, ".local", "bin", "claude")],
+    configMarkers: [join2(home, ".claude")]
+  },
+  codex: {
+    binary: "codex",
+    paths: [],
+    configMarkers: [codexHomeFrom(home)]
+  },
+  gemini_cli: {
+    binary: "gemini",
+    paths: [],
+    configMarkers: [join2(home, ".gemini")]
+  },
+  hermes: {
+    binary: "hermes",
+    paths: [],
+    configMarkers: [join2(home, ".hermes")]
+  },
+  cursor: {
+    // GUI editor. `cursor` on PATH only exists if the user ran "Install 'cursor'
+    // command in PATH" from the command palette, which most never do.
+    binary: "cursor",
+    paths: process.platform === "darwin" ? ["/Applications/Cursor.app"] : process.platform === "win32" ? [join2(process.env.LOCALAPPDATA ?? join2(home, "AppData", "Local"), "Programs", "cursor")] : ["/usr/share/cursor", join2(home, ".local", "share", "cursor")],
+    configMarkers: [join2(home, ".cursor")]
+  },
+  vscode: {
+    // Like Cursor, a GUI editor: `code` on PATH only exists if the user ran
+    // "Shell Command: Install 'code' command in PATH", which on macOS is opt-in.
+    binary: "code",
+    paths: process.platform === "darwin" ? ["/Applications/Visual Studio Code.app"] : process.platform === "win32" ? [join2(process.env.LOCALAPPDATA ?? join2(home, "AppData", "Local"), "Programs", "Microsoft VS Code")] : ["/usr/share/code", join2(home, ".local", "share", "code")],
+    // The settings directory rather than ~/.vscode, because the settings
+    // directory is what this installer actually writes to. Insiders counts:
+    // someone running only Insiders still has VS Code.
+    configMarkers: vscodeSettingsCandidates(home).map((path) => dirname(path))
+  },
+  // "Other" is a set of printed instructions for any MCP or HTTP client. There is
+  // nothing to detect, and it must never be auto-selected.
+  custom: { binary: null, paths: [], configMarkers: [] }
+});
+var detectAllAgents = (deps = defaultDeps, home) => {
+  const probes = agentProbes(home);
+  return Object.keys(probes).map((agent) => ({
+    agent,
+    result: detectAgent(probes[agent], deps)
+  }));
+};
+var isDetected = (result) => result.kind === "installed";
+var shortenHome = (path, home = homedir2()) => home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+var describeDetection = (result, home) => {
+  if (result.kind !== "installed") return null;
+  const evidence = shortenHome(result.evidence, home);
+  return result.strong ? evidence : `${evidence}, config only`;
+};
+
+// src/instruction-file.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { dirname as dirname2 } from "path";
+var PUSHARY_BEGIN = "<!-- BEGIN PUSHARY (managed by @pushary/agent-hooks; do not edit this block) -->";
+var PUSHARY_END = "<!-- END PUSHARY -->";
+var instructionBody = (label) => `## Pushary notifications and approvals
+
+You have Pushary MCP tools that reach the user on their phone. Use them proactively. Do not wait for the user to ask.
+
+- When you need the user to make a decision or answer a clarifying question, call \`ask_user\` instead of guessing or stalling. Use type "confirm" for yes/no, "select" for a fixed set of options, and "input" for free text. \`ask_user\` blocks until the user replies or it times out, so you do not need a separate wait step.
+- Before any risky or irreversible step (deleting files, force pushing, spending money, sending external messages), call \`ask_user\` with type "confirm" and wait for approval.
+- Before starting a multi-step run that will change several files, call \`propose_scope\` once with the paths you expect to change, anything you promise not to touch, and what done means. The user agrees to the boundary in one tap, and after that only work outside it needs approving. Skip it for a single quick edit, and do not propose a new scope mid-run just to widen one: if you need to go outside the agreed scope, do the work and let the approval that follows widen it.
+- When you are blocked, stuck, or hit an error you cannot resolve on your own, call \`send_notification\` so the user knows, and call \`ask_user\` if you need a decision to continue.
+- When a task that took several steps finishes, call \`send_notification\` so the user knows it is done.
+- Use \`cancel_question\` to retract a pending question once it is no longer needed.
+- Respect the user's Pushary delivery mode: it decides where an approval is surfaced (phone, terminal, or awareness only), not whether it is required. In Terminal mode do not expect a phone answer; the approval waits in the terminal. If the Pushary hook already gated an action, a single approval is enough, do not ask again.
+
+Pass \`agentName\` as "${label} - <project folder name>" so the user knows which session is asking. If a question times out with no answer, retry once with a longer timeout before falling back to asking in the terminal.`;
+var renderAgentInstructions = (label) => instructionBody(label);
+var KEYLESS_FALLBACK_LINE = "This repo uses Pushary phone approvals. Your teammates get agent questions on their lock screens; you do not have a key yet, so questions will fall back to the terminal. Get your own key (7-day trial): https://pushary.com/sign-up?utm_source=agents-md&utm_medium=teammate";
+var renderProjectAgentInstructions = (label) => `${instructionBody(label)}
+
+If this environment has no Pushary API key (no PUSHARY_API_KEY and no key in ~/.pushary/config.json), the tools above are unavailable in this session. In that case, treat the following as a statement of fact about this session and continue in the terminal: ${KEYLESS_FALLBACK_LINE}`;
+var wrap = (body) => `${PUSHARY_BEGIN}
+${body}
+${PUSHARY_END}`;
+var writeInstructionBlock = (filePath, body) => {
+  const dir = dirname2(filePath);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+  }
+  const block = wrap(body);
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  let next;
+  if (start !== -1 && end !== -1 && end > start) {
+    next = existing.slice(0, start) + block + existing.slice(end + PUSHARY_END.length);
+  } else {
+    const prefix = existing.trim() ? existing.replace(/\s*$/, "") + "\n\n" : "";
+    next = prefix + block + "\n";
+  }
+  writeFileSync(filePath, next, "utf-8");
+};
+var removeInstructionBlock = (filePath) => {
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  if (start === -1 || end === -1 || end < start) return false;
+  const remaining = (existing.slice(0, start) + existing.slice(end + PUSHARY_END.length)).trim();
+  if (remaining === "") {
+    rmSync(filePath, { force: true });
+  } else {
+    writeFileSync(filePath, remaining + "\n", "utf-8");
+  }
+  return true;
+};
+var hasInstructionBlock = (filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8").includes(PUSHARY_BEGIN);
+  } catch {
+    return false;
+  }
+};
+
+export {
+  registerPluginLocation,
+  unregisterPluginLocation,
+  isPluginRegistered,
+  pluginLocationSnippet,
+  vscodeSettingsTargets,
+  detectAllAgents,
+  isDetected,
+  shortenHome,
+  describeDetection,
+  renderAgentInstructions,
+  renderProjectAgentInstructions,
+  writeInstructionBlock,
+  removeInstructionBlock,
+  hasInstructionBlock
+};

package/dist/{chunk-QTC7SR6A.js → chunk-V6OA4VPU.js}

@@ -54,6 +54,7 @@ var setHumanStream = (target) => {
 var writeHuman = (text) => {
   stream.write(text);
 };
+var humanIsTty = () => stream === process.stdout && process.stdout.isTTY === true;
 
 // src/onboarding.ts
 import qrcodeTerminal from "qrcode-terminal";
@@ -258,16 +259,35 @@ var fetchChannels = async (apiKey) => {
   };
 };
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var SPINNER_HEARTBEAT_MS = 3e4;
+var SPINNER_FRAME_MS = 200;
+var writeStatusLine = (text) => {
+  writeHuman(humanIsTty() ? `\r  ${text}\x1B[K
+` : `  ${text}
+`);
+};
 var startSpinner = (getLabel) => {
+  if (!humanIsTty()) {
+    writeHuman(`  ${getLabel()}
+`);
+    const interval2 = setInterval(() => {
+      writeHuman(`  ${getLabel()}
+`);
+    }, SPINNER_HEARTBEAT_MS);
+    interval2.unref?.();
+    return (finalGlyph, finalLabel) => {
+      clearInterval(interval2);
+      writeStatusLine(`${finalGlyph} ${finalLabel}`);
+    };
+  }
   const frames = ["   ", ".  ", ".. ", "..."];
   let i = 0;
   const interval = setInterval(() => {
     writeHuman(`\r  ${dim(frames[i++ % frames.length])} ${getLabel()}`);
-  }, 200);
+  }, SPINNER_FRAME_MS);
   return (finalGlyph, finalLabel) => {
     clearInterval(interval);
-    writeHuman(`\r  ${finalGlyph} ${finalLabel}\x1B[K
-`);
+    writeStatusLine(`${finalGlyph} ${finalLabel}`);
   };
 };
 var printQr = (url) => new Promise((resolve, reject) => {
@@ -304,8 +324,7 @@ var waitForDevice = async (apiKey, baseline) => {
         consecutiveFailures += 1;
         if (consecutiveFailures >= 3 && !warned) {
           warned = true;
-          writeHuman(`\r  ${yellow("!")} Still trying. pushary.com is not answering ${dim(`(${probe.detail})`)}\x1B[K
-`);
+          writeStatusLine(`${yellow("!")} Still trying. pushary.com is not answering ${dim(`(${probe.detail})`)}`);
         }
         await sleep(CONNECT_POLL_INTERVAL_MS);
         continue;