@anhlp/alp-client 0.0.0-stage → 0.10.0

package/dist/setup.js

@@ -0,0 +1,146 @@
+// packages/client/src/setup.js
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { initProject } from "@anhlp/alp-core/init";
+import { MODELS } from "@anhlp/alp-core/models";
+import { fitEffort, modelEfforts } from "@anhlp/alp-core/profiles";
+import { resolveTeam } from "@anhlp/alp-core/teams";
+import { validateSettings } from "@anhlp/alp-core/validation";
+import { Cancelled, select, text } from "./prompt.js";
+var PROVIDERS = ["claude", "codex"];
+var PROVIDER_LABEL = { claude: "Claude", codex: "Codex" };
+var DEFAULTS = {
+  main: { claude: ["claude-opus-5-5", "high"], codex: ["gpt-6.1-sol", "high"] },
+  worker: { claude: ["claude-opus-5-5", "high"], codex: ["gpt-6.1-sol", "high"] },
+  supervisor: { claude: ["claude-sonnet-5", "medium"], codex: ["gpt-6-luna", "medium"] },
+  oracle: { claude: ["claude-fable-5-1", "high"], codex: ["gpt-6-astra", "high"] }
+};
+var FLAGS = { main: "model", worker: "model", supervisor: "supervisor", oracle: "oracle" };
+var SEAT_LABEL = { main: "main", worker: "lead, reviewer", supervisor: "supervisor", oracle: "oracle" };
+var ANY_EFFORT = ["low", "medium", "high", "xhigh", "max"];
+async function setup(args, home) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: Object.fromEntries(
+    ["runtime", "prefer", ...PROVIDERS.flatMap((provider) => Object.values(FLAGS).map((flag) => `${provider}-${flag}`))].map((name) => [name, { type: "string" }])
+  ) });
+  if (positionals.length > 1) throw new Error("setup takes at most one directory");
+  const root = path.resolve(positionals[0] ?? process.cwd());
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  try {
+    const runtime = values.runtime ?? (interactive ? await select({ message: "Runtime", initial: "mix", choices: [
+      { label: "Mix", value: "mix", hint: "Claude and Codex: main runs on one, the others can run on either" },
+      { label: "Codex only", value: "codex" },
+      { label: "Claude only", value: "claude" }
+    ] }) : void 0);
+    if (runtime === void 0) throw new Error("Pass --runtime codex, claude or mix when setup is not running in a terminal");
+    if (!["codex", "claude", "mix"].includes(runtime)) throw new Error("--runtime must be codex, claude or mix");
+    const prefer = values.prefer ?? (runtime !== "mix" ? runtime : interactive ? await select({ message: "Main runs on", initial: "claude", choices: [
+      { label: "Claude", value: "claude", hint: "Claude first for the others too" },
+      { label: "Codex", value: "codex", hint: "Codex first for the others too" }
+    ] }) : "claude");
+    if (!PROVIDERS.includes(prefer) || runtime !== "mix" && prefer !== runtime) throw new Error("--prefer must be an enabled runtime");
+    const enabled = runtime === "mix" ? [prefer, ...PROVIDERS.filter((provider) => provider !== prefer)] : [runtime];
+    for (const provider of PROVIDERS) {
+      for (const flag of Object.values(FLAGS)) {
+        if (!enabled.includes(provider) && values[`${provider}-${flag}`]) throw new Error(`--${provider}-${flag} is unavailable in ${runtime}-only mode`);
+      }
+    }
+    const seats = {};
+    for (const [seat, flag] of Object.entries(FLAGS)) {
+      seats[seat] = (seat === "main" ? [prefer] : enabled).map((provider) => {
+        const option = `${provider}-${flag}`;
+        const [fallback, effort] = DEFAULTS[seat][provider];
+        const model = nativeModel(values[option] ?? fallback, provider, `--${option}`);
+        return { provider, model, effort: fitEffort(`${provider}:${model}`, effort) };
+      });
+    }
+    const peers = enabled.map((provider) => `${provider}:*`);
+    const file = path.join(root, ".alp/settings.json");
+    const settings = await readFile(file, "utf8").then((content) => {
+      try {
+        return JSON.parse(content);
+      } catch (error) {
+        throw new Error(`${file} is not valid JSON: ${error.message}`);
+      }
+    }, (error) => {
+      if (error.code === "ENOENT") return void 0;
+      throw new Error(`${file}: ${error.message}`);
+    });
+    const show = () => {
+      for (const [seat, choices] of Object.entries(seats)) console.log(`  ${SEAT_LABEL[seat]}: ${choices.map(describe).join(", ")}`);
+      console.log(`  peer: ${peers.join(", ")} (any model: whoever assigns a peer picks its model and effort for the task)`);
+    };
+    console.log(`Profiles for Ph\u1EDF and Cafe in ${file}:`);
+    show();
+    const replaced = ["pho", "cafe"].filter((id) => (settings?.team ?? settings?.profile)?.[id]);
+    if (replaced.length) console.log(`These replace the ${replaced.join(" and ")} profiles already in the file; a backup is kept in ${file}.bak.`);
+    if (interactive) {
+      for (; ; ) {
+        const next2 = await select({ message: "Save these profiles?", initial: "save", choices: [
+          { label: "Save", value: "save" },
+          { label: "Change a model", value: "change" },
+          { label: "Cancel", value: "cancel" }
+        ] });
+        if (next2 === "cancel") throw new Cancelled();
+        if (next2 === "save") break;
+        await change(seats);
+        show();
+      }
+    }
+    const profile = await profiles(root, home, seats, peers, settings);
+    validateSettings({ ...settings ?? {}, team: { ...settings?.profile ?? {}, ...settings?.team ?? {}, ...profile } }, file);
+    if (!settings) await initProject(root, { library: home });
+    else if (replaced.length) await copyFile(file, `${file}.bak`);
+    const written = settings ?? JSON.parse(await readFile(file, "utf8"));
+    const next = { ...written, team: { ...written.profile ?? {}, ...written.team ?? {}, ...profile } };
+    delete next.profile;
+    await writeFile(file, JSON.stringify(next, null, 2) + "\n");
+    console.log("Setup saved. New sessions in this project use these profiles; edit the file to change one agent. Run alp doctor to check that each CLI is installed and logged in.");
+  } catch (error) {
+    if (!(error instanceof Cancelled)) throw error;
+    console.log(error.message);
+  }
+}
+var describe = (choice) => `${choice.provider}:${choice.model}${choice.effort ? `:${choice.effort}` : ""}`;
+async function change(seats) {
+  const [seat, at] = await select({ message: "Which model?", choices: Object.entries(seats).flatMap(([seat2, choices]) => choices.map((choice, at2) => ({ label: `${SEAT_LABEL[seat2]} \xB7 ${PROVIDER_LABEL[choice.provider]}`, value: [seat2, at2], hint: describe(choice) }))) });
+  const current = seats[seat][at];
+  const offered = MODELS.filter((model2) => model2.runtime === current.provider);
+  const picked = await select({ message: `${SEAT_LABEL[seat]} on ${PROVIDER_LABEL[current.provider]}`, initial: current.model, choices: [
+    ...offered.map((model2) => ({ label: model2.label, value: model2.id, hint: `${model2.id} \xB7 ${model2.description}` })),
+    { label: "Other\u2026", value: void 0, hint: "type a model ID" }
+  ] });
+  const model = picked ?? nativeModel(await text(`${PROVIDER_LABEL[current.provider]} model ID:`), current.provider, "The model ID");
+  const efforts = modelEfforts(`${current.provider}:${model}`) ?? ANY_EFFORT;
+  const effort = efforts.length > 1 ? await select({
+    message: "Effort",
+    initial: efforts.includes(current.effort) ? current.effort : DEFAULTS[seat][current.provider][1],
+    choices: efforts.map((effort2) => ({ label: effort2, value: effort2 }))
+  }) : efforts[0];
+  seats[seat][at] = { provider: current.provider, model, ...effort ? { effort } : {} };
+}
+async function profiles(root, home, seats, peers, settings) {
+  const profile = {};
+  for (const id of ["pho", "cafe"]) {
+    const team = await resolveTeam(root, id, { library: home });
+    const agents = {};
+    const seat = (name, choices) => {
+      agents[name] = { profiles: choices.map((choice) => typeof choice === "string" ? choice : describe(choice)), autocompact: (settings?.team ?? settings?.profile)?.[id]?.[name]?.autocompact ?? "auto" };
+    };
+    for (const [name, member] of Object.entries(team.members)) {
+      if (name !== "oracle") seat(name, name === team.main ? seats.main : member.role === "peer" ? peers : seats.worker);
+    }
+    if (team.supervisor) seat(team.supervisor.agent, seats.supervisor);
+    if (team.members.oracle) seat("oracle", seats.oracle);
+    profile[id] = agents;
+  }
+  return profile;
+}
+function nativeModel(id, provider, where) {
+  const model = id.startsWith(`${provider}:`) ? id.slice(provider.length + 1) : id;
+  if (!model || /\s/.test(model) || /^(codex|claude):/.test(model) || model.includes(":") && !id.startsWith(`${provider}:`)) throw new Error(`${where} expects a ${provider} model, got '${id}'`);
+  return model;
+}
+export {
+  setup
+};

