Merge 0.4.9 into master

[RetricSu]

No description provided.

[coderabbitai]

📝 Walkthrough

Summary by CodeRabbit

• New Features

  • Added daemon mode with node stop, startup safeguards, and improved lifecycle handling.
  • Added structured --json output across CLI commands.
  • Added devnet status monitoring, readiness checks, and mainnet/testnet forking.
  • Added UDT balance, transfer, issue, and destroy commands.
  • Added private-key file support and safer account display options.

• Bug Fixes

  • Improved fork safety, indexer readiness, debugging, downloads, and transaction output reliability.

• Documentation

  • Expanded setup, daemon, JSON, monitoring, fork, deployment, and account guidance.

Walkthrough

OffCKB 0.4.9 adds daemon lifecycle management, structured JSON output, devnet forking, readiness and replay-safety checks, UDT commands and SDK support, status monitoring, hardened tooling, expanded tests, and updated release documentation.

Changes

CLI, daemon, and fork runtime

Layer / File(s)	Summary
CLI runtime and machine output src/cli.ts, src/util/logger.ts, src/util/private-key.ts, src/util/validator.ts, src/cfg/setting.ts	Commands support async execution, JSON results/failures, private-key files, validated settings, and UDT input validation.
Daemon supervision src/cmd/node.ts, src/node/init-chain.ts	Devnet startup supervises CKB, miner, and RPC proxy processes; daemon mode adds PID reservation, identity checks, graceful shutdown, escalation, and cleanup.
Devnet forking and readiness src/devnet/fork.ts, src/devnet/readiness.ts, src/util/fork-safety.ts, src/cmd/devnet-fork.ts, src/cmd/devnet-info.ts	Existing CKB data can be forked into an isolated devnet with genesis validation, migration, persisted fork state, readiness reporting, and mainnet replay-risk checks.

UDT and transaction operations

Layer / File(s)	Summary
UDT SDK and commands src/sdk/ckb.ts, src/type/base.ts, src/cmd/balance.ts, src/cmd/transfer.ts, src/cmd/transfer-all.ts, src/cmd/udt.ts, src/cmd/deposit.ts, src/cmd/deploy.ts	SUDT/XUDT balances, transfers, issuance, destruction, fork-boundary input checks, signing-key resolution, readiness checks, and structured transaction results are implemented.
Fork-aware accounts and scripts src/cmd/accounts.ts, src/cmd/system-scripts.ts, src/scripts/const.ts, src/scripts/private.ts, src/scripts/util.ts	Account addresses, system scripts, CCC clients, and address prefixes adapt to pure, testnet-forked, and mainnet-forked devnets.

Tooling and reliability

Layer / File(s)	Summary
Debug and transaction tooling src/util/json-rpc.ts, src/cmd/debug.ts, src/tools/ckb-tx-dumper.ts	Raw JSON-RPC requests handle transport failures and truncated responses; missing transactions and full header objects are fetched for debug output.
TUI installation and failure propagation src/tools/ckb-tui.ts, src/cmd/clean.ts, src/cmd/config.ts, src/cmd/create.ts, src/node/install.ts, src/util/fs.ts	CKB-TUI downloads are checksum-pinned and path-confined, while command and filesystem failures propagate as exceptions.

Validation and release support

