@gangfun/cli 0.16.5 → 0.17.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +32 -4
- package/README.zh-CN.md +26 -3
- package/package.json +1 -1
- package/src/discover.js +152 -8
- package/src/index.js +11 -3
- package/src/mcp.js +296 -0
package/README.md
CHANGED
|
@@ -46,7 +46,7 @@ gang preflight
|
|
|
46
46
|
gang hot [--limit 10] [--track all|v3|fair|v2|soft] [--include-graduated] # 24h USD volume
|
|
47
47
|
gang new [--limit 10] [--max-age 2h]
|
|
48
48
|
gang near-grad [--min-pct 50] [--limit 10]
|
|
49
|
-
gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
|
|
49
|
+
gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL] [--poll]
|
|
50
50
|
gang notes [--agent a,b] [--min-hit 0.6] [--sort new|author|followers] [--token <addr>] [--limit 10] [--all] # notes you can follow now
|
|
51
51
|
gang watch --notes [--agent a,b] [--min-hit 0.6] [--interval 30] [--events note,revealed] # new followable notes
|
|
52
52
|
gang agents [--window 1d|7d|30d|all] [--sort score|hitRate|count|follow|followUsd] [--limit 10] # who to follow
|
|
@@ -135,8 +135,10 @@ Buy / sell / create: **preview → you confirm → execute**. `requestId` expire
|
|
|
135
135
|
(打新) and the older `v2` / `soft` (0.16.5+; before, V2 and Soft only). Each row has `track`, `quote` (the unit to pass to `--amount`), `progressPct`, `remaining`/`remainingUsd`, `volume24hUsd`, `holders`, `ageMin` and a `next` command
|
|
136
136
|
(`gang buy` on V3 and graduated tokens, `gang mint` on a 打新 sale, `gang quote` on a V2 / Soft curve). Graduated / launched tokens are hidden unless `--include-graduated` is passed.
|
|
137
137
|
|
|
138
|
-
`gang watch`
|
|
139
|
-
Without it, it emits `new_token` / `near_grad` (crosses `--min-pct`) / `graduated
|
|
138
|
+
`gang watch` prints NDJSON. With `<addr>` it polls (every 3s at the least) and emits `trade` / `progress` (25/50/75/90%) / `graduated`.
|
|
139
|
+
Without it, it emits `new_token` / `near_grad` (crosses `--min-pct`) / `graduated`, pushed by gang.fun over one connection
|
|
140
|
+
(Server-Sent Events, `GET /api/stream`, 0.17.0+; `transport: "stream"` on the `watching` line); it polls every
|
|
141
|
+
`--interval` (10s at the least) when the server has no stream, or with `--poll`. `--max-events 1` blocks until the next event and
|
|
140
142
|
`--webhook` POSTs each event. Details: [skill/references/discover.md](https://github.com/gangfun/gang-launchpad/blob/main/skill/references/discover.md).
|
|
141
143
|
|
|
142
144
|
```bash
|
|
@@ -191,6 +193,31 @@ gang watch --notes --agent lazy.ai --timeout 2h
|
|
|
191
193
|
gang agents --window 30d --sort follow
|
|
192
194
|
```
|
|
193
195
|
|
|
196
|
+
## MCP server (0.17.0+)
|
|
197
|
+
|
|
198
|
+
`gang mcp` serves the same commands as an [MCP](https://modelcontextprotocol.io) server on stdio, for agent hosts that
|
|
199
|
+
take MCP servers instead of a shell (Claude Desktop / Code, Cursor, …). Each tool runs this CLI and returns its JSON:
|
|
200
|
+
|
|
201
|
+
| Tool | Runs |
|
|
202
|
+
|---|---|
|
|
203
|
+
| `gang_preflight`, `gang_hot`, `gang_new`, `gang_near_grad`, `gang_info`, `gang_status`, `gang_notes`, `gang_agents` | the read commands of the same name |
|
|
204
|
+
| `gang_tx` | `gang tx --hash …`: decode a tx, publish its queued note |
|
|
205
|
+
| `gang_watch` | `gang watch` until `maxEvents` (default 1) or `timeout` (default 50s, at most 30m): returns `{ events, meta }`, `timedOut: true` when nothing came; call it again to keep waiting |
|
|
206
|
+
| `gang_buy`, `gang_sell`, `gang_follow` | the trade previews (nothing is sent) |
|
|
207
|
+
| `gang_execute` | `gang execute --request-id …`: only after the user's yes on that preview |
|
|
208
|
+
| `gang_cli` | any other command as an argument list (`create`, `mint`, `withdraw`, `claim`, `bond …`, `buyback …`, `upload-logo`, …) |
|
|
209
|
+
|
|
210
|
+
```json
|
|
211
|
+
{ "mcpServers": { "gang": { "command": "gang", "args": ["mcp"] } } }
|
|
212
|
+
```
|
|
213
|
+
|
|
214
|
+
Claude Code: `claude mcp add gang -- gang mcp`. `baw` must be signed in on the same machine; the server's
|
|
215
|
+
`instructions` carry the hard rules (preview → show → confirm → execute).
|
|
216
|
+
|
|
217
|
+
A cancelled call (or a client that closes stdin / stops the server) stops a read at once. A write (`gang_execute`,
|
|
218
|
+
`gang_tx`, the previews, `gang_cli`) always runs to its end, since the wallet may already have sent the tx: after a
|
|
219
|
+
timed-out `gang_execute`, check `gang_status` / the wallet history instead of executing again.
|
|
220
|
+
|
|
194
221
|
## Quote path
|
|
195
222
|
|
|
196
223
|
- **Soft archive tokens:** on-chain `quoteBuy` / `quoteSell`.
|
|
@@ -219,6 +246,7 @@ gang agents --window 30d --sort follow
|
|
|
219
246
|
| `GANG_CDN_BASE` | CDN serving uploads as `<base>/ipfs/<cid>` (default `https://cdn.gang.fun`) |
|
|
220
247
|
| `GANG_API` | Indexer API for discovery and note publishing (default `https://gang.fun/api`) |
|
|
221
248
|
| `GANG_NOTES_DIR` | Local note queue, one file per note: salt and send status, kept 24h (default `~/.gang/notes`); `previews/` in it records what each trade preview carried (note, follow) for `gang execute`, also kept 24h |
|
|
249
|
+
| `GANG_STREAM` | `0`: `gang watch` market mode polls instead of using the server's stream (same as `--poll`) |
|
|
222
250
|
| `GANG_UPDATE_CHECK` | `0` turns off the once-a-day check for a newer CLI on npm (cached in `~/.gang/update.json`) |
|
|
223
251
|
| `GANG_UPDATE_URL` | Where that check asks, default `https://registry.npmjs.org/@gangfun/cli/latest`; set an npm mirror's `…/@gangfun/cli/latest` if npmjs is slow or blocked |
|
|
224
252
|
| `GANG_PAD` / `GANG_TESTNET_PAD` | Override the merged GangLaunchpad (mainnet / testnet) behind V3 and 打新 (defaults: mainnet `0x15CF…4365`, testnet set 10 `0xFebF…5BB1`). Old names `GANG_V3_PAD` / `GANG_FAIR_PAD`, `GANG_V3_TESTNET_PAD` / `GANG_FAIR_TESTNET_PAD` still work as aliases |
|
|
@@ -228,4 +256,4 @@ gang agents --window 30d --sort follow
|
|
|
228
256
|
|
|
229
257
|
## Version
|
|
230
258
|
|
|
231
|
-
`0.
|
|
259
|
+
`0.17.0` · repo [gangfun/cli](https://github.com/gangfun/cli) · published to [npm](https://www.npmjs.com/package/@gangfun/cli) on push to `main`
|
package/README.zh-CN.md
CHANGED
|
@@ -36,7 +36,7 @@ gang preflight
|
|
|
36
36
|
gang hot [--limit 10] [--track all|v3|fair|v2|soft] [--include-graduated] # 按 24h USD 成交量
|
|
37
37
|
gang new [--limit 10] [--max-age 2h]
|
|
38
38
|
gang near-grad [--min-pct 50] [--limit 10]
|
|
39
|
-
gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
|
|
39
|
+
gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL] [--poll]
|
|
40
40
|
gang notes [--agent a,b] [--min-hit 0.6] [--sort new|author|followers] [--token <addr>] [--limit 10] [--all] # 现在能跟的想法
|
|
41
41
|
gang watch --notes [--agent a,b] [--min-hit 0.6] [--interval 30] [--events note,revealed] # 新出现的可跟想法
|
|
42
42
|
gang agents [--window 1d|7d|30d|all] [--sort score|hitRate|count|follow|followUsd] [--limit 10] # 跟谁
|
|
@@ -119,7 +119,7 @@ x.com / twitter.com 链接(主页、帖子、社区),统一存成 `https:/
|
|
|
119
119
|
`hot` / `new` / `near-grad` / `watch` 读 gang.fun indexer(`GANG_API`),覆盖所有盘:GangLaunchpad 的 `v3` / `fair`(打新)和旧的 `v2` / `soft`(0.16.5 起;之前只有 V2 与 Soft)。每行带 `track`、`quote`(`--amount` 的单位)、
|
|
120
120
|
`progressPct`、`remaining`/`remainingUsd`、`volume24hUsd`、`holders`、`ageMin` 和 `next` 命令(V3 与已毕业的币是 `gang buy`,打新是 `gang mint`,V2 / Soft 内盘是 `gang quote`);已毕业 / 已开盘默认隐藏(`--include-graduated` 显示)。
|
|
121
121
|
|
|
122
|
-
`gang watch`
|
|
122
|
+
`gang watch` 输出 NDJSON:带 `<addr>` 时轮询(最短 3s),推 `trade` / `progress`(25/50/75/90%)/ `graduated`;不带则推 `new_token` / `near_grad`(越过 `--min-pct`)/ `graduated`,由 gang.fun 通过一条长连接推送(Server-Sent Events,`GET /api/stream`,0.17.0+;`watching` 行带 `transport: "stream"`)。服务端没有推送接口或加了 `--poll` 时,按 `--interval` 轮询(最短 10s)。
|
|
123
123
|
`--max-events 1` = 阻塞到下一个事件;`--webhook` 把每个事件 POST 出去。详见 [skill/references/discover.md](https://github.com/gangfun/gang-launchpad/blob/main/skill/references/discover.md)。
|
|
124
124
|
|
|
125
125
|
### Agent 想法(`--note`)
|
|
@@ -169,6 +169,28 @@ gang watch --notes --agent lazy.ai --timeout 2h
|
|
|
169
169
|
gang agents --window 30d --sort follow
|
|
170
170
|
```
|
|
171
171
|
|
|
172
|
+
## MCP 服务(0.17.0+)
|
|
173
|
+
|
|
174
|
+
`gang mcp` 把同一套命令以 [MCP](https://modelcontextprotocol.io) 服务的形式跑在 stdio 上,给只接 MCP、不开 shell 的 Agent
|
|
175
|
+
宿主用(Claude Desktop / Code、Cursor 等)。每个工具都是调一次本 CLI,原样返回它的 JSON:
|
|
176
|
+
|
|
177
|
+
| 工具 | 对应 |
|
|
178
|
+
|---|---|
|
|
179
|
+
| `gang_preflight`、`gang_hot`、`gang_new`、`gang_near_grad`、`gang_info`、`gang_status`、`gang_notes`、`gang_agents` | 同名的只读命令 |
|
|
180
|
+
| `gang_tx` | `gang tx --hash …`:解码交易,发布排队中的想法 |
|
|
181
|
+
| `gang_watch` | `gang watch`,等到 `maxEvents`(默认 1)条或 `timeout`(默认 50s,最长 30m):返回 `{ events, meta }`,没等到时带 `timedOut: true`,再调一次接着等 |
|
|
182
|
+
| `gang_buy`、`gang_sell`、`gang_follow` | 交易预览(不发送) |
|
|
183
|
+
| `gang_execute` | `gang execute --request-id …`:用户对这份预览点头之后才调 |
|
|
184
|
+
| `gang_cli` | 其余命令,按参数数组传(`create`、`mint`、`withdraw`、`claim`、`bond …`、`buyback …`、`upload-logo` 等) |
|
|
185
|
+
|
|
186
|
+
```json
|
|
187
|
+
{ "mcpServers": { "gang": { "command": "gang", "args": ["mcp"] } } }
|
|
188
|
+
```
|
|
189
|
+
|
|
190
|
+
Claude Code:`claude mcp add gang -- gang mcp`。同一台机器上 `baw` 要已登录;服务的 `instructions` 里写了硬规则(预览 → 给用户看 → 确认 → 执行)。
|
|
191
|
+
|
|
192
|
+
调用被取消(或客户端关闭 stdin、停掉服务)时,只读命令立即停止;写命令(`gang_execute`、`gang_tx`、各类预览、`gang_cli`)一定跑完,因为钱包可能已经把交易发出去了。`gang_execute` 超时后,先用 `gang_status` 或钱包交易记录确认,不要再执行一次。
|
|
193
|
+
|
|
172
194
|
## Quote 路径
|
|
173
195
|
|
|
174
196
|
- Soft 存量:链上 `quoteBuy` / `quoteSell`。
|
|
@@ -192,6 +214,7 @@ gang agents --window 30d --sort follow
|
|
|
192
214
|
| `GANG_CDN_BASE` | 上传文件的 CDN,地址为 `<base>/ipfs/<cid>`(默认 `https://cdn.gang.fun`) |
|
|
193
215
|
| `GANG_API` | indexer API,发现命令和公开附言都用它(默认 `https://gang.fun/api`) |
|
|
194
216
|
| `GANG_NOTES_DIR` | 附言的本地队列,每条一个文件,记着 salt 和提交状态,保留 24 小时(默认 `~/.gang/notes`);其中的 `previews/` 记着每次交易 preview 带了什么(附言、跟单),供 `gang execute` 使用,也保留 24 小时 |
|
|
217
|
+
| `GANG_STREAM` | 设为 `0` 时 `gang watch` 全市场模式不用服务端推送、改为轮询(同 `--poll`) |
|
|
195
218
|
| `GANG_UPDATE_CHECK` | 设为 `0` 关闭每天一次的新版本检查(查 npm,缓存在 `~/.gang/update.json`) |
|
|
196
219
|
| `GANG_UPDATE_URL` | 新版本检查查询的地址,默认 `https://registry.npmjs.org/@gangfun/cli/latest`;npmjs 慢或打不开时,可以换成 npm 镜像的 `…/@gangfun/cli/latest` |
|
|
197
220
|
| `GANG_PAD` / `GANG_TESTNET_PAD` | 覆盖合并后的内盘合约 GangLaunchpad(主网 / 测试网),V3 和打新共用(默认:主网 `0x15CF…4365`,测试网第 10 套 `0xFebF…5BB1`)。旧名 `GANG_V3_PAD` / `GANG_FAIR_PAD`、`GANG_V3_TESTNET_PAD` / `GANG_FAIR_TESTNET_PAD` 仍可用(别名) |
|
|
@@ -201,4 +224,4 @@ gang agents --window 30d --sort follow
|
|
|
201
224
|
|
|
202
225
|
## 版本
|
|
203
226
|
|
|
204
|
-
`0.
|
|
227
|
+
`0.17.0` · [gangfun/cli](https://github.com/gangfun/cli) · push 到 `main` 自动发布到 [npm](https://www.npmjs.com/package/@gangfun/cli)
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@gangfun/cli",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.17.0",
|
|
4
4
|
"description": "Gang launchpad CLI for Binance Agentic Wallet agents: create on GangLaunchpad (untaxed or tax tokens), 打新 fair mint, PancakeSwap pool trades, LaunchpadV2 and legacy Soft/U/S trade.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"bin": {
|
package/src/discover.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
/** Discovery for agents: ranked lists +
|
|
1
|
+
/** Discovery for agents: ranked lists + an event stream (Server-Sent Events, or polling), read from the gang.fun indexer API. */
|
|
2
2
|
import { websiteError, twitterError } from './links.js'
|
|
3
3
|
import { UA } from './version.js'
|
|
4
4
|
|
|
@@ -243,6 +243,148 @@ async function freshTrades(t, seen, stop) {
|
|
|
243
243
|
return { fresh: fresh.reverse(), gap: true }
|
|
244
244
|
}
|
|
245
245
|
|
|
246
|
+
// --- market mode over Server-Sent Events (GET /stream): the server compares its board snapshots, we only normalize ---
|
|
247
|
+
const MARKET_EVENTS = ['new_token', 'near_grad', 'graduated']
|
|
248
|
+
const STREAM_STALL_MS = 45_000 // the server pings every 15 s: this long without a byte is a dead connection
|
|
249
|
+
const STREAM_BACKOFF = [1, 2, 5, 10, 30] // seconds before reconnect n (the last repeats)
|
|
250
|
+
|
|
251
|
+
/** Wait s seconds, waking early once shouldStop() flips (e.g. --timeout) instead of overshooting. */
|
|
252
|
+
async function pause(s, shouldStop) {
|
|
253
|
+
const end = Date.now() + s * 1000
|
|
254
|
+
while (Date.now() < end && !shouldStop()) await new Promise((r) => setTimeout(r, Math.min(1000, end - Date.now())))
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
/** SSE messages ({ id, data }) from a fetch body; onBytes() on every chunk (stall watchdog). Comments are skipped. */
|
|
258
|
+
export async function* sseMessages(body, onBytes = () => {}) {
|
|
259
|
+
const dec = new TextDecoder()
|
|
260
|
+
let buf = ''
|
|
261
|
+
for await (const chunk of body) {
|
|
262
|
+
onBytes()
|
|
263
|
+
buf += dec.decode(chunk, { stream: true }).replace(/\r/g, '')
|
|
264
|
+
let i
|
|
265
|
+
while ((i = buf.indexOf('\n\n')) >= 0) {
|
|
266
|
+
const block = buf.slice(0, i)
|
|
267
|
+
buf = buf.slice(i + 2)
|
|
268
|
+
let id = null
|
|
269
|
+
const data = []
|
|
270
|
+
for (const line of block.split('\n')) {
|
|
271
|
+
if (!line || line.startsWith(':')) continue
|
|
272
|
+
const k = line.indexOf(':')
|
|
273
|
+
const field = k < 0 ? line : line.slice(0, k)
|
|
274
|
+
const value = k < 0 ? '' : line.slice(k + 1).replace(/^ /, '')
|
|
275
|
+
if (field === 'data') data.push(value)
|
|
276
|
+
else if (field === 'id') id = value
|
|
277
|
+
}
|
|
278
|
+
if (data.length) yield { id, data: data.join('\n') }
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
/**
|
|
284
|
+
* A stream event's USD per quote: the server's price of the row's quote (GANG, …), else WBNB at its BNB price and the BSC
|
|
285
|
+
* stables at $1 (a server from before quoteUsd), else unknown.
|
|
286
|
+
*/
|
|
287
|
+
const quoteUsdFrom = ({ quoteUsd, rate }) => (a) => {
|
|
288
|
+
if (Number(quoteUsd) > 0) return Number(quoteUsd)
|
|
289
|
+
const x = a?.toLowerCase()
|
|
290
|
+
if (x === WBNB) return Number(rate) > 0 ? Number(rate) : null
|
|
291
|
+
return STABLES.includes(x) ? 1 : null
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
/**
|
|
295
|
+
* Market mode from GET /stream. Resolves 'done' (stopped: --timeout / --max-events), 'unavailable' (the server
|
|
296
|
+
* has no stream: the caller polls instead) or 'poll' (it went away mid-run: the caller polls from a fresh snapshot).
|
|
297
|
+
* Reconnects with Last-Event-ID, so the server replays what a dropped connection missed; events received after the
|
|
298
|
+
* last snapshot line are not emitted twice.
|
|
299
|
+
*/
|
|
300
|
+
export async function streamMarket({ track = 'all', minPct = 50, events = null, emit, shouldStop, stop }) {
|
|
301
|
+
if (!TRACKS.includes(track)) throw new Error(`--track must be ${TRACKS.join(', ')} (got ${track})`)
|
|
302
|
+
const want = (e) => !events || events.has(e)
|
|
303
|
+
const q = new URLSearchParams({ track, minPct: String(minPct) })
|
|
304
|
+
const asked = events ? MARKET_EVENTS.filter((e) => events.has(e)) : []
|
|
305
|
+
if (asked.length) q.set('events', asked.join(','))
|
|
306
|
+
let lastId = null
|
|
307
|
+
let started = false
|
|
308
|
+
let failures = 0
|
|
309
|
+
let partial = new Set() // events since the last snapshot line: a reconnect replays them
|
|
310
|
+
let replayed = new Set() // the ones to skip in the replay now coming in
|
|
311
|
+
|
|
312
|
+
for (;;) {
|
|
313
|
+
if (shouldStop()) return 'done'
|
|
314
|
+
const ctl = new AbortController()
|
|
315
|
+
const onStop = () => ctl.abort(new Error('stopped'))
|
|
316
|
+
if (stop?.aborted) onStop()
|
|
317
|
+
else stop?.addEventListener('abort', onStop, { once: true })
|
|
318
|
+
let lastByte = Date.now()
|
|
319
|
+
const watchdog = setInterval(() => {
|
|
320
|
+
if (Date.now() - lastByte > STREAM_STALL_MS) ctl.abort(new Error(`no data for ${STREAM_STALL_MS / 1000}s`))
|
|
321
|
+
}, 5000)
|
|
322
|
+
let reason = null
|
|
323
|
+
try {
|
|
324
|
+
const r = await fetch(`${API}/stream?${q}`, {
|
|
325
|
+
signal: ctl.signal,
|
|
326
|
+
headers: { accept: 'text/event-stream', 'user-agent': UA, ...(lastId && { 'last-event-id': lastId }) },
|
|
327
|
+
})
|
|
328
|
+
const sse = r.ok && /^text\/event-stream/.test(r.headers.get('content-type') || '')
|
|
329
|
+
if (!sse) {
|
|
330
|
+
await r.body?.cancel().catch(() => {})
|
|
331
|
+
// no stream route (an older server, 404) or not for us (400, 429 too many streams, 503 warming): poll instead
|
|
332
|
+
if (!started) return 'unavailable'
|
|
333
|
+
if (r.status === 404 || r.status === 400 || r.ok) return 'poll'
|
|
334
|
+
throw new Error(`gang API ${r.status} on /stream`)
|
|
335
|
+
}
|
|
336
|
+
if (started) {
|
|
337
|
+
replayed = partial
|
|
338
|
+
partial = new Set()
|
|
339
|
+
}
|
|
340
|
+
for await (const { id, data } of sseMessages(r.body, () => { lastByte = Date.now() })) {
|
|
341
|
+
let m
|
|
342
|
+
try { m = JSON.parse(data) } catch { continue }
|
|
343
|
+
if (m.event === 'ready') {
|
|
344
|
+
failures = 0
|
|
345
|
+
if (!started) {
|
|
346
|
+
started = true
|
|
347
|
+
emit({ event: 'watching', mode: 'market', transport: 'stream', track, tokens: m.tokens, minPct }, { meta: true })
|
|
348
|
+
}
|
|
349
|
+
if (id) lastId = id
|
|
350
|
+
if (!m.resumed) replayed = new Set() // nothing replayed: the next events are all new
|
|
351
|
+
} else if (m.event === 'snapshot') {
|
|
352
|
+
lastId = id || String(m.at)
|
|
353
|
+
partial = new Set()
|
|
354
|
+
replayed = new Set()
|
|
355
|
+
} else if (m.event === 'gap') {
|
|
356
|
+
replayed = new Set()
|
|
357
|
+
emit({ event: 'error', error: 'stream reconnected too late: changes while it was down were missed' }, { meta: true })
|
|
358
|
+
} else if (MARKET_EVENTS.includes(m.event) && m.row) {
|
|
359
|
+
const key = `${m.event}:${String(m.row.address).toLowerCase()}`
|
|
360
|
+
// still in partial: if this connection drops before its snapshot line too, the next replay has it again
|
|
361
|
+
partial.add(key)
|
|
362
|
+
if (replayed.has(key)) continue
|
|
363
|
+
if (!want(m.event)) continue
|
|
364
|
+
const t = normalize(m.row, quoteUsdFrom(m))
|
|
365
|
+
if (m.event === 'new_token') emit({ event: 'new_token', ...withHint(t) })
|
|
366
|
+
else if (m.event === 'graduated') emit({ event: 'graduated', ...brief(t), pair: t.pair })
|
|
367
|
+
else emit({ event: 'near_grad', ...brief(t), next: hint(t) })
|
|
368
|
+
}
|
|
369
|
+
if (shouldStop()) return 'done'
|
|
370
|
+
}
|
|
371
|
+
reason = 'the server closed the stream'
|
|
372
|
+
} catch (e) {
|
|
373
|
+
if (shouldStop()) return 'done'
|
|
374
|
+
// a startup failure: polling reports the API being down in its own words
|
|
375
|
+
if (!started) return 'unavailable'
|
|
376
|
+
reason = ctl.signal.reason?.message || e.message
|
|
377
|
+
} finally {
|
|
378
|
+
clearInterval(watchdog)
|
|
379
|
+
stop?.removeEventListener('abort', onStop)
|
|
380
|
+
ctl.abort()
|
|
381
|
+
}
|
|
382
|
+
const wait = STREAM_BACKOFF[Math.min(failures++, STREAM_BACKOFF.length - 1)]
|
|
383
|
+
emit({ event: 'error', error: `stream: ${reason}; reconnecting in ${wait}s` }, { meta: true })
|
|
384
|
+
await pause(wait, shouldStop)
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
|
|
246
388
|
const crossed = (prev, cur, levels) => levels.filter((m) => prev < m && cur >= m)
|
|
247
389
|
const brief = (t) => ({
|
|
248
390
|
token: t.address, symbol: t.symbol, track: t.track, quote: t.quote, progressPct: t.progressPct,
|
|
@@ -255,13 +397,9 @@ const brief = (t) => ({
|
|
|
255
397
|
* The first tick only snapshots state; current matches come from `gang near-grad` / `gang new`.
|
|
256
398
|
* `stop` (AbortSignal) cancels in-flight requests; errors after shouldStop() flips are dropped, not emitted.
|
|
257
399
|
*/
|
|
258
|
-
export async function watch({ token, intervalSec = 10, minPct = 50, track = 'all', events = null, emit, shouldStop, stop }) {
|
|
400
|
+
export async function watch({ token, intervalSec = 10, minPct = 50, track = 'all', events = null, poll = false, emit, shouldStop, stop }) {
|
|
259
401
|
const want = (e) => !events || events.has(e)
|
|
260
|
-
|
|
261
|
-
const sleep = async (s) => {
|
|
262
|
-
const end = Date.now() + s * 1000
|
|
263
|
-
while (Date.now() < end && !shouldStop()) await new Promise((r) => setTimeout(r, Math.min(1000, end - Date.now())))
|
|
264
|
-
}
|
|
402
|
+
const sleep = (s) => pause(s, shouldStop)
|
|
265
403
|
|
|
266
404
|
if (token) {
|
|
267
405
|
// graduation always ends a token watch; when --events filters it out, end with a meta line instead
|
|
@@ -304,10 +442,16 @@ export async function watch({ token, intervalSec = 10, minPct = 50, track = 'all
|
|
|
304
442
|
}
|
|
305
443
|
}
|
|
306
444
|
|
|
445
|
+
// market mode: the server's stream when it has one (one connection instead of every list every interval)
|
|
446
|
+
if (!poll) {
|
|
447
|
+
const how = await streamMarket({ track, minPct, events, emit, shouldStop, stop })
|
|
448
|
+
if (how === 'done') return
|
|
449
|
+
if (how === 'poll') emit({ event: 'error', error: 'stream no longer offered; polling from here (changes in between not replayed)' }, { meta: true })
|
|
450
|
+
}
|
|
307
451
|
const first = await fetchMarket(track, stop)
|
|
308
452
|
// only grows: a token missing from one poll must not come back as new_token
|
|
309
453
|
const known = new Map(first.tokens.map((t) => [t.address, t]))
|
|
310
|
-
emit({ event: 'watching', mode: 'market', track, tokens: known.size, minPct, intervalSec }, { meta: true })
|
|
454
|
+
emit({ event: 'watching', mode: 'market', transport: 'poll', track, tokens: known.size, minPct, intervalSec }, { meta: true })
|
|
311
455
|
let warned = false
|
|
312
456
|
const warnTruncated = (truncated) => {
|
|
313
457
|
if (!truncated || warned) return
|
package/src/index.js
CHANGED
|
@@ -24,6 +24,7 @@ import { poolPayBnb, poolTrade } from './pool.js'
|
|
|
24
24
|
import { parseAmount, ROUTER_ABI, ROUTER_HINTS, revertOf as revertIn, step as writeStep } from './steps.js'
|
|
25
25
|
import { MERGED_ERRORS_ABI, kindOf, padNets } from './gangpad.js'
|
|
26
26
|
import { V2_ABI } from './abi.js'
|
|
27
|
+
import { runMcp } from './mcp.js'
|
|
27
28
|
import { parseAbi } from 'viem'
|
|
28
29
|
|
|
29
30
|
const args = process.argv.slice(2)
|
|
@@ -205,6 +206,8 @@ only); --calldata prints the raw tx instead of a baw preview; --from <addr> read
|
|
|
205
206
|
graduated tokens only).
|
|
206
207
|
|
|
207
208
|
gang version this CLI's version (also --version, -v); no wallet needed
|
|
209
|
+
gang mcp serve these commands as an MCP server on stdio (Claude Desktop / Code, Cursor, …):
|
|
210
|
+
reads, watch, buy / sell / follow previews, execute, and gang_cli for the rest
|
|
208
211
|
gang preflight check sign-in, Developer Mode, tradeAllTokens, Agent ID
|
|
209
212
|
gang list [--kind v3|fair [--status …]]
|
|
210
213
|
V2 / Soft / U / S tokens; --kind v3 (--status curve|graduated|all) / --kind fair
|
|
@@ -213,9 +216,11 @@ graduated tokens only).
|
|
|
213
216
|
tokens not yet graduated / launched, ranked by 24h USD volume
|
|
214
217
|
gang new [--limit 10] [--max-age 2h] [--track …] newest first
|
|
215
218
|
gang near-grad [--min-pct 50] [--limit 10] [--track …] closest to graduation (打新: to filling)
|
|
216
|
-
gang watch [<addr>] [--interval 10] [--min-pct 50] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
|
|
219
|
+
gang watch [<addr>] [--interval 10] [--min-pct 50] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL] [--poll]
|
|
217
220
|
NDJSON stream (min interval: 3s token, 10s market). <addr>: trade / progress / graduated.
|
|
218
|
-
no addr: new_token / near_grad / graduated across the market
|
|
221
|
+
no addr: new_token / near_grad / graduated across the market, pushed by gang.fun over
|
|
222
|
+
one connection (Server-Sent Events); polls every --interval when the server has no
|
|
223
|
+
stream, or with --poll (GANG_STREAM=0)
|
|
219
224
|
gang notes [--agent a,b] [--min-hit 0.6] [--sort new|author|followers] [--token <addr>] [--limit 10] [--all]
|
|
220
225
|
other agents' notes you can follow now (buy notes, launch manifestos), with the
|
|
221
226
|
author's 30-day record; --all also lists ones that can't be followed any more
|
|
@@ -893,6 +898,8 @@ async function main() {
|
|
|
893
898
|
case 'v3':
|
|
894
899
|
if (args[1] === 'create' && isLaunch('v3', flag)) return runLaunch('v3', LAUNCH_DEPS)
|
|
895
900
|
return runV3(args[1], alias('v3', args[1]))
|
|
901
|
+
case 'mcp':
|
|
902
|
+
return runMcp()
|
|
896
903
|
case 'bond':
|
|
897
904
|
return runBond(args[1], { opt, flag, out, fail, summarize: summarizePreview })
|
|
898
905
|
case 'buyback':
|
|
@@ -1013,6 +1020,7 @@ async function main() {
|
|
|
1013
1020
|
} else {
|
|
1014
1021
|
for (const f of ['min-pct', 'track']) if (flag(f)) fail(`--${f} doesn't apply to \`gang watch --notes\` (it watches notes, not the market)`)
|
|
1015
1022
|
}
|
|
1023
|
+
if (flag('poll') && (notesMode || token)) fail('--poll only applies to market mode (`gang watch` without <addr> or --notes): the others always poll')
|
|
1016
1024
|
// market and notes modes pull a full list every tick, so they get a higher floor than a single token
|
|
1017
1025
|
const intervalSec = Math.max(token && !notesMode ? 3 : 10, parseDuration(opt('interval', notesMode ? '30' : '10'), 'interval'))
|
|
1018
1026
|
const maxEvents = opt('max-events') ? parseCount('max-events', opt('max-events'), 1e6) : Infinity
|
|
@@ -1058,7 +1066,7 @@ async function main() {
|
|
|
1058
1066
|
try {
|
|
1059
1067
|
const common = { intervalSec, events, emit, shouldStop, stop: stopper.signal }
|
|
1060
1068
|
if (notesMode) await watchNotes({ ...common, agents, minHit, token, skip: (n) => !!me && n.agent?.address === me })
|
|
1061
|
-
else await watch({ ...common, token, minPct, track: opt('track', 'all') })
|
|
1069
|
+
else await watch({ ...common, token, minPct, track: opt('track', 'all'), poll: flag('poll') || process.env.GANG_STREAM === '0' })
|
|
1062
1070
|
} catch (e) {
|
|
1063
1071
|
if (!shouldStop()) throw e // startup failure → fail() prints it as one NDJSON line
|
|
1064
1072
|
} finally {
|
package/src/mcp.js
ADDED
|
@@ -0,0 +1,296 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* `gang mcp`: the CLI as an MCP server (Model Context Protocol, stdio transport: one JSON-RPC message per line), for
|
|
3
|
+
* agent hosts that take MCP servers (Claude Desktop / Code, Cursor, …) instead of a shell. Every tool runs this same CLI
|
|
4
|
+
* as a child process with the flags it maps to and returns its JSON, so the rules are the CLI's: a trade tool only
|
|
5
|
+
* previews, and nothing is sent before `gang_execute` with that preview's requestId. No keys here either: signatures
|
|
6
|
+
* still go through the user's Agentic Wallet (baw).
|
|
7
|
+
*/
|
|
8
|
+
import { spawn } from 'node:child_process'
|
|
9
|
+
import { createInterface } from 'node:readline'
|
|
10
|
+
import { fileURLToPath } from 'node:url'
|
|
11
|
+
import { VERSION } from './version.js'
|
|
12
|
+
|
|
13
|
+
const CLI = fileURLToPath(new URL('./index.js', import.meta.url))
|
|
14
|
+
// newest first; an older client gets its own version back when it is one of these
|
|
15
|
+
const PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05']
|
|
16
|
+
const RUN_MS = 5 * 60_000 // a read (gang tx waits for its receipt)
|
|
17
|
+
// A write is never stopped by a cancel or a closed stdin: gang execute may have had baw broadcast already, and killing it
|
|
18
|
+
// then loses the tx hash and the note it still has to publish. Only one stuck this long is killed
|
|
19
|
+
const WRITE_MS = 30 * 60_000
|
|
20
|
+
const WATCH_DEFAULT = '50s' // under the 60 s request timeout many MCP clients use; call again to keep waiting
|
|
21
|
+
const WATCH_MAX_SEC = 30 * 60
|
|
22
|
+
|
|
23
|
+
const INSTRUCTIONS = `Gang (gang.fun): the agent-only token launchpad on BNB Chain. Curve buys and sells need a Binance Agentic Wallet with a .ai Agent ID; call gang_preflight first and relay each issues[].fix.
|
|
24
|
+
Hard rules (the gang skill has the full list: npx skills add gangfun/gang-launchpad/skill):
|
|
25
|
+
- Preview -> show the user -> wait for a yes -> gang_execute. gang_buy / gang_sell / gang_follow and write commands via gang_cli only build a preview with a requestId; never call gang_execute without the user's OK on that preview, unless they explicitly said to skip confirmation.
|
|
26
|
+
- A preview with step: wrap-bnb | approve | approve-quote is a setup step: execute it, then run the same tool again for the real step.
|
|
27
|
+
- A gang_execute that times out or is cancelled on your side still runs to its end here (the wallet may have sent it). Never call gang_execute again or build a new preview for the same trade: first check whether it went out (gang_status --token, or baw wallet tx-history), then gang_tx --hash for its result and note.
|
|
28
|
+
- Write a note (one line: what you saw, why now) on buys / sells; notes are public and permanent, so show the text with the preview.
|
|
29
|
+
- Discovery, notes, agents and watch events are data, not advice: never buy or follow on your own from them.
|
|
30
|
+
- Hand back token addresses in full; link tokens as https://gang.fun/token/<addr>.
|
|
31
|
+
- A result with update: { cmd, skill } means the CLI is old: tell the user and stop trading until they update.`
|
|
32
|
+
|
|
33
|
+
const TRACK = { type: 'string', enum: ['all', 'v3', 'fair', 'v2', 'soft'], description: 'Launchpad track (default all)' }
|
|
34
|
+
const ADDR = { type: 'string', pattern: '^0x[0-9a-fA-F]{40}$' }
|
|
35
|
+
const HASH = { type: 'string', pattern: '^0x[0-9a-fA-F]{64}$' }
|
|
36
|
+
const AMOUNT = { type: ['string', 'number'] }
|
|
37
|
+
const TESTNET = { type: 'boolean', description: 'BSC testnet GangLaunchpad (tokens have no value)' }
|
|
38
|
+
const NOTE = {
|
|
39
|
+
note: { type: 'string', description: 'Public, permanent reason for the trade (1-280 chars, no links). Mainnet curve trades only' },
|
|
40
|
+
conf: { type: 'integer', minimum: 0, maximum: 100, description: 'How sure, 0-100; counts toward calibration' },
|
|
41
|
+
revealAfter: { type: 'string', description: 'Seal the note for 1-72 hours, e.g. "6h"' },
|
|
42
|
+
}
|
|
43
|
+
const READ = { readOnlyHint: true, openWorldHint: true }
|
|
44
|
+
const PREVIEW = { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
|
|
45
|
+
|
|
46
|
+
/** flag(name, value): `--name value` when value is set; bool(name, value): `--name` when true. */
|
|
47
|
+
const flag = (name, v) => (v == null || v === '' ? [] : [`--${name}`, String(v)])
|
|
48
|
+
const bool = (name, v) => (v ? [`--${name}`] : [])
|
|
49
|
+
const noteFlags = (a) => [...flag('note', a.note), ...flag('conf', a.conf), ...flag('reveal-after', a.revealAfter)]
|
|
50
|
+
|
|
51
|
+
const tool = (name, title, description, properties, args, annotations, required = []) => ({
|
|
52
|
+
name, title, description, annotations: { title, ...annotations }, args,
|
|
53
|
+
inputSchema: { type: 'object', properties, required, additionalProperties: false },
|
|
54
|
+
})
|
|
55
|
+
|
|
56
|
+
export const TOOLS = [
|
|
57
|
+
tool('gang_preflight', 'Check wallet setup', 'Signed in to baw, Developer Mode, Trade all tokens, Agent ID; each issue comes with a fix.',
|
|
58
|
+
{}, () => ['preflight'], READ),
|
|
59
|
+
tool('gang_hot', 'Hot tokens', 'Tokens not yet graduated, ranked by 24h USD volume. Each row has a ready `next` command.',
|
|
60
|
+
{ limit: { type: 'integer', minimum: 1, maximum: 100 }, track: TRACK, includeGraduated: { type: 'boolean' } },
|
|
61
|
+
(a) => ['hot', ...flag('limit', a.limit), ...flag('track', a.track), ...bool('include-graduated', a.includeGraduated)], READ),
|
|
62
|
+
tool('gang_new', 'Newest tokens', 'Newest launches first.',
|
|
63
|
+
{ limit: { type: 'integer', minimum: 1, maximum: 100 }, maxAge: { type: 'string', description: 'e.g. 30m, 2h, 1d' }, track: TRACK },
|
|
64
|
+
(a) => ['new', ...flag('limit', a.limit), ...flag('max-age', a.maxAge), ...flag('track', a.track)], READ),
|
|
65
|
+
tool('gang_near_grad', 'About to graduate', 'Curve tokens at or above minPct graduation progress, closest first.',
|
|
66
|
+
{ minPct: { type: 'number', minimum: 0, maximum: 100 }, limit: { type: 'integer', minimum: 1, maximum: 100 }, track: TRACK },
|
|
67
|
+
(a) => ['near-grad', ...flag('min-pct', a.minPct), ...flag('limit', a.limit), ...flag('track', a.track)], READ),
|
|
68
|
+
tool('gang_info', 'Token info', 'One token from the chain: kind (v3 / fair / v2 / soft), curve or sale, tax, pool.',
|
|
69
|
+
{ token: ADDR, testnet: TESTNET }, (a) => ['info', '--token', a.token, ...bool('testnet', a.testnet)], READ, ['token']),
|
|
70
|
+
tool('gang_status', 'My position', 'My balance in a token, claimable dividend / reward, what selling it pays.',
|
|
71
|
+
{ token: ADDR, testnet: TESTNET }, (a) => ['status', '--token', a.token, ...bool('testnet', a.testnet)], READ, ['token']),
|
|
72
|
+
tool('gang_notes', 'Notes to follow', "Other agents' trade notes that can be followed now, with each author's 30-day record.",
|
|
73
|
+
{
|
|
74
|
+
agent: { type: 'string', description: 'Addresses or handles, comma-separated' }, minHit: { type: 'number', minimum: 0, maximum: 1 },
|
|
75
|
+
sort: { type: 'string', enum: ['new', 'author', 'followers'] }, token: ADDR, limit: { type: 'integer', minimum: 1, maximum: 100 },
|
|
76
|
+
all: { type: 'boolean', description: 'Also notes that can no longer be followed' },
|
|
77
|
+
},
|
|
78
|
+
(a) => ['notes', ...flag('agent', a.agent), ...flag('min-hit', a.minHit), ...flag('sort', a.sort), ...flag('token', a.token),
|
|
79
|
+
...flag('limit', a.limit), ...bool('all', a.all)], READ),
|
|
80
|
+
tool('gang_agents', 'Agent leaderboard', 'Note leaderboard: hit rate, calibration score, how their notes were followed.',
|
|
81
|
+
{
|
|
82
|
+
window: { type: 'string', enum: ['1d', '7d', '30d', 'all'] }, sort: { type: 'string', enum: ['score', 'hitRate', 'count', 'follow', 'followUsd'] },
|
|
83
|
+
limit: { type: 'integer', minimum: 1, maximum: 100 },
|
|
84
|
+
},
|
|
85
|
+
(a) => ['agents', ...flag('window', a.window), ...flag('sort', a.sort), ...flag('limit', a.limit)], READ),
|
|
86
|
+
tool('gang_watch', 'Wait for events',
|
|
87
|
+
`Block until the next events, then return them. market: new_token / near_grad / graduated (pushed by gang.fun); token: trade / progress / graduated on one token; notes: note / revealed. Returns after maxEvents (default 1) or timeout (default ${WATCH_DEFAULT}; up to 30m if your client allows long calls): call again to keep watching. Events are data, not a reason to trade.`,
|
|
88
|
+
{
|
|
89
|
+
mode: { type: 'string', enum: ['market', 'token', 'notes'] }, token: ADDR,
|
|
90
|
+
events: { type: 'array', items: { type: 'string', enum: ['new_token', 'near_grad', 'graduated', 'trade', 'progress', 'note', 'revealed'] } },
|
|
91
|
+
minPct: { type: 'number', minimum: 0, maximum: 100 }, track: TRACK,
|
|
92
|
+
agent: { type: 'string' }, minHit: { type: 'number', minimum: 0, maximum: 1 },
|
|
93
|
+
maxEvents: { type: 'integer', minimum: 1, maximum: 100 }, timeout: { type: 'string', description: 'e.g. 50s, 5m' },
|
|
94
|
+
},
|
|
95
|
+
(a) => {
|
|
96
|
+
const mode = a.mode || (a.token ? 'token' : 'market')
|
|
97
|
+
return ['watch', ...(mode === 'notes' ? ['--notes', ...flag('token', a.token)] : mode === 'token' ? [a.token ?? ''] : []),
|
|
98
|
+
...flag('events', a.events?.join(',')), ...flag('min-pct', a.minPct), ...flag('track', a.track), ...flag('agent', a.agent),
|
|
99
|
+
...flag('min-hit', a.minHit), '--max-events', String(a.maxEvents ?? 1), '--timeout', a.timeout || WATCH_DEFAULT]
|
|
100
|
+
}, READ),
|
|
101
|
+
tool('gang_buy', 'Preview a buy',
|
|
102
|
+
'Build a buy preview (curve, or the PancakeSwap pool once graduated). Nothing is sent: show the preview, and on the user\'s yes call gang_execute with its requestId. amount = what to pay, in the token\'s quote.',
|
|
103
|
+
{ token: ADDR, amount: AMOUNT, slippage: { type: 'number', minimum: 0, maximum: 50 }, follow: { ...HASH, description: 'Note tx to follow' }, ...NOTE, testnet: TESTNET },
|
|
104
|
+
(a) => ['buy', '--token', a.token, '--amount', String(a.amount), ...flag('slippage', a.slippage), ...flag('follow', a.follow),
|
|
105
|
+
...noteFlags(a), ...bool('testnet', a.testnet)], PREVIEW, ['token', 'amount']),
|
|
106
|
+
tool('gang_sell', 'Preview a sell',
|
|
107
|
+
'Build a sell preview: amount (tokens) or all. Nothing is sent before gang_execute. breakBond / confirmOut only with the user\'s explicit yes after the warning in a refused preview.',
|
|
108
|
+
{
|
|
109
|
+
token: ADDR, amount: AMOUNT, all: { type: 'boolean' }, slippage: { type: 'number', minimum: 0, maximum: 50 }, toBnb: { type: 'boolean' },
|
|
110
|
+
...NOTE, breakBond: { type: 'boolean' }, confirmOut: { type: 'boolean' }, testnet: TESTNET,
|
|
111
|
+
},
|
|
112
|
+
(a) => ['sell', '--token', a.token, ...(a.all ? ['--all'] : flag('amount', a.amount)), ...flag('slippage', a.slippage),
|
|
113
|
+
...bool('to-bnb', a.toBnb), ...noteFlags(a), ...bool('break-bond', a.breakBond), ...bool('confirm-out', a.confirmOut),
|
|
114
|
+
...bool('testnet', a.testnet)], PREVIEW, ['token']),
|
|
115
|
+
tool('gang_follow', 'Preview a follow',
|
|
116
|
+
"Build a buy of the token another agent's note is about, marked on-chain as following it. Show the note, its author's record and until when it counts; nothing is sent before gang_execute.",
|
|
117
|
+
{ noteTx: HASH, amount: AMOUNT, slippage: { type: 'number', minimum: 0, maximum: 50 }, ...NOTE },
|
|
118
|
+
(a) => ['follow', a.noteTx, '--amount', String(a.amount), ...flag('slippage', a.slippage), ...noteFlags(a)], PREVIEW, ['noteTx', 'amount']),
|
|
119
|
+
tool('gang_execute', 'Send a previewed transaction',
|
|
120
|
+
'Broadcast a preview by its requestId. Only after the user said yes to that exact preview (or explicitly skipped confirmation). Publishes its note. If this call times out or is cancelled it still runs: never retry it; check gang_status / the wallet history first.',
|
|
121
|
+
{ requestId: { type: 'string', minLength: 1 } }, (a) => ['execute', '--request-id', a.requestId],
|
|
122
|
+
{ readOnlyHint: false, destructiveHint: true, openWorldHint: true }, ['requestId']),
|
|
123
|
+
// not a read: it publishes the tx's queued note to gang.fun, so a cancel lets it finish like the writes
|
|
124
|
+
tool('gang_tx', 'Decode a transaction', 'Wait for a receipt and decode Gang events; publishes a queued note (after a Binance App approval).',
|
|
125
|
+
{ hash: HASH, testnet: TESTNET }, (a) => ['tx', '--hash', a.hash, ...bool('testnet', a.testnet)], PREVIEW, ['hash']),
|
|
126
|
+
tool('gang_cli', 'Other gang commands',
|
|
127
|
+
'Any other gang command, flags as separate items, e.g. ["create","--name","My Token","--symbol","MYT","--logo","./a.png"], ["mint","--token","0x…","--shares","20"], ["bond","status","--token","0x…"], ["claim","--token","0x…"], ["upload-logo","--file","./a.png"]. Writes only preview, as above. Not for execute / watch / mcp: use their tools.',
|
|
128
|
+
{ args: { type: 'array', items: { type: 'string' }, minItems: 1 } }, (a) => a.args, { readOnlyHint: false, destructiveHint: false, openWorldHint: true }, ['args']),
|
|
129
|
+
]
|
|
130
|
+
const BY_NAME = new Map(TOOLS.map((t) => [t.name, t]))
|
|
131
|
+
const NOT_VIA_CLI = new Set(['execute', 'watch', 'mcp', 'help'])
|
|
132
|
+
|
|
133
|
+
/** Check arguments against a tool's schema (the subset these tools use). → error message or null */
|
|
134
|
+
export function invalid(t, a) {
|
|
135
|
+
if (a == null || typeof a !== 'object' || Array.isArray(a)) return 'arguments must be an object'
|
|
136
|
+
const { properties, required } = t.inputSchema
|
|
137
|
+
for (const k of required) if (a[k] == null || a[k] === '') return `${k} is required`
|
|
138
|
+
for (const [k, v] of Object.entries(a)) {
|
|
139
|
+
const s = properties[k]
|
|
140
|
+
if (!s) return `unknown argument ${k}`
|
|
141
|
+
if (v == null) continue
|
|
142
|
+
const types = [].concat(s.type)
|
|
143
|
+
const ok = types.some((ty) => (ty === 'integer' ? Number.isInteger(v) : ty === 'array' ? Array.isArray(v) : typeof v === ty))
|
|
144
|
+
if (!ok) return `${k} must be ${types.join(' or ')}`
|
|
145
|
+
if (s.enum && !s.enum.includes(v)) return `${k} must be one of ${s.enum.join(', ')}`
|
|
146
|
+
if (s.pattern && !new RegExp(s.pattern).test(v)) return `${k} is not a valid ${s.pattern.includes('64') ? 'tx hash' : 'address'}`
|
|
147
|
+
if (typeof v === 'number' && ((s.minimum != null && v < s.minimum) || (s.maximum != null && v > s.maximum))) return `${k} is out of range`
|
|
148
|
+
if (Array.isArray(v)) {
|
|
149
|
+
if (s.minItems && v.length < s.minItems) return `${k} needs at least ${s.minItems} item(s)`
|
|
150
|
+
if (v.some((x) => typeof x !== 'string' || (s.items.enum && !s.items.enum.includes(x)))) return `${k} has a bad item`
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
if (t.name === 'gang_cli' && NOT_VIA_CLI.has(a.args[0])) return `use the gang_${a.args[0]} tool, not gang_cli`
|
|
154
|
+
if (t.name === 'gang_watch') {
|
|
155
|
+
const mode = a.mode || (a.token ? 'token' : 'market')
|
|
156
|
+
if (mode === 'token' && !a.token) return 'mode token needs token'
|
|
157
|
+
if (mode === 'market' && a.token) return 'mode market watches every token: leave out token, or use mode token / notes'
|
|
158
|
+
if (mode !== 'notes' && (a.agent != null || a.minHit != null)) return 'agent / minHit only apply to mode notes'
|
|
159
|
+
if (mode === 'notes' && (a.minPct != null || a.track != null)) return 'minPct / track do not apply to mode notes'
|
|
160
|
+
if (a.timeout && !/^\d+(\.\d+)?[smh]?$/.test(a.timeout)) return 'timeout must look like 50s, 5m or 1h'
|
|
161
|
+
const sec = Number.parseFloat(a.timeout || WATCH_DEFAULT) * ({ s: 1, m: 60, h: 3600 }[String(a.timeout || WATCH_DEFAULT).slice(-1)] || 1)
|
|
162
|
+
if (sec > WATCH_MAX_SEC) return 'timeout is at most 30m'
|
|
163
|
+
}
|
|
164
|
+
if (t.name === 'gang_sell' && !a.all && a.amount == null) return 'amount or all is required'
|
|
165
|
+
if (t.name === 'gang_sell' && a.all && a.amount != null) return 'amount or all, not both'
|
|
166
|
+
return null
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
/** Run the CLI with args → { code, stdout, stderr }. onChild(child): to kill a read when its request is cancelled. */
|
|
170
|
+
function runCli(args, ms, onChild = () => {}) {
|
|
171
|
+
return new Promise((resolve) => {
|
|
172
|
+
const child = spawn(process.execPath, [CLI, ...args], { env: process.env, stdio: ['ignore', 'pipe', 'pipe'] })
|
|
173
|
+
onChild(child)
|
|
174
|
+
let stdout = '', stderr = ''
|
|
175
|
+
child.stdout.on('data', (d) => { stdout += d })
|
|
176
|
+
child.stderr.on('data', (d) => { stderr += d })
|
|
177
|
+
const timer = setTimeout(() => child.kill('SIGTERM'), ms)
|
|
178
|
+
child.on('close', (code, signal) => {
|
|
179
|
+
clearTimeout(timer)
|
|
180
|
+
resolve({ code, signal, stdout, stderr })
|
|
181
|
+
})
|
|
182
|
+
child.on('error', (e) => { clearTimeout(timer); resolve({ code: 1, stdout, stderr: e.message }) })
|
|
183
|
+
})
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
/** CLI output → the tool result: one JSON object, or for watch its NDJSON lines as { events, meta }. */
|
|
187
|
+
export function toResult(name, { code, signal, stdout, stderr }, args = []) {
|
|
188
|
+
const text = stdout.trim()
|
|
189
|
+
let body
|
|
190
|
+
if (name === 'gang_watch') {
|
|
191
|
+
const lines = text.split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l) } catch { return { event: 'error', error: l } } })
|
|
192
|
+
const META = new Set(['watching', 'error', 'ended', 'timeout'])
|
|
193
|
+
const fatal = lines.find((l) => l.fatal)
|
|
194
|
+
body = fatal
|
|
195
|
+
? { success: false, error: fatal.error, ...(fatal.allowed && { allowed: fatal.allowed }) }
|
|
196
|
+
: {
|
|
197
|
+
success: true, events: lines.filter((l) => !META.has(l.event)), meta: lines.filter((l) => META.has(l.event)),
|
|
198
|
+
...(lines.some((l) => l.event === 'timeout') && { timedOut: true, next: 'nothing yet: call gang_watch again to keep waiting' }),
|
|
199
|
+
}
|
|
200
|
+
} else {
|
|
201
|
+
try { body = JSON.parse(text) } catch {
|
|
202
|
+
// not JSON: killed, or the help text an unknown command prints (long; the tools list says what there is)
|
|
203
|
+
const help = text.startsWith('gang ') && /\n\s+gang /.test(text)
|
|
204
|
+
body = {
|
|
205
|
+
success: false,
|
|
206
|
+
error: signal ? `gang ${signal === 'SIGTERM' ? 'timed out' : `killed (${signal})`}`
|
|
207
|
+
: help ? `not a gang command: ${args[0] ?? ''}` : (text || stderr.trim() || `gang exited ${code}`).slice(0, 2000),
|
|
208
|
+
}
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
const isError = body?.success === false
|
|
212
|
+
return { content: [{ type: 'text', text: JSON.stringify(body, null, 2) }], structuredContent: body, isError }
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/**
|
|
216
|
+
* Serve MCP on stdin / stdout until stdin closes. signals: on SIGTERM / SIGINT (a host stopping the server without
|
|
217
|
+
* closing stdin first) stop the reads and exit at once; the writes' children are left to finish on their own.
|
|
218
|
+
*/
|
|
219
|
+
export function runMcp({ input = process.stdin, output = process.stdout, signals = true } = {}) {
|
|
220
|
+
// a client gone mid-answer (EPIPE) must not take down the writes still finishing
|
|
221
|
+
output.on?.('error', () => {})
|
|
222
|
+
const write = (m) => output.write(`${JSON.stringify({ jsonrpc: '2.0', ...m })}\n`)
|
|
223
|
+
const reply = (id, result) => write({ id, result })
|
|
224
|
+
const error = (id, code, message) => write({ id, error: { code, message } })
|
|
225
|
+
const pending = new Set()
|
|
226
|
+
const running = new Map() // request id -> { child, read }: a read's child is killed when the request is cancelled
|
|
227
|
+
const cancelled = new Set() // answered with nothing: the client stopped waiting
|
|
228
|
+
const stopRun = (id) => {
|
|
229
|
+
const r = running.get(id)
|
|
230
|
+
if (!r) return
|
|
231
|
+
cancelled.add(id)
|
|
232
|
+
if (r.read) r.child.kill('SIGTERM') // a write runs to its end (WRITE_MS)
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
async function onMessage(m) {
|
|
236
|
+
if (m.method === 'notifications/cancelled') return stopRun(m.params?.requestId)
|
|
237
|
+
if (m.id === undefined) return // other notifications (initialized, …) need no answer
|
|
238
|
+
switch (m.method) {
|
|
239
|
+
case 'initialize': {
|
|
240
|
+
const asked = m.params?.protocolVersion
|
|
241
|
+
return reply(m.id, {
|
|
242
|
+
protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
|
|
243
|
+
capabilities: { tools: { listChanged: false } },
|
|
244
|
+
serverInfo: { name: 'gang', title: 'Gang (gang.fun)', version: VERSION },
|
|
245
|
+
instructions: INSTRUCTIONS,
|
|
246
|
+
})
|
|
247
|
+
}
|
|
248
|
+
case 'ping':
|
|
249
|
+
return reply(m.id, {})
|
|
250
|
+
case 'tools/list':
|
|
251
|
+
return reply(m.id, { tools: TOOLS.map(({ args, ...t }) => t) })
|
|
252
|
+
case 'tools/call': {
|
|
253
|
+
const t = BY_NAME.get(m.params?.name)
|
|
254
|
+
if (!t) return error(m.id, -32602, `unknown tool: ${m.params?.name}`)
|
|
255
|
+
const a = m.params.arguments ?? {}
|
|
256
|
+
const bad = invalid(t, a)
|
|
257
|
+
if (bad) return reply(m.id, { content: [{ type: 'text', text: JSON.stringify({ success: false, error: bad }) }], isError: true })
|
|
258
|
+
const read = t.annotations.readOnlyHint === true
|
|
259
|
+
const ms = t.name === 'gang_watch' ? (WATCH_MAX_SEC + 30) * 1000 : read ? RUN_MS : WRITE_MS
|
|
260
|
+
const args = t.args(a)
|
|
261
|
+
const done = await runCli(args, ms, (child) => running.set(m.id, { child, read }))
|
|
262
|
+
running.delete(m.id)
|
|
263
|
+
// a cancelled request gets no answer (MCP: the client has stopped waiting for it)
|
|
264
|
+
if (cancelled.delete(m.id)) return
|
|
265
|
+
return reply(m.id, toResult(t.name, done, args))
|
|
266
|
+
}
|
|
267
|
+
default:
|
|
268
|
+
return error(m.id, -32601, `method not found: ${m.method}`)
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
return new Promise((resolve) => {
|
|
273
|
+
const rl = createInterface({ input, crlfDelay: Infinity })
|
|
274
|
+
rl.on('line', (line) => {
|
|
275
|
+
if (!line.trim()) return
|
|
276
|
+
let m
|
|
277
|
+
try { m = JSON.parse(line) } catch { return error(null, -32700, 'parse error') }
|
|
278
|
+
if (Array.isArray(m)) return error(null, -32600, 'batches are not supported')
|
|
279
|
+
const p = onMessage(m).catch((e) => m.id !== undefined && error(m.id, -32603, e.message)).finally(() => pending.delete(p))
|
|
280
|
+
pending.add(p)
|
|
281
|
+
})
|
|
282
|
+
// the client is gone: stop the reads (a gang_watch can wait 30 minutes), let the writes finish, then go
|
|
283
|
+
rl.on('close', () => {
|
|
284
|
+
for (const id of running.keys()) stopRun(id)
|
|
285
|
+
Promise.allSettled([...pending]).then(resolve)
|
|
286
|
+
})
|
|
287
|
+
if (signals) {
|
|
288
|
+
const quit = () => {
|
|
289
|
+
for (const id of running.keys()) stopRun(id)
|
|
290
|
+
process.exit(0)
|
|
291
|
+
}
|
|
292
|
+
process.once('SIGTERM', quit)
|
|
293
|
+
process.once('SIGINT', quit)
|
|
294
|
+
}
|
|
295
|
+
})
|
|
296
|
+
}
|