package/dist/supervise.d.ts

@@ -0,0 +1,12 @@
+export function holdDaemon(home: string, by?: string): Promise<void>;
+export function releaseHold(home: string): Promise<void>;
+export function daemonHeld(home: string): Promise<boolean>;
+export function startDaemon(options: { home: string; entry?: string; env?: NodeJS.ProcessEnv; timeoutMs?: number }): Promise<string>;
+export function superviseDaemon(options: {
+  home: string;
+  entry?: string | (() => string | undefined);
+  env?: NodeJS.ProcessEnv;
+  intervalMs?: number;
+  misses?: number;
+  log?: (message: string) => void;
+}): (() => Promise<void>) & { started: Promise<void> };

package/dist/supervise.js

@@ -0,0 +1,81 @@
+// packages/client/src/supervise.js
+import { mkdir, unlink, writeFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { ensureDaemon, lockAlive, readLock } from "./index.js";
+import { installedProgram, serviceFor, startService } from "./service.js";
+var holdFile = (home) => path.join(home, "state", "alpd.held");
+async function holdDaemon(home, by = "alp daemon stop") {
+  await mkdir(path.dirname(holdFile(home)), { recursive: true, mode: 448 });
+  await writeFile(holdFile(home), JSON.stringify({ by, at: (/* @__PURE__ */ new Date()).toISOString() }) + "\n", { mode: 384 });
+}
+async function releaseHold(home) {
+  await unlink(holdFile(home)).catch(() => {
+  });
+}
+async function daemonHeld(home) {
+  return stat(holdFile(home)).then(() => true, () => false);
+}
+async function whenReady(home, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const lock = await readLock(home);
+    if (lockAlive(lock) && lock.ready) return lock.socket;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`alpd did not become ready within ${timeoutMs / 1e3} s; see ${path.join(home, "logs")}`);
+}
+async function startDaemon({ home, entry, env = process.env, timeoutMs = 15e3 }) {
+  await releaseHold(home);
+  const lock = await readLock(home);
+  if (lockAlive(lock)) return lock.ready ? lock.socket : whenReady(home, timeoutMs);
+  const service = serviceFor({ home, env });
+  if (service && await installedProgram(service)) {
+    await startService(service);
+    return whenReady(home, timeoutMs);
+  }
+  return ensureDaemon({ home, entry, env, timeoutMs });
+}
+function superviseDaemon({ home, entry, env = process.env, intervalMs = 5e3, misses = 2, log = () => {
+} }) {
+  let stopped = false;
+  let missed = 0;
+  let starting;
+  const start = (reason) => {
+    starting ??= startDaemon({ home, entry: typeof entry === "function" ? entry() : entry, env }).then(() => log(`alpd ${reason}`), (error) => log(`could not start alpd: ${error?.message ?? error}`)).finally(() => {
+      starting = void 0;
+      missed = 0;
+    });
+    return starting;
+  };
+  const check = async () => {
+    if (stopped || starting) return;
+    if (lockAlive(await readLock(home))) {
+      missed = 0;
+      return;
+    }
+    if (await daemonHeld(home)) {
+      missed = 0;
+      return;
+    }
+    if (++missed >= misses && !stopped) await start("was down; started it again");
+  };
+  const initial = start("started with Paseo");
+  const timer = setInterval(() => {
+    void check();
+  }, intervalMs);
+  timer.unref?.();
+  const stop = () => {
+    stopped = true;
+    clearInterval(timer);
+    return starting ?? Promise.resolve();
+  };
+  stop.started = initial;
+  return stop;
+}
+export {
+  daemonHeld,
+  holdDaemon,
+  releaseHold,
+  startDaemon,
+  superviseDaemon
+};