Layer / File(s)	Summary
Behavioral tests tests/*	Tests cover daemon lifecycle, fork preparation, readiness, signing safety, UDT operations, JSON output/RPC, TUI verification, debug dumping, and command behavior.
Release metadata and documentation CHANGELOG.md, README.md, package.json, pnpm-workspace.yaml	Version 0.4.9 notes, command documentation, package metadata, dependency updates, and security overrides are added or updated.

Estimated code review effort: 5 (Critical) | ~120 minutes

Possibly related PRs

• ckb-devrel/offckb#453: Covers the same devnet fork, debug transaction, and fork-aware system-script code paths.
• ckb-devrel/offckb#457: Overlaps on daemon lifecycle, readiness, fork isolation, UDT semantics, and replay-risk handling.
• ckb-devrel/offckb#458: Shares the 0.4.9 version and changelog updates.

Suggested labels: dependencies, javascript

🚥 Pre-merge checks | ✅ 3 | ❌ 2

❌ Failed checks (1 warning, 1 inconclusive)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 11.29% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.
Description check	❓ Inconclusive	No description was provided, so the PR context is too sparse to assess beyond the title.	Add a brief summary of the release contents or primary changes so the PR intent is clear.

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title accurately reflects that this is a 0.4.9 release merge into master.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

---

_{Comment @coderabbitai help to get the list of available commands.}

[github-actions]

❌ Missing Changeset

Please add a changeset describing your changes:

pnpm changeset

If your changes do not need a version bump (docs, CI, refactoring),
add the skip-changeset label to this PR.

For dependency updates, use the dependencies label.

[coderabbitai]

Actionable comments posted: 8

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (4)

src/cmd/config.ts (1)

48-76: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Overly broad try/catch mislabels unrelated errors as validation failures.

Both set+proxy (lines 48-59) and set+ckbVersion (lines 61-76) wrap readSettings()/writeSettings() inside the same try that validates input, so a writeSettings I/O failure gets reported as invalid proxyURL: ... / invalid version value: ..., misleading users about the real cause. The ckbVersion branch additionally re-wraps its own explicit validation-failure throw, producing a doubled prefix (invalid version value: invalid version value, ...).

🛠️ Proposed fix — narrow the try/catch to only the validation call

       case ConfigItem.proxy: {
         if (value == null) throw new Error('No proxyUrl!');

-        try {
-          const proxy = Request.parseProxyUrl(value);
-          const settings = readSettings();
-          settings.proxy = proxy;
-          return writeSettings(settings);
-        } catch (error: unknown) {
-          throw new Error(`invalid proxyURL: ${(error as Error).message}`);
-        }
+        let proxy;
+        try {
+          proxy = Request.parseProxyUrl(value);
+        } catch (error: unknown) {
+          throw new Error(`invalid proxyURL: ${(error as Error).message}`);
+        }
+        const settings = readSettings();
+        settings.proxy = proxy;
+        return writeSettings(settings);
       }

       case ConfigItem.ckbVersion: {
         const settings = readSettings();
-        try {
-          if (isValidVersion(value)) {
-            const version = extractVersion(value!);
-            settings.bins.defaultCKBVersion = version;
-            return writeSettings(settings);
-          } else {
-            throw new Error(
-              `invalid version value, ${value}. Check available versions on https://github.com/nervosnetwork/ckb/tags`,
-            );
-          }
-        } catch (error: unknown) {
-          throw new Error(`invalid version value: ${(error as Error).message}`);
-        }
+        if (!isValidVersion(value)) {
+          throw new Error(
+            `invalid version value, ${value}. Check available versions on https://github.com/nervosnetwork/ckb/tags`,
+          );
+        }
+        const version = extractVersion(value!);
+        settings.bins.defaultCKBVersion = version;
+        return writeSettings(settings);
       }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/config.ts` around lines 48 - 76, Restrict the try/catch blocks in the
ConfigItem.proxy and ConfigItem.ckbVersion branches to only the relevant
validation/parsing calls: Request.parseProxyUrl and the ckb version
validation/extraction logic. Move readSettings and writeSettings outside those
catches so their errors propagate unchanged, and ensure ckbVersion validation
errors receive only one “invalid version value” prefix.

src/cfg/setting.ts (1)

105-118: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Fallback paths still hand out the shared defaultSettings reference.

The deepClone at Line 112 protects the merge path, but the two fallbacks (missing file / validation failure) return the module-level defaultSettings object directly. Callers mutate the returned settings in place (e.g. Config does settings.proxy = proxy before writeSettings), so on first run or on a validation error the shared default is corrupted for the rest of the process. Return a clone here too.

🛡️ Proposed fix

     } else {
-      return defaultSettings;
+      return deepClone(defaultSettings);
     }
   } catch (error) {
     logger.error('Error reading settings:', error);
-    return defaultSettings;
+    return deepClone(defaultSettings);
   }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cfg/setting.ts` around lines 105 - 118, Update readSettings so both
fallback paths—when configPath is absent and when reading or validation
throws—return a deep clone of defaultSettings rather than the shared object.
Reuse the existing deepClone helper and preserve the merged clone behavior for
valid configuration files.

src/cmd/transfer-all.ts (1)

19-27: 🔒 Security & Privacy | 🟠 Major | 🏗️ Heavy lift

Other (CWE-294): Authentication Bypass by Capture-replay

Reachability: External

● Entry
  src/cli.ts:183
  transferAll
│
▼
● Sink
  src/cmd/transfer-all.ts

transfer-all bypasses the mainnet-fork replay-safety enforcement applied elsewhere.

transfer and deposit call validateMainnetForkSigning(...), which blocks non-built-in keys and returns a rejectInputsAtOrBeforeBlock boundary that the SDK enforces via assertInputsCreatedAfter. Here transferAll only calls the warn-only warnIfMainnetForkSigning and invokes ckb.transferAll({ toAddress, privateKey }) with no boundary. Since transfer-all sweeps the entire balance — the path most likely to select copied pre-fork mainnet cells — this leaves the highest-risk command with no replay protection.

Route it through validateMainnetForkSigning and thread the returned boundary into transferAll (SDK support required, mirroring transfer).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/transfer-all.ts` around lines 19 - 27, Replace the warn-only
warnIfMainnetForkSigning call in transfer-all with validateMainnetForkSigning,
capture its rejectInputsAtOrBeforeBlock boundary, and pass that boundary through
the CKB transferAll invocation. Update the SDK transferAll path as needed so it
enforces the boundary via assertInputsCreatedAfter, mirroring transfer and
preserving replay protection for swept inputs.

README.md (1)

23-42: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

TOC missing the new "Fork Mainnet/Testnet" section.

The "Get started" TOC lists steps 1-6 only, but a new step 7 heading (### 7. Fork Mainnet/Testnet Into Your Devnet {#fork-devnet}) was added later in the doc (line 389). The TOC entry for it is missing, so readers can't navigate to it from the table of contents.

📝 Proposed fix

   - [6. Tweak Devnet Config {`#tweak-devnet-config`}](`#6-tweak-devnet-config-tweak-devnet-config`)
+  - [7. Fork Mainnet/Testnet Into Your Devnet {`#fork-devnet`}](`#7-fork-mainnettestnet-into-your-devnet-fork-devnet`)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@README.md` around lines 23 - 42, Add the missing step 7 “Fork Mainnet/Testnet
Into Your Devnet” entry under the “Get started” table-of-contents section,
linking it to the existing fork-devnet anchor and preserving the ordering after
step 6.

🧹 Nitpick comments (4)

src/cmd/devnet-config.ts (1)

73-77: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Preserve the original error object src/cmd/devnet-config.ts:73-77
Attach the tip to the caught InitializationError and rethrow it directly so the original stack and name stay intact. For non-Error values, keep normalizing to new Error(String(error)).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/devnet-config.ts` around lines 73 - 77, Update the error handling in
the devnet configuration flow to append the initialization tip to an
InitializationError while rethrowing that same error object, preserving its name
and stack. For non-Error values, continue normalizing them to a new Error using
their string representation.

src/sdk/ckb.ts (1)

280-335: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

scanned is a shared budget across both scans; XUDT balances can be silently dropped.

scanned is declared once and reused by the SUDT scan (Line 331) and the XUDT scan (Line 333). If the SUDT scan alone reaches maxCells, the XUDT scan starts already at the cap, immediately warns, and returns no XUDT balances — so a lock with many SUDT cells reports incomplete UDT balances while only emitting a generic warning. Consider making the cap per-kind by declaring the counter inside scan.

♻️ Per-kind scan budget

-    let scanned = 0;
-
     const scan = async (scriptInfo: UdtScriptInfo, kind: UdtKind) => {
+      let scanned = 0;
       for await (const cell of this.client.findCells(

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/sdk/ckb.ts` around lines 280 - 335, Make the maxCells budget local to
each invocation of the scan function by moving the scanned counter inside scan.
Preserve the existing stopping and warning behavior so SUDT and XUDT scans each
independently process up to maxCells cells.

src/cmd/node.ts (1)

383-404: 🔒 Security & Privacy | 🔵 Trivial | ⚡ Quick win

Injection (CWE-78): Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')

Reachability: Internal

● Entry
  src/cli.ts:268
  devnetInfo
│
▼
● Hop
  src/cmd/devnet-info.ts
│
▼
● Hop
  src/devnet/fork.ts:302
  migrationNeededFromExitCode
│
▼
● Hop
  src/cmd/status.ts
│
▼
● Hop
  src/devnet/readiness.ts:69
  waitForNodeReady
│
▼
● Sink
  src/cmd/node.ts

Prefer execFile over exec for the command-line lookup.

pid is validated as a positive integer on every reachable path (guarded by isProcessAlive / Number.isInteger), so this isn't actually injectable — but switching to execFile with an argument array removes the interpolated shell command, silences the two static-analysis ERRORs here, and stays safe if a future refactor loosens the pid validation.

♻️ Proposed refactor

-function getProcessCommandLine(pid: number): Promise<string | null> {
-  return new Promise((resolve) => {
-    if (process.platform === 'win32') {
-      exec(`wmic process where ProcessId=${pid} get CommandLine /format:list`, (error, stdout) => {
-        if (error) {
-          resolve(null);
-          return;
-        }
-        const match = stdout.match(/CommandLine=(.+)/);
-        resolve(match ? match[1].trim() : null);
-      });
-    } else {
-      exec(`ps -p ${pid} -o args=`, (error, stdout) => {
-        if (error) {
-          resolve(null);
-          return;
-        }
-        resolve(stdout.trim());
-      });
-    }
-  });
-}
+function getProcessCommandLine(pid: number): Promise<string | null> {
+  return new Promise((resolve) => {
+    const [cmd, args] =
+      process.platform === 'win32'
+        ? ['wmic', ['process', 'where', `ProcessId=${pid}`, 'get', 'CommandLine', '/format:list']]
+        : ['ps', ['-p', String(pid), '-o', 'args=']];
+    execFile(cmd, args as string[], (error, stdout) => {
+      if (error) {
+        resolve(null);
+        return;
+      }
+      if (process.platform === 'win32') {
+        const match = stdout.match(/CommandLine=(.+)/);
+        resolve(match ? match[1].trim() : null);
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}

Update the import to import { execFile, spawn, ChildProcess } from 'child_process';.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/node.ts` around lines 383 - 404, Replace exec with execFile in
getProcessCommandLine, importing execFile alongside the existing child_process
symbols. Invoke WMIC and ps using executable names plus argument arrays rather
than interpolated shell command strings, while preserving the current callbacks,
error handling, and command-line parsing behavior.

Source: Linters/SAST tools

src/util/validator.ts (1)

153-163: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Duplicate branch, and the strict 32-byte check may reject valid xUDT args.

Both branches evaluate the identical condition byteLength !== 32; only the message differs, so they can collapse into one check. Separately, xUDT type-script args are commonly the owner lock hash (32 bytes) plus an optional 4-byte flags field and extension data, whereas SUDT is exactly 32 bytes. Enforcing exactly 32 for xudt will reject transfers/destroys/balance lookups against pre-existing xUDT tokens that carry extension args. Please confirm whether extended xUDT args must be supported here.

♻️ If only 32-byte args are intended

-  if (kind === 'sudt' && byteLength !== 32) {
-    throw new Error(`invalid SUDT type args length: expected 32 bytes, got ${byteLength}`);
-  }
-  if (kind === 'xudt' && byteLength !== 32) {
-    throw new Error(`invalid xUDT type args length: expected 32 bytes, got ${byteLength}`);
-  }
+  if (byteLength !== 32) {
+    throw new Error(
+      `invalid ${kind === 'sudt' ? 'SUDT' : 'xUDT'} type args length: expected 32 bytes, got ${byteLength}`,
+    );
+  }

xUDT type script args format owner lock hash flags extension length

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/util/validator.ts` around lines 153 - 163, Update validateUdtTypeArgs so
SUDT retains the exact 32-byte validation while xUDT accepts the supported
owner-hash, flags, and extension argument lengths, including pre-existing
extended xUDT tokens. Remove the duplicate identical branch and keep error
messages specific to the validation that remains.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/cmd/debug.ts`:
- Around line 91-117: The transaction hash must be validated before it is
interpolated into cache paths. In the flow that calls
buildTransactionJsonFilePath and buildDebugFullTransactionFilePath, reject any
--tx-hash that is not exactly an 0x-prefixed 32-byte hexadecimal value, and only
build or access those paths after validation.

In `@src/cmd/deploy.ts`:
- Around line 30-33: The deploy flow currently only warns about Mainnet-fork
signing and does not enforce the fork replay guard. Replace
warnIfMainnetForkSigning in deploy with validateMainnetForkSigning, retain its
returned fork block, and thread that value through the deploy
transaction/input-selection path so inputs at or before the fork boundary are
rejected, matching transfer/deposit behavior.

In `@src/cmd/node.ts`:
- Around line 216-227: Do not use the first successful RPC response in the
fork-boundary flow to call markForkFirstRunComplete; ensure forkBlockNumber
comes from validated state belonging to the spawned CKB process, or defer
clearing firstRunPending until that process has definitively bound the RPC
listener. Preserve the genesis validation and keep validateMainnetForkSigning()
aligned with the trusted boundary.

In `@src/cmd/udt.ts`:
- Around line 32-82: Update udtIssue and udtDestroy to use replay-safe fork
validation rather than only warnIfMainnetForkSigning: propagate the fork
boundary, reject non-built-in private keys unless allowMainnetReplayRisk is
enabled, and preserve the built-in-key exception. Before the CKB SDK sends each
transaction, apply the same assertInputsCreatedAfter gating used by the transfer
flow so inputs created before the fork are rejected.

In `@src/devnet/fork.ts`:
- Around line 270-273: Update the source-copy loop in the fork flow to inspect
each source entry with lstatSync or an equivalent non-following containment
check before fs.cpSync; reject symlinked entries, especially data/db, and ensure
resolved targets remain within configPath/sourceData before copying. Preserve
copying of valid regular files and directories.

In `@src/tools/ckb-tui.ts`:
- Around line 11-12: Align the download timeout constants and the curl timeout
used by the download flow so the outer spawnSync timeout does not terminate
before curl’s --max-time limit. Update the timeout referenced by the relevant
spawnSync call and curl arguments together, preserving the existing extraction
timeout and download behavior.
- Around line 182-188: Update the installation move step around fs.renameSync to
handle EXDEV by copying extractedBinary to this.binaryPath and then removing the
source when the rename crosses filesystems; rethrow other rename errors
unchanged. Preserve the existing Unix chmod behavior after either move path
completes.

In `@tests/node-command.test.ts`:
- Around line 80-83: Remove the unused logFile binding from the test setup,
unless the test is intended to verify log-file opening; in that case, add an
assertion using logFile with mockOpenSync. Keep the existing dataPath and
pidFile behavior unchanged.

---

Outside diff comments:
In `@README.md`:
- Around line 23-42: Add the missing step 7 “Fork Mainnet/Testnet Into Your
Devnet” entry under the “Get started” table-of-contents section, linking it to
the existing fork-devnet anchor and preserving the ordering after step 6.

In `@src/cfg/setting.ts`:
- Around line 105-118: Update readSettings so both fallback paths—when
configPath is absent and when reading or validation throws—return a deep clone
of defaultSettings rather than the shared object. Reuse the existing deepClone
helper and preserve the merged clone behavior for valid configuration files.

In `@src/cmd/config.ts`:
- Around line 48-76: Restrict the try/catch blocks in the ConfigItem.proxy and
ConfigItem.ckbVersion branches to only the relevant validation/parsing calls:
Request.parseProxyUrl and the ckb version validation/extraction logic. Move
readSettings and writeSettings outside those catches so their errors propagate
unchanged, and ensure ckbVersion validation errors receive only one “invalid
version value” prefix.

In `@src/cmd/transfer-all.ts`:
- Around line 19-27: Replace the warn-only warnIfMainnetForkSigning call in
transfer-all with validateMainnetForkSigning, capture its
rejectInputsAtOrBeforeBlock boundary, and pass that boundary through the CKB
transferAll invocation. Update the SDK transferAll path as needed so it enforces
the boundary via assertInputsCreatedAfter, mirroring transfer and preserving
replay protection for swept inputs.

---

Nitpick comments:
In `@src/cmd/devnet-config.ts`:
- Around line 73-77: Update the error handling in the devnet configuration flow
to append the initialization tip to an InitializationError while rethrowing that
same error object, preserving its name and stack. For non-Error values, continue
normalizing them to a new Error using their string representation.

In `@src/cmd/node.ts`:
- Around line 383-404: Replace exec with execFile in getProcessCommandLine,
importing execFile alongside the existing child_process symbols. Invoke WMIC and
ps using executable names plus argument arrays rather than interpolated shell
command strings, while preserving the current callbacks, error handling, and
command-line parsing behavior.

In `@src/sdk/ckb.ts`:
- Around line 280-335: Make the maxCells budget local to each invocation of the
scan function by moving the scanned counter inside scan. Preserve the existing
stopping and warning behavior so SUDT and XUDT scans each independently process
up to maxCells cells.

In `@src/util/validator.ts`:
- Around line 153-163: Update validateUdtTypeArgs so SUDT retains the exact
32-byte validation while xUDT accepts the supported owner-hash, flags, and
extension argument lengths, including pre-existing extended xUDT tokens. Remove
the duplicate identical branch and keep error messages specific to the
validation that remains.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 1aa213f6-0d19-43b1-b28d-51358a12c532

📥 Commits

Reviewing files that changed from the base of the PR and between 1e517e9 and 1a362aa.

⛔ Files ignored due to path filters (1)

• pnpm-lock.yaml is excluded by !**/pnpm-lock.yaml

