dsh-acp-replay 0.1.1 → 0.1.3

package/README.md

@@ -2,9 +2,9 @@
 
 A community ACP bridge for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) that answers `session/load`, so a client can rebuild a session transcript after its own restart.
 
-**Status: prototype.** It works end to end on `dsh 0.1.5-rc.1` through `0.1.5-rc.3`, but it is a vendored fork of `@deepseek-ai/dsh-acp` and needs a rebase whenever that package changes. `0.1.6-alpha.1` changed the persistence API and, per a field report on 2026-09-23, answers no ACP request with either profile; the guard below is what reports why.
+**Status: prototype.** It works end to end on `dsh 0.1.5-rc.1`, `0.1.5-rc.3`, and `0.1.7-rc.2`, but it is a vendored fork of `@deepseek-ai/dsh-acp` and needs a rebase whenever that package changes. No harness version probed here advertises `loadSession` itself, so the bridge is still the only path to a rebuilt transcript; a field report of `0.1.6-alpha.1` answering nothing did not reproduce on the `0.1.7` release candidate.
 
-Published on npm as `dsh-acp-replay`. Its version is independent of the harness version it targets, which `peerDependencies` states. `0.1.1` ships `test/*.mjs`, so the self-check below runs from an installed copy. (`0.1.5-rc.1` was published with an incomplete file list, so it fails to load; it is deprecated.)
+Published on npm as `dsh-acp-replay`. Its version is independent of the harness version it targets, which `peerDependencies` states. `0.1.2` ships `test/*.mjs` and exposes the self-check and the pin check as bins, so both run from an installed copy. (`0.1.5-rc.1` was published with an incomplete file list, so it fails to load; it is deprecated.)
 
 ## Why this exists
 
@@ -42,23 +42,63 @@ Use the shipped bridge instead ("dsh --profile acp"), or update this plugin for
 https://github.com/zheng1/dsh-acp-replay
 ```
 
-Run the self-check after a harness upgrade to get that answer without a full client. From a checkout that is `node test/selfcheck.mjs`; from an installed copy it is `npx dsh-acp-replay-selfcheck`, and a global install puts the same command on `PATH`.
+Run the self-check after a harness upgrade to get that answer without a full client. From a checkout that is `node test/selfcheck.mjs`; from an installed copy it is `npx dsh-acp-replay-selfcheck`, and a global install puts the same command on `PATH`. `dsh-acp-replay-pincheck` runs both profiles and prints which of the upgrade outcomes below applies.
+
+The self-check reports "no ACP initialize response" when the harness never answers, which is also what a failed mount looks like. `dsh` rewrites the profile's `cordis.yml` while preparing it, so a sandbox that denies writes to `DSH_HOME` exits on EPERM before answering; the check says so when it sees `EPERM` or `prepareProfile` in the captured stderr, and prints that stderr otherwise.
+
+## Upgrading the harness pin
+
+The pin is the harness version whose `dsh-acp` this fork was rebased against. Check the candidate before moving it:
+
+```
+$ DSH_BIN=~/.local/bin/dsh npx dsh-acp-replay-pincheck
+harness: /Users/you/.local/bin/dsh (0.1.5-rc.3)
+shipped profile "acp"             does not advertise loadSession
+bridge profile "acp-replay"       advertises loadSession (image: yes)
+
+PIN: bridge — upgrade the harness and move the pin; this bridge answers session/load on it
+```
+
+| Outcome | Meaning | What to do |
+| --- | --- | --- |
+| `upstream` | The shipped profile advertises `loadSession` too | Drop the bridge and unpin; point the client back at `dsh --profile acp` |
+| `bridge` | Only the bridged profile advertises it | Upgrade the harness, then move the pin |
+| `refuses` | Neither profile advertises it | Stay on the pinned harness |
+
+`test/replay-check.mjs` is the other half of that check: it records a session and replays it in a new process, so use a session with real content. A 376-byte session legitimately replays nothing, and zero counts then look like a broken bridge.
 
 ## Use it
 
-The bridge replaces the shipped `acp` row in a profile. Two ways:
+The bridge replaces the shipped `acp` row in a profile. Either way you install it, the bridge row needs a `provider` and a `model`.
+
+**From npm.** The package declares `dsh.bundle.patch`, so installing it composes the rows: the shipped `acp` row is disabled and the bridge is inserted.
 
-**Install into an existing profile.** Add the package to the profile and append to its `cordis.patch.yml`:
+```bash
+dsh plugin --profile acp-replay add dsh-acp-replay
+```
+
+Then set the model on the inserted row, because the bundle carries none (the model id changes between harness releases) — that is an id-targeted override in the profile's own patch layer, not a second `insert`:
+
+```yaml
+# $DSH_HOME/profiles/acp-replay/cordis.patch.yml
+- id: acp-replay
+  config:
+    provider: deepseek-official
+    model: deepseek-v4-flash
+```
 
-Published on npm as [`dsh-acp-replay`](https://www.npmjs.com/package/dsh-acp-replay):
+Read the values off the shipped row rather than guessing, since the id differs per release (`deepseek-flash` on 0.1.5, `deepseek-v4-flash` on 0.1.7):
 
 ```bash
