@openagents-org/agent-launcher 0.2.171 → 0.2.173

package/src/adapters/antigravity.js

@@ -0,0 +1,390 @@
+/**
+ * Antigravity CLI (agy) adapter for OpenAgents workspace.
+ *
+ * Successor to the Gemini CLI adapter: Google transitioned Gemini CLI into
+ * Antigravity CLI in May 2026 and cut individual-account access to the old
+ * CLI that June. agy is a closed-source Go binary — no npm runtime prefix and
+ * no .cmd/.js shim resolution needed — driven headless via
+ * `agy -p <prompt> --output-format stream-json`.
+ *
+ * Stream interpretation, argv building, and failure classification live in
+ * ./antigravity-stream.js (pure, unit-tested); this file owns process
+ * lifecycle and workspace I/O, structurally mirroring gemini.js.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+
+const BaseAdapter = require('./base');
+const { whereBinary } = require('../paths');
+const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
+const { buildClaudeSystemPrompt } = require('./workspace-prompt');
+const {
+  buildAgyArgv,
+  parseAgyEvent,
+  AgyRunState,
+  classifyAgyFailure,
+  agyBinaryCandidates,
+} = require('./antigravity-stream');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+class AntigravityAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   * @param {string} [opts.workingDir]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    // Read-only pinned context, same as gemini: agy has no MCP bridge to the
+    // workspace knowledge tools, so it can see the decision log but not write it.
+    this._usesPinnedContext = true;
+    this._channelConversations = {}; // channel → agy conversation_id
+    this._channelProcesses = {}; // channel → child process
+    this._sessionsFile = path.join(
+      os.homedir(), '.openagents', 'sessions',
+      `${this.workspaceId}_${this.agentName}_antigravity.json`
+    );
+    this._loadSessions();
+  }
+
+  _loadSessions() {
+    try {
+      if (fs.existsSync(this._sessionsFile)) {
+        const data = JSON.parse(fs.readFileSync(this._sessionsFile, 'utf-8'));
+        if (data && typeof data === 'object') {
+          Object.assign(this._channelConversations, data);
+          this._log(`Loaded ${Object.keys(data).length} conversation(s)`);
+        }
+      }
+    } catch {
+      this._log('Could not load sessions file, starting fresh');
+    }
+  }
+
+  _saveSessions() {
+    try {
+      const dir = path.dirname(this._sessionsFile);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this._sessionsFile, JSON.stringify(this._channelConversations));
+    } catch {}
+  }
+
+  async _onControlAction(action, _payload) {
+    if (action === 'stop') {
+      await this._stopAllProcesses();
+    }
+  }
+
+  async _stopProcess(proc) {
+    if (!proc || proc.exitCode !== null) return;
+    try {
+      if (IS_WINDOWS) {
+        try { execSync(`taskkill /F /T /PID ${proc.pid}`, { timeout: 5000 }); } catch {}
+      } else {
+        try { process.kill(-proc.pid, 'SIGTERM'); } catch {
+          proc.kill('SIGTERM');
+        }
+        await new Promise((resolve) => {
+          const timeout = setTimeout(() => {
+            try { process.kill(-proc.pid, 'SIGKILL'); } catch {
+              proc.kill('SIGKILL');
+            }
+            resolve();
+          }, 5000);
+          proc.on('exit', () => { clearTimeout(timeout); resolve(); });
+        });
+      }
+    } catch {}
+  }
+
+  async _stopAllProcesses() {
+    const entries = Object.entries(this._channelProcesses);
+    if (!entries.length) return;
+    this._log(`Stopping ${entries.length} running process(es)...`);
+    for (const [channel, proc] of entries) {
+      await this._stopProcess(proc);
+      delete this._channelProcesses[channel];
+      delete this._channelQueues[channel];
+      try {
+        await this.sendStatus(channel, 'Execution stopped by user');
+      } catch {}
+    }
+  }
+
+  _findAgyBinary() {
+    // PATH first (codepage-safe lookup, see whereBinary), then the install
+    // script's fixed destinations.
+    const viaWhere = whereBinary('agy');
+    if (viaWhere) return viaWhere;
+    const candidates = agyBinaryCandidates({
+      home: os.homedir(),
+      isWindows: IS_WINDOWS,
+      localAppData: process.env.LOCALAPPDATA,
+    });
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    return null;
+  }
+
+  /**
+   * agy ignores a bare GEMINI_API_KEY unless the settings file also selects
+   * the gemini provider — and, inversely, refuses to start when the provider
+   * is selected but the key is missing. When the user configured a key for
+   * this agent, select the provider for them; never touch the file otherwise
+   * (a keyring/OAuth sign-in needs no provider entry and must not gain one,
+   * or the CLI stops starting the day the key is removed).
+   */
+  _ensureAgyAuth() {
+    if (this._agyAuthReady) return;
+    this._agyAuthReady = true;
+    try {
+      const env = this.agentEnv || process.env;
+      const apiKey = (env.GEMINI_API_KEY || '').trim();
+      if (!apiKey) return; // OAuth / keyring — leave the user's setup alone.
+      const dir = path.join(os.homedir(), '.gemini', 'antigravity-cli');
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, 'settings.json');
+      let settings = {};
+      try { settings = JSON.parse(fs.readFileSync(file, 'utf-8')) || {}; } catch {}
+      if (settings.modelProvider === 'gemini') return; // already selected.
+      settings.modelProvider = 'gemini';
+      fs.writeFileSync(file, JSON.stringify(settings, null, 2));
+      this._log('Configured Antigravity CLI for API-key auth (~/.gemini/antigravity-cli/settings.json)');
+    } catch (e) {
+      this._log(`agy auth setup skipped: ${e.message}`);
+    }
+  }
+
+  _buildAgyCmd(prompt, channelName, { skipResume = false } = {}) {
+    this._ensureAgyAuth();
+    const agyBin = this._findAgyBinary();
+    if (!agyBin) {
+      throw new Error(
+        'agy CLI not found. Install with: curl -fsSL https://antigravity.google/cli/install.sh | bash'
+      );
+    }
+
+    const pinned = this.pinnedPromptOpts(channelName);
+    const systemPrompt = '\n' + buildClaudeSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      mode: this._mode,
+      decisionLog: pinned.decisionLog ? { ...pinned.decisionLog, writeAccess: false } : null,
+      glossary: pinned.glossary ? { ...pinned.glossary, writeAccess: false } : null,
+    });
+
+    // No system-prompt flag in agy's print mode either — prepend it.
+    const fullPrompt = `${systemPrompt}\n\n---\n\nUser message:\n${prompt}`;
+
+    const env = this.agentEnv || process.env;
+    const model = (env.ANTIGRAVITY_MODEL || env.AGY_MODEL || '').trim();
+
+    const args = buildAgyArgv({
+      prompt: fullPrompt,
+      model,
+      conversationId: this._channelConversations[channelName],
+      skipResume,
+    });
+    return { cmd: [agyBin, ...args] };
+  }
+
+  async _handleMessage(msg) {
+    let content = (msg.content || '').trim();
+    const attachments = msg.attachments || [];
+
+    const attText = formatAttachmentsForPrompt(attachments);
+    if (attText) {
+      content = content ? content + attText : attText.trim();
+    }
+
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    if (!this._titledSessions.has(msgChannel)) {
+      this._titledSessions.add(msgChannel);
+      try {
+        const info = await this.client.getSession(this.workspaceId, msgChannel, this.token);
+        const resumeFrom = info.resumeFrom;
+        if (resumeFrom && !this._channelConversations[msgChannel]) {
+          const sourceConversation = this._channelConversations[resumeFrom];
+          if (sourceConversation) {
+            this._channelConversations[msgChannel] = sourceConversation;
+            this._saveSessions();
+            this._log(`Resuming channel ${msgChannel} from ${resumeFrom}`);
+          }
+        }
+        const title = generateSessionTitle(content);
+        if (title && !info.titleManuallySet && SESSION_DEFAULT_RE.test(info.title || '')) {
+          await this.client.updateSession(
+            this.workspaceId, msgChannel, this.token,
+            { title, autoTitle: true }
+          );
+        }
+      } catch {}
+    }
+
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    let cmd;
+    const cleanEnv = { ...(this.agentEnv || process.env) };
+
+    let _shouldRetry = false;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const built = this._buildAgyCmd(content, msgChannel, { skipResume: attempt > 0 });
+        cmd = built.cmd;
+      } catch (e) {
+        await this.sendError(msgChannel, e.message);
+        return;
+      }
+
+      try {
+        const proc = spawn(cmd[0], cmd.slice(1), {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          env: cleanEnv,
+          cwd: this.workingDir,
+          detached: !IS_WINDOWS,
+          windowsHide: true,
+        });
+        this._channelProcesses[msgChannel] = proc;
+
+        const run = new AgyRunState();
+        let stderrBuf = '';
+        let lineBuffer = '';
+        let _pendingLines = Promise.resolve();
+
+        if (proc.stderr) {
+          proc.stderr.on('data', (chunk) => { stderrBuf += chunk.toString('utf-8'); });
+        }
+
+        _shouldRetry = await new Promise((resolve, reject) => {
+          let consecutiveTimeouts = 0;
+          let lastDataTime = Date.now();
+          let timeoutTimer = null;
+
+          const resetTimeout = () => {
+            consecutiveTimeouts = 0;
+            lastDataTime = Date.now();
+          };
+
+          const startTimeoutMonitor = () => {
+            timeoutTimer = setInterval(async () => {
+              const elapsed = Date.now() - lastDataTime;
+              if (elapsed >= 15000) {
+                consecutiveTimeouts++;
+                lastDataTime = Date.now();
+                if (consecutiveTimeouts === 2) {
+                  try { await this.sendStatus(msgChannel, 'Processing...'); } catch {}
+                }
+                if (consecutiveTimeouts >= 20) {
+                  this._log(`Process idle for ${consecutiveTimeouts * 15}s, killing...`);
+                  await this._stopProcess(proc);
+                }
+              }
+            }, 15000);
+          };
+          startTimeoutMonitor();
+
+          const processLine = async (line) => {
+            const event = parseAgyEvent(line);
+            if (!event) return;
+            resetTimeout();
+            for (const action of run.consume(event)) {
+              if (action.type === 'conversation') {
+                this._channelConversations[msgChannel] = action.id;
+                this._saveSessions();
+              } else if (action.type === 'thinking') {
+                try { await this.sendThinking(msgChannel, action.text); } catch {}
+              } else if (action.type === 'tool') {
+                try { await this.sendStatus(msgChannel, `${action.name} › ${action.preview}`); } catch {}
+              }
+              // 'result' is read from `run` after exit.
+            }
+          };
+
+          proc.on('exit', async (code) => {
+            if (timeoutTimer) clearInterval(timeoutTimer);
+
+            try { await _pendingLines; } catch {}
+
+            const lines = lineBuffer.split('\n');
+            for (const line of lines) {
+              try { await processLine(line); } catch {}
+            }
+
+            delete this._channelProcesses[msgChannel];
+
+            if (code !== 0) {
+              this._log(`CLI exited with code ${code}`);
+              if (stderrBuf.trim()) {
+                this._log(`stderr: ${stderrBuf.trim().slice(0, 500)}`);
+              }
+            }
+
+            const response = run.finalResponse();
+            const failed = code !== 0 || run.status === 'ERROR';
+
+            if (response && !failed) {
+              try { await this.sendResponse(msgChannel, response); } catch {}
+              resolve(false);
+            } else if (failed && this._channelConversations[msgChannel] && attempt === 0) {
+              // A stored conversation id the CLI no longer knows fails the
+              // whole run — clear it and retry once from scratch.
+              this._log(`Stale conversation for ${msgChannel}, clearing and retrying without resume`);
+              delete this._channelConversations[msgChannel];
+              this._saveSessions();
+              resolve(true);
+            } else if (failed) {
+              // Surface the real reason (auth, provider config, bad model)
+              // instead of a generic retry prompt — the gemini adapter's
+              // silent-stderr dead end is what this branch fixes.
+              const { kind, message } = classifyAgyFailure({ code, stderr: stderrBuf, error: run.error });
+              this._log(`run failed (${kind})`);
+              try { await this.sendError(msgChannel, message); } catch {}
+              resolve(false);
+            } else {
+              if (!run.sawText()) {
+                try { await this.sendResponse(msgChannel, 'No response generated. Please try again.'); } catch {}
+              }
+              resolve(false);
+            }
+          });
+
+          proc.on('error', (err) => {
+            if (timeoutTimer) clearInterval(timeoutTimer);
+            reject(err);
+          });
+
+          proc.stdout.on('data', (chunk) => {
+            lineBuffer += chunk.toString('utf-8');
+            resetTimeout();
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop();
+            for (const line of lines) {
+              _pendingLines = _pendingLines.then(() => processLine(line)).catch(() => {});
+            }
+          });
+        });
+      } catch (e) {
+        this._log(`Error handling message: ${e.message}`);
+        await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+        break;
+      }
+      if (!_shouldRetry) break;
+    }
+  }
+}
+
+module.exports = AntigravityAdapter;