📒 Files selected for processing (63)

• CHANGELOG.md
• README.md
• package.json
• pnpm-workspace.yaml
• src/cfg/setting.ts
• src/cli.ts
• src/cmd/accounts.ts
• src/cmd/balance.ts
• src/cmd/clean.ts
• src/cmd/config.ts
• src/cmd/create.ts
• src/cmd/debug.ts
• src/cmd/deploy.ts
• src/cmd/deposit.ts
• src/cmd/devnet-config.ts
• src/cmd/devnet-fork.ts
• src/cmd/devnet-info.ts
• src/cmd/node.ts
• src/cmd/status.ts
• src/cmd/system-scripts.ts
• src/cmd/transfer-all.ts
• src/cmd/transfer.ts
• src/cmd/udt.ts
• src/devnet/fork.ts
• src/devnet/readiness.ts
• src/node/init-chain.ts
• src/node/install.ts
• src/scripts/const.ts
• src/scripts/private.ts
• src/scripts/util.ts
• src/sdk/ckb.ts
• src/tools/ckb-tui.ts
• src/tools/ckb-tx-dumper.ts
• src/type/base.ts
• src/util/fork-safety.ts
• src/util/fs.ts
• src/util/json-rpc.ts
• src/util/link.ts
• src/util/logger.ts
• src/util/private-key.ts
• src/util/validator.ts
• tests/accounts.test.ts
• tests/ckb-tui-checksum.test.ts
• tests/ckb-tx-dumper.test.ts
• tests/debug-tx-file.test.ts
• tests/deposit.test.ts
• tests/devnet-config-command.test.ts
• tests/devnet-fork.test.ts
• tests/devnet-info.test.ts
• tests/fork-safety.test.ts
• tests/init-chain.test.ts
• tests/json-rpc.test.ts
• tests/logger.test.ts
• tests/node-command.test.ts
• tests/node-supervisor.test.ts
• tests/private-key.test.ts
• tests/readiness-warning.test.ts
• tests/readiness.test.ts
• tests/sdk/ckb.udt.test.ts
• tests/status.test.ts
• tests/system-scripts.test.ts
• tests/udt.test.ts
• tests/validator.test.ts

