@raegent/earshot 0.2.0 → 0.3.1

package/dist/main.js

@@ -18381,7 +18381,7 @@ class ShadowGit {
 }
 
 // packages/core/src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.3.1";
 
 // packages/core/src/session/repair.ts
 var REPAIR_TEXT = "No result was recorded for this call: earshot exited before the tool finished. " + "The call may or may not have run, so treat its effect as unknown and check " + "the current state rather than assuming either outcome.";
@@ -18642,7 +18642,16 @@ function parseArgs(argv) {
       positionals.push(arg);
     }
   }
-  const known = new Set(["auth", "mcp", "extensions", "config", "models", "acp", "doctor"]);
+  const known = new Set([
+    "auth",
+    "mcp",
+    "extensions",
+    "config",
+    "models",
+    "acp",
+    "doctor",
+    "update"
+  ]);
   const command = positionals[0] !== undefined && known.has(positionals[0]) ? positionals[0] : undefined;
   return { command, flags, positionals: command ? positionals.slice(1) : positionals };
 }
@@ -22654,6 +22663,378 @@ ${models.length} models across ${new Set(models.map((m) => m.providerId)).size}
   return 0;
 }
 
+// packages/cli/src/commands/update.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createHash as createHash4 } from "node:crypto";
+import { existsSync as existsSync2, realpathSync } from "node:fs";
+import { chmod, readdir as readdir8, rename as rename2, rm as rm2, writeFile as writeFile10 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname9, join as join19, sep as sep5 } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+var PACKAGE = "@raegent/earshot";
+var REPO = "rishabhguptajs/earshot";
+var REGISTRY = `https://registry.npmjs.org/${PACKAGE.replace("/", "%2f")}/latest`;
+var RELEASE = `https://api.github.com/repos/${REPO}/releases/latest`;
+var BUNFS_MARKERS = ["/$bunfs/", "\\$bunfs\\", "/~BUN/", "\\~BUN\\"];
+var ASSETS = {
+  "darwin-arm64": "earshot-darwin-arm64",
+  "darwin-x64": "earshot-darwin-x64",
+  "linux-x64": "earshot-linux-x64",
+  "linux-arm64": "earshot-linux-arm64",
+  "win32-x64": "earshot-windows-x64.exe"
+};
+function modulePath(moduleUrl) {
+  try {
+    return fileURLToPath(moduleUrl);
+  } catch {
+    return moduleUrl;
+  }
+}
+function managerOf(dir) {
+  const lower = dir.toLowerCase().replaceAll("\\", "/");
+  if (lower.includes("/.bun/install/global"))
+    return "bun";
+  if (lower.includes("/.volta/"))
+    return "volta";
+  if (lower.includes("/pnpm/global") || lower.includes("/.pnpm/"))
+    return "pnpm";
+  if (lower.includes("/.yarn/") || lower.includes("/yarn/global"))
+    return "yarn";
+  return "npm";
+}
+function detectInstall(options) {
+  const { execPath, moduleUrl, bunVersion, platform: platform7, arch } = options;
+  const realpath = options.realpath ?? ((path) => path);
+  const file = modulePath(moduleUrl);
+  if (BUNFS_MARKERS.some((marker3) => file.includes(marker3)) && bunVersion !== undefined) {
+    const asset = ASSETS[`${platform7}-${arch}`];
+    const target = realpath(execPath);
+    if (asset === undefined) {
+      return {
+        kind: "binary",
+        path: target,
+        reason: `no release asset is built for ${platform7}-${arch}`
+      };
+    }
+    return { kind: "binary", path: target, asset };
+  }
+  const marker2 = `${sep5}node_modules${sep5}${PACKAGE.split("/").join(sep5)}${sep5}`;
+  const index = `${file}${sep5}`.indexOf(marker2);
+  if (index !== -1) {
+    const packageDir = file.slice(0, index + marker2.length - 1);
+    const tree = packageDir.slice(0, packageDir.indexOf(`${sep5}node_modules${sep5}`));
+    const isProjectRoot = options.isProjectRoot ?? (() => false);
+    return {
+      kind: "npm",
+      path: packageDir,
+      manager: managerOf(packageDir),
+      local: isProjectRoot(tree)
+    };
+  }
+  if (file.includes(`${sep5}packages${sep5}cli${sep5}`) || file.endsWith(".ts")) {
+    return { kind: "source", path: file, reason: "running from a source checkout" };
+  }
+  return { kind: "unknown", path: file, reason: `cannot tell how ${execPath} was installed` };
+}
+function compareVersions(a, b) {
+  const split = (value) => {
+    const [core = "", pre] = value.replace(/^v/, "").split("-");
+    const parts = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    return { parts, pre };
+  };
+  const left = split(a);
+  const right = split(b);
+  for (let i = 0;i < 3; i++) {
+    const diff2 = (left.parts[i] ?? 0) - (right.parts[i] ?? 0);
+    if (diff2 !== 0)
+      return diff2 < 0 ? -1 : 1;
+  }
+  if (left.pre === right.pre)
+    return 0;
+  if (left.pre === undefined)
+    return 1;
+  if (right.pre === undefined)
+    return -1;
+  return left.pre < right.pre ? -1 : 1;
+}
+function releaseAuth(env) {
+  const token = env.EARSHOT_GITHUB_TOKEN ?? env.GITHUB_TOKEN ?? env.GH_TOKEN;
+  return token ? { headers: { authorization: `Bearer ${token}` } } : {};
+}
+function releaseNotFound(env) {
+  return releaseAuth(env).headers === undefined ? "GitHub returned 404. The releases are not public, so this needs a token: " + "set GITHUB_TOKEN (or GH_TOKEN) to one that can read the repository." : "GitHub returned 404 for the token in GITHUB_TOKEN; it may not have access " + "to this repository.";
+}
+async function fetchRelease(fetchImpl, env) {
+  const response = await fetchImpl(RELEASE, releaseAuth(env));
+  if (response.status === 404)
+    throw new Error(releaseNotFound(env));
+  if (!response.ok)
+    throw new Error(`GitHub releases returned ${response.status}`);
+  const body = await response.json();
+  if (!body.tag_name)
+    throw new Error("GitHub returned a release with no tag");
+  const assets = {};
+  for (const asset of body.assets ?? [])
+    assets[asset.name] = asset.url;
+  return { version: body.tag_name.replace(/^v/, ""), assets };
+}
+async function resolveLatest(kind, fetchImpl, env = process.env) {
+  if (kind === "npm") {
+    const response = await fetchImpl(REGISTRY);
+    if (!response.ok)
+      throw new Error(`npm registry returned ${response.status}`);
+    const body = await response.json();
+    if (!body.version)
+      throw new Error("npm registry returned no version");
+    return body.version;
+  }
+  return (await fetchRelease(fetchImpl, env)).version;
+}
+function findChecksum(sums, asset) {
+  for (const line of sums.split(`
+`)) {
+    const [hash, ...rest] = line.trim().split(/\s+/);
+    const name = rest.join(" ").replace(/^\*/, "");
+    if (hash && name && basename2(name) === asset)
+      return hash.toLowerCase();
+  }
+  return;
+}
+var installCommand = {
+  npm: `npm install -g ${PACKAGE}@latest`,
+  bun: `bun add -g ${PACKAGE}@latest`,
+  pnpm: `pnpm add -g ${PACKAGE}@latest`,
+  yarn: `yarn global add ${PACKAGE}@latest`,
+  volta: `volta install ${PACKAGE}@latest`
+};
+async function runUpdate(options = {}) {
+  const out = options.out ?? ((text2) => process.stdout.write(text2));
+  const err = options.err ?? ((text2) => process.stderr.write(text2));
+  const current = options.current ?? VERSION;
+  const install = options.install ?? detectInstall({
+    execPath: process.execPath,
+    moduleUrl: import.meta.url,
+    bunVersion: process.versions.bun,
+    platform: process.platform,
+    arch: process.arch,
+    realpath: (path) => {
+      try {
+        return realpathSync(path);
+      } catch {
+        return path;
+      }
+    },
+    isProjectRoot: (dir) => existsSync2(join19(dir, "package.json"))
+  });
+  const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+  if (install.kind === "source" || install.kind === "unknown") {
+    err(`earshot update: ${install.reason}
+`);
+    err(install.kind === "source" ? `update the checkout with git instead
+` : `reinstall from ${`https://github.com/${REPO}/releases`}
+`);
+    return 2;
+  }
+  if (install.kind === "binary" && install.asset === undefined) {
+    err(`earshot update: ${install.reason}
+`);
+    return 2;
+  }
+  let latest;
+  let release2;
+  try {
+    if (install.kind === "binary") {
+      release2 = await fetchRelease(fetchImpl, options.env ?? process.env);
+      latest = release2.version;
+    } else {
+      latest = await resolveLatest(install.kind, fetchImpl, options.env ?? process.env);
+    }
+  } catch (error) {
+    err(`earshot update: ${error.message}
+`);
+    return 1;
+  }
+  if (compareVersions(current, latest) >= 0) {
+    out(`earshot ${current} is the latest version
+`);
+    return 0;
+  }
+  const where = install.kind === "npm" ? `installed with ${install.manager}, ${install.local ? "in this project" : "globally"}` : "standalone binary";
+  out(`earshot ${current}  ->  ${latest}   (${where})
+`);
+  if (install.kind === "npm") {
+    const manager2 = install.manager ?? "npm";
+    const command = install.local ? `${manager2 === "npm" ? "npm install" : `${manager2} add`} ${PACKAGE}@latest` : installCommand[manager2];
+    out(`
+  ${command}
+
+`);
+    if (install.local || manager2 !== "npm") {
+      out(`run that to update
+`);
+      return options.check ? 4 : 0;
+    }
+    if (options.check)
+      return 4;
+    if (!await confirmed(options, "run it now?")) {
+      out(`run that to update
+`);
+      return 0;
+    }
+    const run4 = options.run ?? runCommand2;
+    const result = run4("npm", ["install", "-g", `${PACKAGE}@latest`]);
+    if (result.status !== 0) {
+      err(`earshot update: npm exited ${result.status}
+`);
+      return 1;
+    }
+    out(`updated to ${latest}
+`);
+    return 0;
+  }
+  return await updateBinary(install, release2, options, out, err);
+}
+function runCommand2(command, args) {
+  const result = spawnSync2(command, args, { stdio: "inherit", windowsHide: true, shell: false });
+  return { status: result.status };
+}
+async function confirmed(options, question) {
+  if (options.yes)
+    return true;
+  const confirm = options.confirm ?? defaultConfirm;
+  return await confirm(question);
+}
+async function defaultConfirm(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY)
+    return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(`${question} [y/N] `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function updateBinary(install, release2, options, out, err) {
+  const target = install.path;
+  const asset = install.asset;
+  const dir = dirname9(target);
+  const latest = release2.version;
+  const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+  await sweepStale(dir, target);
+  out(`  ${target}   ${asset}
+`);
+  if (options.check)
+    return 4;
+  try {
+    await writeFile10(join19(dir, `.earshot-update-probe-${process.pid}`), "");
+    await rm2(join19(dir, `.earshot-update-probe-${process.pid}`), { force: true });
+  } catch {
+    err(`earshot update: cannot write to ${dir}
+`);
+    err(`re-run with the permissions that own that directory
+`);
+    return 1;
+  }
+  if (!await confirmed(options, `download ${asset} and replace it?`)) {
+    out(`nothing was changed
+`);
+    return 0;
+  }
+  const assetUrl = release2.assets[asset];
+  const sumsUrl = release2.assets.SHA256SUMS;
+  if (assetUrl === undefined || sumsUrl === undefined) {
+    err(`earshot update: release v${latest} does not publish ${assetUrl ? "SHA256SUMS" : asset}
+`);
+    return 1;
+  }
+  const temp = join19(dir, `.earshot-update-${process.pid}.tmp`);
+  try {
+    const auth2 = releaseAuth(options.env ?? process.env);
+    const octet = {
+      ...auth2,
+      headers: { ...auth2.headers, accept: "application/octet-stream" }
+    };
+    out("  downloading… ");
+    const download = await fetchImpl(assetUrl, octet);
+    if (download.status === 404)
+      throw new Error(releaseNotFound(options.env ?? process.env));
+    if (!download.ok)
+      throw new Error(`downloading ${asset} returned ${download.status}`);
+    const bytes = new Uint8Array(await download.arrayBuffer());
+    out("verifying SHA256… ");
+    const sumsResponse = await fetchImpl(sumsUrl, octet);
+    if (!sumsResponse.ok)
+      throw new Error(`SHA256SUMS returned ${sumsResponse.status}`);
+    const expected = findChecksum(await sumsResponse.text(), asset);
+    if (expected === undefined)
+      throw new Error(`SHA256SUMS does not list ${asset}`);
+    const actual = createHash4("sha256").update(bytes).digest("hex");
+    if (actual !== expected) {
+      throw new Error(`checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
+    }
+    out("replacing… ");
+    await writeFile10(temp, bytes);
+    const platform7 = options.platform ?? process.platform;
+    if (platform7 !== "win32")
+      await chmod(temp, 493);
+    await replace(temp, target, platform7);
+    out(`
+updated to ${latest}
+`);
+    return 0;
+  } catch (error) {
+    await rm2(temp, { force: true });
+    out(`
+`);
+    err(`earshot update: ${error.message}
+`);
+    err(`nothing was replaced
+`);
+    return 1;
+  }
+}
+var realIo = {
+  rename: (from, to) => rename2(from, to),
+  remove: (path) => rm2(path, { force: true })
+};
+async function replace(temp, target, platform7, io = realIo) {
+  if (platform7 !== "win32") {
+    await io.rename(temp, target);
+    return;
+  }
+  const aside = `${target}.old-${process.pid}`;
+  await io.rename(target, aside);
+  try {
+    await io.rename(temp, target);
+  } catch (error) {
+    await io.rename(aside, target).catch(() => {});
+    throw error;
+  }
+  await io.remove(aside).catch(() => {});
+}
+async function sweepStale(dir, target) {
+  const prefix = `${basename2(target)}.old-`;
+  const entries = await readdir8(dir).catch(() => []);
+  for (const entry of entries) {
+    if (entry.startsWith(prefix))
+      await rm2(join19(dir, entry), { force: true }).catch(() => {});
+  }
+}
+async function updateCommand(args) {
+  if (args.positionals.length > 0) {
+    process.stderr.write(`earshot update: unexpected argument "${args.positionals[0]}"
+`);
+    process.stderr.write(`usage: earshot update [--check] [--yes]
+`);
+    return 2;
+  }
+  return runUpdate({
+    check: args.flags.check === true,
+    yes: args.flags.yes === true || args.flags.y === true
+  });
+}
+
 // packages/cli/src/index.ts
 var HELP = `earshot ${VERSION} - a terminal coding agent that actually listens
 
@@ -22666,6 +23047,7 @@ Usage
   earshot extensions <cmd>     list, trust or untrust in-process extensions
   earshot acp                  serve editor clients over ACP v1 on stdio
   earshot doctor               diagnose the local setup
+  earshot update [--check]     update earshot to the latest release
 
 Flags
   --model <provider/model>     model for this session
@@ -22705,6 +23087,8 @@ async function main(argv = process.argv.slice(2)) {
     return authCommand(args);
   if (command === "doctor")
     return doctorCommand(args);
+  if (command === "update")
+    return updateCommand(args);
   if (command === "acp")
     return acpCommand(args);
   if (command) {
@@ -22719,5 +23103,5 @@ async function main(argv = process.argv.slice(2)) {
 var code = await main();
 process.exitCode = code;
 
-//# debugId=B062C0361E20E53764756E2164756E21
+//# debugId=6AB54613CF301A9064756E2164756E21
 //# sourceMappingURL=main.js.map