dsh-cliworker-now 0.0.0-stage → 0.7.6

package/lib/grok-catalog.mjs

@@ -0,0 +1,145 @@
+// Native ACP initialize only: no session creation, auth request or prompt.
+import { spawn } from 'node:child_process'
+import { StringDecoder } from 'node:string_decoder'
+import { nativeLaunchArgv } from './native-launch.mjs'
+
+process.umask(0o077)
+const [executable, cwd] = process.argv.slice(2)
+if (!executable || !cwd || process.argv.length !== 4) throw new Error('Invalid catalog arguments')
+const argv = nativeLaunchArgv([executable, 'agent', '--no-leader', 'stdio'])
+const child = spawn(argv[0], argv.slice(1), {
+  cwd,
+  env: process.env,
+  detached: false,
+  stdio: ['pipe', 'pipe', 'pipe'],
+})
+const decoder = new StringDecoder('utf8')
+let pending = '',
+  bytes = 0,
+  closed = false,
+  received = false,
+  models,
+  failure
+let complete, reject
+const reply = new Promise((resolve, fail) => {
+  complete = resolve
+  reject = fail
+})
+void reply.catch(() => {})
+const done = new Promise((resolve) =>
+  child.once('close', (code, signal) => {
+    closed = true
+    if (!received) reject(new Error('Grok closed before initialize reply'))
+    resolve({ code, signal })
+  }),
+)
+function abort(message) {
+  failure ??= new Error(message)
+  reject(failure)
+  child.kill('SIGTERM')
+}
+child.on('error', () => abort('Unable to start Grok catalog'))
+child.stdin.on('error', () => abort('Grok catalog input closed'))
+const interrupt = () => abort('Grok catalog interrupted')
+process.on('SIGTERM', interrupt)
+process.on('SIGINT', interrupt)
+const timeout = setTimeout(() => abort('Grok catalog timeout'), 10000)
+const hardTimeout = setTimeout(() => child.kill('SIGKILL'), 12000)
+function receive(chunk, stderr = false) {
+  bytes += chunk.length
+  if (bytes > 2097152) return abort('Grok catalog output exceeds limit')
+  if (stderr) return
+  pending += decoder.write(chunk)
+  if (Buffer.byteLength(pending) > 1048576) return abort('Grok catalog event exceeds limit')
+  let end
+  while ((end = pending.indexOf('\n')) >= 0) {
+    const line = pending.slice(0, end).trim()
+    pending = pending.slice(end + 1)
+    if (!line) continue
+    try {
+      const e = JSON.parse(line)
+      if (e.jsonrpc !== '2.0') throw new Error('Invalid ACP reply')
+      if (e.method && e.id !== undefined) {
+        child.stdin.write(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            id: e.id,
+            error: { code: -32601, message: 'Catalog is read only' },
+          }) + '\n',
+        )
+      } else if (e.id !== undefined) {
+        if (received || e.id !== 1 || e.error || e.result?.protocolVersion !== 1)
+          throw new Error('Invalid initialize response')
+        received = true
+        const state = e.result?._meta?.modelState
+        if (!Array.isArray(state?.availableModels) || !state.availableModels.length)
+          throw new Error('Missing Grok models')
+        models = state.availableModels.map((model) => {
+          if (typeof model.modelId !== 'string' || !model.modelId) throw new Error('Missing Grok model ID')
+          const meta = model._meta
+          const efforts =
+            meta?.supportsReasoningEffort === false
+              ? ['default']
+              : Array.isArray(meta?.reasoningEfforts)
+                ? meta.reasoningEfforts.map((x) => x.id)
+                : []
+          if (
+            !efforts.length ||
+            efforts.some(
+              (x) =>
+                !['default', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(x),
+            )
+          )
+            throw new Error('Unsupported Grok reasoning directory')
+          return {
+            id: model.modelId,
+            label: typeof model.name === 'string' ? model.name : model.modelId,
+            efforts,
+          }
+        })
+        complete()
+      }
+    } catch {
+      abort('Invalid Grok ACP model directory')
+    }
+  }
+}
+child.stdout.on('data', (x) => receive(x))
+child.stderr.on('data', (x) => receive(x, true))
+try {
+  child.stdin.write(
+    JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        protocolVersion: 1,
+        clientCapabilities: {},
+        clientInfo: { name: 'cliworker-catalog', version: '1' },
+      },
+    }) + '\n',
+  )
+  await reply
+  child.stdin.end()
+  // Grok stdio may remain idle after EOF. Stop the read-only agent explicitly.
+  if (!closed) child.kill('SIGTERM')
+  const outcome = await done
+  if (failure || (![0, 143].includes(outcome.code) && outcome.signal !== 'SIGTERM') || pending.trim())
+    throw new Error('Grok catalog did not close cleanly')
+  process.stdout.write(JSON.stringify(models) + '\n')
+} catch {
+  process.stderr.write('Grok 原生模型目录查询失败；请检查 CLI 版本。\n')
+  process.exitCode = 1
+} finally {
+  child.stdin.end()
+  if (!closed) child.kill('SIGTERM')
+  const force = setTimeout(() => {
+    if (!closed) child.kill('SIGKILL')
+  }, 1000)
+  await done
+  clearTimeout(force)
+  clearTimeout(timeout)
+  clearTimeout(hardTimeout)
+  process.off('SIGTERM', interrupt)
+  process.off('SIGINT', interrupt)
+}