[coderabbitai]

🔒 Security & Privacy | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
rg -n "buildTransactionJsonFilePath|buildDebugFullTransactionFilePath" src/cmd/debug.ts -B2 -A6
rg -n "txHash" src/cli.ts -B3 -A3

Repository: ckb-devrel/offckb

Length of output: 2987

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "## src/cmd/debug.ts"
cat -n src/cmd/debug.ts | sed -n '1,180p'

echo
echo "## search for tx hash validation helpers"
rg -n "0x[0-9a-fA-F]{64}|isValid.*hash|validate.*hash|txHash.*regex|hash.*regex|parseTxHash|transaction hash" src

Repository: ckb-devrel/offckb

Length of output: 13906

---

Path Traversal (CWE-22): Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

Reachability: External

Validate --tx-hash before using it in cache paths. buildTransactionJsonFilePath and buildDebugFullTransactionFilePath interpolate the CLI value directly, so a crafted --tx-hash with path separators can escape the cache directory and overwrite arbitrary files. Restrict it to the expected 0x-prefixed 32-byte hex format before building the file paths.

🧰 Tools

🪛 ast-grep (0.44.1)

[warning] 114-114: Filesystem path is not a string literal; a request-/variable-derived path can enable path traversal. Validate and normalize the path before use.
Context: fs.writeFileSync(txJsonFilePath, JSON.stringify(result.transaction, null, 2))
Note: [CWE-22] Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal').

