@quantiya/codevibe-antigravity-plugin 1.0.0

package/dist/installer-cli.js

@@ -0,0 +1,478 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/installer-cli.ts
+var installer_cli_exports = {};
+__export(installer_cli_exports, {
+  __testing: () => __testing
+});
+module.exports = __toCommonJS(installer_cli_exports);
+var path2 = __toESM(require("path"));
+
+// src/installer.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var crypto = __toESM(require("crypto"));
+var MANIFEST_FILENAME = "antigravity-plugin.json";
+var SENTINEL_FILENAME = ".codevibe-manifest-hash";
+var MCP_SERVERS_KEY = "codevibe-antigravity";
+var LOCK_ACQUIRE_TIMEOUT_MS = 5e3;
+var LOCK_RETRY_INTERVAL_MS = 50;
+function resolveInstallerPaths(opts) {
+  const home = opts.homedir ?? os.homedir();
+  return {
+    pluginJsonSourcePath: path.join(opts.pluginPkgDir, MANIFEST_FILENAME),
+    installDir: path.join(home, ".gemini", "antigravity-cli", "plugins", "codevibe-antigravity"),
+    mcpConfigPath: path.join(home, ".gemini", "config", "mcp_config.json"),
+    serverScriptPath: path.join(opts.pluginPkgDir, "dist", "server.js")
+  };
+}
+async function ensureInstalled(options) {
+  const logger = options.logger ?? defaultLogger();
+  const {
+    pluginJsonSourcePath,
+    installDir,
+    mcpConfigPath,
+    serverScriptPath
+  } = options;
+  const pid = options.pidOverride ?? process.pid;
+  let manifestContent;
+  let manifestFd = null;
+  try {
+    manifestFd = await fs.promises.open(
+      pluginJsonSourcePath,
+      fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW
+    );
+    manifestContent = await manifestFd.readFile("utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ELOOP" || code === "EMLINK") {
+      throw new Error(
+        `Refusing to install: ${MANIFEST_FILENAME} source is a symlink (${pluginJsonSourcePath}). The packaged manifest must be a regular file.`
+      );
+    }
+    throw err;
+  } finally {
+    if (manifestFd) {
+      try {
+        await manifestFd.close();
+      } catch {
+      }
+    }
+  }
+  const expectedManifestHash = sha256Hex(manifestContent);
+  const lockPath = path.join(path.dirname(installDir), ".codevibe-install.lock");
+  const releaseLock = await acquireLock(lockPath, LOCK_ACQUIRE_TIMEOUT_MS, logger, "install");
+  try {
+    await crashRecoverySweep(installDir, logger);
+    const currentHash = await tryReadCurrentHash(installDir);
+    if (currentHash === expectedManifestHash) {
+      await ensureMcpConfigEntry(mcpConfigPath, serverScriptPath, logger);
+      return { installed: false, upToDate: true, installDir, manifestHash: currentHash };
+    }
+    await stageAndInstall({
+      installDir,
+      pluginJsonSourcePath,
+      manifestContent,
+      expectedManifestHash,
+      pid,
+      logger
+    });
+    await ensureMcpConfigEntry(mcpConfigPath, serverScriptPath, logger);
+    logger.info("codevibe-antigravity-plugin installed", {
+      installDir,
+      manifestHash: expectedManifestHash
+    });
+    return {
+      installed: true,
+      upToDate: false,
+      installDir,
+      manifestHash: expectedManifestHash
+    };
+  } finally {
+    await releaseLock();
+  }
+}
+async function stageAndInstall(args) {
+  const { installDir, manifestContent, expectedManifestHash, pid } = args;
+  const stagingDir = `${installDir}.new.${pid}`;
+  const oldDir = `${installDir}.old.${pid}`;
+  await fs.promises.mkdir(path.dirname(installDir), { recursive: true });
+  await rmRecursive(stagingDir);
+  await fs.promises.mkdir(stagingDir, { recursive: true, mode: 493 });
+  const manifestDest = path.join(stagingDir, MANIFEST_FILENAME);
+  const manifestTmp = `${manifestDest}.partial`;
+  await fs.promises.writeFile(manifestTmp, manifestContent, { mode: 420 });
+  await fs.promises.rename(manifestTmp, manifestDest);
+  const sentinelDest = path.join(stagingDir, SENTINEL_FILENAME);
+  await fs.promises.writeFile(sentinelDest, expectedManifestHash + "\n", { mode: 420 });
+  const installExists = await lstatExists(installDir);
+  if (installExists) {
+    await rmRecursive(oldDir);
+    await fs.promises.rename(installDir, oldDir);
+  }
+  try {
+    await fs.promises.rename(stagingDir, installDir);
+  } catch (err) {
+    if (installExists) {
+      try {
+        await fs.promises.rename(oldDir, installDir);
+      } catch {
+        args.logger.error("Installer: failed to restore previous install dir", {
+          installDir,
+          oldDir,
+          error: String(err)
+        });
+      }
+    }
+    throw err;
+  }
+  if (installExists) {
+    await rmRecursive(oldDir);
+  }
+}
+async function crashRecoverySweep(installDir, logger) {
+  const parent = path.dirname(installDir);
+  const baseName = path.basename(installDir);
+  let entries;
+  try {
+    entries = await fs.promises.readdir(parent, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!entry.name.startsWith(`${baseName}.new.`)) continue;
+    const dir = path.join(parent, entry.name);
+    const sentinel = path.join(dir, SENTINEL_FILENAME);
+    if (await pathExists(sentinel)) {
+      if (!await lstatExists(installDir)) {
+        try {
+          await fs.promises.rename(dir, installDir);
+          logger.info("Crash-recovery: adopted orphan staging dir as install", { adopted: dir });
+        } catch (err) {
+          logger.warn("Crash-recovery: failed to adopt orphan staging dir", {
+            dir,
+            error: String(err)
+          });
+        }
+        continue;
+      }
+      logger.info("Crash-recovery: discarding orphan staging dir (current install exists)", { dir });
+      await rmRecursive(dir);
+      continue;
+    }
+    logger.info("Crash-recovery: deleting incomplete staging dir", { dir });
+    await rmRecursive(dir);
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (!entry.name.startsWith(`${baseName}.old.`)) continue;
+    const dir = path.join(parent, entry.name);
+    logger.info("Crash-recovery: deleting orphan .old dir", { dir });
+    await rmRecursive(dir);
+  }
+}
+async function ensureMcpConfigEntry(mcpConfigPath, serverScriptPath, logger) {
+  try {
+    await fs.promises.mkdir(path.dirname(mcpConfigPath), { recursive: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOTDIR" || code === "EEXIST") {
+      throw new Error(
+        `mcp_config.json parent path exists as a file, expected a directory: ${path.dirname(mcpConfigPath)}`
+      );
+    }
+    throw err;
+  }
+  const lockPath = `${mcpConfigPath}.lock`;
+  const releaseLock = await acquireLock(lockPath, LOCK_ACQUIRE_TIMEOUT_MS, logger, "mcp-config");
+  try {
+    await doEnsureMcpConfigEntry(mcpConfigPath, serverScriptPath, logger);
+  } finally {
+    await releaseLock();
+  }
+}
+async function doEnsureMcpConfigEntry(mcpConfigPath, serverScriptPath, logger) {
+  let config = {};
+  let existingMode = null;
+  try {
+    const stat = await fs.promises.stat(mcpConfigPath);
+    existingMode = stat.mode & 511;
+    if (stat.size > 0) {
+      const raw = await fs.promises.readFile(mcpConfigPath, "utf8");
+      try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          config = parsed;
+        } else {
+          logger.warn("mcp_config.json root is not a plain object; overwriting", {
+            mcpConfigPath
+          });
+        }
+      } catch {
+        logger.warn("mcp_config.json was malformed JSON; overwriting with valid empty config", {
+          mcpConfigPath
+        });
+        config = {};
+      }
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (!config.mcpServers || typeof config.mcpServers !== "object" || Array.isArray(config.mcpServers)) {
+    config.mcpServers = {};
+  }
+  const expected = {
+    command: "node",
+    args: [serverScriptPath]
+  };
+  const current = config.mcpServers[MCP_SERVERS_KEY];
+  if (current?.env && typeof current.env === "object" && !Array.isArray(current.env)) {
+    expected.env = current.env;
+  }
+  const envEqual = !current?.env && !expected.env ? true : JSON.stringify(current?.env ?? null) === JSON.stringify(expected.env ?? null);
+  const needsWrite = !current || current.command !== expected.command || !arraysEqual(current.args ?? [], expected.args) || !envEqual;
+  if (!needsWrite) return;
+  config.mcpServers[MCP_SERVERS_KEY] = expected;
+  const targetMode = existingMode ?? 420;
+  const randSuffix = `${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+  const tmpPath = `${mcpConfigPath}.tmp.${randSuffix}`;
+  const tmpFd = await fs.promises.open(tmpPath, "wx", targetMode);
+  try {
+    await tmpFd.writeFile(JSON.stringify(config, null, 2) + "\n", "utf8");
+    await tmpFd.close();
+  } catch (writeErr) {
+    try {
+      await tmpFd.close();
+    } catch {
+    }
+    try {
+      await fs.promises.unlink(tmpPath);
+    } catch {
+    }
+    throw writeErr;
+  }
+  try {
+    await fs.promises.rename(tmpPath, mcpConfigPath);
+  } catch (err) {
+    try {
+      await fs.promises.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  logger.info("Updated mcp_config.json with codevibe-antigravity entry", {
+    mcpConfigPath,
+    serverScriptPath
+  });
+}
+function sha256Hex(s) {
+  return crypto.createHash("sha256").update(s, "utf8").digest("hex");
+}
+async function tryReadCurrentHash(installDir) {
+  try {
+    const sentinel = await fs.promises.readFile(path.join(installDir, SENTINEL_FILENAME), "utf8");
+    return sentinel.trim();
+  } catch {
+    return null;
+  }
+}
+async function pathExists(p) {
+  try {
+    await fs.promises.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function lstatExists(p) {
+  try {
+    await fs.promises.lstat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(lockPath, timeoutMs, logger, label = "install") {
+  await fs.promises.mkdir(path.dirname(lockPath), { recursive: true });
+  const myPidLine = `${process.pid}
+`;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const tmpSuffix = `${process.pid}.${Date.now()}.${crypto.randomBytes(6).toString("hex")}`;
+    const tmpPath = `${lockPath}.create.${tmpSuffix}`;
+    let tmpWritten = false;
+    try {
+      await fs.promises.writeFile(tmpPath, myPidLine, { flag: "wx", mode: 384 });
+      tmpWritten = true;
+      try {
+        await fs.promises.link(tmpPath, lockPath);
+      } catch (linkErr) {
+        const code = linkErr.code;
+        if (code !== "EEXIST") {
+          throw linkErr;
+        }
+        try {
+          await fs.promises.unlink(tmpPath);
+        } catch {
+        }
+        tmpWritten = false;
+        const holder = await readLockHolder(lockPath);
+        const stale = holder === null || !isPidAlive(holder);
+        if (stale) {
+          const takeoverPath = `${lockPath}.takeover.${process.pid}.${Date.now()}`;
+          try {
+            await fs.promises.rename(lockPath, takeoverPath);
+            try {
+              await fs.promises.unlink(takeoverPath);
+            } catch {
+            }
+            logger.warn(`Stale ${label} lock detected \u2014 taking over`, {
+              lockPath,
+              deadPid: holder
+            });
+            continue;
+          } catch (renameErr) {
+            const rcode = renameErr.code;
+            if (rcode !== "ENOENT") {
+              logger.warn(`Failed to take over stale ${label} lock; retrying`, {
+                lockPath,
+                error: String(renameErr)
+              });
+            }
+          }
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(
+            `Failed to acquire ${label} lock ${lockPath} within ${timeoutMs}ms (held by pid ${holder ?? "<unknown>"})`
+          );
+        }
+        await new Promise((r) => setTimeout(r, LOCK_RETRY_INTERVAL_MS));
+        continue;
+      }
+      try {
+        await fs.promises.unlink(tmpPath);
+      } catch {
+      }
+      tmpWritten = false;
+      return async () => {
+        try {
+          const currentHolder = await readLockHolder(lockPath);
+          if (currentHolder !== process.pid) return;
+          await fs.promises.unlink(lockPath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (tmpWritten) {
+        try {
+          await fs.promises.unlink(tmpPath);
+        } catch {
+        }
+      }
+      throw err;
+    }
+  }
+}
+async function readLockHolder(lockPath) {
+  try {
+    const raw = await fs.promises.readFile(lockPath, "utf8");
+    const pid = parseInt(raw.trim(), 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function rmRecursive(p) {
+  try {
+    await fs.promises.rm(p, { recursive: true, force: true });
+  } catch {
+  }
+}
+function arraysEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function defaultLogger() {
+  return {
+    info: () => {
+    },
+    warn: (msg, meta) => console.warn("[installer]", msg, meta ?? ""),
+    error: (msg, meta) => console.error("[installer]", msg, meta ?? "")
+  };
+}
+
+// src/installer-cli.ts
+async function main() {
+  const pkgDir = path2.resolve(__dirname, "..");
+  const paths = resolveInstallerPaths({ pluginPkgDir: pkgDir });
+  try {
+    const result = await ensureInstalled({
+      ...paths,
+      logger: {
+        info: (msg, meta) => {
+          if (process.env.CODEVIBE_AGY_INSTALLER_VERBOSE === "1") {
+            console.log(`[installer] ${msg}`, meta ?? "");
+          }
+        },
+        warn: (msg, meta) => console.warn(`[installer] WARN: ${msg}`, meta ?? ""),
+        error: (msg, meta) => console.error(`[installer] ERROR: ${msg}`, meta ?? "")
+      }
+    });
+    if (result.installed && process.env.CODEVIBE_AGY_INSTALLER_VERBOSE === "1") {
+      console.log(`[installer] Installed fresh manifest hash=${result.manifestHash}`);
+    }
+    process.exit(0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[installer] FATAL: ${msg}`);
+    process.exit(1);
+  }
+}
+if (require.main === module) {
+  void main();
+}
+var __testing = {
+  main
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __testing
+});