@agentex/agent 0.0.38 → 0.0.40

package/src/providers/codex/transcript.ts

@@ -28,10 +28,10 @@ import { createReadStream } from "node:fs";
 import { readdir, stat, open as fsOpen } from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import * as readline from "node:readline";
 
 import { getDefaultRuntimeHome, getRuntimeHomeEnvVar } from "../../utils/runtime-homes.js";
 import type { FoundTranscript, TranscriptOps } from "../../types.js";
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 
 /** Bytes scanned from the tail of the file in {@link peekCodexTranscript}. */
 const PEEK_TAIL_BYTES = 16 * 1024;
@@ -316,16 +316,11 @@ export async function* readCodexTranscript(
 
   const stream = createReadStream(filePath, { start: fromOffset, encoding: undefined });
   stream.on("error", () => {});
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   const fileIdentity = rolloutIdentityFromPath(filePath);
-  let pos = fromOffset;
   try {
-    for await (const line of rl) {
-      const lineStart = pos;
-      pos += Buffer.byteLength(line, "utf8") + 1;
-
-      const trimmed = line.trim();
+    for await (const line of readJsonlLines(stream, fromOffset)) {
+      const trimmed = line.text.trim();
       if (!trimmed) continue;
 
       const parsed = parseCodexLine(trimmed);
@@ -334,15 +329,14 @@ export async function* readCodexTranscript(
       // Replay-stable synthetic identity: (rollout identity, line start offset).
       // Codex emits no native per-event uuid, so this is the idempotency key
       // hosts use to dedup transcript replays. Deterministic across reads.
-      parsed.eventId = `codex:${fileIdentity}:${lineStart}`;
+      parsed.eventId = `codex:${fileIdentity}:${line.start}`;
 
-      yield { event: parsed, offset: pos };
+      yield { event: parsed, offset: line.end };
     }
   } catch (err) {
     const e = err as NodeJS.ErrnoException;
     if (e?.code !== "ENOENT") throw err;
   } finally {
-    rl.close();
     stream.destroy();
   }
 }

package/src/providers/codex/usage-scanner.ts

@@ -1,9 +1,9 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
-import * as readline from "node:readline";
 import { createReadStream } from "node:fs";
 import type { TokenUsage } from "../../types.js";
+import { readJsonlLines } from "../../utils/jsonl-lines.js";
 
 // ---------------------------------------------------------------------------
 // Log path resolution
@@ -104,16 +104,14 @@ async function scanFile(
 ): Promise<void> {
   let stream: ReturnType<typeof createReadStream>;
   try {
-    stream = createReadStream(filePath, { encoding: "utf-8" });
+    stream = createReadStream(filePath);
   } catch {
     return;
   }
 
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
   try {
-    for await (const line of rl) {
-      const trimmed = line.trim();
+    for await (const line of readJsonlLines(stream)) {
+      const trimmed = line.text.trim();
       if (!trimmed) continue;
 
       let parsed: Record<string, unknown>;
@@ -172,7 +170,6 @@ async function scanFile(
       usageByModel.set(model, existing);
     }
   } finally {
-    rl.close();
     stream.destroy();
   }
 }

package/src/providers/gemini/index.ts

@@ -7,6 +7,12 @@ import { resolveAuthForProvider } from "../../utils/auth.js";
  * `@google/gemini-cli` on PATH; Gemini handles its own Google auth (GEMINI_API_KEY,
  * GOOGLE_API_KEY, or an OAuth login).
  *
+ * Since 2026-06-18 Gemini CLI no longer serves free, Google AI Pro, or Google
+ * AI Ultra sign-ins ("This client is no longer supported for Gemini Code
+ * Assist for individuals"); those accounts moved to the Antigravity CLI — use
+ * the `antigravity` provider. Gemini CLI still works with a paid API key and
+ * Gemini Code Assist Standard/Enterprise.
+ *
  * Replaces the previous one-shot `--output-format stream-json` adapter: the ACP
  * base gives gemini real sessions, streaming, tool-call correlation, permission
  * bridging (via `onUserInputRequest`), and mode discovery — none of which the

package/src/registry.ts

@@ -8,6 +8,7 @@ import { cursorProvider } from "./providers/cursor/index.js";
 import { opencodeProvider } from "./providers/opencode/index.js";
 import { piProvider } from "./providers/pi/index.js";
 import { copilotProvider } from "./providers/copilot/index.js";
+import { antigravityProvider } from "./providers/antigravity/index.js";
 
 const providers = new Map<string, ProviderModule>();
 
@@ -21,6 +22,7 @@ providers.set("cursor", cursorProvider);
 providers.set("opencode", opencodeProvider);
 providers.set("pi", piProvider);
 providers.set("copilot", copilotProvider);
+providers.set("antigravity", antigravityProvider);
 
 export function getProvider(type: string): ProviderModule {
   const provider = providers.get(type);

package/src/types.ts

@@ -667,8 +667,8 @@ export interface ProviderConfig {
   model?: string;
   /** Provider-native model variant, independent from reasoning effort. */
   modelVariant?: string;
-  /** Provider reasoning effort. Claude maps this to `--effort`; Codex sends
-   *  it as the app-server `turn/start.effort` override. */
+  /** Provider reasoning effort. Claude and Antigravity map this to `--effort`;
+   *  Codex sends it as the app-server `turn/start.effort` override. */
   effort?: string;
   /** Behavior when a host does not provide or loses its input callback. */
   unattendedPermissionPolicy?: "allow" | "deny";
@@ -729,15 +729,16 @@ export interface ProviderConfig {
   sandbox?: boolean;
   thinking?: string;
   /**
-   * Provider-specific mode pass-through. Currently used by `cursor` for its
-   * `--mode <mode>` flag. Don't use this for plan mode — set `planMode: true`
+   * Provider-specific mode pass-through. Used by `cursor` and `antigravity`
+   * for their `--mode <mode>` flag. Don't use this for plan mode — set `planMode: true`
    * instead, which is the cross-provider abstraction.
    */
   mode?: string;
   /**
    * Select a provider operating mode by id (one of `listModes()`). Honored by
    * providers with `capabilities.modes === true` (codex collaboration modes,
-   * ACP session modes, copilot allow-all/agent/plan). Ignored otherwise.
+   * ACP session modes, copilot allow-all/agent/plan, antigravity
+   * default/accept-edits/plan). Ignored otherwise.
    * Distinct from `mode` (cursor's raw `--mode` passthrough) and `planMode`
    * (the cross-provider read-only abstraction).
    */

package/src/utils/auth.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import type {
@@ -94,6 +95,12 @@ export function detectAuth(providerType: string, env: Record<string, string>): R
       }
       return { method: "subscription", billingType: "subscription" };
     }
+    case "antigravity": {
+      if (hasEnv(env, "GEMINI_API_KEY") && readAgyModelProvider() === "gemini") {
+        return { method: "api_key", billingType: "api" };
+      }
+      return { method: "subscription", billingType: "subscription" };
+    }
     case "opencode":
     case "pi":
       return { method: "api_key", billingType: "api" };
@@ -434,6 +441,74 @@ async function resolveGeminiAuth(ctx?: AuthResolveContext): Promise<AuthReport>
   };
 }
 
+// ---------------------------------------------------------------------------
+// Antigravity — no status subcommand, but `agy models` exits 1 with "Please
+// sign in" when no cached sign-in exists, so its exit status is the CLI's own
+// answer. A GEMINI_API_KEY counts only when settings.json selects the Gemini
+// API (`"modelProvider": "gemini"`); the CLI ignores the variable otherwise.
+// ---------------------------------------------------------------------------
+
+/** Home directory as agy (a Go binary) resolves it: os.UserHomeDir semantics. */
+function agyHomeDir(): string {
+  const fromEnv = process.platform === "win32" ? process.env["USERPROFILE"] : process.env["HOME"];
+  return fromEnv && fromEnv.trim() ? fromEnv : os.homedir();
+}
+
+function agySettingsPath(): string {
+  return path.join(agyHomeDir(), ".gemini", "antigravity-cli", "settings.json");
+}
+
+function readAgyModelProvider(): string | null {
+  try {
+    const settings = JSON.parse(readFileSync(agySettingsPath(), "utf-8")) as Record<string, unknown>;
+    return typeof settings["modelProvider"] === "string" ? settings["modelProvider"] : null;
+  } catch {
+    return null;
+  }
+}
+
+async function resolveAntigravityAuth(ctx?: AuthResolveContext): Promise<AuthReport> {
+  const env = buildEnv(ctx?.env);
+  const binary = await checkBinary("agy", ctx?.command, env);
+  const apiKeyProvider = readAgyModelProvider() === "gemini";
+  let signedIn = false;
+  let usedCli = false;
+  if (binary.installed && binary.resolvedPath) {
+    try {
+      const result = await runChildProcess({
+        runId: "antigravity-auth-status",
+        command: binary.resolvedPath,
+        args: [...binary.prefixArgs, "models"],
+        cwd: process.cwd(),
+        env,
+        timeoutSec: 20,
+      });
+      const output = `${result.stdout}\n${result.stderr}`;
+      signedIn = result.exitCode === 0 && !/sign in|authentication required/i.test(output);
+      usedCli = !result.timedOut;
+    } catch {
+      // Presence stays false; the binary could not be run.
+    }
+  }
+  return {
+    providerType: "antigravity",
+    binary: stripPrefixArgs(binary),
+    options: [
+      {
+        method: "subscription",
+        source: { kind: "cli", command: "agy models" },
+        present: signedIn && !apiKeyProvider,
+      },
+      {
+        method: "api_key",
+        source: { kind: "env", var: "GEMINI_API_KEY" },
+        present: apiKeyProvider && hasEnv(env, "GEMINI_API_KEY"),
+      },
+    ],
+    source: usedCli ? "cli" : "filesystem",
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Cursor uses its selected binary's `status` command. Other providers in this
 // section use environment or native-store presence reports.
@@ -538,6 +613,8 @@ async function resolveInternal(providerType: string, ctx?: AuthResolveContext):
       return resolveGeminiAuth(ctx);
     case "cursor":
       return resolveCursorAuth(ctx);
+    case "antigravity":
+      return resolveAntigravityAuth(ctx);
     case "opencode":
       return resolveOpencodeAuth(ctx);
     case "pi":
@@ -626,7 +703,7 @@ export async function hasBedrock(
  * Shell command a host should surface when an `auth_required` event fires
  * for `providerType`, or when `isLoggedIn` returns false. Values are the
  * provider's canonical CLI subcommand for interactive login — they spawn
- * a browser flow (Claude, Codex, Gemini, Cursor) or print API-key setup
+ * a browser flow (Claude, Codex, Gemini, Cursor, Antigravity) or print API-key setup
  * instructions (OpenCode, Pi).
  *
  * Unknown provider types fall back to `${providerType} login`, which is
@@ -647,6 +724,10 @@ export function loginCommandFor(providerType: string): string {
       return "gemini";
     case "cursor":
       return "cursor-agent login";
+    case "antigravity":
+      // No login subcommand: running `agy` signs in through the browser and
+      // caches the session in the OS keyring for headless runs.
+      return "agy";
     case "opencode":
       return "opencode auth login";
     case "pi":

package/src/utils/binary.ts

@@ -44,6 +44,13 @@ const COMMON_PATHS_UNIX: Record<string, string[]> = {
     "/usr/local/bin/pi",
     path.join(os.homedir(), ".npm-global", "bin", "pi"),
   ],
+  // Antigravity CLI. Its installer writes ~/.local/bin/agy, which GUI apps
+  // launched outside a login shell usually don't have on PATH.
+  agy: [
+    path.join(os.homedir(), ".local", "bin", "agy"),
+    "/usr/local/bin/agy",
+    "/opt/homebrew/bin/agy",
+  ],
 };
 
 function getCommonPathsWindows(name: string): string[] {
@@ -54,6 +61,8 @@ function getCommonPathsWindows(name: string): string[] {
     path.join(appData, "npm", `${name}.cmd`),
     path.join(localAppData, "pnpm", `${name}.cmd`),
     path.join(userProfile, ".local", "bin", `${name}.exe`),
+    // Native installers that keep a per-tool folder (Antigravity: %LOCALAPPDATA%\agy\bin).
+    path.join(localAppData, name, "bin", `${name}.exe`),
   ];
 }
 
@@ -158,6 +167,7 @@ export async function findBinary(name: string, configOverride?: string): Promise
     agent: "Install the Cursor CLI agent",
     opencode: "Install: npm install -g opencode-ai",
     pi: "Install: npm install -g @mariozechner/pi-coding-agent",
+    agy: "Install the Antigravity CLI: curl -fsSL https://antigravity.google/cli/install.sh | bash",
   };
   throw new Error(
     `Could not find "${name}" binary. Searched common install paths and PATH. ` +

package/src/utils/instructions.ts

@@ -77,11 +77,12 @@ const RUNTIME_INSTRUCTIONS: Record<SkillRuntime, RuntimeInstructionSpec> = {
   codex: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
   opencode: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
   gemini: { projectFile: "AGENTS.md", nativeFile: "GEMINI.md", nativeFileMode: "copy", hasGlobalFile: true },
+  antigravity: { projectFile: "AGENTS.md", nativeFile: "GEMINI.md", nativeFileMode: "copy", hasGlobalFile: true },
   cursor: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: false },
   pi: { projectFile: "AGENTS.md", nativeFile: "AGENTS.md", nativeFileMode: "copy", hasGlobalFile: true },
 };
 
-const ALL_RUNTIMES: SkillRuntime[] = ["claude", "codex", "gemini", "cursor", "opencode", "pi"];
+const ALL_RUNTIMES: SkillRuntime[] = ["claude", "codex", "gemini", "antigravity", "cursor", "opencode", "pi"];
 
 const DEFAULT_MANAGED_TAG = "agentex";
 
@@ -235,19 +236,19 @@ export function resolveInstructionTargets(options?: {
     return [...byFile.values()].map((target) => ({ ...target, runtimes: dedupeRuntimes(target.runtimes) }));
   }
 
-  // global: each runtime reads its own native file in its own home dir.
-  const targets: InstructionTarget[] = [];
+  // global: each runtime reads its own native file in its own home dir. Gemini
+  // CLI and Antigravity share ~/.gemini/GEMINI.md, so targets merge by path.
+  const byPath = new Map<string, InstructionTarget>();
   for (const runtime of runtimes) {
     const spec = RUNTIME_INSTRUCTIONS[runtime];
     if (!spec.hasGlobalFile) continue; // e.g. cursor global = app User Rules, not a file
     const home = getDefaultRuntimeHome(runtime, options?.homeDir);
-    targets.push({
-      filename: spec.nativeFile,
-      targetPath: path.join(home, spec.nativeFile),
-      runtimes: [runtime],
-    });
+    const targetPath = path.join(home, spec.nativeFile);
+    const existing = byPath.get(targetPath);
+    if (existing) existing.runtimes.push(runtime);
+    else byPath.set(targetPath, { filename: spec.nativeFile, targetPath, runtimes: [runtime] });
   }
-  return targets;
+  return [...byPath.values()];
 }
 
 function dedupeRuntimes(runtimes: SkillRuntime[]): SkillRuntime[] {

package/src/utils/jsonl-lines.ts

@@ -0,0 +1,80 @@
+/**
+ * Line splitting for JSONL files on disk.
+ *
+ * `node:readline` also breaks lines at U+2028 (LINE SEPARATOR), U+2029
+ * (PARAGRAPH SEPARATOR) and a lone `\r`. JSON allows U+2028/U+2029 unescaped
+ * inside strings, and both `JSON.stringify` (Claude Code) and serde_json
+ * (Codex) write them raw, typically in text copied from web pages. readline
+ * cuts such a record in two, both halves fail to parse, and the record
+ * silently disappears. Every byte offset after it also drifts by two bytes
+ * per separator, so a resume offset can land mid-record.
+ *
+ * {@link readJsonlLines} splits on `\n` only, drops the `\r` of a `\r\n`
+ * ending, and reports exact byte offsets.
+ */
+
+export interface JsonlLine {
+  /** Line text without its `\n` or `\r\n` terminator. */
+  text: string;
+  /** Byte offset of the line's first byte. */
+  start: number;
+  /**
+   * Byte offset just past the line's `\n`, which is where the next line
+   * starts. For a final line with no `\n`, the end of the file.
+   */
+  end: number;
+}
+
+const NEWLINE = 0x0a;
+const CARRIAGE_RETURN = 0x0d;
+
+function decodeLine(bytes: Buffer): string {
+  const length = bytes.length > 0 && bytes[bytes.length - 1] === CARRIAGE_RETURN
+    ? bytes.length - 1
+    : bytes.length;
+  return bytes.toString("utf8", 0, length);
+}
+
+/**
+ * Yield the lines of a byte stream, typically `createReadStream(path, { start })`
+ * opened without an encoding. `startOffset` is the stream's starting byte
+ * offset in the file, so reported offsets are file offsets.
+ *
+ * Splitting happens on bytes before decoding. A `\n` byte never occurs inside
+ * a multi-byte UTF-8 sequence, so no character is split across lines.
+ */
+export async function* readJsonlLines(
+  input: AsyncIterable<Buffer | string>,
+  startOffset = 0,
+): AsyncGenerator<JsonlLine> {
+  let pending: Buffer[] = [];
+  let pendingBytes = 0;
+  let lineStart = startOffset;
+
+  for await (const value of input) {
+    const chunk = typeof value === "string" ? Buffer.from(value, "utf8") : value;
+    let from = 0;
+    let newline = chunk.indexOf(NEWLINE, from);
+    while (newline !== -1) {
+      const piece = chunk.subarray(from, newline);
+      const bytes = pendingBytes > 0 ? Buffer.concat([...pending, piece], pendingBytes + piece.length) : piece;
+      const end = lineStart + bytes.length + 1;
+      yield { text: decodeLine(bytes), start: lineStart, end };
+      lineStart = end;
+      pending = [];
+      pendingBytes = 0;
+      from = newline + 1;
+      newline = chunk.indexOf(NEWLINE, from);
+    }
+    if (from < chunk.length) {
+      const tail = chunk.subarray(from);
+      pending.push(tail);
+      pendingBytes += tail.length;
+    }
+  }
+
+  if (pendingBytes > 0) {
+    const bytes = Buffer.concat(pending, pendingBytes);
+    yield { text: decodeLine(bytes), start: lineStart, end: lineStart + bytes.length };
+  }
+}

package/src/utils/runtime-homes.ts

@@ -10,6 +10,7 @@ const ENV_VAR_MAP: Record<SkillRuntime, string | null> = {
   claude: "CLAUDE_CONFIG_DIR",
   codex: "CODEX_HOME",
   gemini: "GEMINI_CONFIG_DIR",
+  antigravity: null,  // agy has no home override
   cursor: "CURSOR_CONFIG_DIR",
   opencode: "XDG_CONFIG_HOME",  // affects ~/.config/opencode/
   pi: "PI_HOME",
@@ -22,6 +23,9 @@ const HOME_SUBPATH_MAP: Record<SkillRuntime, string[]> = {
   claude: [".claude"],
   codex: [".codex"],
   gemini: [".gemini"],
+  // Shared with Gemini CLI: agy reads its global GEMINI.md from ~/.gemini and
+  // keeps its own settings and skills in ~/.gemini/antigravity-cli.
+  antigravity: [".gemini"],
   cursor: [".cursor"],
   opencode: [".config", "opencode"],
   pi: [".pi"],

package/src/utils/skills.ts

@@ -2,13 +2,13 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
 
-export type SkillRuntime = "claude" | "codex" | "gemini" | "cursor" | "opencode" | "pi";
+export type SkillRuntime = "claude" | "codex" | "gemini" | "antigravity" | "cursor" | "opencode" | "pi";
 
 export type SkillLocation = "global" | "workspace";
 
 /**
  * The two standard skill discovery channels:
- * - "agents": ~/.agents/skills/ or {cwd}/.agents/skills/ — scanned by Codex, Gemini, Cursor, OpenCode, Pi
+ * - "agents": ~/.agents/skills/ or {cwd}/.agents/skills/ — scanned by Codex, Gemini, Antigravity, Cursor, OpenCode, Pi
  * - "claude": ~/.claude/skills/ or {cwd}/.claude/skills/ — scanned by Claude Code (the only agent that doesn't scan .agents/)
  */
 export type SkillChannel = "agents" | "claude";
@@ -23,6 +23,12 @@ const NATIVE_DIRS: Record<string, { global: string; workspace: (cwd: string) =>
     global: path.join(os.homedir(), ".gemini", "skills"),
     workspace: (cwd) => path.join(cwd, ".gemini", "skills"),
   },
+  // Antigravity reads workspace skills from the standard .agents/skills
+  // channel; only its global folder is its own.
+  antigravity: {
+    global: path.join(os.homedir(), ".gemini", "antigravity-cli", "skills"),
+    workspace: (cwd) => path.join(cwd, ".agents", "skills"),
+  },
   cursor: {
     global: path.join(os.homedir(), ".cursor", "skills"),
     workspace: (cwd) => path.join(cwd, ".cursor", "skills"),
@@ -139,7 +145,14 @@ function resolveTargets(
 ): Array<{ target: string; skillsHome: string }> {
   const targets = resolveStandardPaths(location, cwd);
   if (includeNativeDirs) {
-    targets.push(...resolveNativePaths(location, cwd));
+    // A runtime whose native folder is a standard channel (Antigravity's
+    // workspace .agents/skills) is already covered by that channel.
+    const seen = new Set(targets.map((t) => t.skillsHome));
+    for (const native of resolveNativePaths(location, cwd)) {
+      if (seen.has(native.skillsHome)) continue;
+      seen.add(native.skillsHome);
+      targets.push(native);
+    }
   }
   return targets;
 }
@@ -152,7 +165,7 @@ function resolveTargets(
  * Install skill directories into agent discovery paths via idempotent symlinks.
  *
  * By default, installs into the two standard channels:
- * - `.agents/skills/` — discovered by Codex, Gemini, Cursor, OpenCode, Pi
+ * - `.agents/skills/` — discovered by Codex, Gemini, Antigravity, Cursor, OpenCode, Pi
  * - `.claude/skills/` — discovered by Claude Code
  *
  * Set `includeNativeDirs: true` to also install into each runtime's