(detect-non-literal-fs-filename-typescript)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/debug.ts` around lines 91 - 117, The transaction hash must be
validated before it is interpolated into cache paths. In the flow that calls
buildTransactionJsonFilePath and buildDebugFullTransactionFilePath, reject any
--tx-hash that is not exactly an 0x-prefixed 32-byte hexadecimal value, and only
build or access those paths after validation.

Source: Linters/SAST tools

[coderabbitai]

🔒 Security & Privacy | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '\n== locate relevant symbols ==\n'
rg -n "warnIfMainnetForkSigning|validateMainnetForkSigning|deployBinaries|fork boundary|Mainnet-derived devnet|non-built-in private keys|copied Mainnet cell" src -S

printf '\n== inspect src/cmd/deploy.ts ==\n'
wc -l src/cmd/deploy.ts
sed -n '1,220p' src/cmd/deploy.ts

printf '\n== inspect related helpers ==\n'
for f in $(rg -l "warnIfMainnetForkSigning|validateMainnetForkSigning" src); do
  printf '\n-- %s --\n' "$f"
  wc -l "$f"
  sed -n '1,260p' "$f"
done

printf '\n== inspect deployBinaries references ==\n'
rg -n "deployBinaries\(" src -S

printf '\n== inspect transaction input / creation block handling ==\n'
rg -n "creation block|block number|created at|fork boundary|since" src -S

Repository: ckb-devrel/offckb

Length of output: 23784

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '\n== inspect src/deploy/index.ts ==\n'
wc -l src/deploy/index.ts
sed -n '1,260p' src/deploy/index.ts

printf '\n== inspect relevant signing guards in src/sdk/ckb.ts ==\n'
sed -n '360,470p' src/sdk/ckb.ts

printf '\n== inspect deploy-related methods in src/sdk/ckb.ts ==\n'
rg -n "deploy|rejectInputsAtOrBeforeBlock|validateMainnetForkSigning|allowMainnetReplayRisk|build.*deploy" src/sdk/ckb.ts -n -S

Repository: ckb-devrel/offckb

Length of output: 10609

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

sed -n '520,660p' src/sdk/ckb.ts

Repository: ckb-devrel/offckb

Length of output: 5220

---

Other (CWE-294): Authentication Bypass by Capture-replay

Reachability: External

● Entry
  src/cli.ts:96
  DeployOptions
│
▼
● Sink
  src/cmd/deploy.ts

Mainnet-fork deploy needs the same replay guard as transfer/deposit
src/cmd/deploy.ts only warns on Mainnet forks. That leaves deploys free to use non-built-in keys and to spend copied Mainnet inputs without any fork-boundary check, so a tx selected from a forked devnet can still be replayable on Mainnet. Switch to validateMainnetForkSigning and thread the returned fork block into the deploy path so input origins are rejected at or before the fork boundary.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/deploy.ts` around lines 30 - 33, The deploy flow currently only warns
about Mainnet-fork signing and does not enforce the fork replay guard. Replace
warnIfMainnetForkSigning in deploy with validateMainnetForkSigning, retain its
returned fork block, and thread that value through the deploy
transaction/input-selection path so inputs at or before the fork boundary are
rejected, matching transfer/deposit behavior.