-dsh plugin --profile acp-replay add dsh-acp-replay   # installs it into that profile
+DSH_HOME=~/.dsh dsh --profile acp --dump-config | sed -n '/- id: acp$/,/^$/p'
 ```
 
-The same package also works installed globally (`npm install -g dsh-acp-replay`) or copied from a checkout (put `lib/` and `package.json` in `$DSH_HOME/profiles/node_modules/dsh-acp-replay/`).
+Skip that step and prompts answer with `Internal error: prompt variable "{{model}}" has no value for this assembly`. Add a second `insert` entry for `acp-replay` while the bundle is active and the mount fails with `duplicate loader entry id: acp-replay`.
+
+**From a checkout (no bundle).** Install globally (`npm install -g dsh-acp-replay`) or copy `lib/`, `package.json`, and `cordis.patch.yml` into `$DSH_HOME/profiles/node_modules/dsh-acp-replay/`, then spell out both rows:
 
 ```yaml
+# $DSH_HOME/profiles/acp-replay/cordis.patch.yml
 - id: acp
   disabled: true
 
@@ -68,7 +108,7 @@ The same package also works installed globally (`npm install -g dsh-acp-replay`)
       inject: [acpAppStartup]
       config:
         provider: deepseek-official
-        model: deepseek-flash
+        model: deepseek-v4-flash
 ```
 
 Then point the client at `dsh --profile acp-replay` instead of `dsh --profile acp`. In Paseo that is the provider's `command`:
@@ -87,7 +127,7 @@ Then point the client at `dsh --profile acp-replay` instead of `dsh --profile ac
 }
 ```
 
-**Or use it as a bundle.** The package declares `dsh.bundle.patch`, so adding `dsh-acp-replay` to a profile's `dsh.profile.bundles` composes the same rows.
+The rows the bundle composes are the same two above, so a profile can point at either path without changing the client config.
 
 ## Build
 
@@ -122,6 +162,16 @@ Against `dsh 0.1.5-rc.1`, a scratch `DSH_HOME`, and a real API key:
 
 `test/replay-check.mjs` runs both phases (`record` then `load <session-id>`); `test/selfcheck.mjs` only performs `initialize` and reports whether `loadSession` is advertised.
 
+**Harness versions.** Each candidate installed with `dsh plugin --profile acp-replay add dsh-acp-replay` into a profile created by that same harness:
+
+| Harness | Shipped `acp` profile | Bridged profile | Note |
+| --- | --- | --- | --- |
+| `0.1.5-rc.1` | answers, no `loadSession` | `loadSession: true` | original target; replay verified |
+| `0.1.5-rc.3` (npm `latest`) | answers, no `loadSession` | `loadSession: true` | guard passes, so the pin can move |
+| `0.1.7-rc.2` (npm `next`) | answers, no `loadSession` | `loadSession: true` | record + replay verified |
+
+The shipped profile answering every time is the part a bare `initialize` probe can misread: no harness version probed here advertises `loadSession` itself, so the bridge stays necessary.
+
 **End to end through a client** (Paseo 0.7.2 daemon, `dsh 0.1.5-rc.1`, two DSH providers on one daemon so only the bridge differs). Each agent ran one prompt, then the daemon was restarted — the event that used to erase the visible conversation:
 
 | Provider | Before restart | After restart |
@@ -150,10 +200,12 @@ $ DSH_PROFILE=acp dsh-acp-replay-selfcheck
 FAIL: the bridge answered but does not advertise loadSession        # exit 1
 ```
 