package/src/adapters/base.js

@@ -81,6 +81,10 @@ class BaseAdapter {
     this._processedIds = new Set();
     this._titledSessions = new Set();
     this._mode = 'execute';
+    // Workspace-selected model id (WorkspaceMember.model). Synced from
+    // discover at startup and via the `model.set` control event; null means
+    // the agent CLI runs with its own default.
+    this.workspaceModel = null;
     this._lastControlId = null;
     this._controlWake = null;
     // Per-channel task tracking for parallel execution
@@ -212,6 +216,10 @@ class BaseAdapter {
         this.disabledModules = skillsToDisabledModules(self.enabledSkills);
         this._log(`Synced skills from workspace: disabled=[${[...this.disabledModules].join(',')}]`);
       }
+      if (self && self.model) {
+        this.workspaceModel = self.model;
+        this._log(`Synced model from workspace: ${this.workspaceModel}`);
+      }
     } catch (e) {
       this._log(`Warning: skill sync failed (non-fatal): ${e.message}`);
     }
@@ -360,6 +368,11 @@ class BaseAdapter {
       await this._handleSkillInstall(payload);
     } else if (action === 'skill.uninstall') {
       await this._handleSkillUninstall(payload);
+    } else if (action === 'model.set') {
+      // Adapters read workspaceModel when (re)spawning their CLI; ones with
+      // a staleness check (claude.js) respawn on the next message.
+      this.workspaceModel = (payload && payload.model) || null;
+      this._log(`Workspace model set to ${this.workspaceModel || '(default)'}`);
     }
   }
 