[coderabbitai]

🔒 Security & Privacy | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '\n### node.ts around target lines\n'
sed -n '180,260p' src/cmd/node.ts | cat -n

printf '\n### locate first-run helpers/usages\n'
rg -n "markForkFirstRunComplete|firstRunPending|forkBlockNumber|get_tip_block_number|get_block_hash|expectedGenesisHash|rpcUrl" src -S

printf '\n### outline candidate file if available\n'
ast-grep outline src/cmd/node.ts --view expanded || true

Repository: ckb-devrel/offckb

Length of output: 11373

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '\n### src/devnet/fork.ts relevant sections\n'
sed -n '1,130p' src/devnet/fork.ts | cat -n
printf '\n--- later sections around fork creation ---\n'
sed -n '340,560p' src/devnet/fork.ts | cat -n

printf '\n### src/cmd/node.ts relevant sections around daemon startup\n'
sed -n '1,180p' src/cmd/node.ts | cat -n
sed -n '480,560p' src/cmd/node.ts | cat -n

printf '\n### src/devnet/readiness.ts\n'
sed -n '1,120p' src/devnet/readiness.ts | cat -n

Repository: ckb-devrel/offckb

Length of output: 31944

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '\n### fork safety consumers\n'
rg -n "forkBlockNumber|firstRunPending|readForkState|markForkFirstRunComplete|networkIsolated" src -S

printf '\n### src/util/fork-safety.ts\n'
sed -n '1,160p' src/util/fork-safety.ts | cat -n

printf '\n### settings for devnet rpc url and defaults\n'
sed -n '60,100p' src/cfg/setting.ts | cat -n

Repository: ckb-devrel/offckb

Length of output: 7822

---

Other (CWE-345)

Reachability: External

● Entry
  src/cli.ts:268
  devnetInfo
│
▼
● Hop
  src/cmd/devnet-info.ts
│
▼
● Hop
  src/devnet/fork.ts:302
  migrationNeededFromExitCode
│
▼
● Hop
  src/cmd/status.ts
│
▼
● Hop
  src/devnet/readiness.ts:69
  waitForNodeReady
│
▼
● Sink
  src/cmd/node.ts

Do not trust the first RPC responder for fork boundary state src/cmd/node.ts:216-227
forkBlockNumber is later used as the Mainnet fork replay boundary in validateMainnetForkSigning(), so a local process that wins the 127.0.0.1:8114 race can clear firstRunPending with a bogus tip before the spawned node is definitely the responder. Derive the boundary from the validated fork state, or only clear the flag after the RPC listener is bound to the spawned CKB process.

🧰 Tools

🪛 ast-grep (0.44.1)

[warning] Importing child_process exposes a command-execution surface; ensure any command/argument built from input is validated, and prefer execFile/spawn with an argument array over exec.
Context: import { exec, spawn, ChildProcess } from 'child_process';
Note: [CWE-78] Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

