limixbot 0.3.18 → 0.3.19

package/dist-server/server/drivers/antigravity.js

@@ -5,6 +5,7 @@ import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveA
 import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
 import { VERIFICATION_TEMP_KEY, scheduleAntigravityTempSweep } from "./antigravity-temp.js";
 import { augmentedPath } from "../env-path.js";
+import { agyCliFor, releaseAgyCli } from "../limix-agy-cli.js";
 import { bundledEngineCatalog } from "../model-manifest/bundled.js";
 import { currentEngineCatalog } from "../model-manifest/manifest.js";
 export const STATIC_ANTIGRAVITY_MODELS = bundledEngineCatalog("antigravity");
@@ -53,6 +54,9 @@ const support = {
     clientFileSystem: true,
     sanitizeToolPayload: true,
     resolveCommand: async (env, config, instanceId) => {
+        const agyCli = agyCliFor(instanceId, env);
+        if (agyCli)
+            return { command: agyCli, args: ["acp"] };
         const runtime = await resolveAntigravityRuntime(config.cli, env);
         const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
         if (profile.tempDirectory)
@@ -64,6 +68,8 @@ const support = {
         };
     },
     resolveModels: async (env, config, instanceId) => {
+        if (agyCliFor(instanceId, env))
+            return currentEngineCatalog("antigravity");
         const runtime = await resolveAntigravityRuntime(config.cli, env);
         const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
         if (!(await antigravityProfileAuthenticated(profile)))
@@ -80,6 +86,8 @@ const support = {
     authFailure: "fail",
     requireAuthenticationBeforeSpawn: true,
     isAuthenticated: async (env, config, instanceId) => {
+        if (agyCliFor(instanceId, env))
+            return true;
         try {
             const runtime = await resolveAntigravityRuntime(config.cli, env);
             const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
@@ -90,6 +98,8 @@ const support = {
         }
     },
     snapshot: async (env, config, instanceId) => {
+        if (agyCliFor(instanceId, env))
+            return { state: "available", version: "Antigravity CLI", authenticated: true };
         try {
             const runtime = await resolveAntigravityRuntime(config.cli, env);
             const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
@@ -180,6 +190,7 @@ export const AntigravityDriver = {
             signOut: async () => {
                 auth.cancel();
                 await removeAntigravitySignIn(input.instanceId);
+                releaseAgyCli(input.instanceId);
             },
             dispose: async () => {
                 auth.cancel();

package/dist-server/server/limix-agy-cli.js

@@ -0,0 +1,65 @@
+// Limix: the fast lane for Google Antigravity. The managed runtime (agy_acp_server, a PyInstaller one-file build)
+// unpacks 0.3-1.3 GB into a temp folder on every launch. Google's Antigravity CLI (`agy`, default install
+// %LOCALAPPDATA%\agy\bin\agy.exe) starts at once and serves the same protocol with `agy acp`. Its Google sign-in
+// lives in the OS keyring, so one computer has ONE such account: the first Antigravity AI that asks gets the CLI
+// lane; every other one keeps the managed runtime with its own profile. LIMIX_AGY_CLI=0 turns the lane off.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { DATA_DIR } from "./config.js";
+const claimFile = () => join(DATA_DIR, "limix-agy-cli.json");
+export function findAgyCli(env = process.env) {
+    if (env.LIMIX_AGY_CLI === "0")
+        return null;
+    const win = process.platform === "win32";
+    const name = win ? "agy.exe" : "agy";
+    const candidates = [];
+    const localAppData = env.LOCALAPPDATA ?? process.env.LOCALAPPDATA;
+    if (win && localAppData)
+        candidates.push(join(localAppData, "agy", "bin", name));
+    if (!win)
+        candidates.push(join(homedir(), ".local", "bin", name));
+    for (const dir of (env.PATH ?? env.Path ?? process.env.PATH ?? "").split(delimiter))
+        if (dir)
+            candidates.push(join(dir, name));
+    return candidates.find((candidate) => existsSync(candidate)) ?? null;
+}
+function claimedBy() {
+    try {
+        const value = JSON.parse(readFileSync(claimFile(), "utf8"));
+        return typeof value.instanceId === "string" ? value.instanceId : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The CLI path when `instanceId` owns the CLI lane (claiming it when free), else null. */
+export function agyCliFor(instanceId, env = process.env) {
+    const cli = findAgyCli(env);
+    if (!cli)
+        return null;
+    const owner = claimedBy();
+    if (owner && owner !== instanceId)
+        return null;
+    if (!owner) {
+        try {
+            mkdirSync(DATA_DIR, { recursive: true });
+            writeFileSync(claimFile(), JSON.stringify({ instanceId, cli, at: new Date().toISOString() }));
+        }
+        catch {
+            return null;
+        }
+    }
+    return cli;
+}
+/** Signing out of the AI that owns the lane frees it for the next one. */
+export function releaseAgyCli(instanceId) {
+    if (claimedBy() !== instanceId)
+        return;
+    try {
+        writeFileSync(claimFile(), JSON.stringify({ instanceId: null }));
+    }
+    catch {
+        // a stale claim only keeps this AI on the CLI lane
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limixbot",
-  "version": "0.3.18",
+  "version": "0.3.19",
   "description": "Run the Limix Bot server anywhere and pair your devices to it (Leox ৹ Limix AI)",
   "license": "Apache-2.0",
   "type": "module",