+**`0.1.1` changed no served code.** A downstream field check diffed the published `0.1.1` tarball against the installed `0.1.0`: `lib/` and `cordis.patch.yml` byte-identical, `package.json` differing only in the version, the `bin` entry, and `files`. After the upgrade the same 1.2 MB session replayed to identical counts (`user_message_chunk` 17, `agent_message_chunk` 90, `agent_thought_chunk` 103, `tool_call` 114, `tool_call_update` 114, `usage_update` 113) and the provider diagnostic stayed Ready.
+
 ## Not verified / known limits
 
 - Tool-call replay is mapped but not exercised by the test above.
-- The `0.1.6-alpha.1` no-response finding above is a field report; this repository has not re-probed an alpha harness. npm `latest` is `0.1.5-rc.2` and `next` is `0.1.5-rc.3`, both of which work.
+- The `0.1.6-alpha.1` no-response finding was a field report and does not generalize: `0.1.5-rc.3` and `0.1.7-rc.2` both answer and both mount this bridge. No alpha harness has been probed here.
 - An older host (`dsh 0.1.2-rc.1`) exposes a different persistence API (`load`/`inspect` instead of `open`/`read`), so this fork targets `0.1.5-rc.1` and newer only.
 - Replayed history is delivered before `session/load` returns, one notification at a time; a very long session makes that call proportionally long.
 - The profile's own help text still reads `--profile acp` (it comes from the bundled `dsh-acp-app` command provider, not from this package).

package/cordis.patch.yml

@@ -1,5 +1,20 @@
 # Replace the shipped automation bridge with this one, which also answers
 # `session/load` so a client can rebuild a transcript after its own restart.
+#
+# This row carries no `provider`/`model`: the shipped `acp` row sets them, and its
+# model id changes between releases (`deepseek-flash` on 0.1.5, `deepseek-v4-flash`
+# on 0.1.7). Copy that config into the profile's own patch layer, as an id-targeted
+# override — a second `insert` for this id fails the mount:
+#
+#   DSH_HOME=~/.dsh dsh --profile acp --dump-config | sed -n '/- id: acp$/,/^$/p'
+#
+#   # $DSH_HOME/profiles/<profile>/cordis.patch.yml
+#   - id: acp-replay
+#     config:
+#       provider: deepseek-official
+#       model: deepseek-v4-flash
+#
+# Without it, prompts fail with `prompt variable "{{model}}" has no value`.
 
 - id: acp
   disabled: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-acp-replay",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Community ACP bridge for DeepSeek Harness that supports session/load by replaying a persisted session's transcript",
   "type": "module",
   "main": "lib/index.js",