(detect-child-process-typescript)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/node.ts` around lines 216 - 227, Do not use the first successful RPC
response in the fork-boundary flow to call markForkFirstRunComplete; ensure
forkBlockNumber comes from validated state belonging to the spawned CKB process,
or defer clearing firstRunPending until that process has definitively bound the
RPC listener. Preserve the genesis validation and keep
validateMainnetForkSigning() aligned with the trusted boundary.

[coderabbitai]

🔒 Security & Privacy | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

printf '--- src/cmd/udt.ts ---\n'
ast-grep outline src/cmd/udt.ts --view expanded || true

printf '\n--- fork-safety references ---\n'
rg -n "warnIfMainnetForkSigning|validateMainnetForkSigning|assertInputsCreatedAfter|udtIssue|udtDestroy" src -S

printf '\n--- src/util/fork-safety.ts ---\n'
wc -l src/util/fork-safety.ts
cat -n src/util/fork-safety.ts | sed -n '1,260p'

printf '\n--- src/cmd/udt.ts (relevant slice) ---\n'
cat -n src/cmd/udt.ts | sed -n '1,220p'

Repository: ckb-devrel/offckb

Length of output: 246

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- src/cmd/udt.ts outline ---'
ast-grep outline src/cmd/udt.ts --view expanded || true

echo
echo '--- fork-safety references ---'
rg -n "warnIfMainnetForkSigning|validateMainnetForkSigning|assertInputsCreatedAfter|udtIssue|udtDestroy" src -S

echo
echo '--- src/util/fork-safety.ts ---'
wc -l src/util/fork-safety.ts
cat -n src/util/fork-safety.ts | sed -n '1,260p'

echo
echo '--- src/cmd/udt.ts (relevant slice) ---'
cat -n src/cmd/udt.ts | sed -n '1,220p'

Repository: ckb-devrel/offckb

Length of output: 9462

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- src/sdk/ckb.ts around assertInputsCreatedAfter and UDT methods ---'
cat -n src/sdk/ckb.ts | sed -n '180,540p'

Repository: ckb-devrel/offckb

Length of output: 14515

---

Other (CWE-294): Authentication Bypass by Capture-replay

Reachability: External

● Entry
  src/cli.ts:157
  DepositOptions
│
▼
● Hop
  src/cmd/deposit.ts:16
  deposit: deposit from devnet miner
│
▼
● Hop
  src/sdk/ckb.ts:57
  UdtIssueOption
│
▼
● Sink
  src/cmd/udt.ts

Use replay-safe fork validation for UDT issue/destroy

udtIssue and udtDestroy only warn on a Mainnet fork, so they can still sign transactions that spend pre-fork inputs. Those signed txs can be replayed on Mainnet if they consume copied cells. Propagate the fork boundary here and reject non-built-in keys unless --allow-mainnet-replay-risk is set, then gate the SDK send path with assertInputsCreatedAfter like the transfer flow.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/cmd/udt.ts` around lines 32 - 82, Update udtIssue and udtDestroy to use
replay-safe fork validation rather than only warnIfMainnetForkSigning: propagate
the fork boundary, reject non-built-in private keys unless
allowMainnetReplayRisk is enabled, and preserve the built-in-key exception.
Before the CKB SDK sends each transaction, apply the same
assertInputsCreatedAfter gating used by the transfer flow so inputs created
before the fork are rejected.

[coderabbitai]

🔒 Security & Privacy | 🟡 Minor | ⚡ Quick win

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== file outline =="
ast-grep outline src/devnet/fork.ts --view expanded || true

echo
echo "== relevant lines in src/devnet/fork.ts =="
nl -ba src/devnet/fork.ts | sed -n '1,380p'

echo
echo "== search validateSourceDir and data/db references =="
rg -n "validateSourceDir|data/db|cpSync|readdirSync|lstatSync|realpathSync|symlink" src/devnet -S

Repository: ckb-devrel/offckb

Length of output: 2788

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== validateSourceDir / copySourceData region =="
sed -n '130,290p' src/devnet/fork.ts

echo
echo "== database migration region =="
sed -n '290,360p' src/devnet/fork.ts

echo
echo "== symlink-related search across src/devnet =="
rg -n "symlink|lstatSync|realpathSync|readlinkSync|cpSync|readdirSync|validateSourceDir|copySourceData|migrateDatabaseCopy" src/devnet -S

Repository: ckb-devrel/offckb

Length of output: 9610

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "== isFolderExists definition =="
rg -n "function isFolderExists|const isFolderExists|isFolderExists\\(" src -S

echo
echo "== surrounding code for isFolderExists if found =="
for f in $(rg -l "function isFolderExists|const isFolderExists" src -S); do
  echo "--- $f ---"
  sed -n '1,220p' "$f"
done

Repository: ckb-devrel/offckb

Length of output: 6536

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail
node - <<'JS'
const fs = require('fs');
const path = require('path');
const os = require('os');

const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'cp-sync-probe-'));
const src = path.join(tmp, 'src');
const dest = path.join(tmp, 'dest');
const ext = path.join(tmp, 'external');
fs.mkdirSync(src, { recursive: true });
fs.mkdirSync(ext, { recursive: true });
fs.mkdirSync(path.join(src, 'data'), { recursive: true });
fs.symlinkSync(ext, path.join(src, 'data', 'db'), 'dir');

console.log('lstat on source link isSymlink:', fs.lstatSync(path.join(src, 'data', 'db')).isSymbolicLink());
console.log('stat on source link isDirectory:', fs.statSync(path.join(src, 'data', 'db')).isDirectory());

fs.cpSync(src, dest, { recursive: true });

const copied = path.join(dest, 'data', 'db');
console.log('lstat on copied link isSymlink:', fs.lstatSync(copied).isSymbolicLink());
console.log('copied symlink target:', fs.readlinkSync(copied));
console.log('copied link resolves to external dir:', fs.realpathSync(copied) === fs.realpathSync(ext));
JS

Repository: ckb-devrel/offckb

Length of output: 368

---

Path Traversal (CWE-59)

Reachability: External

● Entry
  src/cmd/udt.ts:25
  udtIssue
│
▼
● Hop
  src/devnet/readiness.ts:87
  warnIfForkIndexerIsBehind
│
▼
● Sink
  src/devnet/fork.ts

Reject symlinks in the source tree before copying validateSourceDir() follows data/db symlinks, and fs.cpSync() preserves them, so a crafted --from directory can fork a data/db link outside configPath and let migration/startup touch an external CKB database. Use lstatSync or realpath containment checks before copying.

🧰 Tools

🪛 ast-grep (0.44.1)

