@fxz26284407/yuanma-gateway 0.1.0 → 0.1.2

package/README.md

@@ -2,6 +2,42 @@
 
 远码的 Mac 本地网关与 HTTP/WS 公网密文中继。只包含两端网关，不包含鸿蒙工程、签名文件、个人文档库或运行数据。
 
+## 局域网直连（本地开发版本，尚未发布到 npm）
+
+本地代码已支持手机直接连接 Mac，无需启动 Relay。npm 已发布的 0.1.0 仍沿用原中继流程；使用直连需同时更新本地网关和鸿蒙 App，旧 App 不支持新的直连二维码。
+
+在本仓库使用 Node.js 22 构建后运行：
+
+```sh
+npm run build
+node bin/yuanma-gateway.mjs init
+node bin/yuanma-gateway.mjs pair
+```
+
+首次初始化的中继地址可以留空。单个常规内网 IPv4 自动选择，多个地址展示网卡与 IP 供选择；虚拟网卡需确认手机可达。默认端口为 `19089`，二维码地址为 `ws://所选内网IP:19089/v1/secure`。仅该加密入口对内网开放，本地管理接口继续使用 Unix socket。仍需准备与桌面共享的 Codex 后端及现有密钥保存模式。
+
+普通 start/restart 沿用已保存模式；pair 默认局域网，多个内网 IP 时交互选择，直接执行：
+
+```sh
+node bin/yuanma-gateway.mjs pair
+```
+
+非交互或需要指定网卡、端口时：
+
+```sh
+node bin/yuanma-gateway.mjs pair --lan-host 192.168.1.10 --lan-port 19089
+```
+
+将示例 IP 替换为本机实际内网地址。IP 失效时重新选择并扫码，端口冲突时更换端口；不要将手机的 localhost 当作 Mac。网关保存连接方式，后续启动复用；设备身份与授权保持原样。
+
+保留 Relay 扩展，切换时使用：
+
+```sh
+node bin/yuanma-gateway.mjs pair --relay-url wss://relay.example.com
+```
+
+局域网和 Relay 首版互斥，不会自动回退公网。以下中继安装与部署说明适用于已有发布版本及需要中继扩展的用户。
+
 ## 项目系列
 
 [远码 Yuanma · GitHub Project](https://github.com/users/fxz26284407/projects/2)
@@ -38,6 +74,14 @@
 - Codex 与 DeepSeek 共用下一步建议开关、预览及采用流程，各自使用自己的模型和额度。建议只填入可编辑草稿，不自动发送。
 - DeepSeek 建议复用 `/Applications/DeepSeek Harness.app` 内置 SDK 和既有登录，独立请求近期会话文本，不加载 Agent、会话持久化或工具。支持 `deepseek-account` 与 `deepseek-official` 路由；其他第三方提供方尚未适配。桌面 SDK 更新不兼容时，建议暂不可用，原会话仍走现有桌面 Host。
 
+## Antigravity 接入进度
+
+支持读取 Antigravity App 的已有工作区、会话、历史分页和全文。手机可切换第三个智能体，文件引用按 Markdown 标签展示。CLI 不可用时保留只读浏览。
+
+控制通道使用官方 Antigravity CLI 1.5.0 的 ACP，默认可执行文件为 `~/.local/bin/agy`；其他路径可在网关配置中设置 `antigravityCli`。目前已接线已有会话发送、实时进度、手机回合取消、原生审批／字符串问题回复、模型与思考档位、执行策略及图片输入。实际用户任务的发送、审批与取消闭环尚未完成验收；新建、引导、会话菜单、文档附件、扩展、Diff 和下一步建议未开放。
+
+进程重启后无法确认的发送会保留未知状态，不自动重发。当前只支持取消手机通过本网关发起的回合，尚不提供桌面独立回合的停止或审批接管，整体使用体验仍未与 Codex 对齐。历史与摘要单文件上限为 32 MiB，超限会明确提示。
+
 ## Mac 网关安装（npm）
 
 需要 **macOS、Node.js 22**，以及已登录、与桌面共用的 Codex app-server。当前适配固定为 app-server **0.166.0**；其他版本需要先适配协议。DeepSeek 功能另外依赖本机已有的 DeepSeek Harness 和登录。

package/bin/yuanma-gateway.mjs

@@ -9,8 +9,9 @@ import {parseArgs} from 'node:util';
 import {createInterface} from 'node:readline/promises';
 import {setTimeout as delay} from 'node:timers/promises';
 import {Rpc} from '../dist/rpc.mjs';
-import {relayEndpoint} from '../dist/relay.js';
-import {gatewayLaunch, restartGateway, gatewayStatus, stopGateway, openGatewayLog} from '../scripts/restart-local-gateway.mjs';
+import {lanAddresses, lanConfig, DEFAULT_LAN_PORT} from '../dist/lan.js';
+import {relayEndpoint} from '../dist/relay-client.js';
+import {connectionArgs, gatewayLaunch, restartGateway, gatewayStatus, stopGateway, openGatewayLog} from '../scripts/restart-local-gateway.mjs';
 
 process.umask(0o077);
 const root=fileURLToPath(new URL('../',import.meta.url));
@@ -22,7 +23,10 @@ const help=`远码网关（需要 Node.js 22 和与桌面共享的 Codex 后端
   yuanma-gateway init --config 原配置绝对路径 --state-dir 原状态目录绝对路径
   yuanma-gateway start [--relay-url wss://域名]
   yuanma-gateway restart [--relay-url wss://域名]
-  yuanma-gateway pair [--relay-url wss://域名]
+  yuanma-gateway pair（默认局域网，交互选择内网 IP）
+  yuanma-gateway pair --relay-url ws[s]://中继地址
+  局域网选项：--connection-mode lan [--lan-host 内网IP] [--lan-port 19089]
+  中继选项：--relay-url ws[s]://中继地址（start/restart 沿用原模式，pair 默认局域网）
   yuanma-gateway status | stop | projects | devices | security
   yuanma-gateway device-project-policy --device-id 设备ID --capability control
 默认配置与状态位于 ~/.local/share/yuanma/gateway/，npm 升级不会覆盖。
@@ -44,6 +48,7 @@ async function createJson(path,value){
 }
 function validateConfig(config){
  if(!Array.isArray(config.projects)||!config.projects.length||config.projects.some(p=>typeof p.id!=='string'||!p.id||!Array.isArray(p.roots)||!p.roots.length||p.roots.some(r=>typeof r!=='string'||!r.startsWith('/'))))throw Error('配置需要明确的项目 ID 和绝对根目录');
+ if(config.connectionMode!==undefined&&!['lan','relay'].includes(config.connectionMode))throw Error('配置中的连接模式无效');
  if(config.relayUrl!=null)relayEndpoint(config.relayUrl);
 }
 async function installation(values){
@@ -53,16 +58,46 @@ async function installation(values){
  if(typeof info.config!=='string'||!info.config.startsWith('/')||typeof info.stateDir!=='string'||!info.stateDir.startsWith('/'))throw Error('安装记录中的路径无效');
  const config=await privateJson(info.config);validateConfig(config);
  await lstat(info.stateDir);await privateDirectory(info.stateDir);
- if(info.relayUrl!==undefined)relayEndpoint(info.relayUrl);
+ if(info.relayUrl!=null)relayEndpoint(info.relayUrl);
  return {...info,configData:config};
 }
-async function rememberRelay(info,relayUrl){
+async function rememberConnection(info,connection){
  const current=await privateJson(settingsPath).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
- if(!current||current.config!==info.config||current.stateDir!==info.stateDir||current.relayUrl===relayUrl)return;
+ if(!current||current.config!==info.config||current.stateDir!==info.stateDir){
+  const config=await privateJson(info.config);
+  const temporary=join(dirname(info.config),'connection-'+randomUUID()+'.tmp');
+  try{await createJson(temporary,{...config,...connection,relayUrl:connection.connectionMode==='relay'?connection.relayUrl:null});await rename(temporary,info.config);}
+  finally{await unlink(temporary).catch(e=>{if(e.code!=='ENOENT')throw e;});}
+  return;
+ }
  const temporary=join(home,'installation-'+randomUUID()+'.tmp');
- try{await createJson(temporary,{...current,relayUrl});await rename(temporary,settingsPath);}
+ try{await createJson(temporary,{...current,...connection,relayUrl:connection.connectionMode==='relay'?connection.relayUrl:null});await rename(temporary,settingsPath);}
  finally{await unlink(temporary).catch(e=>{if(e.code!=='ENOENT')throw e;});}
 }
+async function selectConnection(values,saved={},choose=false){
+ if(values['relay-url']!==undefined&&values['connection-mode']==='lan')throw Error('--relay-url 与局域网模式冲突');
+ if(values['lan-host']!==undefined&&(values['relay-url']!==undefined||values['connection-mode']==='relay'))throw Error('--lan-host 与 Relay 模式冲突');
+ const mode=values['connection-mode']??(values['relay-url']!==undefined?'relay':values['lan-host']!==undefined?'lan':saved.connectionMode??(saved.relayUrl?'relay':'lan'));
+ if(mode==='relay')return {connectionMode:'relay',relayUrl:relayEndpoint(values['relay-url']??saved.relayUrl)};
+ if(mode!=='lan')throw Error('--connection-mode 只能是 lan 或 relay');
+ let host=values['lan-host']??saved.lanHost;
+ const addresses=lanAddresses();
+ if(values['lan-host']!==undefined)lanConfig(host,values['lan-port']??saved.lanPort??DEFAULT_LAN_PORT);
+ if(!addresses.some(a=>a.address===host)||(choose&&values['lan-host']===undefined&&new Set(addresses.map(a=>a.address)).size>1)){
+  if(host&&!addresses.some(a=>a.address===host))console.log('原局域网 IP 已不可用，请重新选择。');
+  const unique=addresses.filter((a,i)=>addresses.findIndex(b=>a.address===b.address)===i);
+  if(!unique.length)throw Error('未发现局域网 IPv4，请连接 Wi-Fi 或有线网络');
+  unique.forEach((a,i)=>console.log(`${i+1}. ${a.name}: ${a.address}${a.virtual?'（虚拟网卡/VPN，请确认手机可达）':''}`));
+  if(unique.length===1&&!unique[0].virtual)host=unique[0].address;
+  else{
+   if(!process.stdin.isTTY)throw Error('请显式提供 --lan-host 选择局域网 IP');
+   const prompt=createInterface({input:process.stdin,output:process.stdout});
+   try{const previous=unique.findIndex(a=>a.address===host)+1;const answer=(await prompt.question('选择手机可达的局域网 IP 序号'+(previous?'（回车沿用 '+previous+'）':'')+'：')).trim()||(previous?String(previous):'');const index=Number(answer);if(!/^\d+$/.test(answer)||index<1||index>unique.length)throw Error('网卡序号无效');host=unique[index-1].address;}finally{prompt.close();}
+  }
+ }
+ const lan=lanConfig(host,values['lan-port']??saved.lanPort??DEFAULT_LAN_PORT);
+ return {connectionMode:'lan',lanHost:lan.host,lanPort:lan.port,relayUrl:null};
+}
 async function catalog(socket){
  const rpc=new Rpc(socket,'yuanma_gateway_setup',{retainMessages:false});
  try{await rpc.initialize();const result=await rpc.call('project/list',{limit:100});return result.data;}finally{rpc.close();}
@@ -80,16 +115,18 @@ async function init(values){
   const active=await gatewayStatus(info.stateDir).catch(e=>{if(['ENOENT','ECONNREFUSED'].includes(e.code))return null;throw e;});
   if(active)await gatewayLaunch(info.stateDir);
   // ponytail: 原地登记既有目录，不复制正在使用的 SQLite 或身份文件。
-  await createJson(settingsPath,{config:info.config,stateDir:info.stateDir,...(active?.relayUrl||info.configData.relayUrl?{relayUrl:relayEndpoint(active?.relayUrl??info.configData.relayUrl)}:{})});
+  await createJson(settingsPath,{config:info.config,stateDir:info.stateDir,...(active?.connectionMode==='lan'?{connectionMode:'lan',lanHost:active.lanHost,lanPort:active.lanPort,relayUrl:null}:info.configData.connectionMode==='lan'?{connectionMode:'lan',lanHost:info.configData.lanHost,lanPort:info.configData.lanPort,relayUrl:null}:active?.relayUrl||info.configData.relayUrl?{relayUrl:relayEndpoint(active?.relayUrl??info.configData.relayUrl)}:{})});
   console.log('已沿用原配置、密钥、设备授权和消息账本；请保留原目录。');return;
  }
  const configPath=join(home,'config.json'),stateDir=join(home,'state');
  const saved=await privateJson(configPath).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
- if(saved){validateConfig(saved);await lstat(stateDir);await privateDirectory(stateDir);await createJson(settingsPath,{config:configPath,stateDir,...(saved.relayUrl?{relayUrl:relayEndpoint(saved.relayUrl)}:{})});console.log('已保留原配置并恢复安装记录。');return;}
+ if(saved){validateConfig(saved);await lstat(stateDir);await privateDirectory(stateDir);await createJson(settingsPath,{config:configPath,stateDir,...(saved.connectionMode==='lan'?{connectionMode:'lan',lanHost:saved.lanHost,lanPort:saved.lanPort,relayUrl:null}:saved.relayUrl?{relayUrl:relayEndpoint(saved.relayUrl)}:{})});console.log('已保留原配置并恢复安装记录。');return;}
  let prompt;
- const ask=async question=>{if(!process.stdin.isTTY)throw Error('非交互初始化需提供 --relay-url、--projects、--allow-development-keys 和 --accept-project-access');prompt??=createInterface({input:process.stdin,output:process.stdout});return prompt.question(question);};
+ const ask=async question=>{if(!process.stdin.isTTY)throw Error('非交互初始化需提供 --projects、--allow-development-keys 和 --accept-project-access；多网卡时还需 --lan-host');prompt??=createInterface({input:process.stdin,output:process.stdout});return prompt.question(question);};
  try{
-  const relay=relayEndpoint(values['relay-url']??await ask('中继地址（ws:// 或 wss://）：'));
+  const entered=values['relay-url']??(values['connection-mode']||values['lan-host']||!process.stdin.isTTY?'':await ask('中继地址（可留空使用局域网直连）：'));
+  prompt?.close();prompt=undefined;
+  const connection=await selectConnection({...values,...(entered.trim()?{'relay-url':entered.trim()}:{})});
   const socket=resolve(values['codex-socket']??join(homedir(),'.local/share/yuanma/shared/app-server.sock'));
   const projects=await catalog(socket);
   if(!Array.isArray(projects)||!projects.length)throw Error('共享 Codex 后端没有可选择的项目');
@@ -105,23 +142,23 @@ async function init(values){
   if(!allow)throw Error('未启用当前版本所需的密钥模式，未创建配置或网关身份');
   const accepted=values['accept-project-access']||(await ask('配对后所有发现的项目和工作区默认可执行，初始项目列表不是权限白名单。接受此策略？[y/N]：')).trim().toLowerCase()==='y';
   if(!accepted)throw Error('未接受现有项目访问策略，未创建配置或网关身份');
-  const config={codexSocket:socket,relayUrl:relay,allowDevelopmentKeys:true,projects:selected.map(p=>({id:p.id,...(p.name?{name:p.name}:{}),roots:p.roots}))};validateConfig(config);
+  const config={codexSocket:socket,...connection,allowDevelopmentKeys:true,projects:selected.map(p=>({id:p.id,...(p.name?{name:p.name}:{}),roots:p.roots}))};validateConfig(config);
   await privateDirectory(stateDir);
   await createJson(configPath,config);
-  await createJson(settingsPath,{config:configPath,stateDir,relayUrl:relay});
+  await createJson(settingsPath,{config:configPath,stateDir,...connection});
   console.log('初始化完成；配置：'+configPath+'\n状态：'+stateDir+'\n接下来运行 yuanma-gateway start 和 yuanma-gateway pair。');
  }finally{prompt?.close();}
 }
-async function start(info,relay){
- const value=relay??info.relayUrl??info.configData.relayUrl??undefined;
- const wanted=value===undefined?undefined:relayEndpoint(value);
+async function start(info,connection){
+ const flags=connectionArgs(connection);
+ const endpoint=connection.connectionMode==='relay'?relayEndpoint(connection.relayUrl):`ws://${connection.lanHost}:${connection.lanPort}/v1/secure`;
  const current=await gatewayStatus(info.stateDir).catch(e=>{if(['ENOENT','ECONNREFUSED'].includes(e.code))return null;throw e;});
- if(current){await gatewayLaunch(info.stateDir);if(wanted&&current.relayUrl!==wanted)return restartGateway(info.stateDir,wanted);if(!current.backendReady)throw Error('已有网关尚未就绪，请查看状态和日志');return current;}
+ if(current){await gatewayLaunch(info.stateDir);if((current.endpoint??current.relayUrl)!==endpoint||current.connectionMode!==connection.connectionMode)return restartGateway(info.stateDir,connection);if(!current.backendReady)throw Error('已有网关尚未就绪，请查看状态和日志');return current;}
  await privateDirectory(info.stateDir);
  const logPath=join(info.stateDir,'gateway.log');
  const log=await openGatewayLog(logPath);
  try{
-  const args=[cli,'start','--config',info.config,'--state-dir',info.stateDir];if(wanted)args.push('--relay-url',wanted);
+  const args=[cli,'start','--config',info.config,'--state-dir',info.stateDir];args.push(...flags);
   const child=spawn(process.execPath,args,{cwd:dirname(info.config),detached:true,stdio:['ignore',log.fd,log.fd]});child.unref();
   let error,exited=false;child.on('error',e=>{error=e;});child.on('exit',()=>{exited=true;});
   for(let n=0;n<150;n++){
@@ -129,7 +166,7 @@ async function start(info,relay){
    if(exited)throw Error('网关启动失败，请查看 '+logPath);
    const state=await gatewayStatus(info.stateDir).catch(e=>{if(['ENOENT','ECONNREFUSED'].includes(e.code))return null;throw e;});
    if(state?.processId&&state.processId!==child.pid)throw Error('另一实例取得了网关状态目录，未启动第二套身份');
-   if(state?.backendReady)return state;
+   if(state?.backendReady&&state.endpoint===endpoint&&state.connectionMode===connection.connectionMode)return state;
    await delay(100);
   }
   throw Error('启动尚未完成，请检查 yuanma-gateway status 和 '+logPath+'；不要重复初始化');
@@ -146,7 +183,7 @@ try{
  if(['help','--help','-h'].includes(action)||args.includes('--help'))console.log(help);
  else if(['--version','version'].includes(action))console.log(JSON.parse(await readFile(join(root,'package.json'),'utf8')).version);
  else{
-  const {values}=parseArgs({args,options:{config:{type:'string'},'state-dir':{type:'string'},'relay-url':{type:'string'},'codex-socket':{type:'string'},projects:{type:'string'},'allow-development-keys':{type:'boolean'},'accept-project-access':{type:'boolean'},backend:{type:'string'},'device-id':{type:'string'},capability:{type:'string'},'claim-id':{type:'string'},'grants-json':{type:'string'}}});
+  const {values}=parseArgs({args,options:{config:{type:'string'},'state-dir':{type:'string'},'relay-url':{type:'string'},'connection-mode':{type:'string'},'lan-host':{type:'string'},'lan-port':{type:'string'},'codex-socket':{type:'string'},projects:{type:'string'},'allow-development-keys':{type:'boolean'},'accept-project-access':{type:'boolean'},backend:{type:'string'},'device-id':{type:'string'},capability:{type:'string'},'claim-id':{type:'string'},'grants-json':{type:'string'}}});
   if(action==='init')await init(values);
   else if(action==='projects'){
    if(values.backend&&values.backend!=='codex')await run(cli,['projects','--backend',values.backend]);
@@ -154,15 +191,17 @@ try{
   }else if(['start','restart','stop','status','pair','devices','security','device-project-policy','pairing-pending','pairing-approve','pairing-reject','device-revoke'].includes(action)){
    const info=await installation(values);
    if(action==='start'||action==='restart'){
-    const state=action==='start'?await start(info,values['relay-url']):await restartGateway(info.stateDir,values['relay-url']??info.relayUrl);
-    if(state.relayUrl)await rememberRelay(info,state.relayUrl);
+    const connection=await selectConnection(values,{...info.configData,...info});
+    const state=action==='start'?await start(info,connection):await restartGateway(info.stateDir,connection);
+    await rememberConnection(info,connection);
     console.log(JSON.stringify(state,null,2));
    }
    else if(action==='stop'){await stopGateway(info.stateDir);console.log('网关已停止，配置和设备数据保留。');}
    else if(action==='status')console.log(JSON.stringify(await gatewayStatus(info.stateDir),null,2));
    else if(action==='pair'){
-    const state=await start(info,values['relay-url']);if(state.relayUrl)await rememberRelay(info,state.relayUrl);
-    await run(join(root,'scripts/pairing-qr.mjs'),['--state-dir',info.stateDir,'--auto-approve','--no-ui',...(values['relay-url']?['--relay-url',values['relay-url']]:[])]);
+    const connection=await selectConnection({...values,'connection-mode':values['connection-mode']??(values['relay-url']!==undefined?'relay':'lan')},{...info.configData,...info},process.stdin.isTTY);
+    await start(info,connection);await rememberConnection(info,connection);
+    await run(join(root,'scripts/pairing-qr.mjs'),['--state-dir',info.stateDir,'--auto-approve','--no-ui',...connectionArgs(connection)]);
    }else{
     const forwarded=[action,'--state-dir',info.stateDir];
     for(const key of ['backend','device-id','capability','claim-id','grants-json'])if(values[key]!==undefined)forwarded.push('--'+key,values[key]);

package/dist/agents.js

@@ -1,4 +1,4 @@
-export const AGENT_KINDS = ['codex', 'deepseek'];
+export const AGENT_KINDS = ['codex', 'deepseek', 'antigravity'];
 export const DEFAULT_AGENT = AGENT_KINDS[0];
 export function isAgentKind(value) {
     return AGENT_KINDS.some(kind => kind === value);

package/dist/antigravity-acp.js

@@ -0,0 +1,132 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+import { dirname, basename } from 'node:path';
+import { Fault, requireValue } from './domain.js';
+/** Official ACP stdio only. No desktop ports, cookies, or private service credentials. */
+export class AntigravityAcp extends EventEmitter {
+    executable;
+    dataRoot;
+    child;
+    pending = new Map();
+    starting;
+    buffer = '';
+    stopped = false;
+    ready = false;
+    constructor(executable, dataRoot) {
+        super();
+        this.executable = executable;
+        this.dataRoot = dataRoot;
+    }
+    async connect() {
+        requireValue(!this.stopped, 'BACKEND_UNAVAILABLE', 'Antigravity 连接已关闭', 503);
+        if (this.ready)
+            return;
+        if (!this.starting)
+            this.starting = this.start().finally(() => { this.starting = undefined; });
+        return this.starting;
+    }
+    async start() {
+        this.buffer = '';
+        const child = spawn(this.executable, ['acp', '--disable-telemetry', '--gemini-dir', dirname(this.dataRoot), '--app-data-dir', basename(this.dataRoot)], { stdio: ['pipe', 'pipe', 'pipe'] });
+        this.child = child;
+        child.stderr.on('data', () => { }); // Diagnostics can contain conversation text; do not forward them to logs.
+        child.once('error', () => this.disconnected(child));
+        child.once('close', () => this.disconnected(child));
+        child.stdin.on('error', () => this.disconnected(child));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            if (child !== this.child)
+                return;
+            this.buffer += chunk;
+            if (Buffer.byteLength(this.buffer) > 16 * 1024 * 1024) {
+                this.disconnected(child);
+                return;
+            }
+            let end;
+            while ((end = this.buffer.indexOf('\n')) >= 0) {
+                const line = this.buffer.slice(0, end);
+                this.buffer = this.buffer.slice(end + 1);
+                if (!line.trim())
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    this.disconnected(child);
+                    return;
+                }
+                if (message.jsonrpc !== '2.0') {
+                    this.disconnected(child);
+                    return;
+                }
+                if (message.id !== undefined && !message.method) {
+                    const entry = this.pending.get(String(message.id));
+                    if (!entry)
+                        continue;
+                    this.pending.delete(String(message.id));
+                    if (entry.timer)
+                        clearTimeout(entry.timer);
+                    if (message.error)
+                        entry.reject(Object.assign(new Error('Antigravity 请求未完成，需核对原生结果'), { rpcError: message.error }));
+                    else
+                        entry.resolve(message.result);
+                }
+                else if (typeof message.method === 'string') {
+                    this.emit(message.id === undefined ? 'notification' : 'request', message);
+                }
+            }
+        });
+        try {
+            const init = await this.call('initialize', { protocolVersion: 1, clientCapabilities: { elicitation: { form: {} } }, clientInfo: { name: 'yuanma_gateway', title: '远码', version: '0.1.0' } });
+            requireValue(init.protocolVersion === 1 && init.agentInfo?.name === 'Antigravity ACP Server' && init.agentInfo?.version === '1.5.0' && init.agentCapabilities?.loadSession, 'PROTOCOL_INCOMPATIBLE', '当前仅适配 Antigravity ACP 1.5.0，请核对 CLI 版本', 503);
+            this.ready = true;
+        }
+        catch (error) {
+            this.disconnected(child);
+            throw error;
+        }
+    }
+    disconnected(child) {
+        if (child !== this.child)
+            return;
+        this.child = undefined;
+        this.ready = false;
+        child.kill('SIGTERM');
+        for (const entry of this.pending.values()) {
+            if (entry.timer)
+                clearTimeout(entry.timer);
+            entry.reject(new Error('Antigravity 连接断开，执行结果可能未知'));
+        }
+        this.pending.clear();
+        this.emit('disconnected');
+    }
+    call(method, params, timeout = 30000, id = randomUUID()) {
+        return new Promise((resolve, reject) => {
+            const entry = { resolve, reject };
+            if (timeout)
+                entry.timer = setTimeout(() => { this.pending.delete(id); reject(new Error('Antigravity 请求超时，结果可能未知')); }, timeout);
+            this.pending.set(id, entry);
+            try {
+                this.write({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                if (entry.timer)
+                    clearTimeout(entry.timer);
+                reject(error);
+            }
+        });
+    }
+    notify(method, params) { this.write({ jsonrpc: '2.0', method, params }); }
+    reply(id, result) { this.write({ jsonrpc: '2.0', id, result }); }
+    reject(id, message = '当前客户端不支持此请求') { this.write({ jsonrpc: '2.0', id, error: { code: -32601, message } }); }
+    write(message) {
+        if (!this.child?.stdin.writable)
+            throw new Fault('BACKEND_UNAVAILABLE', '请安装并登录 Antigravity CLI 1.5.0', 503);
+        this.child.stdin.write(JSON.stringify(message) + '\n');
+    }
+    close() { this.stopped = true; if (this.child)
+        this.disconnected(this.child); this.removeAllListeners(); }
+}

package/dist/antigravity-conversation.js

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { requireValue } from './domain.js';
+export const fingerprint = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 16);
+const valueText = (value) => typeof value === 'string' ? value : value === undefined ? '' : JSON.stringify(value, null, 2);
+export function userText(step) {
+    const text = valueText(step.content);
+    // Strip only the observed whole envelope, never arbitrary user-authored tags.
+    const match = /^<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>(?:\s*<(ADDITIONAL_METADATA|USER_SETTINGS_CHANGE)>[\s\S]*?<\/\2>)*\s*$/.exec(text);
+    return match ? match[1] : text;
+}
+export function stepParts(step) {
+    const parts = [];
+    if (step.source === 'USER_EXPLICIT' && step.type === 'USER_INPUT') {
+        const text = userText(step);
+        if (text.trim() && !/^<USER_SETTINGS_CHANGE>[\s\S]*<\/USER_SETTINGS_CHANGE>$/.test(text.trim()))
+            parts.push({ part: 'content', role: 'user', text });
+    }
+    else if (step.source === 'MODEL' && step.type === 'PLANNER_RESPONSE') {
+        if (step.thinking)
+            parts.push({ part: 'thinking', role: 'tool', text: valueText(step.thinking), label: '思考记录' });
+        if (Array.isArray(step.tool_calls) && step.tool_calls.length)
+            parts.push({ part: 'tools', role: 'tool', text: valueText(step.tool_calls), label: '工具调用记录' });
+        if (step.content)
+            parts.push({ part: 'content', role: 'assistant', text: valueText(step.content) });
+    }
+    else if (step.source === 'MODEL' && step.type === 'GENERIC' && step.content) {
+        parts.push({ part: 'content', role: 'tool', text: valueText(step.content), label: '执行记录' });
+    }
+    return parts;
+}
+export function recordSteps(lines) {
+    const records = [];
+    let turnId = 'agy-context';
+    const latest = new Map();
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let step;
+        try {
+            step = JSON.parse(line);
+        }
+        catch {
+            throw new Error('Antigravity 历史格式损坏，请刷新后重试');
+        }
+        requireValue(Number.isSafeInteger(step.step_index) && step.step_index >= 0 && typeof step.type === 'string' && typeof step.source === 'string', 'PROTOCOL_INCOMPATIBLE', 'Antigravity 历史步骤格式已变化', 503);
+        latest.set(step.step_index, step);
+    }
+    // Native rewrites may append another version of an existing step.
+    for (const step of [...latest.values()].sort((a, b) => a.step_index - b.step_index)) {
+        if (step.source === 'USER_EXPLICIT' && step.type === 'USER_INPUT' && !/^<USER_SETTINGS_CHANGE>/.test(userText(step).trim()))
+            turnId = 'agy-turn-' + step.step_index;
+        records.push({ step, turnId });
+    }
+    return records;
+}
+export function partId(step, part) { return 'agy:' + step.step_index + ':' + fingerprint(step) + ':' + part; }
+export function conversationPage(records, nextCursor, fullReplies = new Map()) {
+    const turns = new Map();
+    for (const { step, turnId } of records)
+        for (const part of stepParts(step)) {
+            const fields = step.truncated_fields ?? [];
+            const id = partId(step, part.part), reply = part.role === 'assistant';
+            const text = fullReplies.get(id) ?? part.text;
+            const truncated = (!reply && text.length > 1000) || (fields.includes(part.part === 'tools' ? 'tool_calls' : part.part) && !fullReplies.has(id));
+            const item = { id, type: part.role === 'user' ? 'userMessage' : reply ? 'agentMessage' : 'commandExecution', role: part.role, text: reply ? text : text.slice(0, 1000), totalChars: text.length, truncated };
+            if (part.role === 'tool')
+                item.execution = { kind: part.part === 'thinking' ? 'reasoning' : 'tool', label: part.label, status: step.status === 'ERROR' ? 'failed' : 'unknown' };
+            if (!turns.has(turnId))
+                turns.set(turnId, { id: turnId, status: 'recorded', items: [] });
+            turns.get(turnId).items.push(item);
+        }
+    return { data: [...turns.values()].reverse(), nextCursor };
+}

package/dist/antigravity-native.js

@@ -0,0 +1,150 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { request } from 'node:https';
+import { readFile, stat } from 'node:fs/promises';
+import { Fault, requireValue } from './domain.js';
+const exec = promisify(execFile);
+const app = '/Applications/Antigravity.app/Contents/Resources/app';
+const binary = '/Applications/Antigravity.app/Contents/Resources/bin/language_server';
+/** Same-user desktop process only. Local CSRF credentials never leave this client. */
+export class AntigravityNative {
+    #authority;
+    #checked = 0;
+    ready = false;
+    get generation() { return this.#authority ? this.#authority.pid + ':' + this.#authority.port : ''; }
+    async connect() {
+        if (this.ready && Date.now() - this.#checked < 1000)
+            return;
+        requireValue(process.platform === 'darwin', 'BACKEND_UNAVAILABLE', 'Antigravity 桌面接入需要 macOS', 503);
+        const version = JSON.parse(await readFile(app + '/package.json', 'utf8')).version;
+        requireValue(version === '2.29.0', 'PROTOCOL_INCOMPATIBLE', '当前仅适配 Antigravity App 2.29.0，请核对桌面版本', 503);
+        const { stdout } = await exec('/bin/ps', ['-axo', 'uid,pid,ppid,command'], { maxBuffer: 4 * 1024 * 1024 });
+        const processes = stdout.split('\n').flatMap(line => {
+            const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.*)$/.exec(line);
+            if (!match || Number(match[1]) !== process.getuid?.() || !match[4].startsWith(binary + ' '))
+                return [];
+            const flag = (name) => new RegExp('--' + name + '(?:=|\\s+)([^\\s]+)').exec(match[4])?.[1];
+            if (flag('app_data_dir') !== 'antigravity' || flag('subclient_type') !== 'hub' || flag('override_ide_name') !== 'antigravity')
+                return [];
+            const token = flag('csrf_token');
+            return token ? [{ pid: Number(match[2]), token }] : [];
+        });
+        requireValue(processes.length === 1, 'BACKEND_UNAVAILABLE', '请打开唯一的 Antigravity App 桌面实例', 503);
+        const desktop = processes[0];
+        const { stdout: listeners } = await exec('/usr/sbin/lsof', ['-nP', '-a', '-p', String(desktop.pid), '-iTCP', '-sTCP:LISTEN', '-Fn'], { maxBuffer: 65536 });
+        const ports = [...new Set([...listeners.matchAll(/^n(?:127\.0\.0\.1|\*|\[::1\]):(\d+)$/gm)].map(m => Number(m[1])))];
+        requireValue(ports.length > 0 && ports.length <= 4, 'BACKEND_UNAVAILABLE', '无法核实 Antigravity 桌面监听地址', 503);
+        const executable = await stat(binary);
+        requireValue(executable.isFile() && !(executable.mode & 0o002), 'UNSAFE_STORAGE', 'Antigravity 可执行文件权限异常', 403);
+        let found;
+        for (const port of ports) {
+            const authority = { ...desktop, port };
+            try {
+                const value = await this.rpc(authority, 'GetAllCascadeTrajectories', { excludeSubtrajectories: true }, 5000);
+                if (value.trajectorySummaries && typeof value.trajectorySummaries === 'object') {
+                    found = authority;
+                    break;
+                }
+            }
+            catch { /* Only ports owned by the verified desktop process are considered. */ }
+        }
+        requireValue(found, 'BACKEND_UNAVAILABLE', 'Antigravity 桌面会话接口未就绪', 503);
+        this.#authority = found;
+        this.#checked = Date.now();
+        this.ready = true;
+    }
+    async call(method, params, timeout = 15000) {
+        await this.connect();
+        const authority = this.#authority;
+        try {
+            return await this.rpc(authority, method, params, timeout);
+        }
+        catch (error) {
+            this.ready = false;
+            this.#checked = 0;
+            throw error;
+        }
+    }
+    async state() {
+        await this.connect();
+        const authority = this.#authority;
+        return new Promise((resolve, reject) => {
+            const payload = Buffer.from('{}'), frame = Buffer.alloc(5 + payload.length);
+            frame.writeUInt32BE(payload.length, 1);
+            payload.copy(frame, 5);
+            const req = request({ hostname: '127.0.0.1', port: authority.port, path: '/exa.language_server_pb.LanguageServerService/JetboxSubscribeToState', method: 'POST', rejectUnauthorized: false, headers: { 'content-type': 'application/connect+json', 'connect-protocol-version': '1', 'x-codeium-csrf-token': authority.token } }, res => {
+                let buffer = Buffer.alloc(0);
+                res.on('data', (chunk) => {
+                    buffer = Buffer.concat([buffer, chunk]);
+                    if (buffer.length > 8 * 1024 * 1024) {
+                        req.destroy();
+                        reject(new Error('Antigravity 设置响应过大'));
+                        return;
+                    }
+                    if (buffer.length < 5)
+                        return;
+                    const length = buffer.readUInt32BE(1);
+                    if (buffer.length < 5 + length)
+                        return;
+                    try {
+                        const value = JSON.parse(buffer.subarray(5, 5 + length).toString());
+                        if (buffer[0] !== 0)
+                            throw new Error('设置流提前结束');
+                        resolve(value);
+                    }
+                    catch {
+                        reject(new Error('Antigravity 设置格式不兼容'));
+                    }
+                    finally {
+                        req.destroy();
+                    }
+                });
+                res.on('end', () => reject(new Error('Antigravity 设置流已关闭')));
+                res.on('error', () => reject(new Error('Antigravity 设置连接已中断')));
+                res.on('aborted', () => reject(new Error('Antigravity 设置连接已中断')));
+            });
+            req.on('error', () => reject(new Error('无法读取 Antigravity 桌面设置')));
+            req.setTimeout(10000, () => req.destroy(new Error('设置请求超时')));
+            req.end(frame);
+        });
+    }
+    rpc(authority, method, params, timeout) {
+        return new Promise((resolve, reject) => {
+            const payload = Buffer.from(JSON.stringify(params));
+            if (payload.length > 32 * 1024 * 1024) {
+                reject(new Fault('PAYLOAD_TOO_LARGE', 'Antigravity 输入超过接口容量限制', 413));
+                return;
+            }
+            // Match the desktop's trust policy only for the loopback port owned by its verified PID.
+            // Never disable TLS validation globally or forward this authorization to a remote host.
+            const req = request({ hostname: '127.0.0.1', port: authority.port, path: '/exa.language_server_pb.LanguageServerService/' + method, method: 'POST', rejectUnauthorized: false, headers: { 'content-type': 'application/json', 'connect-protocol-version': '1', 'content-length': payload.length, 'x-codeium-csrf-token': authority.token } }, res => {
+                let size = 0;
+                const chunks = [];
+                res.on('data', (chunk) => { size += chunk.length; if (size > 32 * 1024 * 1024) {
+                    req.destroy(new Error('Antigravity 返回内容超过容量限制'));
+                    return;
+                } chunks.push(chunk); });
+                res.on('error', () => reject(new Error('Antigravity 本地响应中断，结果可能未知')));
+                res.on('end', () => {
+                    let value;
+                    try {
+                        value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    }
+                    catch {
+                        reject(new Error('Antigravity 返回了不兼容的响应'));
+                        return;
+                    }
+                    if (res.statusCode !== 200) {
+                        reject(Object.assign(new Error('Antigravity 本地请求未完成，需核对原生状态'), { rpcError: { code: value.code, message: value.message } }));
+                        return;
+                    }
+                    resolve(value);
+                });
+            });
+            req.on('error', () => reject(new Error('Antigravity 桌面连接中断，结果可能未知')));
+            req.setTimeout(timeout, () => req.destroy(new Error('Antigravity 本地请求超时')));
+            req.end(payload);
+        });
+    }
+    close() { this.#authority = undefined; this.#checked = 0; this.ready = false; }
+}