@cocorograph/hub-agent 0.8.114 → 0.8.116

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocorograph/hub-agent",
-  "version": "0.8.114",
+  "version": "0.8.116",
   "description": "Hub Hosted Cockpit のローカル常駐 agent。Hub と outbound WSS で接続し、ローカルの Claude / Codex チャットと tmux セッションを中継する。",
   "type": "module",
   "license": "UNLICENSED",
@@ -34,6 +34,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.158",
     "commander": "^12.1.0",
     "pino": "^9.0.0",
+    "smol-toml": "^1.9.1",
     "ws": "^8.18.0"
   },
   "repository": {

package/src/chat-removal-guard.mjs

@@ -5,7 +5,7 @@
  * **消える直前の dir を cwd とする会話**が新しく生まれ、削除後には cwd が存在しない会話として
  * 残る（「送ったら起きる」方式にしたので、この窓は利用者の送信 1 回で簡単に開く）。
  *
- * ⚠️ 検査は **attach の定義側 2 箇所**（claude-stream-bridge / codex-stream-bridge）に置く。
+ * ⚠️ 検査は **attach の定義側 3 箇所**（claude-stream-bridge / codex-stream-bridge / grok-stream-bridge）に置く。
  * 呼び出し元は現時点で 4 箇所あるが、経路ごとに掛けると経路が増えたときに片方だけ守られる。
  * 会話が生まれる場所は attach だけなので、そこで 1 回見れば足りる。
  *

package/src/chat-session-starter.mjs

@@ -17,7 +17,8 @@ export async function ensureChatSession({ cwd, cliKind, bridges, logger, resolve
       const existing = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
       if (existing) return { ok: true, session: existing, cwd }
       const bridge = cliKind === "claude" ? bridges?.claudeBridge
-        : cliKind === "codex" ? bridges?.codexBridge : null
+        : cliKind === "codex" ? bridges?.codexBridge
+        : cliKind === "grok" ? bridges?.grokBridge : null
       if (!bridge?.attach) throw new Error(`chat bridge unavailable: ${cliKind}`)
       const prepared = await prepareChatWorkspace({ cwd, cliKind, waitForSync: false, logger })
       cwd = prepared.cwd
@@ -71,7 +72,7 @@ export async function ensureChatSession({ cwd, cliKind, bridges, logger, resolve
       const concurrent = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
       if (concurrent) return { ok: true, session: concurrent, cwd }
       const stream_id = `auto-${randomUUID()}`
-      if (cliKind === "codex") await bridge.attach({ stream_id, cwd })
+      if (cliKind === "codex" || cliKind === "grok") await bridge.attach({ stream_id, cwd })
       else bridge.attach({ ...resolveClaudeOptions?.(), stream_id, cwd })
       const session = describeLiveSessionsUnion(bridges, { cwd, cliKind })[0]
       return { ok: true, session, cwd }

package/src/codex-binary.mjs

@@ -3,6 +3,44 @@ import { execFileSync } from "node:child_process"
 import os from "node:os"
 import path from "node:path"
 
+/**
+ * CLI 共通の実行可能判定と PATH 探索。探索順と unavailable の診断は各 resolver が持つ。
+ */
+export function createBinaryLookup({ platform, accessSyncImpl, statSyncImpl, execFileSyncImpl }) {
+  const pathApi = platform === "win32" ? path.win32 : path
+  const executable = (candidate) => {
+    try {
+      if (!statSyncImpl(candidate).isFile()) return false
+      accessSyncImpl(candidate, fsConstants.X_OK)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  const findOnPath = (command) => {
+    try {
+      const lookup = platform === "win32" ? "where" : "which"
+      const output = execFileSyncImpl(lookup, [command], { encoding: "utf8" })
+      const resolved = String(output)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean)
+      if (resolved) {
+        return {
+          available: true,
+          path: pathApi.isAbsolute(resolved) ? resolved : pathApi.resolve(resolved),
+          source: "path",
+        }
+      }
+    } catch {
+      // 候補が無い場合のフォールバックは呼び出し側が決める。
+    }
+    return null
+  }
+  return { pathApi, executable, findOnPath }
+}
+
 /**
  * Cockpit が起動する Codex の共通 resolver。
  *
@@ -17,16 +55,9 @@ export function resolveCodexBinary({
   statSyncImpl = statSync,
   execFileSyncImpl = execFileSync,
 } = {}) {
-  const pathApi = platform === "win32" ? path.win32 : path
-  const executable = (candidate) => {
-    try {
-      if (!statSyncImpl(candidate).isFile()) return false
-      accessSyncImpl(candidate, fsConstants.X_OK)
-      return true
-    } catch {
-      return false
-    }
-  }
+  const { pathApi, executable, findOnPath } = createBinaryLookup({
+    platform, accessSyncImpl, statSyncImpl, execFileSyncImpl,
+  })
 
   const explicit = typeof env.HUB_CODEX_BIN === "string" ? env.HUB_CODEX_BIN.trim() : ""
   if (explicit) {
@@ -50,23 +81,8 @@ export function resolveCodexBinary({
     return { available: true, path: pluginPath, source: "plugin-appserver" }
   }
 
-  try {
-    const lookup = platform === "win32" ? "where" : "which"
-    const output = execFileSyncImpl(lookup, ["codex"], { encoding: "utf8" })
-    const resolved = String(output)
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .find(Boolean)
-    if (resolved) {
-      return {
-        available: true,
-        path: pathApi.isAbsolute(resolved) ? resolved : pathApi.resolve(resolved),
-        source: "path",
-      }
-    }
-  } catch {
-    // PATH に無い場合は unavailable。plugin は次回呼び出し時に再評価される。
-  }
+  const fromPath = findOnPath("codex")
+  if (fromPath) return fromPath
 
   return { available: false, path: null, source: "path", error: "codex CLI is unavailable" }
 }

package/src/config.mjs

@@ -14,6 +14,7 @@ import { randomUUID } from "node:crypto"
 import { execFile, execFileSync } from "node:child_process"
 import { promisify } from "node:util"
 import { resolveCodexBinary } from "./codex-binary.mjs"
+import { resolveGrokBinary } from "./grok-binary.mjs"
 
 const _execFileP = promisify(execFile)
 
@@ -60,16 +61,16 @@ export function detectPlatform({ execImpl } = {}) {
 }
 
 /** このホストで起動可否を検出する CLI 種別の候補。 */
-export const CLI_CANDIDATES = ["claude", "codex"]
+export const CLI_CANDIDATES = ["claude", "codex", "grok"]
 
 /**
  * 起動可能な CLI 種別 (capability) を検出する。Cockpit が「この hub-agent で
  * どの CLI を起動できるか」を知るため、起動時に 1 回呼んで enroll/hello payload で
- * Hub に広告する (`CockpitAgent.available_clis`)。Codex は共通 resolver、その他は
+ * Hub に広告する (`CockpitAgent.available_clis`)。Codex / Grok は共通 resolver、その他は
  * which/where が成功したものだけ返す。
  *
- * @param {{candidates?:string[], exec?:(cmd:string,args:string[])=>Promise<any>, _resolveCodexBinary?:()=>{available:boolean}}} [opts]
- *   exec / _resolveCodexBinary はテスト差し替え用。
+ * @param {{candidates?:string[], exec?:(cmd:string,args:string[])=>Promise<any>, _resolveCodexBinary?:()=>{available:boolean}, _resolveGrokBinary?:()=>{available:boolean}}} [opts]
+ *   exec / _resolveCodexBinary / _resolveGrokBinary はテスト差し替え用。
  * @returns {Promise<string[]>} 例: ["claude", "codex"]
  */
 export async function detectAvailableClis(opts = {}) {
@@ -82,6 +83,10 @@ export async function detectAvailableClis(opts = {}) {
       if ((opts._resolveCodexBinary || resolveCodexBinary)().available) found.push(cli)
       continue
     }
+    if (cli === "grok") {
+      if ((opts._resolveGrokBinary || resolveGrokBinary)().available) found.push(cli)
+      continue
+    }
     try {
       await exec(lookup, [cli])
       found.push(cli)

package/src/dispatch-scheduler.mjs

@@ -65,6 +65,7 @@ function chatMode(type) {
   if (typeof type !== "string") return null
   if (type === "claude.attach" || type.startsWith("claude.")) return "claude"
   if (type === "codex.attach" || type.startsWith("codex.")) return "codex"
+  if (type === "grok.attach" || type.startsWith("grok.")) return "grok"
   return null
 }
 
@@ -93,7 +94,7 @@ export function attachLaneKey(mode, msg, defaultCwd = "") {
   const cwd = (typeof msg?.cwd === "string" ? msg.cwd.trim() : "") || defaultCwd
   if (cwd) return `${mode}:cwd:${cwd}`
   const resumeId =
-    mode === "claude"
+    mode === "claude" || mode === "grok"
       ? msg?.resume_session_id
       : msg?.resume_thread_id || msg?.thread_id
   if (typeof resumeId === "string" && resumeId) return `${mode}:resume:${resumeId}`
@@ -106,7 +107,7 @@ export function attachLaneKey(mode, msg, defaultCwd = "") {
  * （直列化に使う内部キーそのものは変えない）。
  */
 export function laneKindForLog(lane) {
-  const m = /^(claude|codex):(cwd|resume|stream):/.exec(typeof lane === "string" ? lane : "")
+  const m = /^(claude|codex|grok):(cwd|resume|stream):/.exec(typeof lane === "string" ? lane : "")
   return m ? `${m[1]}:${m[2]}` : lane
 }
 
@@ -115,7 +116,7 @@ export function laneKindForLog(lane) {
  *   run: (msg: object) => Promise<void>|void,
  *   logger?: {debug?: Function, warn?: Function, error?: Function},
  *   shouldBypass?: (type: string|undefined) => boolean,
- *   defaultCwd?: (mode: "claude"|"codex") => string,
+ *   defaultCwd?: (mode: "claude"|"codex"|"grok") => string,
  * }} options
  */
 export class DispatchScheduler {
@@ -151,7 +152,7 @@ export class DispatchScheduler {
   }
 
   _rememberStreamLane(streamId, laneKey) {
-    const mode = laneKey.startsWith("codex:") ? "codex" : "claude"
+    const mode = /^(claude|codex|grok):/.exec(laneKey)?.[1] ?? "claude"
     const streamKey = streamId ? `${mode}:${streamId}` : ""
     if (!streamKey) return
     this.streamLaneKeys.set(streamKey, laneKey)
@@ -177,7 +178,7 @@ export class DispatchScheduler {
    * cwd 省略時にハンドラ／bridge が使う既定 cwd を、CLI 種別ごとに引く。
    * ⚠️ レーン分類は全メッセージが通る経路なので、設定の読み取りが失敗しても dispatch を
    * 止めない。取れなければ省略時の従来分類 (stream / control) へ戻す。
-   * @param {"claude"|"codex"} mode
+   * @param {"claude"|"codex"|"grok"} mode
    */
   _resolveDefaultCwd(mode) {
     try {
@@ -201,15 +202,16 @@ export class DispatchScheduler {
     if (type === "chat.session.stop") {
       if (msg.scope === "cwd") {
         const cwd = typeof msg.cwd === "string" ? msg.cwd.trim() : ""
-        return cwd && (msg.cli_kind === "claude" || msg.cli_kind === "codex")
+        return cwd && (msg.cli_kind === "claude" || msg.cli_kind === "codex" || msg.cli_kind === "grok")
           ? `${msg.cli_kind}:cwd:${cwd}` : "control"
       }
       if (msg.cli_kind === "claude") {
         const cwd = typeof msg.cwd === "string" ? msg.cwd.trim() : ""
         return cwd ? `claude:cwd:${cwd}` : "control"
       }
-      if (msg.cli_kind === "codex" && msg.stream_id) {
-        return this.streamLaneKeys.get("codex:" + msg.stream_id) || `codex:stream:${msg.stream_id}`
+      if ((msg.cli_kind === "codex" || msg.cli_kind === "grok") && msg.stream_id) {
+        const kind = msg.cli_kind
+        return this.streamLaneKeys.get(`${kind}:${msg.stream_id}`) || `${kind}:stream:${msg.stream_id}`
       }
       return "control"
     }
@@ -240,7 +242,7 @@ export class DispatchScheduler {
 
   _previousFor(lane) {
     const own = this.laneTails.get(lane)
-    const match = /^(claude|codex):(global|cwd:|resume:|stream:)/.exec(lane)
+    const match = /^(claude|codex|grok):(global|cwd:|resume:|stream:)/.exec(lane)
     if (!match) return own || Promise.resolve()
 
     const mode = match[1]
@@ -311,7 +313,7 @@ export class DispatchScheduler {
     const streamId = typeof msg?.stream_id === "string" ? msg.stream_id : ""
     const mode = chatMode(type)
     const streamKey = mode && streamId ? `${mode}:${streamId}` : ""
-    const isDetach = type === "claude.detach" || type === "codex.detach"
+    const isDetach = type === "claude.detach" || type === "codex.detach" || type === "grok.detach"
     if (isDetach && streamKey) {
       // attach がまだ lane 内で待機中でも、その実行前に stale と判定できるよう
       // detach の dispatch 完了を待たず受信時点の順序を記録する。真偽値だけだと
@@ -332,7 +334,7 @@ export class DispatchScheduler {
           return
         }
         if (
-          (type === "claude.attach" || type === "codex.attach") &&
+          (type === "claude.attach" || type === "codex.attach" || type === "grok.attach") &&
           streamKey &&
           (this.detachedAtByStream.get(streamKey) ?? -1) > sequence
         ) {

package/src/grok-acp-client.mjs

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process'
+import { EventEmitter } from 'node:events'
+import { createInterface } from 'node:readline'
+
+/** Transport only: one Grok ACP process, newline-delimited JSON-RPC. */
+export class GrokAcpClient extends EventEmitter {
+  constructor({ grokCmd, cwd, env, args = ['agent', 'stdio'], requestTimeoutMs = 20_000, logger } = {}) {
+    super()
+    Object.assign(this, { grokCmd, cwd, env, args, requestTimeoutMs, logger })
+    this.child = null
+    this.closed = false
+    this.pending = new Map()
+    this.nextId = 0
+  }
+
+  start() {
+    if (this.child || this.closed) return
+    if (!this.grokCmd) throw new Error('grokCmd is required')
+    this.child = spawn(this.grokCmd, this.args, {
+      cwd: this.cwd,
+      env: { ...(this.env || process.env), GROK_CLAUDE_MCPS_ENABLED: 'false', GROK_CLAUDE_HOOKS_ENABLED: 'false' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    })
+    this.done = new Promise((resolve) => this.child.once('close', resolve))
+    createInterface({ input: this.child.stdout }).on('line', (line) => {
+      if (this.closed) return
+      let message
+      try { message = JSON.parse(line) } catch {
+        this.logger?.warn?.('grok ACP: invalid JSON line skipped')
+        return
+      }
+      if (!message || typeof message !== 'object') return
+      if (message.method !== undefined) {
+        this.emit(message.id != null ? 'request' : 'notification', message)
+      } else {
+        const pending = this.pending.get(message.id)
+        if (message.error) pending?.reject(Object.assign(new Error(message.error.message), { code: message.error.code }))
+        else pending?.resolve(message.result)
+      }
+    })
+    // Do not copy arbitrary stderr (which can contain credentials) into logs.
+    this.child.stderr.on('data', (chunk) => this.emit('stderr', chunk))
+    this.child.stdin.on('error', (error) => this._fail(error))
+    this.child.on('error', (error) => this._fail(error))
+    this.child.on('exit', (code, signal) => {
+      this.closed = true
+      this._rejectAll(new Error(`grok ACP exited (code=${code}, signal=${signal})`))
+      void this.stop()
+      this.emit('exit', { code, signal })
+    })
+  }
+
+  _fail(error) {
+    if (this.closed) return
+    this._rejectAll(error)
+    this.emit('error', error)
+    void this.stop()
+  }
+
+  _rejectAll(error) {
+    for (const pending of this.pending.values()) pending.reject(error)
+  }
+
+  _write(message) {
+    if (!this.child || this.closed) throw new Error('grok ACP is not running')
+    this.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...message }) + '\n')
+  }
+
+  request(method, params, { timeoutMs = this.requestTimeoutMs } = {}) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.nextId
+      let timer
+      const settle = (fn) => (value) => {
+        clearTimeout(timer)
+        this.pending.delete(id)
+        fn(value)
+      }
+      const pending = { resolve: settle(resolve), reject: settle(reject) }
+      this.pending.set(id, pending)
+      if (timeoutMs > 0) timer = setTimeout(() => pending.reject(new Error(`grok ACP request timed out: ${method}`)), timeoutMs)
+      try { this._write({ id, method, params }) } catch (error) { pending.reject(error) }
+    })
+  }
+
+  notify(method, params) { if (this.closed) return; this._write({ method, params }) }
+  respond(id, result = {}) { if (this.closed) return; this._write({ id, result }) }
+  respondError(id, error) { if (this.closed) return; this._write({ id, error }) }
+
+  stop() {
+    if (this.stopPromise) return this.stopPromise
+    this.closed = true
+    this._rejectAll(new Error('grok ACP stopped'))
+    this.stopPromise = this._reapGroup()
+    return this.stopPromise
+  }
+
+  /** Resolves true once the process group is gone, false if it survived SIGKILL (never rejects). */
+  async _reapGroup() {
+    const pid = this.child?.pid
+    if (!Number.isInteger(pid)) return true
+    const exists = () => {
+      try { process.kill(-pid, 0); return true } catch (error) {
+        // EPERM (and any unexpected error) is not evidence of disappearance.
+        return error.code !== 'ESRCH'
+      }
+    }
+    const kill = (signal) => {
+      try { process.kill(-pid, signal) } catch { /* Polling checks disappearance. */ }
+    }
+    const waitUntilGone = async (timeoutMs) => {
+      const deadline = Date.now() + timeoutMs
+      while (exists()) {
+        const remaining = deadline - Date.now()
+        if (remaining <= 0) return false
+        // Keep the host alive until group cleanup completes.
+        await new Promise((resolve) => setTimeout(resolve, Math.min(50, remaining)))
+      }
+      return true
+    }
+    try { this.child.stdin.end() } catch { /* Already closed. */ }
+    kill('SIGTERM')
+    if (await waitUntilGone(3000)) return true
+    kill('SIGKILL')
+    if (await waitUntilGone(1000)) return true
+    // No retry: signalling the same PGID later risks hitting a reused process group.
+    this.logger?.warn?.(`grok ACP: process group ${pid} remains after SIGKILL`)
+    return false
+  }
+}

package/src/grok-binary.mjs

@@ -0,0 +1,50 @@
+import { accessSync, statSync } from "node:fs"
+import { execFileSync } from "node:child_process"
+import os from "node:os"
+import { createBinaryLookup } from "./codex-binary.mjs"
+
+/**
+ * Cockpit が起動する Grok の共通 resolver。
+ *
+ * 呼び出しごとに再評価し、バイナリの更新・一時不在からの復帰を daemon 再起動なしで
+ * 反映する。HUB_GROK_BIN は明示指定なので、不正時に別バイナリへ黙って切り替えない。
+ */
+export function resolveGrokBinary({
+  env = process.env,
+  homedir = os.homedir(),
+  platform = process.platform,
+  accessSyncImpl = accessSync,
+  statSyncImpl = statSync,
+  execFileSyncImpl = execFileSync,
+} = {}) {
+  const { pathApi, executable, findOnPath } = createBinaryLookup({
+    platform, accessSyncImpl, statSyncImpl, execFileSyncImpl,
+  })
+
+  const explicit = typeof env.HUB_GROK_BIN === "string" ? env.HUB_GROK_BIN.trim() : ""
+  if (explicit) {
+    if (!pathApi.isAbsolute(explicit)) {
+      return { available: false, path: explicit, source: "env", error: `HUB_GROK_BIN must be an absolute path: ${explicit}` }
+    }
+    const explicitPath = explicit
+    if (executable(explicitPath)) {
+      return { available: true, path: explicitPath, source: "env" }
+    }
+    return {
+      available: false,
+      path: explicitPath,
+      source: "env",
+      error: `HUB_GROK_BIN is not executable: ${explicitPath}`,
+    }
+  }
+
+  const fromPath = findOnPath("grok")
+  if (fromPath) return fromPath
+
+  const fallbackPath = pathApi.join(homedir, ".grok", "bin", "grok")
+  if (executable(fallbackPath)) {
+    return { available: true, path: fallbackPath, source: "home" }
+  }
+
+  return { available: false, source: "none", error: "grok binary not found" }
+}