[warning] Importing child_process exposes a command-execution surface; ensure any command/argument built from input is validated, and prefer execFile/spawn with an argument array over exec.
Context: import { execFileSync, execSync, spawnSync } from 'child_process';
Note: [CWE-78] Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

(detect-child-process-typescript)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/devnet/fork.ts` around lines 270 - 273, Update the source-copy loop in
the fork flow to inspect each source entry with lstatSync or an equivalent
non-following containment check before fs.cpSync; reject symlinked entries,
especially data/db, and ensure resolved targets remain within
configPath/sourceData before copying. Preserve copying of valid regular files
and directories.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

--max-time 300 is unreachable — the outer spawnSync timeout (120s) fires first.

DOWNLOAD_TIMEOUT_MS is 120_000ms, but curl is told --max-time 300 (300s). Node's spawnSync will kill the process at 120s regardless, so the 300s curl flag never takes effect and slow downloads fail earlier than the code suggests.

🛠️ Proposed fix — align both timeouts

-      const curlResult = spawnSync('curl', ['-fsSL', '--max-time', '300', '-o', archivePath, downloadUrl], {
+      const curlResult = spawnSync(
+        'curl',
+        ['-fsSL', '--max-time', String(DOWNLOAD_TIMEOUT_MS / 1000), '-o', archivePath, downloadUrl],
+        {

Also applies to: 152-165

🧰 Tools

🪛 ast-grep (0.44.1)

[warning] Importing child_process exposes a command-execution surface; ensure any command/argument built from input is validated, and prefer execFile/spawn with an argument array over exec.
Context: import { spawnSync } from 'child_process';
Note: [CWE-78] Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

(detect-child-process-typescript)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/tools/ckb-tui.ts` around lines 11 - 12, Align the download timeout
constants and the curl timeout used by the download flow so the outer spawnSync
timeout does not terminate before curl’s --max-time limit. Update the timeout
referenced by the relevant spawnSync call and curl arguments together,
preserving the existing extraction timeout and download behavior.

[coderabbitai]

🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Cross-device rename can fail if the temp dir and data path are on different mounts.

fs.renameSync throws EXDEV when source and destination are on different filesystems. tempDir comes from os.tmpdir() while binaryPath is under the configured data path — these are commonly separate mounts in containers/CI (e.g. tmpfs /tmp). An EXDEV here would abort the entire install with an opaque low-level error.

🛠️ Proposed fix — fall back to copy+unlink on EXDEV

       // 5. Atomically move to the final location
-      fs.renameSync(extractedBinary, this.binaryPath);
+      try {
+        fs.renameSync(extractedBinary, this.binaryPath);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'EXDEV') {
+          fs.copyFileSync(extractedBinary, this.binaryPath);
+          fs.unlinkSync(extractedBinary);
+        } else {
+          throw error;
+        }
+      }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	// 5. Atomically move to the final location
	fs.renameSync(extractedBinary, this.binaryPath);
	// 6. Make executable on Unix
	if (process.platform !== 'win32') {
	fs.chmodSync(this.binaryPath, 0o755);
	}
	// 5. Atomically move to the final location
	try {
	fs.renameSync(extractedBinary, this.binaryPath);
	} catch (error) {
	if ((error as NodeJS.ErrnoException).code === 'EXDEV') {
	fs.copyFileSync(extractedBinary, this.binaryPath);
	fs.unlinkSync(extractedBinary);
	} else {
	throw error;
	}
	}
	// 6. Make executable on Unix
	if (process.platform !== 'win32') {
	fs.chmodSync(this.binaryPath, 0o755);
	}

🧰 Tools

🪛 ast-grep (0.44.1)

[warning] Importing child_process exposes a command-execution surface; ensure any command/argument built from input is validated, and prefer execFile/spawn with an argument array over exec.
Context: import { spawnSync } from 'child_process';
Note: [CWE-78] Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

(detect-child-process-typescript)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/tools/ckb-tui.ts` around lines 182 - 188, Update the installation move
step around fs.renameSync to handle EXDEV by copying extractedBinary to
this.binaryPath and then removing the source when the rename crosses
filesystems; rethrow other rename errors unchanged. Preserve the existing Unix
chmod behavior after either move path completes.

[coderabbitai]

📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Remove or use the unused logFile binding.

logFile is declared but never referenced, which trips @typescript-eslint/no-unused-vars and will fail lint/CI. If it was meant to assert the daemon opens the log file, add an expect(mockOpenSync).toHaveBeenCalledWith(logFile, ...) check; otherwise drop it.

🧹 Proposed removal

 const pidFile = path.join(logDir, 'daemon.pid');
-const logFile = path.join(logDir, 'daemon.log');

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	const dataPath = '/tmp/offckb-devnet-data';
	const logDir = path.join(dataPath, 'logs');
	const pidFile = path.join(logDir, 'daemon.pid');
	const logFile = path.join(logDir, 'daemon.log');
	const dataPath = '/tmp/offckb-devnet-data';
	const logDir = path.join(dataPath, 'logs');
	const pidFile = path.join(logDir, 'daemon.pid');

🧰 Tools

🪛 ESLint

[error] 83-83: 'logFile' is assigned a value but never used. Allowed unused vars must match /^_/u.

(@typescript-eslint/no-unused-vars)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/node-command.test.ts` around lines 80 - 83, Remove the unused logFile
binding from the test setup, unless the test is intended to verify log-file
opening; in that case, add an assertion using logFile with mockOpenSync. Keep
the existing dataPath and pidFile behavior unchanged.

Source: Linters/SAST tools