@@ -14,7 +14,8 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "dsh-acp-replay-selfcheck": "./test/selfcheck.mjs"
+    "dsh-acp-replay-selfcheck": "./test/selfcheck.mjs",
+    "dsh-acp-replay-pincheck": "./test/pin-check.mjs"
   },
   "files": [
     "lib/**/*.js",

package/test/pin-check.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Pin check: probe a candidate harness on the shipped profile and on the bridged
+ * one, and print which of the three outcomes applies, so moving the harness pin
+ * after an upgrade is one command instead of a judgement call.
+ *
+ *   upstream  the shipped profile advertises loadSession itself — drop the bridge
+ *             and unpin: point the client back at `dsh --profile acp`
+ *   bridge    only the bridged profile advertises it — upgrade the harness and
+ *             move the pin
+ *   refuses   neither profile answers with loadSession — stay on the pinned harness
+ *
+ * Usage:
+ *   DSH_BIN=~/.local/bin/dsh dsh-acp-replay-pincheck
+ *
+ * Env: DSH_BIN (default: dsh), DSH_SHIPPED_PROFILE (acp), DSH_PROFILE (acp-replay),
+ *      PIN_CHECK_TIMEOUT_MS (60000).
+ */
+
+import { spawn } from 'node:child_process'
+
+import { OUTCOMES, describeImage, explainMissingResponse, probeProfile } from './probe.mjs'
+
+const bin = process.env.DSH_BIN ?? 'dsh'
+const shippedProfile = process.env.DSH_SHIPPED_PROFILE ?? 'acp'
+const bridgeProfile = process.env.DSH_PROFILE ?? 'acp-replay'
+const timeoutMs = Number(process.env.PIN_CHECK_TIMEOUT_MS ?? 60000)
+
+function harnessVersion() {
+  return new Promise((resolve) => {
+    const child = spawn(bin, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'] })
+    let stdout = ''
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString()
+    })
+    child.on('error', () => resolve(null))
+    child.on('exit', () => resolve(stdout.split('\n')[0].trim() || null))
+  })
+}
+
+function report(label, profile, result) {
+  const answered =
+    result.kind === OUTCOMES.loadSession
+      ? `advertises loadSession (${describeImage(result)})`
+      : result.message
+  return `${`${label} profile "${profile}"`.padEnd(30)} ${answered}`
+}
+
+const [version, shipped, bridged] = await Promise.all([
+  harnessVersion(),
+  probeProfile({ bin, profile: shippedProfile, timeoutMs }),
+  probeProfile({ bin, profile: bridgeProfile, timeoutMs }),
+])
+
+console.log(`harness: ${bin}${version ? ` (${version})` : ''}`)
+console.log(report('shipped', shippedProfile, shipped))
+console.log(report('bridge', bridgeProfile, bridged))
+
+let outcome
+let advice
+if (shipped.kind === OUTCOMES.loadSession) {
+  outcome = 'upstream'
+  advice = `drop the bridge and unpin; point the client at \`${bin} --profile ${shippedProfile}\``
+} else if (bridged.kind === OUTCOMES.loadSession) {
+  outcome = 'bridge'
+  advice = 'upgrade the harness and move the pin; this bridge answers session/load on it'
+} else {
+  outcome = 'refuses'
+  advice = 'stay on the pinned harness; neither profile advertises session/load'
+}
+
+console.log(`\nPIN: ${outcome} — ${advice}`)
+
+for (const result of [shipped, bridged]) {
+  const hint = explainMissingResponse(result)
+  if (hint) console.log(`\n${hint}`)
+}
+
+const answered = new Set([OUTCOMES.loadSession, OUTCOMES.noLoadSession])
+for (const [profile, result] of [
+  [shippedProfile, shipped],
+  [bridgeProfile, bridged],
+]) {
+  if (answered.has(result.kind) || result.stderr.length === 0) continue
+  console.log(`\n--- ${bin} --profile ${profile} stderr ---\n${result.stderr}`)
+}

package/test/probe.mjs