package/package.json

@@ -1,6 +1,137 @@
 {
   "name": "@anhlp/alp-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.10.0",
+  "type": "module",
+  "description": "ALP client module",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "exports": {
+    "./acp-probe": {
+      "alp-source": {
+        "types": "./src/acp-probe.js",
+        "default": "./src/acp-probe.js"
+      },
+      "types": "./dist/acp-probe.d.ts",
+      "default": "./src/acp-probe.js"
+    },
+    "./antigravity-probe": {
+      "alp-source": {
+        "types": "./src/antigravity-probe.js",
+        "default": "./src/antigravity-probe.js"
+      },
+      "types": "./dist/antigravity-probe.d.ts",
+      "default": "./src/antigravity-probe.js"
+    },
+    "./command": {
+      "alp-source": {
+        "types": "./src/command.js",
+        "default": "./src/command.js"
+      },
+      "types": "./dist/command.d.ts",
+      "default": "./src/command.js"
+    },
+    "./doctor": {
+      "alp-source": {
+        "types": "./src/doctor.js",
+        "default": "./src/doctor.js"
+      },
+      "types": "./dist/doctor.d.ts",
+      "default": "./src/doctor.js"
+    },
+    "./index": {
+      "alp-source": {
+        "types": "./src/index.js",
+        "default": "./src/index.js"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.js"
+    },
+    ".": {
+      "alp-source": {
+        "types": "./src/index.js",
+        "default": "./src/index.js"
+      },
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./library-test": {
+      "alp-source": {
+        "types": "./src/library-test.js",
+        "default": "./src/library-test.js"
+      },
+      "types": "./dist/library-test.d.ts",
+      "default": "./src/library-test.js"
+    },
+    "./mcp-probe": {
+      "alp-source": {
+        "types": "./src/mcp-probe.js",
+        "default": "./src/mcp-probe.js"
+      },
+      "types": "./dist/mcp-probe.d.ts",
+      "default": "./src/mcp-probe.js"
+    },
+    "./prompt": {
+      "alp-source": {
+        "types": "./src/prompt.js",
+        "default": "./src/prompt.js"
+      },
+      "types": "./dist/prompt.d.ts",
+      "default": "./src/prompt.js"
+    },
+    "./render": {
+      "alp-source": {
+        "types": "./src/render.js",
+        "default": "./src/render.js"
+      },
+      "types": "./dist/render.d.ts",
+      "default": "./src/render.js"
+    },
+    "./service": {
+      "alp-source": {
+        "types": "./src/service.js",
+        "default": "./src/service.js"
+      },
+      "types": "./dist/service.d.ts",
+      "default": "./src/service.js"
+    },
+    "./setup": {
+      "alp-source": {
+        "types": "./src/setup.js",
+        "default": "./src/setup.js"
+      },
+      "types": "./dist/setup.d.ts",
+      "default": "./src/setup.js"
+    },
+    "./supervise": {
+      "alp-source": {
+        "types": "./src/supervise.js",
+        "default": "./src/supervise.js"
+      },
+      "types": "./dist/supervise.d.ts",
+      "default": "./src/supervise.js"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@anhlp/alp-core": "0.10.0",
+    "@anhlp/alp-protocol": "0.10.0"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-workspace.mjs client",
+    "test": "node ../../scripts/test-package.mjs client",
+    "prepack": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phucanh08/alp-paseo.git",
+    "directory": "packages/client"
+  }
+}

package/src/acp-probe.js

@@ -0,0 +1,46 @@
+import { stdioSession } from './mcp-probe.js';
+
+/**
+ * Starts an ACP provider once and runs initialize (ALPD §46), for `alp provider test`
+ * and the settings screen. It reports who the agent says it is and what it supports;
+ * a provider that needs a login usually says so here, in authMethods. With `discover`,
+ * it also opens a session in `cwd`, as Paseo does, to read the models and modes the agent
+ * offers (ALPD §65); an agent that offers none leaves them out.
+ * @param {{ command: string, args?: string[], env?: Record<string, string>, label?: string, id?: string }} provider
+ * @param {{ cwd?: string, timeoutMs?: number, discover?: boolean }} [options]
+ * @returns {Promise<{ protocolVersion: number, agent?: { name?: string, title?: string, version?: string }, loadSession: boolean, mcpHttp: boolean, authMethods: string[],
+ *   models?: Array<{ id: string, label: string, description?: string }>, currentModel?: string, modes?: Array<{ id: string, label: string, description?: string }>, currentMode?: string }>}
+ */
+export async function probeAcp(provider, { cwd, timeoutMs = 20_000, discover = false } = {}) {
+  const session = stdioSession({ command: provider.command, args: provider.args ?? [], env: provider.env ?? {} }, cwd, timeoutMs);
+  try {
+    const result = await session.request('initialize', {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientInfo: { name: 'alp', title: 'ALP', version: '1' },
+    });
+    if (result.protocolVersion !== 1) throw new Error(`${provider.label ?? provider.id} speaks ACP version ${result.protocolVersion}; ALP speaks version 1`);
+    const info = result.agentInfo;
+    const offered = discover ? await session.request('session/new', { cwd, mcpServers: [] }) : undefined;
+    const choices = list => Array.isArray(list) ? list.filter(item => typeof (item?.modelId ?? item?.id) === 'string')
+      .map(item => ({ id: item.modelId ?? item.id, label: typeof item.name === 'string' && item.name ? item.name : item.modelId ?? item.id, ...(typeof item.description === 'string' && item.description ? { description: item.description } : {}) })) : undefined;
+    const config = offered?.configOptions?.find(option => option.category === 'model' && option.type === 'select');
+    const modeConfig = offered?.configOptions?.find(option => option.category === 'mode' && option.type === 'select');
+    const flatten = options => options?.flatMap(option => option.options ?? [option]).map(option => ({ ...option, id: option.value }));
+    const modelState = offered?.models ?? (config ? { availableModels: flatten(config.options), currentModelId: config.currentValue } : undefined);
+    const modeState = offered?.modes ?? (modeConfig ? { availableModes: flatten(modeConfig.options), currentModeId: modeConfig.currentValue } : undefined);
+    const models = choices(modelState?.availableModels);
+    const modes = choices(modeState?.availableModes);
+    return {
+      ...(models ? { models, ...(typeof modelState.currentModelId === 'string' ? { currentModel: modelState.currentModelId } : {}) } : {}),
+      ...(modes ? { modes, ...(typeof modeState.currentModeId === 'string' ? { currentMode: modeState.currentModeId } : {}) } : {}),
+      protocolVersion: result.protocolVersion,
+      ...(info ? { agent: { ...(info.name ? { name: info.name } : {}), ...(info.title ? { title: info.title } : {}), ...(info.version ? { version: info.version } : {}) } } : {}),
+      loadSession: Boolean(result.agentCapabilities?.loadSession),
+      mcpHttp: Boolean(result.agentCapabilities?.mcpCapabilities?.http),
+      authMethods: (result.authMethods ?? []).map(method => method?.name ?? method?.id).filter(Boolean),
+    };
+  } finally {
+    await session.close();
+  }
+}

package/src/antigravity-probe.js

@@ -0,0 +1,106 @@
+import { spawn } from 'node:child_process';
+
+const 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)' },
+];
+
+const 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 = 20_000 } = {}) {
+  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 / 1000}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()}`));
+    });
+  });
+}
+
+/**
+ * Probes Antigravity CLI for version, status and available models.
+ * @param {{ command?: string, args?: string[], env?: Record<string, string>, label?: string, id?: string, readOnlyMode?: 'instructions' | 'reject' }} [provider]
+ * @param {{ cwd?: string, timeoutMs?: number }} [options]
+ */
+export async function probeAntigravity(provider = {}, { cwd, timeoutMs = 20_000 } = {}) {
+  const command = provider.command || 'agy';
+  const args = provider.args ?? [];
+  const env = { ...process.env, ...(provider.env ?? {}) };
+
+  // Check version
+  let version = '';
+  try {
+    const res = await runCommand(command, [...args, '--version'], { env, cwd, timeoutMs: Math.min(timeoutMs, 5000) });
+    version = res.stdout.trim().split('\n')[0] ?? '';
+  } catch (error) {
+    throw new Error(`Antigravity command '${command}' is not available: ${error.message}`);
+  }
+
+  // Probe models
+  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('\t');
+      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',
+  };
+}

package/src/command.js

@@ -0,0 +1,16 @@
+import { spawn } from 'node:child_process';
+
+/** Runs a command; resolves with its exit code and output, never rejects. */
+export function runCommand(command, args, { cwd, env = process.env, timeoutMs = 15_000 } = {}) {
+  return new Promise(resolve => {
+    let child;
+    try { child = spawn(command, 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 }); });
+  });
+}

package/src/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 }): Promise<DoctorCheck[]>;
+export function repair(checks: DoctorCheck[]): Promise<Array<{ id: string; result: string }>>;