package/src/adapters/claude.js

@@ -471,6 +471,10 @@ class ClaudeAdapter extends BaseAdapter {
     const cmd = [claudeBin, '-p', prompt, '--output-format', 'stream-json', '--verbose'];
 
     cmd.push('--append-system-prompt', systemPrompt);
+    // Workspace-picked model (agent profile panel). Absent = CLI's own default.
+    if (this.workspaceModel) {
+      cmd.push('--model', this.workspaceModel);
+    }
     const disallowedTools = ['AskUserQuestion', 'CronCreate', 'CronDelete', 'CronList', 'ScheduleWakeup'];
     if (browserEnabled) {
       // Hard-ban the native WebFetch: it can't render JS and bypasses the
@@ -1165,13 +1169,16 @@ class ClaudeAdapter extends BaseAdapter {
       // read-only plan process serving execute requests.
       const modeStale = existingPP.spawnMode !== this._mode;
       const pinnedStale = pinnedHash !== null && existingPP.pinnedHash !== pinnedHash;
-      if (modeStale || pinnedStale) {
+      const modelStale = (existingPP.spawnModel || null) !== (this.workspaceModel || null);
+      if (modeStale || pinnedStale || modelStale) {
         // Kill it and fall through to a fresh spawn: --resume keeps the
         // conversation (it lives in the CLI transcript), while the new spawn
         // carries the current mode and re-pins the current knowledge.
         this._log(modeStale
           ? `Mode changed to ${this._mode} for ${msgChannel} — respawning with resume`
-          : `Pinned knowledge changed for ${msgChannel} — respawning with resume to re-pin it`);
+          : modelStale
+            ? `Model changed to ${this.workspaceModel || '(default)'} for ${msgChannel} — respawning with resume`
+            : `Pinned knowledge changed for ${msgChannel} — respawning with resume to re-pin it`);
         await this._killPersistentProc(msgChannel);
       } else {
         this._log(`Reusing persistent process for ${msgChannel}`);
@@ -1258,6 +1265,7 @@ class ClaudeAdapter extends BaseAdapter {
           { entryId: glossaryOpt && glossaryOpt.entryId, content: glossaryOpt && glossaryOpt.content },
         ]);
         pp.spawnMode = this._mode;
+        pp.spawnModel = this.workspaceModel || null;
         this._log(`Spawned persistent process for ${msgChannel} (attempt ${attempt + 1})`);
 
         const result = await this._sendToPersistentProc(pp, effectiveContent);

package/src/adapters/index.js

@@ -22,6 +22,7 @@ const AmpAdapter = require('./amp');
 const MiniSweAgentAdapter = require('./mini');
 const PiAdapter = require('./pi');
 const DeepSeekAdapter = require('./deepseek');
+const AntigravityAdapter = require('./antigravity');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -41,11 +42,12 @@ const ADAPTER_MAP = {
   'mini-swe-agent': MiniSweAgentAdapter,
   pi: PiAdapter,
   deepseek: DeepSeekAdapter,
+  antigravity: AntigravityAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent, pi, deepseek, antigravity)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -76,6 +78,7 @@ module.exports = {
   MiniSweAgentAdapter,
   PiAdapter,
   DeepSeekAdapter,
+  AntigravityAdapter,
   createAdapter,
   ADAPTER_MAP,
 };

package/src/cli.js

@@ -806,6 +806,37 @@ async function cmdTestLLM(connector, _flags, positional) {
   }
 }
 
+async function cmdProbe(connector, flags, positional) {
+  const target = positional[0];
+  if (!target) { print('Usage: agn probe <type|agent> [--json]'); return; }
+
+  // Accept an agent name as a convenience — probe its type.
+  let type = target;
+  try {
+    const agent = connector.config.getAgent(target);
+    if (agent) type = agent.type || 'openclaw';
+  } catch {}
+
+  const result = await connector.probeAgentType(type);
+
+  if (flags && flags.json) {
+    // Machine consumers (the daemon's probe_agent node command) read ONLY
+    // stdout JSON — same contract as `agn runtimes --json`.
+    process.stdout.write(JSON.stringify(result));
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (result.ok) {
+    print(`OK (${result.method}, ${result.durationMs}ms)${result.reply ? ` — ${result.reply}` : ''}`);
+    if (result.code === 'static_only') print(result.message);
+  } else {
+    print(`FAILED [${result.code}] ${result.message || ''}`.trim());
+    for (const line of result.guidance || []) print(`  → ${line}`);
+    process.exitCode = 1;
+  }
+}
+
 async function cmdVersion() {
   const pkg = require('../package.json');
   print(`${pkg.name} v${pkg.version}`);
@@ -874,6 +905,7 @@ Commands:
   tool-mode [agent] [mode]    View/set tool mode (mcp or skills)
   autostart [--disable]       Enable/disable auto-start on login
   test-llm <type>             Test LLM connection
+  probe <type|agent> [--json] Smoke-test an agent (tiny end-to-end prompt)
   logs [agent] [--lines N]    View daemon logs
   workspace create [name]     Create a new workspace
   workspace join <token>      Join workspace with token
@@ -962,6 +994,7 @@ async function main() {
     skills: () => cmdSkills(connector, flags, positional),
     'tool-mode': () => cmdToolMode(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
+    probe: () => cmdProbe(connector, flags, positional),
     update: () => cmdUpdate(connector),
     'mcp-server': () => {
       const { runMcpServer } = require('./mcp-server');