@anhlp/alp 0.0.0-beta.1

package/packages/client/dist/antigravity-probe.js

@@ -0,0 +1,95 @@
+// packages/client/src/antigravity-probe.js
+import { spawn } from "node:child_process";
+var DEFAULT_ANTIGRAVITY_MODELS = [
+  { id: "gemini-3.8-flash-high", label: "Gemini 3.8 Flash (High)" },
+  { id: "gemini-3.8-flash-medium", label: "Gemini 3.8 Flash (Medium)" },
+  { id: "gemini-3.8-flash-low", label: "Gemini 3.8 Flash (Low)" },
+  { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+  { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash" },
+  { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (Thinking)" },
+  { id: "claude-opus-4-6-thinking", label: "Claude Opus 4.6 (Thinking)" },
+  { id: "gpt-oss-120b-medium", label: "GPT-OSS 120B (Medium)" }
+];
+var ANTIGRAVITY_MODES = [
+  {
+    id: "full-access",
+    label: "Full access",
+    description: "Antigravity runs with full access (--dangerously-skip-permissions)."
+  }
+];
+function runCommand(command, args, { env = process.env, cwd, timeoutMs = 2e4 } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${command} ${args.join(" ")} timed out after ${timeoutMs / 1e3}s`));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve({ stdout, stderr });
+      else reject(new Error(`${command} exited with code ${code}: ${stderr.trim() || stdout.trim()}`));
+    });
+  });
+}
+async function probeAntigravity(provider = {}, { cwd, timeoutMs = 2e4 } = {}) {
+  const command = provider.command || "agy";
+  const args = provider.args ?? [];
+  const env = { ...process.env, ...provider.env ?? {} };
+  let version = "";
+  try {
+    const res = await runCommand(command, [...args, "--version"], { env, cwd, timeoutMs: Math.min(timeoutMs, 5e3) });
+    version = res.stdout.trim().split("\n")[0] ?? "";
+  } catch (error) {
+    throw new Error(`Antigravity command '${command}' is not available: ${error.message}`);
+  }
+  let models = [];
+  try {
+    const res = await runCommand(command, [...args, "models"], { env, cwd, timeoutMs });
+    for (const line of res.stdout.trim().split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      const [id, label] = line.split("	");
+      if (id && label) {
+        models.push({ id: id.trim(), label: label.trim() });
+      } else if (id) {
+        models.push({ id: id.trim(), label: id.trim() });
+      }
+    }
+  } catch {
+    models = [...DEFAULT_ANTIGRAVITY_MODELS];
+  }
+  if (!models.length) {
+    models = [...DEFAULT_ANTIGRAVITY_MODELS];
+  }
+  return {
+    version,
+    agent: { name: "antigravity", title: "Antigravity", version },
+    models,
+    currentModel: models[0]?.id,
+    modes: provider.readOnlyMode === "instructions" ? [...ANTIGRAVITY_MODES, {
+      id: "read-only",
+      label: "Read only (instructions)",
+      description: "For new sessions: prompt-only read-only behavior. agy still runs with full access; no OS sandbox enforces this mode."
+    }] : ANTIGRAVITY_MODES,
+    currentMode: "full-access"
+  };
+}
+export {
+  probeAntigravity
+};

package/packages/client/dist/command.d.ts

@@ -0,0 +1,5 @@
+/** Runs a command; resolves with its exit code and output, never rejects. */
+export function runCommand(command: any, args: any, { cwd, env, timeoutMs }?: {
+    env?: NodeJS.ProcessEnv | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<any>;

package/packages/client/dist/command.js

@@ -0,0 +1,33 @@
+// packages/client/src/command.js
+import { spawn } from "node:child_process";
+function runCommand(command, args, { cwd, env = process.env, timeoutMs = 15e3 } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    const script = process.platform === "win32" && /\.[cm]?js$/i.test(command);
+    try {
+      child = spawn(script ? process.execPath : command, script ? [command, ...args] : args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    } catch (error) {
+      resolve({ code: -1, stdout: "", stderr: error.message });
+      return;
+    }
+    let stdout = "", stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = setTimeout(() => child.kill("SIGKILL"), timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({ code: -1, stdout, stderr: error.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ code: code ?? -1, stdout, stderr });
+    });
+  });
+}
+export {
+  runCommand
+};

package/packages/client/dist/doctor.d.ts

@@ -0,0 +1,13 @@
+export type DoctorCheck = {
+  id: string;
+  status: 'ok' | 'info' | 'warn' | 'fail';
+  summary: string;
+  details?: string[];
+  hint?: string;
+  fix?: { describe: string; apply(): Promise<string> };
+};
+export type CommandResult = { code: number; stdout: string; stderr: string };
+export type CommandRunner = (command: string, args: string[], options?: { cwd?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number }) => Promise<CommandResult>;
+export const runCommand: CommandRunner;
+export function diagnose(options?: { home?: string; project?: string; env?: NodeJS.ProcessEnv; run?: CommandRunner; sandbox?: boolean; daemonEntry?: string; timeoutMs?: number }): Promise<DoctorCheck[]>;
+export function repair(checks: DoctorCheck[]): Promise<Array<{ id: string; result: string }>>;