@@ -0,0 +1,123 @@
+/**
+ * Shared ACP probe for the checks in this directory.
+ *
+ * Boots one profile, performs a single `initialize`, and classifies the answer.
+ * Both `selfcheck.mjs` (one profile) and `pin-check.mjs` (shipped profile plus the
+ * bridged one) are built on this, so the two report the same thing about the same
+ * harness.
+ */
+
+import { spawn } from 'node:child_process'
+
+export const OUTCOMES = {
+  loadSession: 'load-session',
+  noLoadSession: 'no-load-session',
+  noResponse: 'no-response',
+  initializeFailed: 'initialize-failed',
+  spawnFailed: 'spawn-failed',
+  exited: 'exited',
+}
+
+/**
+ * @returns {Promise<{kind: string, message: string, image: boolean | null, stderr: string}>}
+ */
+export async function probeProfile({ bin, profile, timeoutMs = 60000 }) {
+  return new Promise((resolve) => {
+    const child = spawn(bin, ['--profile', profile], { stdio: ['pipe', 'pipe', 'pipe'] })
+
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+
+    function finish(result) {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      child.kill('SIGTERM')
+      resolve({ image: null, ...result, stderr: stderr.trim() })
+    }
+
+    const timer = setTimeout(
+      () =>
+        finish({
+          kind: OUTCOMES.noResponse,
+          message: `no ACP initialize response within ${timeoutMs}ms`,
+        }),
+      timeoutMs,
+    )
+
+    child.on('error', (error) =>
+      finish({ kind: OUTCOMES.spawnFailed, message: `could not start ${bin}: ${error.message}` }),
+    )
+    child.on('exit', (code) =>
+      finish({
+        kind: OUTCOMES.exited,
+        message: `${bin} exited early with code ${code} before answering`,
+      }),
+    )
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString()
+    })
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString()
+      let index
+      while ((index = stdout.indexOf('\n')) >= 0) {
+        const line = stdout.slice(0, index).trim()
+        stdout = stdout.slice(index + 1)
+        if (line.length === 0) continue
+        let message
+        try {
+          message = JSON.parse(line)
+        } catch {
+          continue
+        }
+        if (message.id !== 1) continue
+        if (message.error) {
+          finish({
+            kind: OUTCOMES.initializeFailed,
+            message: `initialize failed: ${JSON.stringify(message.error).slice(0, 200)}`,
+          })
+          continue
+        }
+        const capabilities = message.result?.agentCapabilities
+        finish({
+          kind:
+            capabilities?.loadSession === true ? OUTCOMES.loadSession : OUTCOMES.noLoadSession,
+          message:
+            capabilities?.loadSession === true
+              ? 'advertises loadSession'
+              : 'the bridge answered but does not advertise loadSession',
+          image: capabilities?.promptCapabilities?.image === true,
+        })
+      }
+    })
+
+    child.stdin.write(
+      `${JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: { protocolVersion: 1, clientCapabilities: {} },
+      })}\n`,
+    )
+  })
+}
+
+export function describeImage(result) {
+  return result.image === true ? 'image: yes' : 'image: no'
+}
+
+/**
+ * `dsh` rewrites the profile's `cordis.yml` while preparing it, so a sandbox that
+ * denies writes to `DSH_HOME` exits on EPERM before answering — which the probe can
+ * only report as "no response", the same text a failed mount produces.
+ */
+export function explainMissingResponse(result) {
+  if (result.kind === OUTCOMES.loadSession || result.kind === OUTCOMES.noLoadSession) return null
+  if (/EPERM|prepareProfile|cordis\.yml/i.test(result.stderr)) {
+    return 'the harness could not write its profile: run this where DSH_HOME is writable (look for EPERM or prepareProfile in its stderr below)'
+  }
+  return null
+}

package/test/probe.test.mjs

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+
+import { OUTCOMES, describeImage, explainMissingResponse } from './probe.mjs'
+
+test('reports loadSession and the image capability', () => {
+  assert.equal(describeImage({ image: true }), 'image: yes')
+  assert.equal(describeImage({ image: false }), 'image: no')
+  assert.equal(describeImage({ image: null }), 'image: no')
+})
+
+test('explains a silent probe whose harness could not write its profile', () => {
+  const hint = explainMissingResponse({
+    kind: OUTCOMES.noResponse,
+    stderr: 'Error: EPERM: operation not permitted, open cordis.yml',
+  })
+
+  assert.match(hint ?? '', /DSH_HOME is writable/)
+})
+
+test('explains a probe that failed while preparing the profile', () => {
+  const hint = explainMissingResponse({
+    kind: OUTCOMES.exited,
+    stderr: 'prepareProfile failed: read-only file system',
+  })
+
+  assert.match(hint ?? '', /DSH_HOME is writable/)
+})
+
+test('leaves an answered probe alone', () => {
+  assert.equal(
+    explainMissingResponse({ kind: OUTCOMES.loadSession, stderr: 'EPERM cordis.yml' }),
+    null,
+  )
+  assert.equal(
+    explainMissingResponse({ kind: OUTCOMES.noLoadSession, stderr: 'prepareProfile' }),
+    null,
+  )
+})
+
+test('does not guess at an unrelated failure', () => {
+  assert.equal(
+    explainMissingResponse({ kind: OUTCOMES.noResponse, stderr: 'some other error' }),
+    null,
+  )
+})