package/lib/hermes-native-entry.py

@@ -0,0 +1,61 @@
+"""Use a verified current native venv with a separate account home, without installing.
+
+The official launcher, checkout-derived install key and committed facts are checked by
+Host. Recheck facts under the same install lock, then use Hermes' own generation lease.
+No account/config content is copied, imported from another home, or printed here.
+"""
+import fcntl
+import json
+import os
+from pathlib import Path
+import stat
+import sys
+
+checkout, facts, environment = map(Path, sys.argv[1:4])
+arguments = sys.argv[4:]
+if any(path.resolve() != path for path in (checkout, facts, environment)):
+    raise SystemExit("Hermes installation changed; reopen login settings")
+
+def selected():
+    fd = os.open(facts, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
+    with os.fdopen(fd) as stream:
+        info = os.fstat(stream.fileno())
+        if not stat.S_ISREG(info.st_mode) or info.st_nlink != 1 or info.st_size > 4 * 1024 * 1024:
+            raise RuntimeError("Invalid Hermes installation record")
+        return json.load(stream).get("packages", {}).get("venv", {}).get("environment") == str(environment)
+
+release = None
+try:
+    with open(facts.parent / ".install.lock", "a+b") as lock:
+        fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        if not selected():
+            raise RuntimeError("Hermes installation changed; reopen login settings")
+        sys.path.insert(0, str(checkout))
+        from hermes_cli.runtime_state import lease_generation
+        release = lease_generation(environment)
+    os.environ["HERMES_DISABLE_LAZY_INSTALLS"] = "1"
+    os.environ.pop("PYTHONHOME", None)
+    os.environ.pop("PYTHONPATH", None)
+    os.environ.pop("VIRTUAL_ENV", None)
+    sys.argv = [str(checkout / "hermes_cli/main.py"), *arguments]
+    # The native API exposes these boundaries, but main/run_agent pass the
+    # checkout's .env as a fallback. Pin its own home and disable that fallback
+    # and secret-manager hydration before either module imports the function.
+    # No parser or provider/login flow is replaced.
+    account_home = Path(os.environ["HERMES_HOME"])
+    if (account_home / ".cliworker-managed").exists() or (account_home / ".op.env").exists():
+        raise RuntimeError("Hermes plugin login cannot use additional account configuration layers")
+    from hermes_cli import env_loader
+    native_dotenv = env_loader.load_hermes_dotenv
+    def own_dotenv(**_options):
+        if (account_home / ".cliworker-managed").exists():
+            raise RuntimeError("Hermes plugin login cannot use an additional managed configuration")
+        if (account_home / ".op.env").exists():
+            raise RuntimeError("Hermes plugin login supports its own .env; external secret stores are unavailable")
+        return native_dotenv(hermes_home=account_home, project_env=None, load_external_secrets=False)
+    env_loader.load_hermes_dotenv = own_dotenv
+    from hermes_cli.main import main
+    raise SystemExit(main())
+finally:
+    if release is not None:
+        release()