agy-mcp-bridge 0.1.15 → 0.1.17

package/README.md

@@ -411,6 +411,12 @@ Lưu ý bảo mật: nội dung yêu cầu và phản hồi được hiển th
 
 **Mức token (đèn cảnh báo):** Cài đặt → "Mức token" cho đặt hai mức, mặc định **không giới hạn**: mỗi task và mỗi ngày (theo giờ máy của bạn). Danh sách task hiện số token (`total_tokens` agy báo, hoặc input + output nếu không có) và đánh dấu "vượt mức" task nào quá mức; thẻ "Token hôm nay" ở trang Task đổi sang "Vượt mức" khi tổng ngày chạm mức. Đây **chỉ là đèn báo, không phải hạn mức thật và không dừng task**: `agy` không có lệnh nào cho bridge đọc hạn mức, và token của một task chỉ biết khi nó kết thúc. Mức lưu ở `.bridge-state/budget.json`, đổi không cần khởi động lại.
 
+**Nhịp tim khi chờ (thử nghiệm):** nếu client gửi kèm `progressToken` (chuẩn MCP), `antigravity_task_wait` gửi một thông báo tiến độ mỗi 10 giây trong lúc giữ lệnh (nội dung là dòng `activity`). Client nào đặt lại đồng hồ timeout khi nhận tiến độ thì có thể chờ lâu hơn `tool_timeout_sec`; client không làm vậy thì bỏ qua và mọi thứ chạy như cũ. **Chưa biết Codex / Claude Code có đặt lại timeout theo tiến độ hay không**: cách thử là để `tool_timeout_sec` ở mức mặc định (60), đặt thời gian chờ 300 giây trong Cài đặt, giao một task chạy quá 1 phút và xem lệnh chờ có bị báo timeout không. Nếu vẫn timeout thì cần đặt `tool_timeout_sec` như trước. Không có token thì không gửi gì.
+
+**Ghi cấu hình Codex bằng một lệnh:** `agy-mcp-bridge setup codex --apply` hiện đúng thay đổi sẽ ghi vào `~/.codex/config.toml` (hoặc `$CODEX_HOME/config.toml`), hỏi xác nhận (`--yes` để bỏ qua câu hỏi), sao lưu file cũ thành `config.toml.bak-<thời gian>` rồi mới ghi. Nếu mục `[mcp_servers.antigravity]` đã có thì chỉ đổi dòng `tool_timeout_sec` (mặc định **3700** giây, lớn hơn mức chờ tối đa 60 phút của giao diện nên đổi mức chờ không cần chạy lại; đổi bằng `--tool-timeout N`); nếu chưa có thì thêm cả mục. Kiểu viết nó không đọc chắc chắn được (inline table, khóa trong ngoặc kép, hai mục trùng) thì lệnh từ chối và bạn sửa tay. File CRLF giữ nguyên CRLF. Claude Code không bị sửa. Sau khi ghi, mở lại Codex.
+
+**Kết quả "đang chạy" gọn hơn:** khi task còn chạy, `antigravity_task_wait`/`status` chỉ trả `task_id`, `status`, `duration_ms`, `activity` và `next_step` (ngắn). Đường dẫn, số byte, pid... xem ở giao diện web hoặc trong trạng thái đầy đủ khi task đã kết thúc. Mỗi lần Codex hỏi lại vì thế tốn ít token hơn.
+
 - **Đây là mức dùng qua bridge, không phải hạn mức.** `agy` không có lệnh xem hạn mức còn lại và bridge không bịa ra con số đó; xem hạn mức trên tài khoản Antigravity của bạn.
 - Bridge **không biết trước** các trường bên trong `usage` (tên trường do `agy` quyết định): nó cộng mọi giá trị số; một vài tên phổ biến (`input_tokens`, `output_tokens`, `total_tokens`...) được dịch nhãn. Task nào kết quả không có `usage` thì ghi nhận là "không có", không phải 0.
 - Chỉ thống kê task bắt đầu từ bản có tính năng này trở đi. Số liệu usage không được gửi cho Codex/Claude (không tốn token).

package/dist/src/cli.js

@@ -9,6 +9,7 @@ import { existsSync } from 'node:fs';
 import { addSessionWorkspaces } from './config.js';
 import { recoverExecutionLock } from './tasks/execution-lock.js';
 import { renderSetup } from './setup.js';