package/test/selfcheck.mjs

@@ -1,85 +1,37 @@
 #!/usr/bin/env node
 /**
- * Self-check for the dsh-acp-replay prototype.
+ * Self-check for the dsh-acp-replay bridge.
  *
- * Boots a profile, performs one ACP `initialize`, and reports whether the
+ * Boots one profile, performs one ACP `initialize`, and reports whether the
  * bridge answered and advertised `loadSession`. Run it after any harness
  * upgrade: if the vendored bridge no longer matches the installed DSH, the
  * mount-time guard prints its reason to stderr and this script exits non-zero
  * with that text, instead of leaving "the provider will not start" unexplained.
  *
  * Usage:
- *   DSH_BIN=dsh DSH_PROFILE=acp-replay node selfcheck.mjs
+ *   DSH_BIN=dsh DSH_PROFILE=acp-replay dsh-acp-replay-selfcheck
  */
 
-import { spawn } from 'node:child_process'
+import { OUTCOMES, describeImage, explainMissingResponse, probeProfile } from './probe.mjs'
 
 const bin = process.env.DSH_BIN ?? 'dsh'
 const profile = process.env.DSH_PROFILE ?? 'acp-replay'
 const timeoutMs = Number(process.env.SELFCHECK_TIMEOUT_MS ?? 60000)
 
-const child = spawn(bin, ['--profile', profile], { stdio: ['pipe', 'pipe', 'pipe'] })
+const result = await probeProfile({ bin, profile, timeoutMs })
+const ok = result.kind === OUTCOMES.loadSession
 
-let stdout = ''
-let stderr = ''
-let settled = false
-
-function finish(ok, message) {
-  if (settled) return
-  settled = true
-  clearTimeout(timer)
-  child.kill('SIGTERM')
-  const details = stderr.trim()
-  console.log(`${ok ? 'OK' : 'FAIL'}: ${message}`)
-  if (!ok && details.length > 0) console.log(`\n--- ${bin} stderr ---\n${details}`)
-  process.exit(ok ? 0 : 1)
-}
-
-const timer = setTimeout(
-  () => finish(false, `no ACP initialize response within ${timeoutMs}ms`),
-  timeoutMs,
+console.log(
+  ok
+    ? `OK: profile "${profile}" ${result.message} (${describeImage(result)})`
+    : `FAIL: ${result.message}`,
 )
 
-child.on('error', (error) => finish(false, `could not start ${bin}: ${error.message}`))
-child.on('exit', (code) => finish(false, `${bin} exited early with code ${code} before answering`))
+const hint = explainMissingResponse(result)
+if (hint) console.log(`\n${hint}`)
 
-child.stderr.on('data', (chunk) => {
-  stderr += chunk.toString()
-})
-
-child.stdout.on('data', (chunk) => {
-  stdout += chunk.toString()
-  let index
-  while ((index = stdout.indexOf('\n')) >= 0) {
-    const line = stdout.slice(0, index).trim()
-    stdout = stdout.slice(index + 1)
-    if (line.length === 0) continue
-    let message
-    try {
-      message = JSON.parse(line)
-    } catch {
-      continue
-    }
-    if (message.id !== 1) continue
-    if (message.error) {
-      finish(false, `initialize failed: ${JSON.stringify(message.error).slice(0, 200)}`)
-      continue
-    }
-    const capabilities = message.result?.agentCapabilities
-    if (capabilities?.loadSession !== true) {
-      finish(false, 'the bridge answered but does not advertise loadSession')
-      continue
-    }
-    const image = capabilities?.promptCapabilities?.image === true ? 'image: yes' : 'image: no'
-    finish(true, `profile "${profile}" advertises loadSession (${image})`)
-  }
-})
+if (!ok && result.stderr.length > 0) {
+  console.log(`\n--- ${bin} stderr ---\n${result.stderr}`)
+}
 
-child.stdin.write(
-  `${JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'initialize',
-    params: { protocolVersion: 1, clientCapabilities: {} },
-  })}\n`,
-)
+process.exit(ok ? 0 : 1)