@simonepri/refined-antigravity-acp 0.1.2 → 0.2.0

package/build/paseo/assets/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+  <path d="M2.1 19.4C6.3 15.3 5.4 2 12 2s5.7 13.3 9.9 17.4c1.5 1.5-.3 2.2-1.5 1.3C16 17.6 16.3 12.8 12 12.8s-4 4.8-8.4 7.9c-1.2.9-3 .2-1.5-1.3Z"/>
+</svg>

package/build/paseo/assets/logo.svg

@@ -0,0 +1,62 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 640 170" width="640" height="170">
+  <defs>
+    <!-- Antigravity-style gradient: a warm horizontal sweep confined to the top of the mark,
+         faded over a blue body (proportions and stops sampled from the official Antigravity logo).
+         Coordinates are in the ACP path box (0..576 x 0..220). -->
+
+    <!-- Blue body: saturated core held through the legs, lightening into the feet
+         (reference #3A8CF2 / #4589F8 core, #5395FC bars, #96C1EE feet). -->
+    <linearGradient id="agyBody" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="0" y2="220">
+      <stop offset="0" stop-color="#3A8CF2"/>
+      <stop offset="0.62" stop-color="#3E8DF5"/>
+      <stop offset="0.74" stop-color="#4589F8"/>
+      <stop offset="0.80" stop-color="#4E98F3"/>
+      <stop offset="0.90" stop-color="#74ADF3"/>
+      <stop offset="1" stop-color="#96C1EE"/>
+    </linearGradient>
+
+    <!-- Warm band: horizontal left->right sweep, green -> lime -> tan -> orange -> coral,
+         stops sampled from the reference top rows (y=170 / y=210). -->
+    <linearGradient id="agyWarm" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="576" y2="0">
+      <stop offset="0" stop-color="#8FC466"/>
+      <stop offset="0.25" stop-color="#A9BC55"/>
+      <stop offset="0.5" stop-color="#C5A65C"/>
+      <stop offset="0.7" stop-color="#DC8A5F"/>
+      <stop offset="0.82" stop-color="#EA705B"/>
+      <stop offset="1" stop-color="#E65E5E"/>
+    </linearGradient>
+
+    <!-- Vertical fade for the warm band: fully warm until y=55 (top 25%), eased out by y=108 (49%),
+         at the A/C valley (y=106). Plain alpha fade over blue yields the teal (left) and
+         lavender (right) midtones of the reference. -->
+    <linearGradient id="agyFade" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="0" y2="220">
+      <stop offset="0" stop-color="#FFFFFF"/>
+      <stop offset="0.25" stop-color="#FFFFFF"/>
+      <stop offset="0.33" stop-color="#B3B3B3"/>
+      <stop offset="0.41" stop-color="#4D4D4D"/>
+      <stop offset="0.49" stop-color="#000000"/>
+      <stop offset="1" stop-color="#000000"/>
+    </linearGradient>
+    <mask id="agyWarmMask" maskUnits="userSpaceOnUse" x="0" y="0" width="576" height="220">
+      <rect x="0" y="0" width="576" height="220" fill="url(#agyFade)"/>
+    </mask>
+
+    <!-- ACP logomark outline, drawn twice: blue body, then the masked warm band on top. -->
+    <path id="agyMark" d="M568.003 115.821L517.278 27.9661C507.183 10.4816 489.084 0.0227367 468.894 0.0227367C448.727 0.0227367 430.674 10.4361 420.556 27.8752L343.251 161.749H242.755C236.23 161.749 230.386 158.384 227.135 152.745C223.861 147.106 223.861 140.376 227.135 134.715L277.861 46.8603C281.112 41.2216 286.955 37.8338 293.481 37.8338C300.006 37.8338 305.827 41.1988 309.101 46.8603L312.125 52.0897C313.353 54.2042 315.604 55.5002 318.036 55.5002C320.469 55.5002 322.743 54.1815 323.948 52.067L337.385 28.5118C338.795 26.0335 338.522 22.9413 336.703 20.7586C325.699 7.57131 309.874 0 293.322 0C292.662 0 292.003 0 291.321 0.0454733C272.04 0.75031 254.76 11.1864 245.074 27.9434L200.215 105.657L155.81 29.1484C145.465 11.2092 126.594 0.0227367 106.608 0.0227367C105.949 0.0227367 105.289 0.0227367 104.607 0.06821C85.3265 0.773047 68.0467 11.2092 58.3608 27.9661L7.65806 115.821C-6.25678 139.899 -0.868187 168.82 21.05 187.759C29.8945 195.422 41.6039 199.628 54.0181 199.628H148.648C151.081 199.628 153.332 198.332 154.56 196.217L168.52 172.026C169.748 169.911 169.748 167.319 168.52 165.205C167.292 163.09 165.041 161.794 162.608 161.794H56.0417C49.5163 161.794 43.6729 158.429 40.4216 152.79C37.1475 147.152 37.1475 140.422 40.4216 134.76L91.1471 46.9057C94.3985 41.2671 100.242 37.8793 106.767 37.8793C113.293 37.8793 119.113 41.2443 122.387 46.9057L194.826 172.526C195.031 172.89 195.258 173.208 195.531 173.526C198.76 178.665 202.83 183.485 207.786 187.782C216.631 195.444 228.34 199.651 240.754 199.651H321.424L315.581 209.769C314.353 211.883 314.353 214.475 315.581 216.59C316.809 218.704 319.059 220 321.492 220H349.436C351.868 220 354.119 218.704 355.347 216.59L364.396 200.901L367.17 196.468C367.17 196.468 367.261 196.331 367.284 196.263L453.274 46.9285C456.525 41.2898 462.369 37.902 468.894 37.902C475.42 37.902 481.263 41.2671 484.514 46.9285L535.24 134.783C538.491 140.422 538.514 147.174 535.24 152.813C531.988 158.452 526.145 161.84 519.62 161.84H418.669C416.236 161.84 413.985 163.136 412.757 165.25L398.774 189.442C397.546 191.556 397.546 194.148 398.774 196.263C400.002 198.377 402.253 199.673 404.686 199.673H518.21C539.81 199.673 559.295 188.237 569.026 169.843C578.053 152.79 577.666 132.623 567.981 115.843L568.003 115.821Z"/>
+  </defs>
+
+  <!-- Clean dark card -->
+  <rect width="640" height="170" rx="16" fill="#0D1117"/>
+  <rect x="0.5" y="0.5" width="639" height="169" rx="15.5" fill="none" stroke="#21262D" stroke-width="1"/>
+
+  <!-- Scaled up ACP Logomark (scale 0.35 vs 0.24 previously) -->
+  <g transform="translate(320, 58)">
+    <g transform="translate(-100, -38) scale(0.35)">
+      <use xlink:href="#agyMark" href="#agyMark" fill="url(#agyBody)"/>
+      <use xlink:href="#agyMark" href="#agyMark" fill="url(#agyWarm)" mask="url(#agyWarmMask)"/>
+    </g>
+  </g>
+
+  <!-- Typography -->
+  <text x="320" y="132" text-anchor="middle" fill="#F0F6FC" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Inter, sans-serif" font-size="16" font-weight="700" letter-spacing="2.5">REFINED ANTIGRAVITY ACP</text>
+</svg>

package/build/paseo/index.server.ts

@@ -0,0 +1,9 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { createAntigravityProvider } from "./server/provider.js";
+
+export { createAntigravityProvider } from "./server/provider.js";
+
+export default function contribute(server: PluginServerContext) {
+  server.registerProvider(createAntigravityProvider());
+  return () => {};
+}

package/build/paseo/paseo-plugin.json

@@ -0,0 +1,7 @@
+{
+  "id": "refined-antigravity-acp",
+  "requirements": {
+    "paseo": "^0.9.0"
+  },
+  "description": "Hardened wrapper for Google Antigravity ACP with bugfixes, hang mitigation, and steering."
+}

package/build/paseo/server/agy-patch.ts

@@ -0,0 +1,445 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import zlib from "node:zlib";
+import { execFileSync } from "node:child_process";
+
+export const EVENT_PROCESSOR_ENTRY =
+  "google3/third_party/py/google/antigravity/connections/local/event_processor.py";
+
+export const PYCACHE_PREFIX =
+  "google3/third_party/py/google/antigravity/connections/local/__pycache__/event_processor.";
+
+export const ZIP_EOCD_MAGIC = 0x06054b50;
+export const ZIP_CD_MAGIC = 0x02014b50;
+export const ZIP_LOCAL_MAGIC = 0x04034b50;
+
+export const ORIGINAL_ANCHOR = `      elif (
+          tsu.state
+          == localharness_pb2.TrajectoryStateUpdate.State.STATE_FULLY_IDLE
+      ):`;
+
+export const REPLACEMENT_CODE = `      elif tsu.state in (
+          localharness_pb2.TrajectoryStateUpdate.State.STATE_FULLY_IDLE,
+          localharness_pb2.TrajectoryStateUpdate.State.STATE_WAITING_FOR_TASKS,
+      ):`;
+
+export const PROMPT_ANCHOR = `elif (
+            tsu.state
+            == localharness_pb2.TrajectoryStateUpdate.State.STATE_FULLY_IDLE):`;
+
+export const PROMPT_REPLACEMENT = `        elif tsu.state in (
+            localharness_pb2.TrajectoryStateUpdate.State.STATE_FULLY_IDLE,
+            localharness_pb2.TrajectoryStateUpdate.State.STATE_WAITING_FOR_TASKS,
+        ):`;
+
+export type PatchClassification = "patchable" | "already-fixed" | "unrecognized" | "entry-missing";
+
+export interface ZipEntryInfo {
+  name: string;
+  method: number;
+  crc32: number;
+  compSize: number;
+  uncompSize: number;
+  localHeaderOffset: number;
+  cdEntryOffset: number;
+  nameLength: number;
+  extraLength: number;
+  commentLength: number;
+}
+
+export interface ZipArchiveInfo {
+  eocdOffset: number;
+  cdOffset: number;
+  cdSize: number;
+  cdStart: number;
+  baseOffset: number;
+  entries: Map<string, ZipEntryInfo>;
+}
+
+export interface PatchOptions {
+  cacheBaseDir?: string;
+  force?: boolean;
+  skipSign?: boolean;
+}
+
+export interface PatchResult {
+  path: string;
+  patched: boolean;
+  classification: PatchClassification;
+  cached: boolean;
+}
+
+function isValidEocd(buf: Buffer, pos: number): boolean {
+  if (pos + 22 > buf.length) return false;
+  const cdSize = buf.readUInt32LE(pos + 12);
+  const cdStart = pos - cdSize;
+  if (cdStart < 0) return false;
+  if (cdSize === 0) return true;
+  if (cdStart + 4 > buf.length) return false;
+  return buf.readUInt32LE(cdStart) === ZIP_CD_MAGIC;
+}
+
+export function findEocd(buf: Buffer): number {
+  if (buf.length < 22) return -1;
+  const signature = Buffer.from([0x50, 0x4b, 0x05, 0x06]);
+  let pos = buf.length - 22;
+  while (pos >= 0) {
+    pos = buf.lastIndexOf(signature, pos);
+    if (pos === -1) return -1;
+    if (isValidEocd(buf, pos)) return pos;
+    pos -= 1;
+  }
+  return -1;
+}
+
+function parseCdEntries(buf: Buffer, cdStart: number, cdSize: number): Map<string, ZipEntryInfo> {
+  const entries = new Map<string, ZipEntryInfo>();
+  let pos = cdStart;
+  const cdEnd = cdStart + cdSize;
+
+  while (pos + 46 <= cdEnd) {
+    if (buf.readUInt32LE(pos) !== ZIP_CD_MAGIC) break;
+    const method = buf.readUInt16LE(pos + 10);
+    const crc32 = buf.readUInt32LE(pos + 16);
+    const compSize = buf.readUInt32LE(pos + 20);
+    const uncompSize = buf.readUInt32LE(pos + 24);
+    const nameLength = buf.readUInt16LE(pos + 28);
+    const extraLength = buf.readUInt16LE(pos + 30);
+    const commentLength = buf.readUInt16LE(pos + 32);
+    const localHeaderOffset = buf.readUInt32LE(pos + 42);
+    const nameStart = pos + 46;
+    const nameEnd = nameStart + nameLength;
+    if (nameEnd > cdEnd) break;
+    const name = buf.toString("utf8", nameStart, nameEnd);
+
+    entries.set(name, {
+      name,
+      method,
+      crc32,
+      compSize,
+      uncompSize,
+      localHeaderOffset,
+      cdEntryOffset: pos,
+      nameLength,
+      extraLength,
+      commentLength,
+    });
+
+    pos += 46 + nameLength + extraLength + commentLength;
+  }
+
+  return entries;
+}
+
+export function parseZipArchive(buf: Buffer): ZipArchiveInfo | null {
+  const eocdOffset = findEocd(buf);
+  if (eocdOffset < 0) return null;
+
+  const cdSize = buf.readUInt32LE(eocdOffset + 12);
+  const cdOffset = buf.readUInt32LE(eocdOffset + 16);
+  const cdStart = eocdOffset - cdSize;
+  const baseOffset = cdStart - cdOffset;
+  const entries = parseCdEntries(buf, cdStart, cdSize);
+
+  return {
+    eocdOffset,
+    cdOffset,
+    cdSize,
+    cdStart,
+    baseOffset,
+    entries,
+  };
+}
+
+export function getEntryData(buf: Buffer, zip: ZipArchiveInfo, entry: ZipEntryInfo): Buffer | null {
+  const absLocalHdr = zip.baseOffset + entry.localHeaderOffset;
+  if (absLocalHdr < 0 || absLocalHdr + 30 > buf.length) return null;
+  if (buf.readUInt32LE(absLocalHdr) !== ZIP_LOCAL_MAGIC) return null;
+
+  const localNameLen = buf.readUInt16LE(absLocalHdr + 26);
+  const localExtraLen = buf.readUInt16LE(absLocalHdr + 28);
+  const dataOffset = absLocalHdr + 30 + localNameLen + localExtraLen;
+  const dataEnd = dataOffset + entry.uncompSize;
+
+  if (dataEnd > buf.length) return null;
+  return buf.subarray(dataOffset, dataEnd);
+}
+
+export function findAnchorAndReplacement(
+  text: string,
+): { anchor: string; replacement: string } | null {
+  if (text.includes(ORIGINAL_ANCHOR)) {
+    return { anchor: ORIGINAL_ANCHOR, replacement: REPLACEMENT_CODE };
+  }
+  if (text.includes(PROMPT_ANCHOR)) {
+    return { anchor: PROMPT_ANCHOR, replacement: PROMPT_REPLACEMENT };
+  }
+  return null;
+}
+
+export function shortenDecorativeComments(text: string, delta: number): string | null {
+  if (delta <= 0) return text;
+  const matches = [...text.matchAll(/([ \t]*# -{20,})/g)];
+  if (matches.length === 0) return null;
+
+  if (matches.length >= 2) {
+    const d1 = Math.ceil(delta / 2);
+    const d2 = Math.floor(delta / 2);
+    const m1 = matches[0];
+    const m2 = matches[1];
+    if (m1[0].length <= d1 + 5 || m2[0].length <= d2 + 5) return null;
+    const s1 = m1[0].slice(0, m1[0].length - d1);
+    const s2 = m2[0].slice(0, m2[0].length - d2);
+    return (
+      text.slice(0, m1.index) +
+      s1 +
+      text.slice(m1.index + m1[0].length, m2.index) +
+      s2 +
+      text.slice(m2.index + m2[0].length)
+    );
+  }
+
+  const m = matches[0];
+  if (m[0].length <= delta + 5) return null;
+  const s = m[0].slice(0, m[0].length - delta);
+  return text.slice(0, m.index) + s + text.slice(m.index + m[0].length);
+}
+
+export function patchEventProcessorContent(content: string): string | null {
+  const pair = findAnchorAndReplacement(content);
+  if (!pair) return null;
+  const delta =
+    Buffer.byteLength(pair.replacement, "utf8") - Buffer.byteLength(pair.anchor, "utf8");
+  const shortened = shortenDecorativeComments(content, delta);
+  if (!shortened) return null;
+  const patched = shortened.replace(pair.anchor, pair.replacement);
+  if (Buffer.byteLength(patched, "utf8") !== Buffer.byteLength(content, "utf8")) {
+    return null;
+  }
+  return patched;
+}
+
+export function classifyBuffer(buf: Buffer): PatchClassification {
+  const zip = parseZipArchive(buf);
+  if (!zip) return "unrecognized";
+
+  const entry = zip.entries.get(EVENT_PROCESSOR_ENTRY);
+  if (!entry) return "entry-missing";
+  if (entry.method !== 0) return "unrecognized";
+
+  const data = getEntryData(buf, zip, entry);
+  if (!data) return "unrecognized";
+
+  const text = data.toString("utf8");
+  if (text.includes("STATE_WAITING_FOR_TASKS")) {
+    return "already-fixed";
+  }
+
+  const pair = findAnchorAndReplacement(text);
+  if (!pair) return "unrecognized";
+
+  const delta =
+    Buffer.byteLength(pair.replacement, "utf8") - Buffer.byteLength(pair.anchor, "utf8");
+  const shortened = shortenDecorativeComments(text, delta);
+  if (!shortened) return "unrecognized";
+
+  return "patchable";
+}
+
+export function classifyBinary(filePath: string): PatchClassification {
+  try {
+    const buf = fs.readFileSync(filePath);
+    return classifyBuffer(buf);
+  } catch {
+    return "unrecognized";
+  }
+}
+
+function renameSiblingPyc(buf: Buffer, zip: ZipArchiveInfo): void {
+  for (const entry of zip.entries.values()) {
+    if (!entry.name.startsWith(PYCACHE_PREFIX) || !entry.name.endsWith(".pyc")) {
+      continue;
+    }
+
+    const cdExtPos = entry.cdEntryOffset + 46 + entry.nameLength - 4;
+    if (buf.subarray(cdExtPos, cdExtPos + 4).toString("utf8") === ".pyc") {
+      buf.write(".bak", cdExtPos, "utf8");
+    }
+
+    const localHdrPos = zip.baseOffset + entry.localHeaderOffset;
+    const localNameLen = buf.readUInt16LE(localHdrPos + 26);
+    const localExtPos = localHdrPos + 30 + localNameLen - 4;
+    if (buf.subarray(localExtPos, localExtPos + 4).toString("utf8") === ".pyc") {
+      buf.write(".bak", localExtPos, "utf8");
+    }
+  }
+}
+
+export function patchBuffer(buf: Buffer): {
+  patched: boolean;
+  classification: PatchClassification;
+} {
+  const classification = classifyBuffer(buf);
+  if (classification !== "patchable") {
+    return { patched: false, classification };
+  }
+
+  const zip = parseZipArchive(buf)!;
+  const entry = zip.entries.get(EVENT_PROCESSOR_ENTRY)!;
+  const data = getEntryData(buf, zip, entry)!;
+  const text = data.toString("utf8");
+
+  const patchedText = patchEventProcessorContent(text);
+  if (!patchedText) {
+    return { patched: false, classification: "unrecognized" };
+  }
+
+  const localHdrPos = zip.baseOffset + entry.localHeaderOffset;
+  const localNameLen = buf.readUInt16LE(localHdrPos + 26);
+  const localExtraLen = buf.readUInt16LE(localHdrPos + 28);
+  const dataOffset = localHdrPos + 30 + localNameLen + localExtraLen;
+
+  buf.write(patchedText, dataOffset, "utf8");
+
+  const newCrc = zlib.crc32(buf.subarray(dataOffset, dataOffset + entry.uncompSize));
+  buf.writeUInt32LE(newCrc, localHdrPos + 14);
+  buf.writeUInt32LE(newCrc, entry.cdEntryOffset + 16);
+
+  renameSiblingPyc(buf, zip);
+
+  return { patched: true, classification: "already-fixed" };
+}
+
+export function getCacheKey(realpath: string, stat?: { size: number; mtimeMs: number }): string {
+  const s = stat ?? fs.statSync(realpath);
+  return crypto
+    .createHash("sha256")
+    .update(`${realpath}:${s.size}:${s.mtimeMs}`)
+    .digest("hex")
+    .slice(0, 32);
+}
+
+export function getCacheBaseDir(customDir?: string): string {
+  if (customDir) return customDir;
+  const pluginData =
+    process.env.PASEO_PLUGIN_DATA_DIR ?? path.join(os.homedir(), ".paseo", "plugin-data");
+  return path.join(pluginData, "antigravity", "bin");
+}
+
+function cloneFile(src: string, dst: string): void {
+  try {
+    fs.copyFileSync(src, dst, fs.constants.COPYFILE_FICLONE);
+  } catch {
+    fs.copyFileSync(src, dst);
+  }
+}
+
+function reSignBinary(dst: string): void {
+  if (process.platform !== "darwin") return;
+  try {
+    execFileSync(
+      "codesign",
+      ["--force", "-s", "-", "--preserve-metadata=entitlements,flags", dst],
+      { stdio: "ignore" },
+    );
+  } catch {
+    // Gracefully ignore codesign errors
+  }
+}
+
+export function gcCache(baseDir: string, currentKey?: string): void {
+  if (!fs.existsSync(baseDir)) return;
+  try {
+    const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (currentKey && entry.name === currentKey) continue;
+      fs.rmSync(path.join(baseDir, entry.name), {
+        recursive: true,
+        force: true,
+      });
+    }
+  } catch {
+    // Non-fatal if GC fails
+  }
+}
+
+interface CacheTarget {
+  realPath: string;
+  key: string;
+  cacheBase: string;
+  cacheDir: string;
+  dstPath: string;
+}
+
+function resolveCacheTarget(srcPath: string, customBase?: string): CacheTarget {
+  const realPath = fs.realpathSync(srcPath);
+  const stat = fs.statSync(realPath);
+  const key = getCacheKey(realPath, stat);
+  const cacheBase = getCacheBaseDir(customBase);
+  const cacheDir = path.join(cacheBase, key);
+  const dstPath = path.join(cacheDir, path.basename(realPath));
+  return { realPath, key, cacheBase, cacheDir, dstPath };
+}
+
+function cloneAndPatch(
+  realPath: string,
+  dstPath: string,
+  cacheDir: string,
+  skipSign?: boolean,
+): boolean {
+  fs.mkdirSync(cacheDir, { recursive: true, mode: 0o755 });
+  const tempDst = `${dstPath}.tmp.${Date.now()}`;
+  cloneFile(realPath, tempDst);
+  fs.chmodSync(tempDst, 0o755);
+
+  const buf = fs.readFileSync(tempDst);
+  const patchRes = patchBuffer(buf);
+  if (!patchRes.patched) {
+    fs.rmSync(tempDst, { force: true });
+    return false;
+  }
+
+  fs.writeFileSync(tempDst, buf);
+  if (!skipSign) {
+    reSignBinary(tempDst);
+  }
+  fs.renameSync(tempDst, dstPath);
+  return true;
+}
+
+export function patchBinary(srcPath: string, options?: PatchOptions): PatchResult {
+  if (process.env.PASEO_AGY_NO_PATCH === "1") {
+    return { path: srcPath, patched: false, classification: "unrecognized", cached: false };
+  }
+
+  const { realPath, key, cacheBase, cacheDir, dstPath } = resolveCacheTarget(
+    srcPath,
+    options?.cacheBaseDir,
+  );
+
+  if (!options?.force && fs.existsSync(dstPath)) {
+    gcCache(cacheBase, key);
+    return { path: dstPath, patched: false, classification: "already-fixed", cached: true };
+  }
+
+  const classification = classifyBinary(realPath);
+  if (classification !== "patchable") {
+    return { path: srcPath, patched: false, classification, cached: false };
+  }
+
+  const ok = cloneAndPatch(realPath, dstPath, cacheDir, options?.skipSign);
+  if (!ok) {
+    return { path: srcPath, patched: false, classification: "unrecognized", cached: false };
+  }
+
+  gcCache(cacheBase, key);
+  return { path: dstPath, patched: true, classification: "already-fixed", cached: false };
+}
+
+export function ensurePatchedBinary(srcPath: string, options?: PatchOptions): string {
+  const res = patchBinary(srcPath, options);
+  return res.path;
+}

package/build/paseo/server/auth.ts

@@ -0,0 +1,122 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+/**
+ * Resolves the path to the ACP token JSON file under the Gemini home directory.
+ */
+export function getAcpTokenPath(): string {
+  const geminiHome = process.env.GEMINI_HOME || path.join(os.homedir(), ".gemini");
+  return path.join(geminiHome, "antigravity-acp", "acp_token.json");
+}
+
+/**
+ * Checks if the local ACP token file contains an active refresh token.
+ */
+export function hasValidRefreshToken(tokenPath: string = getAcpTokenPath()): boolean {
+  if (!fs.existsSync(tokenPath)) return false;
+  try {
+    const existing = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+    return typeof existing.refresh_token === "string" && existing.refresh_token.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extracts the CLI refresh token from macOS Keychain if available.
+ */
+function extractClientId(idToken: unknown): string | undefined {
+  if (typeof idToken !== "string") return undefined;
+  try {
+    const parts = idToken.split(".");
+    if (parts.length < 2) return undefined;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64").toString("utf-8"));
+    return typeof payload.aud === "string" ? payload.aud : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function readKeychainCredentials(): { refreshToken: string; clientId?: string } | null {
+  if (process.platform !== "darwin") return null;
+  try {
+    const raw = execFileSync(
+      "security",
+      ["find-generic-password", "-s", "gemini", "-a", "antigravity", "-w"],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000 },
+    ).trim();
+
+    if (!raw) return null;
+    const b64 = raw.replace(/^go-keyring-base64:/, "");
+    const parsed = JSON.parse(Buffer.from(b64, "base64").toString("utf-8"));
+    const refreshToken = parsed?.token?.refresh_token;
+    if (!refreshToken) return null;
+
+    const clientId = extractClientId(parsed.id_token);
+    return { refreshToken, clientId };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Writes an authorized_user credential blob to the ACP token path with mode 0600.
+ */
+export function writeAcpTokenFile(
+  tokenPath: string,
+  refreshToken: string,
+  clientId?: string,
+): void {
+  const acpBlob: Record<string, unknown> = {
+    refresh_token: refreshToken,
+    type: "authorized_user",
+  };
+  if (clientId) {
+    acpBlob.client_id = clientId;
+  }
+  fs.mkdirSync(path.dirname(tokenPath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(tokenPath, JSON.stringify(acpBlob, null, 2), { mode: 0o600 });
+  try {
+    fs.chmodSync(tokenPath, 0o600);
+  } catch {
+    // Ignore chmod failure on filesystems that do not support POSIX modes
+  }
+}
+
+/**
+ * Syncs credentials from the official `agy` CLI's Keychain entry (`antigravity`)
+ * into `~/.gemini/antigravity-acp/acp_token.json` if the token file is missing or invalid.
+ */
+export function syncAgyCredentials(): boolean {
+  const tokenPath = getAcpTokenPath();
+  if (hasValidRefreshToken(tokenPath)) {
+    return true;
+  }
+
+  const creds = readKeychainCredentials();
+  if (!creds) {
+    return false;
+  }
+
+  try {
+    writeAcpTokenFile(tokenPath, creds.refreshToken, creds.clientId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ensures the user is authenticated with Antigravity before starting the ACP server.
+ * Throws an actionable error directing the user to run `agy` in their terminal.
+ */
+export function ensureAuthenticated(): void {
+  const ok = syncAgyCredentials();
+  if (!ok && !hasValidRefreshToken(getAcpTokenPath())) {
+    throw new Error(
+      "Not logged in to Google Antigravity. Please run 'agy' in your terminal to log in.",
+    );
+  }
+}