+import { DEFAULT_TOOL_TIMEOUT_SECONDS, codexConfigPath, planCodexConfig, readCodexConfig, writeCodexConfig } from './codex-config.js';
 import { readWait } from './wait-setting.js';
 import { configuredPort } from './http.js';
 import { offerSkillInstall, offerSkillUpdate } from './onboarding.js';
@@ -39,6 +40,9 @@ Usage: ${BIN} [command] [options]
                           packaged copy; a file you edited yourself is never overwritten
   setup codex|claude|both [--port N] [--shell powershell|cmd|bash]
                           Print the exact client configuration and token commands (changes nothing)
+  setup codex|both --apply [--yes] [--tool-timeout N] [--port N]
+                          Write the Codex tool timeout (default 3700 s) into config.toml after showing the change and asking;
+                          a backup is made first. Without an antigravity entry it adds one. Claude Code is never edited
   config [--json]         Show where config, state and the token file live (never prints the token)
   update [--check]        Install the newest version from npm (only for a global install); --check only reports
   unlock                 Reclaim a lock only when both recorded server and child PIDs are dead
@@ -167,12 +171,16 @@ async function updateCommand(args) {
     }
     process.exitCode = status;
 }
-function setup(args) {
+async function setup(args) {
     const target = args[0];
+    const usage = `Usage: ${BIN} setup codex|claude|both [--port N] [--shell powershell|cmd|bash] | setup codex|both --apply [--yes] [--tool-timeout N] [--port N]`;
     if (target !== 'codex' && target !== 'claude' && target !== 'both')
-        throw new Error(`Usage: ${BIN} setup codex|claude|both [--port N] [--shell powershell|cmd|bash]`);
+        throw new Error(usage);
     let port = process.env.PORT !== undefined && process.env.PORT !== '0' ? configuredPort(process.env.PORT) : 3000;
     let shell = process.platform === 'win32' ? ['powershell', 'cmd'] : ['bash'];
+    let apply = false;
+    let yes = false;
+    let toolTimeout = DEFAULT_TOOL_TIMEOUT_SECONDS;
     for (let i = 1; i < args.length; i++) {
         if (args[i] === '--port' && args[i + 1] !== undefined)
             port = configuredPort(args[++i]);
@@ -182,14 +190,66 @@ function setup(args) {
                 throw new Error('--shell must be powershell, cmd or bash');
             shell = [chosen];
         }
+        else if (args[i] === '--apply')
+            apply = true;
+        else if (args[i] === '--yes')
+            yes = true;
+        else if (args[i] === '--tool-timeout' && args[i + 1] !== undefined)
+            toolTimeout = Number(args[++i]);
         else
             throw new Error(`Unknown option for setup: ${args[i]}`);
     }
     if (port === 0)
         throw new Error('Give a fixed port: --port 3000 (0 picks a different port every run, so a client could not be configured)');
+    const mcpUrl = `http://127.0.0.1:${port}/mcp`;
+    if (apply) {
+        await applyCodexSetup(target, mcpUrl, toolTimeout, yes);
+        return;
+    }
     const tokenFile = path.join(paths.stateDirectory, 'http-token');
     const clients = target === 'both' ? ['codex', 'claude'] : [target];
-    console.log(renderSetup({ clients, mcpUrl: `http://127.0.0.1:${port}/mcp`, tokenFile, tokenFileExists: existsSync(tokenFile), tokenFromEnv: Boolean(process.env.BRIDGE_HTTP_TOKEN), shells: shell, bin: BIN, waitSeconds: readWait(paths.stateDirectory) ?? undefined }));
+    console.log(renderSetup({ clients, mcpUrl, tokenFile, tokenFileExists: existsSync(tokenFile), tokenFromEnv: Boolean(process.env.BRIDGE_HTTP_TOKEN), shells: shell, bin: BIN, waitSeconds: readWait(paths.stateDirectory) ?? undefined }));
+}
+/** Shows exactly what would change in Codex's config.toml and writes it only after a yes (or --yes). */
+async function applyCodexSetup(target, mcpUrl, toolTimeout, yes) {
+    if (target === 'claude')
+        throw new Error('--apply edits Codex only. Claude Code is configured with the claude mcp add command printed by setup claude.');
+    const file = codexConfigPath();
+    const plan = planCodexConfig(await readCodexConfig(file), { mcpUrl, toolTimeoutSeconds: toolTimeout });
+    if (plan.action === 'refuse') {
+        console.error(`Not changed: ${plan.reason}. Edit ${file} by hand (see: ${BIN} setup codex).`);
+        process.exitCode = 1;
+        return;
+    }
+    if (plan.action === 'none') {
+        console.log(`Nothing to do: ${plan.reason} in ${file}.`);
+        return;
+    }
+    console.log(`File: ${file}`, `\nChange (${plan.action}):`, `\n  before: ${plan.before}`, `\n  after:  ${plan.after.split('\n').join('\n          ')}`);
+    console.log(`\nA tool timeout of ${toolTimeout} s lets one antigravity_task_wait call be held for as long as the web UI allows. If the bridge ever hangs, Codex waits that long before reporting an error.`);
+    if (!yes) {
+        if (!(process.stdin.isTTY && process.stdout.isTTY)) {
+            console.error('Not changed: this is not an interactive terminal. Run it in a terminal, or add --yes.');
+            process.exitCode = 1;
+            return;
+        }
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question('Apply this change? [y/N] ')).trim().toLowerCase();
+            if (answer !== 'y' && answer !== 'yes') {
+                console.log('Not changed.');
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const backup = await writeCodexConfig(file, plan);
+    console.log(backup ? `Done. Backup: ${backup}` : 'Done (file created).');
+    console.log('Restart Codex so it reads the new setting. The token variable still has to be set: see the first step of ' + `${BIN} setup codex.`);
+    if (target === 'both')
+        console.log('Claude Code was not edited; see: ' + `${BIN} setup claude.`);
 }
 async function workspaces(args) {
     const [action, target] = args;

package/dist/src/codex-config.js

@@ -0,0 +1,82 @@
+import { copyFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Edits Codex's config.toml for `setup codex --apply`. Deliberately narrow: it only touches the [mcp_servers.antigravity] table, changes only
+ * tool_timeout_sec when the table exists, appends a complete table when there is none, and refuses any layout it cannot read with certainty
+ * (the user then edits by hand). The caller shows the plan and asks before anything is written; a backup is made first.
+ */
+export const MIN_TOOL_TIMEOUT_SECONDS = 60;
+export const MAX_TOOL_TIMEOUT_SECONDS = 86400;
+/** Above the longest wait the web UI allows (60 minutes), so changing the wait there never needs this file again. */
+export const DEFAULT_TOOL_TIMEOUT_SECONDS = 3700;
+export const codexConfigPath = (env = process.env) => path.join(env.CODEX_HOME && env.CODEX_HOME.trim() ? env.CODEX_HOME : path.join(os.homedir(), '.codex'), 'config.toml');
+const HEADER = /^\s*\[mcp_servers\.antigravity\]\s*(#.*)?$/;
+const ANY_TABLE = /^\s*\[/;
+const TIMEOUT_LINE = /^\s*tool_timeout_sec\s*=/;
+export function planCodexConfig(existing, input) {
+    const value = input.toolTimeoutSeconds;
+    if (!Number.isInteger(value) || value < MIN_TOOL_TIMEOUT_SECONDS || value > MAX_TOOL_TIMEOUT_SECONDS) {
+        return { action: 'refuse', reason: `the tool timeout must be a whole number of seconds from ${MIN_TOOL_TIMEOUT_SECONDS} to ${MAX_TOOL_TIMEOUT_SECONDS}` };
+    }
+    const newline = existing !== null && existing.includes('\r\n') ? '\r\n' : '\n';
+    const line = `tool_timeout_sec = ${value}`;
+    const block = ['[mcp_servers.antigravity]', `url = '${input.mcpUrl.replace(/'/g, '')}'`, "bearer_token_env_var = 'BRIDGE_HTTP_TOKEN'", 'startup_timeout_sec = 30', line, 'enabled = true'];
+    if (existing === null)
+        return { action: 'create', text: block.join(newline) + newline, before: '(no file yet)', after: block.join(newline) };
+    const lines = existing.split(/\r?\n/);
+    const start = lines.findIndex(entry => HEADER.test(entry));
+    if (start === -1) {
+        if (/mcp_servers[\s\S]{0,40}antigravity/.test(existing))
+            return { action: 'refuse', reason: 'an antigravity entry exists in a form this command does not rewrite (inline table, dotted or quoted key)' };
+        const separator = existing.length === 0 || existing.endsWith('\n') ? (existing.length === 0 ? '' : newline) : newline + newline;
+        return { action: 'append', text: existing + separator + block.join(newline) + newline, before: '(no [mcp_servers.antigravity] table)', after: block.join(newline) };
+    }
+    if (lines.slice(start + 1).some(entry => HEADER.test(entry)))
+        return { action: 'refuse', reason: 'there is more than one [mcp_servers.antigravity] table; remove the extra one first' };
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++)
+        if (ANY_TABLE.test(lines[i])) {
+            end = i;
+            break;
+        }
+    const at = lines.slice(start + 1, end).findIndex(entry => TIMEOUT_LINE.test(entry));
+    if (at !== -1) {
+        const index = start + 1 + at;
+        if (lines[index].replace(/\s+#.*$/, '').trim() === line)
+            return { action: 'none', reason: `tool_timeout_sec is already ${value}` };
+        const before = lines[index].trim();
+        const next = lines.slice();
+        next[index] = line;
+        return { action: 'update', text: next.join(newline), before, after: line };
+    }
+    let insertAfter = end - 1;
+    while (insertAfter > start && lines[insertAfter].trim() === '')
+        insertAfter--;
+    const next = lines.slice();
+    next.splice(insertAfter + 1, 0, line);
+    return { action: 'update', text: next.join(newline), before: '(no tool_timeout_sec: Codex uses its 60 s default)', after: line };
+}
+/** Backs the file up, then replaces it atomically. Returns the backup path (null when there was no file). */
+export async function writeCodexConfig(file, plan, now = new Date()) {
+    await mkdir(path.dirname(file), { recursive: true });
+    let backup = null;
+    if (plan.action !== 'create') {
+        backup = `${file}.bak-${now.toISOString().replace(/[-:T]/g, '').slice(0, 14)}`;
+        await copyFile(file, backup);
+    }
+    await writeFile(`${file}.tmp`, plan.text);
+    await rename(`${file}.tmp`, file);
+    return backup;
+}
+export async function readCodexConfig(file) {
+    try {
+        return await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+//# sourceMappingURL=codex-config.js.map

package/dist/src/setup.js

@@ -25,7 +25,7 @@ export function renderSetup(input) {
     add('   An IDE or desktop app must be restarted from an environment that has this variable; setting it in another terminal does not reach an app that is already running.', '');
     let step = 2;
     if (input.clients.includes('codex')) {
-        add(`${step++}. Codex`, '   Either run:', `     codex mcp add antigravity --url ${posix(input.mcpUrl)} --bearer-token-env-var BRIDGE_HTTP_TOKEN`, '   or merge this block into ~/.codex/config.toml (or $CODEX_HOME/config.toml); replace an existing [mcp_servers.antigravity] entry instead of adding a second one:', '', '     [mcp_servers.antigravity]', `     url = '${input.mcpUrl}'`, "     bearer_token_env_var = 'BRIDGE_HTTP_TOKEN'", '     startup_timeout_sec = 30', `     tool_timeout_sec = ${clientToolTimeoutSeconds(input.waitSeconds ?? 55)}`, '     enabled = true', '', '   Check: codex mcp get antigravity   (then ask Codex to call antigravity_environment)', '');
+        add(`${step++}. Codex`, '   Either run:', `     codex mcp add antigravity --url ${posix(input.mcpUrl)} --bearer-token-env-var BRIDGE_HTTP_TOKEN`, '   or merge this block into ~/.codex/config.toml (or $CODEX_HOME/config.toml); replace an existing [mcp_servers.antigravity] entry instead of adding a second one:', '', '     [mcp_servers.antigravity]', `     url = '${input.mcpUrl}'`, "     bearer_token_env_var = 'BRIDGE_HTTP_TOKEN'", '     startup_timeout_sec = 30', `     tool_timeout_sec = ${clientToolTimeoutSeconds(input.waitSeconds ?? 55)}`, '     enabled = true', '', '   Check: codex mcp get antigravity   (then ask Codex to call antigravity_environment)', `   To only set the tool timeout (and add the entry when it is missing) without editing the file yourself: ${input.bin} setup codex --apply`, '');
     }
     if (input.clients.includes('claude')) {
         add(`${step++}. Claude Code`, '   Either run (single quotes keep ${BRIDGE_HTTP_TOKEN} unexpanded so the token is not stored in the config):');

package/dist/src/tasks/manager.js

@@ -515,6 +515,8 @@ export class TaskManager {
         }
         return this.get(id);
     }
+    /** How often a waiting client that asked for progress hears from the bridge. */
+    get progressIntervalMs() { return this.runtime.progressIntervalMs ?? 10000; }
     async wait(id) {
         const entry = this.entries.get(id);
         if (!entry)

package/dist/src/tools/register.js

@@ -13,8 +13,14 @@ function clientLabel(envelope) {
     return clean || null;
 }
 /** Said at the moment the client decides what to do next: while the task runs, waiting is the whole job (any other call costs tokens and repeats Antigravity's work). */
-export const WAITING_NOTE = 'Task still running. Do nothing else: no file reads, git, tests, logs or review of this change yourself, and write no message. Call antigravity_task_wait again now.';
-const withNextStep = (summary, activity = null) => summary.status === 'running' || summary.status === 'queued' ? { ...summary, ...(activity ? { activity } : {}), next_step: WAITING_NOTE } : summary;
+export const WAITING_NOTE = 'Still running. Do nothing else and write no message; call antigravity_task_wait again now.';
+/**
+ * A task that is still running is reported in a few fields only: the client reads this on every wait, so each field costs tokens many times over,
+ * and everything else (paths, byte counts, pid...) is in the web UI and in the full status once the task has ended.
+ */
+const withNextStep = (summary, activity = null) => summary.status === 'running' || summary.status === 'queued'
+    ? { task_id: summary.task_id, status: summary.status, duration_ms: summary.duration_ms, ...(activity ? { activity } : {}), next_step: WAITING_NOTE }
+    : summary;
 export function createServer(manager, environment) {
     const server = new McpServer({ name: 'antigravity-mcp-bridge', version: readPackageInfo().version });
     const response = (value) => ({ content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value });
@@ -41,8 +47,22 @@ export function createServer(manager, environment) {
     server.registerTool('antigravity_task_wait', {
         description: `Wait up to wait_seconds (1-${manager.maxWaitSeconds}, default ${manager.maxWaitSeconds}) for the task to finish, then return its status without logs. Returns early when the task ends; if still running, call again. Does not cancel the task.`,
         inputSchema: waitSchema, annotations: { readOnlyHint: true, openWorldHint: false }
-    }, async ({ task_id, wait_seconds }) => guard(async () => {
-        await manager.waitFor(task_id, manager.nextWaitSeconds(task_id, wait_seconds));
+    }, async ({ task_id, wait_seconds }, ctx) => guard(async () => {
+        // A client that sent a progress token gets a heartbeat while the wait is held. Clients that reset their tool timeout on progress can then
+        // wait far longer than tool_timeout_sec; clients that do not simply ignore it. Never sent without a token, and a failed send never fails the wait.
+        const token = ctx.mcpReq._meta?.progressToken;
+        let beats = 0;
+        const beat = token === undefined ? null : setInterval(() => {
+            beats += 1;
+            void ctx.mcpReq.notify({ method: 'notifications/progress', params: { progressToken: token, progress: beats, message: manager.activityNote(task_id) ?? 'Antigravity is still working' } }).catch(() => { });
+        }, manager.progressIntervalMs);
+        try {
+            await manager.waitFor(task_id, manager.nextWaitSeconds(task_id, wait_seconds));
+        }
+        finally {
+            if (beat)
+                clearInterval(beat);
+        }
         return withNextStep(manager.summary(task_id), manager.activityNote(task_id));
     }));
     server.registerTool('antigravity_task_output', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-mcp-bridge",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Local authenticated HTTP MCP bridge that lets Codex and Claude Code delegate bounded coding tasks to the Antigravity CLI (agy)",
   "license": "MIT",
   "keywords": [