Compare commits

..

6 Commits

Author SHA1 Message Date
易良
cea15a118b
fix(core,cli): replace full-history structuredClone with shallow/tail variants to prevent OOM on resume (#4644)
* fix(core,cli): replace full-history structuredClone with shallow/tail variants to prevent OOM on resume

Several UI and service call sites clone the entire chat history via
structuredClone(getHistory()) every turn. On a resumed session with
thousands of entries, each clone allocates 150-200 MB transiently.
When multiple async side-requests overlap (suggestion generation,
auto-title, checkpointing), multiple clones coexist on the heap,
pushing V8 past its limit within 10 turns (2 GB heap cap).

Changes:
- AppContainer.tsx: use getHistoryTail(40, true) instead of
  getHistory(true) + slice(-40)
- btwCommand.ts: same pattern, use getHistoryTail(40, true)
- sessionTitle.ts: use getHistoryShallow() (read-only filtering)
- sessionRecap.ts: use getHistoryShallow() (read-only filtering)
- useGeminiStream.ts: use getHistoryShallow() for checkpoint
  serialization (only needs to survive JSON.stringify)

Closes #4624

* fix(test): update mocks for getHistoryShallow/getHistoryTail in sessionTitle and btwCommand tests

* fix(cli): migrate remaining getHistory() clone sites to shallow/tail variants

- AppContainer.tsx rewind path: getHistory() → getHistoryShallow()
  (only used read-only by computeApiTruncationIndex)
- Session.ts ACP rewind: getHistory() → getHistoryShallow()
  (only walks entries to compute truncation index)
- Session.ts stop-hook: getHistory() + filter(.model).pop() →
  getLastModelMessageText() (O(1) backward scan, no clone)

* fix(core): use client-level getHistoryShallow with fallback

sessionTitle.ts and sessionRecap.ts were calling
chat.getHistoryShallow() directly, bypassing the client-level
wrapper that provides a getHistory() fallback when the chat
implementation doesn't support shallow reads. Use
geminiClient.getHistoryShallow() instead.

Update test mocks to match the new call site.

* fix(test): add getHistoryShallow and getLastModelMessageText to Session test mocks

Session.ts now calls chat.getHistoryShallow() in rewindToTurn and
chat.getLastModelMessageText() in the Stop hook. Update all mockChat
instances in Session.test.ts to provide these methods.
2026-06-01 22:53:48 +08:00
JerryLee
68e4819d73
fix(cli): use session channel when closing ACP sessions (#4522)
Detach closeSession/killSession from the session entry's owning channel instead of the current attach target, so the correct channel is decremented and killed during channel overlap (old channel dying while a fresh channel is current). Extracts findChannelInfoForEntry/detachSessionIdFromEntryChannel helpers with unit + integration coverage. Fixes #4325.
2026-06-01 16:23:42 +08:00
qqqys
788f215117
Improve hooks matcher display (#4545)
* feat(cli): improve hooks matcher display

* test(cli): cover hooks navigation levels
2026-06-01 16:18:10 +08:00
jinye
7448724d8a
fix(core): preserve uid in atomicWriteFile to avoid breaking shared-write files (#4431)
* fix(core): preserve uid/gid in atomicWriteFile to avoid breaking shared-write files

atomicWriteFile uses write-to-tmp + rename for crash atomicity. POSIX
rename creates a new inode owned by the calling process's euid/egid, so
the rename silently strips the original uid/gid. On shared-write setups
(e.g. a group-writable file owned by another user in a shared workspace
where the current user has group-write access), every Write/Edit/
NotebookEdit through qwen-code would reset ownership to the running
user and effectively revoke write access for the original collaborators.

The fix:

1. If the target exists and is owned by a different uid/gid than the
   process's effective uid/gid (and we are not root), fall back to
   in-place writeFile. This truncates the existing inode in place,
   preserving uid/gid. The trade-off is loss of crash atomicity for
   this specific case — an acceptable trade for not silently breaking
   shared-write file ownership.

2. If running as root, atomic rename is still used, and ownership is
   restored via chown(uid, gid) after the rename. Root can chown back;
   non-root cannot, hence the in-place fallback for non-root.

3. Windows is unaffected (no POSIX ownership semantics).

Tests:

- New: in-place fallback on uid mismatch — verify content updates, mode
  preserved, and inode unchanged (the inode is the signal that the
  fallback path ran rather than rename).
- New: same scenario triggered via gid mismatch.
- New: positive case — ownership matches → atomic rename → inode changes.

Regression: a v0.16.0 user reported "every write turns a world-writable
file into one other users can no longer write." Bisected to #4096 which
introduced atomicWriteFile + write-to-tmp + rename.

* fix(core): route root through in-place fallback + doc/test follow-ups

Review follow-ups on the atomic-write ownership fix:

1. Remove the root-special-case (rename + post-rename chown). chown
   silently fails inside user-namespaced or CAP_CHOWN-stripped Docker
   containers, which re-triggers the original bug for root-in-Docker
   users — exactly the scenario this fix was reported against. Routing
   root through the same in-place fallback as non-root eliminates this
   failure mode and drops an untestable branch (chown-back can't be
   exercised under non-root CI).

2. Document the three properties traded away by the in-place fallback:
   crash atomicity, concurrent-reader isolation, inotify watcher
   semantics (MODIFY vs MOVED_TO).

3. Document that the in-place fallback surfaces EACCES when the file's
   mode forbids the current user from writing — this is correct
   behavior (atomic rename used to silently replace files the user had
   no permission on, which was arguably a privilege issue).

4. Replace the brittle "see step 6 in the function doc" comment with a
   step-number-independent reference.

5. New test covering the EACCES path: chmod 0o444 + mocked geteuid
   triggers the fallback, fallback hits the read-only file, EACCES
   propagates cleanly, original content is preserved.

* fix(core): harden in-place fallback against symlink/unlink/inode races + doc/test follow-ups

Review follow-ups on #4431 ownership-preservation fix:

CRITICAL — in-place fallback security hardening (wenshao review):

The path-based `fs.writeFile(targetPath, ...)` fallback introduced
three races that the prior `rename(tmp, target)` form did not have:

1. Non-regular files (FIFO/socket/device): fs.writeFile calls
   open(O_WRONLY|O_CREAT|O_TRUNC). On a FIFO this blocks forever
   waiting for a reader. On a character/block device it writes to
   the actual device. The rename path replaced these with a
   regular file.

2. Symlink-swap TOCTOU: an attacker with parent-dir write can swap
   targetPath for a symlink between our stat and our writeFile.
   fs.writeFile follows symlinks at the destination; POSIX rename
   does not. In the very "shared-write workspace / Docker bind-mount"
   scenarios this PR targets, this lets a directory-writable
   attacker redirect agent writes elsewhere (e.g. /etc/passwd if
   the agent runs as root).

3. Unlink race: if targetPath is unlinked between stat and write,
   O_CREAT silently recreates it owned by the calling user — the
   exact ownership change the fallback was designed to prevent.
   Silent regression to the pre-fix bug under this race.

Fix: extract the fallback into writeInPlaceWithFdGuards():

  - open(target, O_WRONLY | O_TRUNC | O_NOFOLLOW) — no O_CREAT, so
    unlink-race surfaces ENOENT instead of silently recreating; and
    O_NOFOLLOW rejects symlink-swaps with ELOOP.
  - fstat(fd) verifies the bound inode's uid/gid still match
    existingStat — refuses the write if an inode-swap happened
    between stat and open.
  - Write through the fd (locked to the verified inode), chmod
    through the fd, close.

Caller now gates the fallback on existingStat.isFile() — non-regular
targets fall through to the atomic path which has well-defined
"replace special-file with regular-file" semantics.

DOC / TEST follow-ups:

- Add hardlink-propagation as a 4th trade-off in the in-place
  fallback JSDoc (review comment #4): rename creates a new inode so
  sibling hardlinks keep old content; in-place truncate+write keeps
  the inode so all hardlinks see new content.

- Update atomicWriteJSON JSDoc to note the write is now
  *conditionally* atomic (review comment #5): atomic when uid/gid
  matches the process, in-place when ownership differs. Previously
  the JSDoc still claimed unconditional atomicity.

- Update caller comments at runtimeStatus.ts and
  worktreeSessionService.ts that advertised crash-atomic writes via
  tmp+rename — those guarantees are now conditional (review
  comment #6).

- Add mode + tmp-leftover assertions to the gid-mismatch test to
  match the uid-mismatch test (review comment #2 — test
  consistency). Without these, a gid-fallback regression that
  silently dropped permissions or left a tmp file would not be
  caught.

- New test: FIFO + ownership mismatch must take the atomic path,
  not in-place (verifies the existingStat.isFile() guard works;
  hang on in-place would trip vitest timeout).

- New test: writing through a symlink with ownership mismatch
  exercises the resolve-then-stat-then-open flow and verifies the
  symlink itself is preserved.

Tests: 192/192 pass (atomicFileWrite + write-file + edit +
fileSystemService).

* fix(core): defer O_TRUNC and verify dev+ino in writeInPlaceWithFdGuards

PR #4431 review follow-up (wenshao critical):

The previous form opened with `O_WRONLY | O_TRUNC | O_NOFOLLOW`, which
truncated the bound file *before* the fd-bound fstat verification ran.
If an attacker swapped the path between the caller's stat and our
open, we would truncate the attacker's substituted inode (destroying
unrelated content) before detecting the swap.

Two fixes:

1. Open without O_TRUNC. Verify dev+ino+uid+gid+isFile match
   expectedStat through fh.stat(). Only then call fh.truncate(0)
   through the validated fd.

2. Expand the verification beyond uid+gid to include dev+ino+isFile.
   uid+gid alone misses a same-owner inode swap (attacker replaces
   the path with a different inode they own). dev+ino is the strong
   identity check; isFile catches a swap to FIFO/socket/device after
   the caller's existingStat.isFile() gate.

JSDoc updated to enumerate the four guards (NOFOLLOW, no CREAT, no
TRUNC at open, dev+ino+uid+gid+isFile via fstat) and explain why
truncation must wait until after verification.

192/192 tests pass.

* fix(core): close FIFO swap race with O_NONBLOCK + cover EOWNERSHIP_CHANGED path

PR #4431 review follow-up (deepseek-v4-pro via /review):

CRITICAL — FIFO swap TOCTOU:

The caller's `existingStat.isFile()` gate uses stat data captured
earlier. An attacker with parent-dir write can swap the regular file
for a FIFO between the caller's stat and our open inside
`writeInPlaceWithFdGuards`. The previous `O_WRONLY | O_NOFOLLOW` open
would then block indefinitely waiting for a FIFO reader; O_NOFOLLOW
only catches symlinks.

Fix: add O_NONBLOCK to the open flags. Defense in depth:

- On a reader-less FIFO, `open(O_WRONLY | O_NONBLOCK)` returns ENXIO
  immediately — no hang.
- If the FIFO has a reader (open succeeds), the subsequent fstat
  isFile() check still refuses the write via EOWNERSHIP_CHANGED.
- For regular files, O_NONBLOCK is a no-op.

CRITICAL test gap — EOWNERSHIP_CHANGED branch untested:

The primary TOCTOU defense (fdStat dev/ino/uid/gid/isFile vs
expectedStat) had no coverage. Exported `writeInPlaceWithFdGuards` so
it can be unit-tested directly:

- New test: simulate post-stat inode swap (unlink + recreate at same
  path), call helper with stale stat, assert EOWNERSHIP_CHANGED and
  that the attacker's content survives.
- New test: simulate post-stat regular→FIFO swap, assert open fails
  fast (ENXIO) or fstat catches it — either way no hang, no write.

DOC fix:

JSDoc said "we open read-write without truncating" but the code uses
O_WRONLY. Wording corrected to "write-only".

194/194 tests pass.

* fix(core): fix flaky inode-swap test + apply review follow-ups

PR #4431 review follow-up (glm-5.1 via /review) — 7 suggestions adopted,
1 partially adopted, 0 rejected:

CI FIX (Ubuntu test failure on tmpfs inode reuse):

The EOWNERSHIP_CHANGED inode-swap test used unlink+create to simulate
a post-stat swap. On Linux tmpfs the freshly-freed inode number is
often reused by the immediately-following create, so dev+ino remained
identical and the guard didn't trip (intermittent on Ubuntu CI; macOS
APFS happened to allocate different inodes). Switched to rename(decoy,
target) which moves an existing distinct inode into place, guaranteed
to differ from the original.

CODE:

- Wrap fh.writeFile failure after fh.truncate(0) with
  EINPLACE_WRITE_FAILED + cause, so callers see explicitly that the
  file was truncated and the write didn't complete (otherwise they
  see raw ENOSPC/EIO and may wrongly assume the original is intact
  given this lives in atomicFileWrite.ts).
- Skip fh.chmod when euid is neither root nor expectedStat.uid —
  chmod is guaranteed to fail with EPERM in that case (POSIX requires
  owner or root). Avoids a guaranteed-failing syscall on every call.
- Caller catches ENOENT from writeInPlaceWithFdGuards and falls
  through to atomic rename path. If the file was deleted between
  caller's stat and our open there is no ownership to preserve; the
  rename path correctly creates a new file at targetPath.

DOC:

- Replaced "defends against four races" with "hardened against
  post-stat races" (the bullet list has 5 items, the count was wrong).
- Reworded "non-regular targets must not reach this function" to
  describe defense-in-depth — O_NONBLOCK + !fdStat.isFile() reject
  post-stat regular→FIFO/socket/device swaps. The old wording made
  it look like O_NONBLOCK was redundant.
- Documented the dual chmod behavior (root vs non-root with foreign
  uid) inline.

TESTS:

- Added happy-path test for writeInPlaceWithFdGuards (write succeeds,
  inode preserved, mode preserved).
- Added ENOENT regression test (verifies the missing-O_CREAT
  property — if file unlinked between stat and open, no silent
  recreate with caller's uid).
- Renamed the misleading "O_NOFOLLOW guard" test (it actually tests
  resolve-through-symlink, not O_NOFOLLOW) to reflect what it does,
  and added a direct ELOOP test that drives writeInPlaceWithFdGuards
  with a path whose final component is a symlink — that's the real
  O_NOFOLLOW exercise.
- Fixed the FIFO test to pass a stat captured from the FIFO itself
  (not a stale regular-file stat) so only the FIFO-specific defense
  fires, not the inode/dev mismatch from a different file.

NOT ADOPTED:

- Skip-when-non-root chmod optimization adopted (small, useful), but
  the larger "structured chmod error model" deferred — best-effort
  matches the existing tryChmod pattern at file scope.

197/197 tests pass.

* fix(core): wrap truncate err + post-write nlink check + guard close + chmod sync

PR #4431 review follow-up (qwen-latest-series-invite-beta-v34 via /review)
— 7 of 10 suggestions adopted, 3 deferred:

CODE:

- **EINPLACE_TRUNCATE_FAILED wrap** (review #3291863048): symmetric to
  the existing EINPLACE_WRITE_FAILED — distinguishes "truncate failed,
  original intact" from "write failed post-truncate, original lost".

- **Post-write nlink === 0 check** (review #3291863059):
  EINODE_UNLINKED_DURING_WRITE detects the fstat-to-close window where
  a concurrent rename-over drops our bound inode's link count to zero
  and our write goes to an anonymous inode close will free. Silent
  data loss path now surfaces.

- **fh.close() guarded in finally** (review #3291863044): close failure
  on NFS/FUSE was masking the original try-body exception (including
  the meaningful EOWNERSHIP_CHANGED, EINPLACE_*, EINODE_*). flush:true
  already fsync'd, so close-after-flush is best-effort.

- **fdStat.uid in canChmod** (review #3291863055 part 1): use the
  fd-bound verified value instead of expectedStat.uid. Defense in depth
  — a future weakening of the fstat guard won't silently widen chmod
  privilege.

- **fh.sync() after chmod** (review #3291863053): chmod is metadata,
  not covered by writeFile({ flush: true }). A crash before lazy
  metadata flush would lose the mode restoration (matters for
  setuid/setgid). One extra syscall, best-effort.

- **@remarks freshness contract** (review #3291863051 partial): JSDoc
  now spells out that expectedStat MUST be a fresh stat captured
  immediately before the call. Stale stats nullify every guard.

- **Concurrent-writer limitation noted** (review #3291863061 partial):
  added a "Known limitation — no advisory locking" paragraph to JSDoc
  rather than adopting flock (Linux-specific, NFS issues, scope
  expansion). Callers needing multi-process coordination should layer
  their own lockfile.

- **@throws documentation** (review #3291863051 partial): four
  documented error codes (EOWNERSHIP_CHANGED, EINODE_UNLINKED_DURING_WRITE,
  EINPLACE_TRUNCATE_FAILED, EINPLACE_WRITE_FAILED).

TESTS:

- **EINPLACE_WRITE_FAILED via FileHandle.prototype.writeFile monkey-patch**
  (review #3291863040): triggers the data-loss path, asserts the wrapped
  code + message + cause, and verifies the file is empty (truncate ran).

- **canChmod=false actually skips chmod** (review #3291863055 part 2):
  prior uid-mismatch test had desiredMode === current mode, couldn't
  distinguish "skipped" from "no-op". New test uses desiredMode=0o755
  on a 0o644 file under canChmod=false → asserts mode stays 0o644.

NOT ADOPTED:

- ENOENT/ELOOP/ENXIO catch extension (review #3291863043): keeping the
  strict refusal for swap-to-special-file. Silent fallthrough-to-replace
  was pre-PR atomic-rename behavior, but in shared-write workspaces
  (this PR's target users) a special-file appearing at the target path
  is a signal worth surfacing, not papering over.

- Diagnostic logging (review #3291863049): the function has no logger
  dependency today; adding one is an architecture decision outside
  this PR's scope. The path taken is implied by the side effects
  (inode preserved vs new) but agreed: out-of-band telemetry would
  help ops. Defer to follow-up.

- flock advisory locking (review #3291863061 main): scope expansion;
  Linux-specific semantics, NFS edge cases. Documented as known
  limitation instead.

- Integration test for ENOENT fallthrough at atomicWriteFile level
  (review #3291863043 part 1): ESM module bindings prevent monkey-
  patching writeInPlaceWithFdGuards from outside. The unit test for
  the helper's ENOENT path covers the throwing behavior; the catch is
  3 lines and review-visible. Defer until a refactor opens an
  injection seam.

- Error code string constants export (review #3291863051 part 3): two
  codes don't merit a constant module. Magic strings are fine at this
  size.

199/199 tests pass.

* docs(core): sync writeRuntimeStatus JSDoc with conditional-atomic contract

PR #4431 review follow-up: function-level JSDoc still claimed
unconditional "Atomically write" and "never sees a partially written
file", inconsistent with the module-level docblock updated in earlier
commits. Updated to describe the conditional-atomic behavior (atomic
when uid/gid matches, in-place fallback when ownership differs) and
explicitly note the concurrent-reader visibility trade-off in the
fallback path. Links to atomicWriteJSON for the full contract.

Doc-only change. 199/199 tests pass.

* fix(core): add explicit fh.sync() — FileHandle.writeFile ignores flush option

PR #4431 review follow-up (qwen3.7-max via /review):

CRITICAL — FileHandle.writeFile silently ignores flush:

Node.js FileHandle.writeFile takes an early-return path that bypasses
the flush option entirely (the option is only honored on the
path-based fs.writeFile form). Our previous code passed
{ flush: true } to fh.writeFile and relied on the implicit fsync.
The only explicit fh.sync() was nested in the chmod block guarded by
canChmod — which is FALSE precisely when a non-root group member
writes to a group-writable file they don't own (the exact shared-write
scenario this PR targets). Net effect: in that branch, zero fsync.
Data sits in the kernel page cache; a crash before lazy flush leaves
the file empty (truncate succeeded) or partially written.

Fix:
- Drop flush from the fhWriteOptions object (silently ignored anyway).
- Add an explicit `fh.sync()` after writeFile succeeds, gated on
  options.flush. Runs BEFORE the chmod block so the canChmod=false
  branch also fsyncs.
- The chmod-block fh.sync() becomes metadata-only (covers the mode
  change), as the data is already on disk.

Updated comments to reflect the actual semantics rather than the
incorrect "writeFile({ flush: true }) fsyncs" assumption.

TESTS (partial adoption of review #3293252349):

- EINPLACE_TRUNCATE_FAILED: sibling test to EINPLACE_WRITE_FAILED.
  Monkey-patches FileHandle.prototype.truncate to throw EIO; asserts
  err.code + cause + "original content is intact" message, and
  verifies the file's original bytes are unchanged (truncate didn't
  run).
- Buffer in in-place fallback: locks in binary fidelity (byte-exact
  comparison) so a future encoding-passthrough regression for Buffer
  data would be caught.

NOT ADOPTED in this commit:

- EINODE_UNLINKED_DURING_WRITE test: requires post-write fh.stat()
  mocking with call-count discrimination (first call: real stat for
  verification; second call: nlink=0). The monkey-patch pattern works
  but is fragile; deferred to a follow-up that may also refactor the
  helper to accept an injectable stat fn for cleaner testability.

201/201 tests pass.

* fix: correct stale flush comment + add fh.sync() regression test

- Fix misleading close() comment that said "flush:true already
  fsync'd" — the explicit fh.sync() does the actual fsync, not the
  flush option (which is silently ignored on FileHandle.writeFile).
- Add regression test verifying fh.sync() is called when flush:true
  and skipped when flush is absent, preventing silent removal of the
  core durability fix.

Addresses wenshao review threads from 2026-05-23.

* test: add EINODE_UNLINKED_DURING_WRITE regression test

Monkey-patches FileHandle.stat to return nlink:0 on the post-write
check, verifying the nlink guard throws with the correct error code.
Addresses wenshao review from 2026-05-28.

* simplify: replace writeInPlaceWithFdGuards with plain fs.writeFile

Address yiliang114's review (CHANGES_REQUESTED):

1. [Critical] Remove ~120 lines of fd-level TOCTOU hardening
   (writeInPlaceWithFdGuards) — over-engineering for a local CLI.
   The in-place fallback now uses plain fs.writeFile + tryChmod,
   matching the EXDEV fallback pattern.

2. [Suggestion] Fix macOS GID false-positive: only compare uid in
   ownershipWouldChange(). macOS inherits parent dir GID for new
   files, so egid !== file.gid was a false positive that needlessly
   dropped crash atomicity.

3. [Suggestion] Trim 60+ lines of JSDoc to project style (AGENTS.md:
   "default to none, add only when WHY is non-obvious").

Net: -748 lines. 24 tests pass.

* fix: restore Stats type import (TS2304 build failure)

* docs: narrow scope from uid/gid to uid-only preservation

The gid check is intentionally skipped because macOS inherits the
parent directory's GID for new files, making egid !== file.gid a
false positive. Update comments and PR description to match the
actual implementation scope.

* test: add inode assertion to symlink ownership-mismatch test

Proves the in-place fallback actually ran instead of atomic rename.
2026-06-01 16:15:15 +08:00
Dragon
59c283670e
Hide internal docs from docs site (#4357) 2026-06-01 15:55:14 +08:00
顾盼
707f1bdb5f
fix(cli): persist /memory toggle state across dialog reopen (#4650)
The Auto-memory / Auto-dream / Auto-skill rows initialized their state
from Config getters, which are frozen at startup and never reflect a
setValue() write. Each /memory reopen re-mounts the dialog and re-reads
that stale snapshot, so a just-flipped toggle appeared to revert. Read the
initial state from the live merged settings instead, matching the existing
write path (bareMode semantics preserved).

Also switch the test's `act` import to `react` — the previously used
@testing-library/react is declared in package.json but not installed, so
the suite could not run — and add a mount/unmount/remount regression test.
2026-06-01 11:29:02 +08:00
66 changed files with 3114 additions and 1446 deletions

View File

@ -17,13 +17,15 @@ npm install
### Setup Content
Link the documentation content from the parent `docs` directory:
Prepare the public documentation content from the parent `docs` directory:
```bash
npm run link
```
This creates a symbolic link from `../docs` to `content` in the project.
This creates a `content` directory with copies of the public docs sections.
Internal planning, design, and E2E notes remain outside the docs site content
tree.
### Development

View File

@ -7,10 +7,10 @@
"type": "module",
"main": "index.js",
"scripts": {
"link": "ln -s ../docs content",
"link": "node scripts/link-public-docs.mjs",
"clean": "rm -rf .next",
"dev": "npm run clean && next --turbopack",
"test": "echo \"Error: no test specified\" && exit 1"
"test": "vitest run --config vitest.config.js"
},
"dependencies": {
"next": "^16.0.8",
@ -18,5 +18,8 @@
"nextra-theme-docs": "^4.6.1",
"react": "^19.2.1",
"react-dom": "^19.2.1"
},
"devDependencies": {
"vitest": "^3.2.4"
}
}

View File

@ -0,0 +1,26 @@
import { cp, mkdir, rm, symlink } from 'node:fs/promises';
import { join } from 'node:path';
import { PUBLIC_DOC_ROOTS } from '../src/app/public-docs.js';
const contentDir = 'content';
async function linkPublicDocs() {
try {
await rm(contentDir, { force: true, recursive: true });
await mkdir(contentDir);
await cp('../docs/index.md', join(contentDir, 'index.md'));
await cp('../docs/_meta.ts', join(contentDir, '_meta.ts'));
for (const root of PUBLIC_DOC_ROOTS) {
await symlink(join('..', '..', 'docs', root), join(contentDir, root));
}
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new Error(
`Failed to link public docs into ${contentDir}: ${message}`,
);
}
}
await linkPublicDocs();

View File

@ -1,10 +1,23 @@
import { generateStaticParamsFor, importPage } from 'nextra/pages';
import { notFound } from 'next/navigation';
import { useMDXComponents as getMDXComponents } from '../../../mdx-components';
import { filterPublicStaticParams, isPublicDocsPath } from '../public-docs';
export const generateStaticParams = generateStaticParamsFor('mdxPath');
const generateAllStaticParams = generateStaticParamsFor('mdxPath');
export const dynamicParams = false;
export async function generateStaticParams(...args) {
const staticParams = await generateAllStaticParams(...args);
return filterPublicStaticParams(staticParams);
}
export async function generateMetadata(props) {
const params = await props.params;
if (!isPublicDocsPath(params.mdxPath)) {
notFound();
}
const { metadata } = await importPage(params.mdxPath);
return metadata;
}
@ -13,6 +26,10 @@ const Wrapper = getMDXComponents().wrapper;
export default async function Page(props) {
const params = await props.params;
if (!isPublicDocsPath(params.mdxPath)) {
notFound();
}
const {
default: MDXContent,
toc,

View File

@ -0,0 +1,59 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
const mocks = vi.hoisted(() => {
const generateAllStaticParams = vi.fn();
return {
generateAllStaticParams,
generateStaticParamsFor: vi.fn(() => generateAllStaticParams),
};
});
vi.mock('nextra/pages', () => ({
generateStaticParamsFor: mocks.generateStaticParamsFor,
importPage: vi.fn(),
}));
vi.mock('next/navigation', () => ({
notFound: vi.fn(),
}));
vi.mock('../../../mdx-components', () => ({
useMDXComponents: () => ({
wrapper: ({ children }) => children,
}),
}));
describe('generateStaticParams', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('filters internal docs from Nextra static params', async () => {
mocks.generateAllStaticParams.mockResolvedValue([
{ mdxPath: [] },
{ mdxPath: ['users', 'foo'] },
{ mdxPath: ['en', 'users'] },
{ mdxPath: ['design', 'bar'] },
{ mdxPath: ['plans'] },
]);
const { generateStaticParams } = await import('./page.jsx');
await expect(generateStaticParams()).resolves.toEqual([
{ mdxPath: [] },
{ mdxPath: ['users', 'foo'] },
{ mdxPath: ['en', 'users'] },
]);
});
it('fails closed if Nextra changes the static params shape', async () => {
mocks.generateAllStaticParams.mockResolvedValue([{ slug: ['users'] }]);
const { generateStaticParams } = await import('./page.jsx');
await expect(generateStaticParams()).rejects.toThrow(
'Expected generateStaticParamsFor("mdxPath") to return objects with an mdxPath array.',
);
});
});

View File

@ -0,0 +1,33 @@
const LOCALE_SEGMENTS = new Set(['en', 'zh', 'de', 'fr', 'ja', 'ru', 'pt-BR']);
// Keep this in sync with the public top-level page entries in docs/_meta.ts.
// docs-site/scripts/link-public-docs.mjs consumes the same allowlist.
export const PUBLIC_DOC_ROOTS = ['users', 'developers'];
const PUBLIC_DOC_ROOT_SET = new Set(PUBLIC_DOC_ROOTS);
function publicRootFromSegments(segments = []) {
if (segments.length === 0 || (segments.length === 1 && segments[0] === '')) {
return undefined;
}
const rootIndex = LOCALE_SEGMENTS.has(segments[0]) ? 1 : 0;
return segments[rootIndex];
}
export function isPublicDocsPath(mdxPath = []) {
const root = publicRootFromSegments(mdxPath);
return root === undefined || PUBLIC_DOC_ROOT_SET.has(root);
}
export function filterPublicStaticParams(staticParams = []) {
return staticParams.filter((staticParam) => {
if (!Array.isArray(staticParam?.mdxPath)) {
throw new TypeError(
'Expected generateStaticParamsFor("mdxPath") to return objects with an mdxPath array.',
);
}
return isPublicDocsPath(staticParam.mdxPath);
});
}

View File

@ -0,0 +1,43 @@
import { describe, expect, it } from 'vitest';
import { filterPublicStaticParams, isPublicDocsPath } from './public-docs.js';
describe('isPublicDocsPath', () => {
it.each([
[[], true],
[[''], true],
[['users', 'foo'], true],
[['design', 'bar'], false],
[['en', 'users'], true],
[['plans'], false],
[['en'], true],
])('returns %s for %j', (mdxPath, expected) => {
expect(isPublicDocsPath(mdxPath)).toBe(expected);
});
});
describe('filterPublicStaticParams', () => {
it('keeps public paths and rejects internal docs paths', () => {
expect(
filterPublicStaticParams([
{ mdxPath: [] },
{ mdxPath: [''] },
{ mdxPath: ['users', 'foo'] },
{ mdxPath: ['en', 'developers'] },
{ mdxPath: ['design', 'bar'] },
{ mdxPath: ['plans'] },
]),
).toEqual([
{ mdxPath: [] },
{ mdxPath: [''] },
{ mdxPath: ['users', 'foo'] },
{ mdxPath: ['en', 'developers'] },
]);
});
it('fails closed if Nextra changes the static params shape', () => {
expect(() => filterPublicStaticParams([{ slug: ['users'] }])).toThrow(
'Expected generateStaticParamsFor("mdxPath") to return objects with an mdxPath array.',
);
});
});

View File

@ -0,0 +1,7 @@
import { defineConfig } from 'vitest/config';
export default defineConfig({
test: {
include: ['src/**/*.test.{js,jsx}'],
},
});

View File

@ -1,9 +1,6 @@
export default {
settings: 'Settings',
auth: 'Authentication',
memory: {
display: 'hidden',
},
'qwen-ignore': 'Ignoring Files',
'trusted-folders': 'Trusted Folders',
themes: 'Themes',

View File

@ -196,6 +196,8 @@ describe('Session', () => {
sendMessageStream: vi.fn(),
addHistory: vi.fn(),
getHistory: vi.fn().mockReturnValue([]),
getHistoryShallow: vi.fn().mockReturnValue([]),
getLastModelMessageText: vi.fn().mockReturnValue(''),
setHistory: vi.fn(),
truncateHistory: vi.fn(),
stripThoughtsFromHistory: vi.fn(),
@ -329,6 +331,7 @@ describe('Session', () => {
{ role: 'model', parts: [{ text: 'second reply' }] },
];
vi.mocked(mockChat.getHistory).mockReturnValue(history);
vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history);
const result = session.rewindToTurn(1);
@ -348,6 +351,7 @@ describe('Session', () => {
{ role: 'model', parts: [{ text: 'first reply' }] },
];
vi.mocked(mockChat.getHistory).mockReturnValue(history);
vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history);
const result = session.rewindToTurn(0);
@ -356,9 +360,9 @@ describe('Session', () => {
});
it('rejects unreachable user turns', () => {
vi.mocked(mockChat.getHistory).mockReturnValue([
{ role: 'user', parts: [{ text: 'first' }] },
]);
const history: Content[] = [{ role: 'user', parts: [{ text: 'first' }] }];
vi.mocked(mockChat.getHistory).mockReturnValue(history);
vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history);
expect(() => session.rewindToTurn(2)).toThrow(
'Cannot rewind to the requested turn',
@ -853,6 +857,8 @@ describe('Session', () => {
sendMessageStream: vi.fn().mockResolvedValue(createEmptyStream()),
addHistory: vi.fn(),
getHistory: vi.fn().mockReturnValue([]),
getHistoryShallow: vi.fn().mockReturnValue([]),
getLastModelMessageText: vi.fn().mockReturnValue(''),
} as unknown as GeminiChat;
mockChat.sendMessageStream = vi
@ -1207,6 +1213,8 @@ describe('Session', () => {
sendMessageStream: vi.fn().mockResolvedValue(createEmptyStream()),
addHistory: vi.fn(),
getHistory: vi.fn().mockReturnValue([]),
getHistoryShallow: vi.fn().mockReturnValue([]),
getLastModelMessageText: vi.fn().mockReturnValue(''),
} as unknown as GeminiChat;
mockConfig.getSessionTokenLimit = vi.fn().mockReturnValue(100);
mockGeminiClient.tryCompressChat
@ -1523,6 +1531,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi
.fn()
.mockResolvedValueOnce(createEmptyStream())
@ -1584,6 +1595,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi
.fn()
.mockResolvedValueOnce(createEmptyStream())
@ -1655,6 +1669,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi
.fn()
.mockResolvedValue(createEmptyStream());
@ -2405,6 +2422,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi.fn().mockResolvedValue(
createStreamWithChunks([
@ -2458,6 +2478,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi
.fn()
.mockResolvedValue(createEmptyStream());
@ -2503,6 +2526,9 @@ describe('Session', () => {
.mockReturnValue([
{ role: 'model', parts: [{ text: 'response text' }] },
]);
mockChat.getLastModelMessageText = vi
.fn()
.mockReturnValue('response text');
mockChat.sendMessageStream = vi
.fn()
.mockResolvedValue(createEmptyStream());

View File

@ -402,7 +402,7 @@ export class Session implements SessionContext {
}
const chat = this.config.getGeminiClient()!.getChat();
const apiHistory = chat.getHistory();
const apiHistory = chat.getHistoryShallow();
const apiTruncateIndex = this.#computeApiTruncationIndexForUserTurn(
apiHistory,
targetTurnIndex,
@ -895,16 +895,10 @@ export class Session implements SessionContext {
return { stopReason: 'end_turn' };
}
// Get response text from the chat history
const history = this.#getCurrentChat().getHistory();
const lastModelMessage = history
.filter((msg: Content) => msg.role === 'model')
.pop();
// Extract last model text without cloning the full history.
const responseText =
lastModelMessage?.parts
?.filter((p: Part): p is { text: string } & Part => 'text' in p)
.map((p: { text: string }) => p.text)
.join('') || '[no response text]';
this.#getCurrentChat().getLastModelMessageText?.() ||
'[no response text]';
const response = await messageBus.request<
HookExecutionRequest,

View File

@ -12,7 +12,6 @@ import {
FileDiscoveryService,
getAllGeminiMdFilenames,
loadServerHierarchicalMemory,
type LoadServerHierarchicalMemoryOptions,
type LoadServerHierarchicalMemoryResponse,
setGeminiMdFilename as setServerGeminiMdFilename,
resolveTelemetrySettings,
@ -1131,7 +1130,6 @@ export async function loadHierarchicalGeminiMemory(
folderTrust: boolean,
memoryImportFormat: 'flat' | 'tree' = 'tree',
contextRuleExcludes: string[] = [],
options: LoadServerHierarchicalMemoryOptions = {},
): Promise<LoadServerHierarchicalMemoryResponse> {
// FIX: Use real, canonical paths for a reliable comparison to handle symlinks.
const realCwd = fs.realpathSync(path.resolve(currentWorkingDirectory));
@ -1151,7 +1149,6 @@ export async function loadHierarchicalGeminiMemory(
folderTrust,
memoryImportFormat,
contextRuleExcludes,
options,
);
}

View File

@ -38,6 +38,8 @@ import type {
import { createDaemonStatusProvider } from './daemonStatusProvider.js';
import {
createHttpAcpBridge,
detachSessionIdFromEntryChannel,
findChannelInfoForEntry,
InvalidClientIdError,
InvalidPermissionOptionError,
InvalidSessionMetadataError,
@ -299,6 +301,56 @@ function makeChannel(opts: FakeAgentOpts = {}): ChannelHandle {
}
describe('createHttpAcpBridge', () => {
it('selects a session entry channel when the current attach channel has changed', () => {
// Model the channel-overlap window directly: old channel A still has
// an entry, while new channel B is the current attach target.
const channelA = { name: 'A' };
const channelB = { name: 'B' };
const infoA = { channel: channelA, label: 'old-dying-channel' };
const infoB = { channel: channelB, label: 'fresh-attach-channel' };
expect(
findChannelInfoForEntry(infoB, [infoA, infoB], {
channel: channelA,
}),
).toBe(infoA);
expect(
findChannelInfoForEntry(infoB, [infoB], {
channel: channelA,
}),
).toBeUndefined();
});
it('detaches a session from its entry channel during channel overlap', () => {
// Model the close/kill overlap window directly: old channel A still owns
// the session entry while fresh channel B is the current attach target.
// The detach helper used by closeSession/killSession must decrement A,
// not the current B channel.
const channelA = { name: 'A' };
const channelB = { name: 'B' };
const infoA = {
channel: channelA,
sessionIds: new Set(['session-a']),
label: 'old-dying-channel',
};
const infoB = {
channel: channelB,
sessionIds: new Set(['session-b']),
label: 'fresh-attach-channel',
};
const selected = detachSessionIdFromEntryChannel(
infoB,
[infoA, infoB],
{ channel: channelA },
'session-a',
);
expect(selected).toBe(infoA);
expect(infoA.sessionIds.has('session-a')).toBe(false);
expect(Array.from(infoB.sessionIds)).toEqual(['session-b']);
});
it('accepts a valid BridgeOptions.eventRingSize at construction time', () => {
// Smoke: positive finite integers are accepted; the underlying
// EventBus ring-size threading is exercised end-to-end in
@ -5840,6 +5892,37 @@ describe('createHttpAcpBridge', () => {
await bridge.shutdown();
});
it('keeps a shared ACP channel alive while closing one of several sessions', async () => {
const handles: ChannelHandle[] = [];
const factory: ChannelFactory = async () => {
const h = makeChannel({ sessionIdPrefix: `s${handles.length}` });
handles.push(h);
return h.channel;
};
const bridge = makeBridge({
channelFactory: factory,
sessionScope: 'thread',
});
const a = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
const b = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
const c = await bridge.spawnOrAttach({ workspaceCwd: WS_A });
expect(handles).toHaveLength(1);
await bridge.closeSession(b.sessionId);
expect(bridge.sessionCount).toBe(2);
expect(handles[0]?.killed).toBe(false);
await bridge.closeSession(a.sessionId);
expect(bridge.sessionCount).toBe(1);
expect(handles[0]?.killed).toBe(false);
await bridge.closeSession(c.sessionId);
expect(bridge.sessionCount).toBe(0);
expect(handles[0]?.killed).toBe(true);
await bridge.shutdown();
});
it('throws SessionNotFoundError for unknown session', async () => {
const bridge = makeBridge();
await expect(bridge.closeSession('nonexistent')).rejects.toThrow(

View File

@ -278,6 +278,33 @@ interface ChannelInfo {
isDying: boolean;
}
/** @internal Visible for bridge lifecycle regression tests. */
export function findChannelInfoForEntry<T extends { channel: unknown }>(
current: T | undefined,
alive: Iterable<T>,
entry: { channel: unknown },
): T | undefined {
if (current?.channel === entry.channel) return current;
for (const info of alive) {
if (info.channel === entry.channel) return info;
}
return undefined;
}
/** @internal Visible for bridge lifecycle regression tests. */
export function detachSessionIdFromEntryChannel<
T extends { channel: unknown; sessionIds: Set<string> },
>(
current: T | undefined,
alive: Iterable<T>,
entry: { channel: unknown },
sessionId: string,
): T | undefined {
const info = findChannelInfoForEntry(current, alive, entry);
info?.sessionIds.delete(sessionId);
return info;
}
interface SessionEntry {
sessionId: string;
workspaceCwd: string;
@ -2031,15 +2058,8 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
return channelInfo;
};
const channelInfoForEntry = (
entry: SessionEntry,
): ChannelInfo | undefined => {
if (channelInfo?.channel === entry.channel) return channelInfo;
for (const info of aliveChannels) {
if (info.channel === entry.channel) return info;
}
return undefined;
};
const channelInfoForEntry = (entry: SessionEntry): ChannelInfo | undefined =>
findChannelInfoForEntry(channelInfo, aliveChannels, entry);
const getChannelClosedReject = (info: ChannelInfo): Promise<never> => {
if (!info.statusClosedReject) {
@ -2887,10 +2907,12 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
: ''),
);
if (defaultEntry === entry) defaultEntry = undefined;
const ci = channelInfo;
if (ci && ci.channel === entry.channel) {
ci.sessionIds.delete(sessionId);
}
const ci = detachSessionIdFromEntryChannel(
channelInfo,
aliveChannels,
entry,
sessionId,
);
for (const id of Array.from(entry.pendingPermissionIds)) {
resolvePending(id, { outcome: { outcome: 'cancelled' } });
}
@ -3717,10 +3739,12 @@ export function createHttpAcpBridge(opts: BridgeOptions): HttpAcpBridge {
// Detach from the channel. The channel dies only when its LAST
// session leaves — other sessions on the same channel keep
// running.
const ci = channelInfo;
if (ci && ci.channel === entry.channel) {
ci.sessionIds.delete(sessionId);
}
const ci = detachSessionIdFromEntryChannel(
channelInfo,
aliveChannels,
entry,
sessionId,
);
// PR 14b fix (codex round 5): tombstone the killed sessionId
// so any in-flight `extNotification` from the (about-to-be-
// killed) child can't seed the early-event buffer for a

View File

@ -1307,22 +1307,6 @@ export const AppContainer = (props: AppContainerProps) => {
config.isTrustedFolder(),
settings.merged.context?.importFormat || 'tree', // Use setting or default to 'tree'
config.getContextRuleExcludes(),
{
onInstructionsLoaded: async (notification) => {
await config
.getHookSystem()
?.fireInstructionsLoadedEvent(
notification.filePath,
notification.memoryType,
notification.loadReason,
{
globs: notification.globs,
triggerFilePath: notification.triggerFilePath,
parentFilePath: notification.parentFilePath,
},
);
},
},
);
config.setUserMemory(memoryContent);
@ -2124,10 +2108,9 @@ export const AppContainer = (props: AppContainerProps) => {
const ac = new AbortController();
suggestionAbortRef.current = ac;
// Use curated history to avoid invalid/empty entries causing API errors
const fullHistory = geminiClient.getChat().getHistory(true);
const conversationHistory =
fullHistory.length > 40 ? fullHistory.slice(-40) : fullHistory;
// Only clone the tail — full structuredClone of a large resumed session
// causes transient heap peaks that trigger OOM (#4624).
const conversationHistory = geminiClient.getHistoryTail(40, true);
generatePromptSuggestion(config, conversationHistory, ac.signal, {
enableCacheSharing: settings.merged.ui?.enableCacheSharing === true,
})
@ -2480,7 +2463,7 @@ export const AppContainer = (props: AppContainerProps) => {
apiTruncateIndex = computeApiTruncationIndex(
historyManager.history,
userItem.id,
geminiClient.getHistory(),
geminiClient.getHistoryShallow(),
);
if (apiTruncateIndex < 0) {
historyManager.addItem(

View File

@ -176,6 +176,11 @@ describe('btwCommand', () => {
.mockReturnValue([
{ role: 'user', parts: [{ text: '杭州天气如何?' }] },
]),
getHistoryTail: vi
.fn()
.mockReturnValue([
{ role: 'user', parts: [{ text: '杭州天气如何?' }] },
]),
getChat: vi.fn().mockReturnValue({
getGenerationConfig: vi.fn().mockReturnValue({
systemInstruction: 'You are helpful',
@ -229,6 +234,10 @@ describe('btwCommand', () => {
{ role: 'user', parts: [{ text: '杭州天气如何?' }] },
{ role: 'user', parts: [{ text: '请顺便解释一下湿度怎么看' }] },
]),
getHistoryTail: vi.fn().mockReturnValue([
{ role: 'user', parts: [{ text: '杭州天气如何?' }] },
{ role: 'user', parts: [{ text: '请顺便解释一下湿度怎么看' }] },
]),
getChat: vi.fn().mockReturnValue({
getGenerationConfig: vi.fn().mockReturnValue({
systemInstruction: 'live system prompt',

View File

@ -55,7 +55,7 @@ function getBtwCacheSafeParams(
geminiClient &&
typeof geminiClient === 'object' &&
typeof geminiClient.getChat === 'function' &&
typeof geminiClient.getHistory === 'function'
typeof geminiClient.getHistoryTail === 'function'
) {
const chat = geminiClient.getChat();
if (
@ -65,12 +65,7 @@ function getBtwCacheSafeParams(
) {
const generationConfig = chat.getGenerationConfig();
if (generationConfig) {
const fullHistory = geminiClient.getHistory(true);
const maxHistoryEntries = 40;
const history =
fullHistory.length > maxHistoryEntries
? fullHistory.slice(-maxHistoryEntries)
: fullHistory;
const history = geminiClient.getHistoryTail(40, true);
return {
generationConfig,

View File

@ -241,22 +241,6 @@ export const directoryCommand: SlashCommand = {
context.services.settings.merged.context?.importFormat ||
'tree', // Use setting or default to 'tree'
config.getContextRuleExcludes(),
{
onInstructionsLoaded: async (notification) => {
await config
.getHookSystem()
?.fireInstructionsLoadedEvent(
notification.filePath,
notification.memoryType,
notification.loadReason,
{
globs: notification.globs,
triggerFilePath: notification.triggerFilePath,
parentFilePath: notification.parentFilePath,
},
);
},
},
);
config.setUserMemory(memoryContent);
config.setGeminiMdFileCount(fileCount);

View File

@ -17,7 +17,6 @@ describe('hooksCommand', () => {
beforeEach(() => {
vi.clearAllMocks();
// Create mock config with hook system
mockConfig = {
getHookSystem: vi.fn().mockReturnValue({
getRegistry: vi.fn().mockReturnValue({
@ -69,4 +68,173 @@ describe('hooksCommand', () => {
});
});
});
describe('non-interactive list output', () => {
function makeContext(opts: {
configHooks: Array<{
eventName: string;
matcher?: string;
source: string;
config: {
type: string;
command?: string;
url?: string;
name?: string;
};
}>;
sessionHooks?: Array<{
eventName: string;
matcher?: string;
config: { type: string; command?: string; name?: string };
}>;
}) {
const sessionConfig = {
getHookSystem: vi.fn().mockReturnValue({
getRegistry: vi.fn().mockReturnValue({
getAllHooks: vi.fn().mockReturnValue(opts.configHooks),
}),
getSessionHooksManager: vi.fn().mockReturnValue({
getAllSessionHooks: vi
.fn()
.mockReturnValue(opts.sessionHooks ?? []),
}),
}),
getSessionId: vi.fn().mockReturnValue('sid'),
};
return createMockCommandContext({
executionMode: 'non_interactive',
services: { config: sessionConfig },
});
}
it('groups hooks under matcher headings', async () => {
const ctx = makeContext({
configHooks: [
{
eventName: 'PreToolUse',
matcher: 'Bash',
source: 'user',
config: { type: 'command', command: '/check-bash.sh' },
},
{
eventName: 'PreToolUse',
matcher: 'Edit|Write',
source: 'project',
config: { type: 'command', command: '/format.sh' },
},
],
});
const result = await hooksCommand.action!(ctx, '');
expect(result).toBeDefined();
const content = (result as { content: string }).content;
expect(content).toContain('### PreToolUse');
expect(content).toContain('#### Matcher: Bash');
expect(content).toContain('/check-bash.sh');
expect(content).toContain('#### Matcher: Edit|Write');
expect(content).toContain('/format.sh');
});
it('renders missing matcher as *', async () => {
const ctx = makeContext({
configHooks: [
{
eventName: 'PreToolUse',
source: 'user',
config: { type: 'command', command: '/anything.sh' },
},
],
});
const result = await hooksCommand.action!(ctx, '');
const content = (result as { content: string }).content;
expect(content).toContain('#### Matcher: *');
expect(content).toContain('/anything.sh');
});
it('does not emit a Matcher heading for non-matcher events like Stop', async () => {
const ctx = makeContext({
configHooks: [
{
eventName: 'Stop',
source: 'user',
config: { type: 'command', command: '/stop-hook.sh' },
},
],
});
const result = await hooksCommand.action!(ctx, '');
const content = (result as { content: string }).content;
expect(content).toContain('### Stop');
expect(content).not.toContain('Matcher:');
expect(content).toContain('/stop-hook.sh');
});
it('preserves registration order for non-matcher events with ignored matchers', async () => {
const ctx = makeContext({
configHooks: [
{
eventName: 'Stop',
matcher: 'A',
source: 'user',
config: { type: 'command', command: '/first.sh' },
},
{
eventName: 'Stop',
matcher: 'B',
source: 'user',
config: { type: 'command', command: '/second.sh' },
},
{
eventName: 'Stop',
matcher: 'A',
source: 'user',
config: { type: 'command', command: '/third.sh' },
},
],
});
const result = await hooksCommand.action!(ctx, '');
const content = (result as { content: string }).content;
expect(content).not.toContain('Matcher:');
expect(content.indexOf('/first.sh')).toBeLessThan(
content.indexOf('/second.sh'),
);
expect(content.indexOf('/second.sh')).toBeLessThan(
content.indexOf('/third.sh'),
);
});
it('groups session hooks by their matcher alongside config hooks', async () => {
const ctx = makeContext({
configHooks: [
{
eventName: 'PreToolUse',
matcher: 'Bash',
source: 'user',
config: { type: 'command', command: '/persistent.sh' },
},
],
sessionHooks: [
{
eventName: 'PreToolUse',
matcher: 'Bash',
config: { type: 'command', command: '/session.sh' },
},
],
});
const result = await hooksCommand.action!(ctx, '');
const content = (result as { content: string }).content;
const matcherOccurrences = content.match(/#### Matcher: Bash/g) ?? [];
expect(matcherOccurrences).toHaveLength(1);
expect(content).toContain('/persistent.sh');
expect(content).toContain('/session.sh');
});
});
});

View File

@ -15,7 +15,10 @@ import { t } from '../../i18n/index.js';
import type {
HookRegistryEntry,
SessionHookEntry,
HookEventName,
} from '@qwen-code/qwen-code-core';
import { supportsMatchers } from '../components/hooks/constants.js';
import { normalizeMatcher } from '../components/hooks/matcherGrouping.js';
/**
* Format hook source for display
@ -71,7 +74,6 @@ const listCommand: SlashCommand = {
const registry = hookSystem.getRegistry();
const configHooks = registry.getAllHooks();
// Get session hooks
const sessionId = config.getSessionId();
const sessionHooksManager = hookSystem.getSessionHooksManager();
const sessionHooks = sessionId
@ -90,86 +92,94 @@ const listCommand: SlashCommand = {
};
}
// Group hooks by event
const hooksByEvent = new Map<
string,
Array<{ hook: HookRegistryEntry | SessionHookEntry; isSession: boolean }>
>();
// Add config hooks
for (const hook of configHooks) {
const eventName = hook.eventName;
if (!hooksByEvent.has(eventName)) {
hooksByEvent.set(eventName, []);
}
hooksByEvent.get(eventName)!.push({ hook, isSession: false });
interface FlattenedHook {
name: string;
source: string;
}
// Add session hooks
for (const hook of sessionHooks) {
const eventName = hook.eventName;
if (!hooksByEvent.has(eventName)) {
hooksByEvent.set(eventName, []);
const hooksByEvent = new Map<string, Map<string, FlattenedHook[]>>();
const addHook = (
eventName: string,
matcher: string,
hook: FlattenedHook,
): void => {
const matcherKey = supportsMatchers(eventName as HookEventName)
? matcher
: '*';
let matcherMap = hooksByEvent.get(eventName);
if (!matcherMap) {
matcherMap = new Map<string, FlattenedHook[]>();
hooksByEvent.set(eventName, matcherMap);
}
hooksByEvent.get(eventName)!.push({ hook, isSession: true });
let bucket = matcherMap.get(matcherKey);
if (!bucket) {
bucket = [];
matcherMap.set(matcherKey, bucket);
}
bucket.push(hook);
};
const extractName = (config: {
type: string;
command?: string;
url?: string;
name?: string;
}): string =>
config.name ||
(config.type === 'command' ? config.command : undefined) ||
(config.type === 'http' ? config.url : undefined) ||
'unnamed';
for (const hook of configHooks) {
const configHook = hook as HookRegistryEntry;
const config = configHook.config as {
type: string;
command?: string;
url?: string;
name?: string;
};
addHook(configHook.eventName, normalizeMatcher(configHook.matcher), {
name: extractName(config),
source: formatHookSource(configHook.source),
});
}
for (const hook of sessionHooks) {
const sessionHook = hook as SessionHookEntry;
const config = sessionHook.config as {
type: string;
command?: string;
url?: string;
name?: string;
};
addHook(sessionHook.eventName, normalizeMatcher(sessionHook.matcher), {
name: extractName(config),
source: formatHookSource('session'),
});
}
let output = `**Configured Hooks (${totalHooks} total)**\n\n`;
for (const [eventName, hooks] of hooksByEvent) {
output += `### ${eventName}\n`;
for (const { hook, isSession } of hooks) {
let name: string;
let source: string;
let matcher: string;
let config: {
type: string;
command?: string;
url?: string;
name?: string;
};
if (isSession) {
// Session hook
const sessionHook = hook as SessionHookEntry;
config = sessionHook.config as {
type: string;
command?: string;
url?: string;
name?: string;
};
name =
config.name ||
(config.type === 'command' ? config.command : undefined) ||
(config.type === 'http' ? config.url : undefined) ||
'unnamed';
source = formatHookSource('session');
matcher = sessionHook.matcher
? ` (matcher: ${sessionHook.matcher})`
: '';
} else {
// Config hook
const configHook = hook as HookRegistryEntry;
config = configHook.config as {
type: string;
command?: string;
url?: string;
name?: string;
};
name =
config.name ||
(config.type === 'command' ? config.command : undefined) ||
(config.type === 'http' ? config.url : undefined) ||
'unnamed';
source = formatHookSource(configHook.source);
matcher = configHook.matcher
? ` (matcher: ${configHook.matcher})`
: '';
for (const [eventName, matcherMap] of hooksByEvent) {
output += `### ${eventName}\n\n`;
const useMatchers = supportsMatchers(eventName as HookEventName);
if (useMatchers) {
for (const [matcher, hookList] of matcherMap) {
output += `#### ${t('Matcher:')} ${matcher}\n`;
for (const hook of hookList) {
output += `- **${hook.name}** [${hook.source}]\n`;
}
output += '\n';
}
output += `- **${name}** [${source}]${matcher}\n`;
} else {
for (const hookList of matcherMap.values()) {
for (const hook of hookList) {
output += `- **${hook.name}** [${hook.source}]\n`;
}
}
output += '\n';
}
output += '\n';
}
return {
@ -191,7 +201,6 @@ export const hooksCommand: SlashCommand = {
context: CommandContext,
args: string,
): Promise<SlashCommandActionReturn> => {
// In interactive mode, open the hooks dialog
const executionMode = context.executionMode ?? 'interactive';
if (executionMode === 'interactive') {
return {
@ -200,7 +209,6 @@ export const hooksCommand: SlashCommand = {
};
}
// In non-interactive mode, list hooks
const result = await listCommand.action?.(context, args);
return result ?? { type: 'message', messageType: 'info', content: '' };
},

View File

@ -4,7 +4,7 @@
* SPDX-License-Identifier: Apache-2.0
*/
import { act } from '@testing-library/react';
import { act } from 'react';
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render } from 'ink-testing-library';
import { MemoryDialog } from './MemoryDialog.js';
@ -41,12 +41,24 @@ describe('MemoryDialog', () => {
mockedUseConfig.mockReturnValue({
getWorkingDir: vi.fn(() => '/tmp/project'),
getProjectRoot: vi.fn(() => '/tmp/project'),
getBareMode: vi.fn(() => false),
// Stale snapshot getters — the dialog must NOT read its toggle state
// from these; it reads from the live merged settings instead.
getManagedAutoMemoryEnabled: vi.fn(() => false),
getManagedAutoDreamEnabled: vi.fn(() => false),
getAutoSkillEnabled: vi.fn(() => false),
} as never);
mockedUseSettings.mockReturnValue({ setValue: vi.fn() } as never);
mockedUseSettings.mockReturnValue({
setValue: vi.fn(),
merged: {
memory: {
enableManagedAutoMemory: false,
enableManagedAutoDream: false,
enableAutoSkill: false,
},
},
} as never);
mockedUseLaunchEditor.mockReturnValue(vi.fn());
});
@ -90,10 +102,10 @@ describe('MemoryDialog', () => {
expect(lastFrame()).toContain('› 1. User memory');
});
it('renders the Auto-skill row with the status from config', () => {
it('renders the Auto-skill row with the status from merged settings', () => {
const { lastFrame } = render(<MemoryDialog onClose={vi.fn()} />);
// beforeEach mocks getAutoSkillEnabled => false
// beforeEach mocks merged.memory.enableAutoSkill => false
expect(lastFrame()).toContain('Auto-skill: off');
});
@ -131,7 +143,10 @@ describe('MemoryDialog', () => {
it('toggles Auto-skill on Enter and persists to workspace settings', () => {
const setValue = vi.fn();
mockedUseSettings.mockReturnValue({ setValue } as never);
mockedUseSettings.mockReturnValue({
setValue,
merged: { memory: { enableAutoSkill: false } },
} as never);
const { lastFrame } = render(<MemoryDialog onClose={vi.fn()} />);
@ -161,4 +176,44 @@ describe('MemoryDialog', () => {
);
expect(lastFrame()).toContain('› Auto-skill: on');
});
it('reflects the persisted value when the dialog is reopened (remounted)', () => {
// Emulate LoadedSettings: setValue writes through to the merged view,
// exactly like the real saveSettings + recomputeMerged path.
const merged = {
memory: {
enableManagedAutoMemory: false,
enableManagedAutoDream: false,
enableAutoSkill: false,
},
};
const setValue = vi.fn((_scope: unknown, key: string, value: boolean) => {
if (key === 'memory.enableAutoSkill') {
merged.memory.enableAutoSkill = value;
}
});
mockedUseSettings.mockReturnValue({ setValue, merged } as never);
const pressKey = (key: { name: string }) => {
const keypressHandler =
mockedUseKeypress.mock.calls[
mockedUseKeypress.mock.calls.length - 1
]![0];
act(() => {
keypressHandler(key as never);
});
};
// First open: toggle Auto-skill on, then close the dialog.
const first = render(<MemoryDialog onClose={vi.fn()} />);
expect(first.lastFrame()).toContain('Auto-skill: off');
pressKey({ name: 'up' }); // focus the Auto-skill row
pressKey({ name: 'return' }); // toggle on
expect(first.lastFrame()).toContain('› Auto-skill: on');
first.unmount();
// Reopen: a fresh mount must read the persisted value, not a stale snapshot.
const second = render(<MemoryDialog onClose={vi.fn()} />);
expect(second.lastFrame()).toContain('Auto-skill: on');
});
});

View File

@ -114,14 +114,20 @@ export function MemoryDialog({ onClose }: MemoryDialogProps) {
const [focusedSection, setFocusedSection] = useState<
'autoMemory' | 'autoDream' | 'autoSkill' | 'list'
>('list');
// Read the initial toggle state from the live merged settings rather than
// the Config snapshot: Config is frozen at startup and never reflects a
// setValue() write, so reopening the dialog would otherwise show stale state.
const bareMode = config.getBareMode();
const readToggle = (value: boolean | undefined): boolean =>
!bareMode && (value ?? true);
const [autoMemoryOn, setAutoMemoryOn] = useState(() =>
config.getManagedAutoMemoryEnabled(),
readToggle(loadedSettings.merged.memory?.enableManagedAutoMemory),
);
const [autoDreamOn, setAutoDreamOn] = useState(() =>
config.getManagedAutoDreamEnabled(),
readToggle(loadedSettings.merged.memory?.enableManagedAutoDream),
);
const [autoSkillOn, setAutoSkillOn] = useState(() =>
config.getAutoSkillEnabled(),
readToggle(loadedSettings.merged.memory?.enableAutoSkill),
);
const [lastDreamAt, setLastDreamAt] = useState<number | null>(null);

View File

@ -0,0 +1,267 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { render } from 'ink-testing-library';
import { HooksConfigSource, HookType } from '@qwen-code/qwen-code-core';
import { HandlerListBody } from './HandlerListBody.js';
import type { HookConfigDisplayInfo } from './types.js';
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
}));
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 120, rows: 24 })),
}));
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: { primary: 'white', secondary: 'gray', accent: 'cyan' },
},
}));
function commandConfig(
command = '/cmd.sh',
async = false,
): HookConfigDisplayInfo {
return {
config: { type: HookType.Command, command, async },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
};
}
function httpConfig(
overrides: Partial<{ name: string; url: string }> = {},
): HookConfigDisplayInfo {
return {
config: {
type: HookType.Http,
url: overrides.url ?? 'https://example.test/hook',
...(overrides.name ? { name: overrides.name } : {}),
} as HookConfigDisplayInfo['config'],
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
};
}
function functionConfig(
overrides: Partial<{ name: string; id: string }> = {},
): HookConfigDisplayInfo {
return {
config: {
type: HookType.Function,
callback: async () => undefined,
errorMessage: 'fn failed',
id: overrides.id ?? 'fn-id',
...(overrides.name ? { name: overrides.name } : {}),
} as HookConfigDisplayInfo['config'],
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
};
}
function promptConfig(
overrides: Partial<{ name: string; prompt: string }> = {},
): HookConfigDisplayInfo {
return {
config: {
type: HookType.Prompt,
prompt: overrides.prompt ?? 'short prompt',
...(overrides.name ? { name: overrides.name } : {}),
} as HookConfigDisplayInfo['config'],
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
};
}
describe('HandlerListBody', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('describeHook (rendered as the row label)', () => {
it('renders the command path for command hooks', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[commandConfig('/check.sh')]}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('[command]');
expect(out).toContain('/check.sh');
});
it('marks async command hooks with " async" in the type column', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[commandConfig('/bg.sh', true)]}
selectedIndex={0}
/>,
);
expect(lastFrame() ?? '').toContain('[command async]');
});
it('prefers the http hook name over the URL', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[httpConfig({ name: 'webhook-A', url: 'https://x' })]}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('[http]');
expect(out).toContain('webhook-A');
expect(out).not.toContain('https://x');
});
it('falls back to the http URL when name is missing', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[httpConfig({ url: 'https://example.test/hook' })]}
selectedIndex={0}
/>,
);
expect(lastFrame() ?? '').toContain('https://example.test/hook');
});
it('prefers the function hook name over the id', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[functionConfig({ name: 'fn-name', id: 'fn-id' })]}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('[function]');
expect(out).toContain('fn-name');
expect(out).not.toContain('fn-id');
});
it('falls back to function id, then to "function-hook" placeholder', () => {
const withId = render(
<HandlerListBody
configs={[functionConfig({ id: 'only-id' })]}
selectedIndex={0}
/>,
);
expect(withId.lastFrame() ?? '').toContain('only-id');
const noNameNoId = render(
<HandlerListBody
configs={[
{
config: {
type: HookType.Function,
callback: async () => undefined,
errorMessage: 'fn failed',
} as HookConfigDisplayInfo['config'],
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
},
]}
selectedIndex={0}
/>,
);
expect(noNameNoId.lastFrame() ?? '').toContain('function-hook');
});
it('truncates long prompt text with "..." and keeps short prompts intact', () => {
const long = 'a'.repeat(80);
const { lastFrame: longFrame } = render(
<HandlerListBody
configs={[promptConfig({ prompt: long })]}
selectedIndex={0}
/>,
);
const longOut = longFrame() ?? '';
expect(longOut).toContain('a'.repeat(50) + '...');
expect(longOut).not.toContain('a'.repeat(51));
const { lastFrame: shortFrame } = render(
<HandlerListBody
configs={[promptConfig({ prompt: 'fits' })]}
selectedIndex={0}
/>,
);
const shortOut = shortFrame() ?? '';
expect(shortOut).toContain('fits');
expect(shortOut).not.toContain('...');
});
it('prefers the prompt name over the prompt text', () => {
const { lastFrame } = render(
<HandlerListBody
configs={[
promptConfig({ name: 'classifier', prompt: 'should not appear' }),
]}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('classifier');
expect(out).not.toContain('should not appear');
});
});
describe('source column', () => {
it('appends the extension name for Extensions-source configs', () => {
const config: HookConfigDisplayInfo = {
config: { type: HookType.Command, command: '/ext.sh' },
source: HooksConfigSource.Extensions,
sourceDisplay: 'my-extension',
enabled: true,
};
const { lastFrame } = render(
<HandlerListBody configs={[config]} selectedIndex={0} />,
);
const out = lastFrame() ?? '';
expect(out).toContain('Extensions');
expect(out).toContain('my-extension');
});
it('uses the long "Session (temporary)" label for session-source configs', () => {
const config: HookConfigDisplayInfo = {
config: { type: HookType.Command, command: '/sess.sh' },
source: HooksConfigSource.Session,
sourceDisplay: 'Session (temporary)',
enabled: true,
};
const { lastFrame } = render(
<HandlerListBody configs={[config]} selectedIndex={0} />,
);
expect(lastFrame() ?? '').toContain('Session (temporary)');
});
});
it('renders numbered rows and footer hint, places arrow on selected', () => {
const configs = [commandConfig('/first.sh'), commandConfig('/second.sh')];
const { lastFrame } = render(
<HandlerListBody configs={configs} selectedIndex={1} />,
);
const out = lastFrame() ?? '';
expect(out).toContain('1.');
expect(out).toContain('2.');
expect(out).toContain('Configured hooks:');
expect(out).toContain('Enter to select · Esc to go back');
const arrowLine = out.split('\n').find((line) => line.includes('❯'));
expect(arrowLine).toBeDefined();
expect(arrowLine).toContain('/second.sh');
});
});

View File

@ -0,0 +1,106 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import { HookType } from '@qwen-code/qwen-code-core';
import type { HookConfigDisplayInfo } from './types.js';
import { getConfigSourceDisplay } from './sourceLabels.js';
import { t } from '../../../i18n/index.js';
interface HandlerListBodyProps {
configs: HookConfigDisplayInfo[];
selectedIndex: number;
}
export function HandlerListBody({
configs,
selectedIndex,
}: HandlerListBodyProps): React.JSX.Element {
const { columns: terminalWidth } = useTerminalSize();
const commandWidth = Math.floor(terminalWidth * 0.65);
const sourceWidth = Math.floor(terminalWidth * 0.3);
return (
<>
<Text bold color={theme.text.primary}>
{t('Configured hooks:')}
</Text>
{configs.map((config, index) => {
const isSelected = index === selectedIndex;
const sourceDisplay = getConfigSourceDisplay(config);
const hookDisplay = describeHook(config);
const typeDisplay = formatTypeDisplay(config);
return (
<Box key={index}>
<Box width={commandWidth}>
<Box minWidth={2}>
<Text
color={isSelected ? theme.text.accent : theme.text.primary}
>
{isSelected ? '❯' : ' '}
</Text>
</Box>
<Text
color={isSelected ? theme.text.accent : theme.text.primary}
bold={isSelected}
wrap="wrap"
>
{`${index + 1}. [${typeDisplay}] ${hookDisplay}`}
</Text>
</Box>
<Box width={2} />
<Box width={sourceWidth}>
<Text color={theme.text.secondary} wrap="wrap">
{sourceDisplay}
</Text>
</Box>
</Box>
);
})}
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('Enter to select · Esc to go back')}
</Text>
</Box>
</>
);
}
function describeHook(info: HookConfigDisplayInfo): string {
const { config } = info;
switch (config.type) {
case HookType.Command:
return config.command || '';
case HookType.Http:
return config.name || config.url || '';
case HookType.Function:
return config.name || config.id || 'function-hook';
case HookType.Prompt: {
const promptText = config.prompt || '';
const maxLength = 50;
return (
config.name ||
(promptText.length > maxLength
? promptText.slice(0, maxLength) + '...'
: promptText)
);
}
default: {
const _exhaustive: never = config;
void _exhaustive;
return '';
}
}
}
function formatTypeDisplay(info: HookConfigDisplayInfo): string {
const { config } = info;
const isAsync = config.type === HookType.Command && config.async === true;
return isAsync ? `${config.type} async` : String(config.type);
}

View File

@ -14,17 +14,14 @@ import {
import { HookConfigDetailStep } from './HookConfigDetailStep.js';
import type { HookEventDisplayInfo, HookConfigDisplayInfo } from './types.js';
// Mock i18n module
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
}));
// Mock useTerminalSize
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 100, rows: 24 })),
}));
// Mock semantic-colors
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: {
@ -51,7 +48,7 @@ describe('HookConfigDetailStep', () => {
},
{ code: 'Other', description: 'show stderr to user only' },
],
configs: [],
matcherGroups: [],
});
const createMockHookConfig = (
@ -170,7 +167,6 @@ describe('HookConfigDetailStep', () => {
<HookConfigDetailStep hookEvent={hookEvent} hookConfig={hookConfig} />,
);
// Should not have Extension label for User Settings
const output = lastFrame();
const extensionMatch = output?.match(/Extension:/g);
expect(extensionMatch).toBeNull();
@ -252,6 +248,74 @@ describe('HookConfigDetailStep', () => {
expect(lastFrame()).toContain('Esc to go back');
});
it('should render Matcher field for matcher-capable events', () => {
const hookEvent = {
...createMockHookEvent(),
event: HookEventName.PreToolUse,
};
const hookConfig: HookConfigDisplayInfo = {
config: {
type: HookType.Command,
command: '/path/to/hook.sh',
},
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
matcher: 'Bash',
enabled: true,
};
const { lastFrame } = render(
<HookConfigDetailStep hookEvent={hookEvent} hookConfig={hookConfig} />,
);
expect(lastFrame()).toContain('Matcher:');
expect(lastFrame()).toContain('Bash');
});
it('should render Matcher as * when matcher is missing for matcher-capable events', () => {
const hookEvent = {
...createMockHookEvent(),
event: HookEventName.PreToolUse,
};
const hookConfig: HookConfigDisplayInfo = {
config: {
type: HookType.Command,
command: '/path/to/hook.sh',
},
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
};
const { lastFrame } = render(
<HookConfigDetailStep hookEvent={hookEvent} hookConfig={hookConfig} />,
);
expect(lastFrame()).toContain('Matcher:');
expect(lastFrame()).toContain('*');
});
it('should not render Matcher field for non-matcher events', () => {
const hookEvent = createMockHookEvent();
const hookConfig: HookConfigDisplayInfo = {
config: {
type: HookType.Command,
command: '/path/to/hook.sh',
},
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
matcher: '*',
enabled: true,
};
const output =
render(
<HookConfigDetailStep hookEvent={hookEvent} hookConfig={hookConfig} />,
).lastFrame() ?? '';
expect(output).not.toContain('Matcher:');
});
it('should handle different event types', () => {
const events = [
HookEventName.PreToolUse,
@ -266,7 +330,7 @@ describe('HookConfigDetailStep', () => {
shortDescription: 'Test',
description: '',
exitCodes: [],
configs: [],
matcherGroups: [],
};
const hookConfig = createMockHookConfig();

View File

@ -10,6 +10,10 @@ import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import type { HookConfigDisplayInfo, HookEventDisplayInfo } from './types.js';
import { HooksConfigSource } from '@qwen-code/qwen-code-core';
import { t } from '../../../i18n/index.js';
import {
getTranslatedSourceDisplayMap,
supportsMatchers,
} from './constants.js';
interface HookConfigDetailStepProps {
hookEvent: HookEventDisplayInfo;
@ -22,26 +26,10 @@ export function HookConfigDetailStep({
}: HookConfigDetailStepProps): React.JSX.Element {
const { columns: terminalWidth } = useTerminalSize();
// Get source display
const getSourceDisplay = (): string => {
switch (hookConfig.source) {
case HooksConfigSource.Project:
return t('Local Settings');
case HooksConfigSource.User:
return t('User Settings');
case HooksConfigSource.System:
return t('System Settings');
case HooksConfigSource.Extensions:
return t('Extensions');
default:
return hookConfig.source;
}
};
const sourceDisplay = getTranslatedSourceDisplayMap()[hookConfig.source];
// Check if this is from an extension
const isFromExtension = hookConfig.source === HooksConfigSource.Extensions;
// Get hook type display
const getHookTypeDisplay = (): string => {
switch (hookConfig.config.type) {
case 'command':
@ -51,7 +39,6 @@ export function HookConfigDetailStep({
}
};
// Get command to display
const getCommand = (): string => {
if (hookConfig.config.type === 'command') {
return hookConfig.config.command;
@ -59,7 +46,6 @@ export function HookConfigDetailStep({
return '';
};
// Get prompt to display
const getPrompt = (): string => {
if (hookConfig.config.type === 'prompt') {
return hookConfig.config.prompt;
@ -67,7 +53,6 @@ export function HookConfigDetailStep({
return '';
};
// Get URL to display
const getUrl = (): string => {
if (hookConfig.config.type === 'http') {
return hookConfig.config.url;
@ -75,22 +60,19 @@ export function HookConfigDetailStep({
return '';
};
// Calculate box width for command display
const commandBoxWidth = Math.min(terminalWidth - 6, 80);
// Label width for alignment (Extension: is the longest label)
const labelWidth = 12;
const showMatcher = supportsMatchers(hookEvent.event);
return (
<Box flexDirection="column" paddingX={1}>
{/* Title */}
<Box marginBottom={1}>
<Text bold color={theme.text.primary}>
{t('Hook details')}
</Text>
</Box>
{/* Event */}
<Box>
<Box width={labelWidth}>
<Text color={theme.text.secondary}>{t('Event:')}</Text>
@ -98,7 +80,15 @@ export function HookConfigDetailStep({
<Text color={theme.text.primary}>{hookEvent.event}</Text>
</Box>
{/* Type */}
{showMatcher && (
<Box>
<Box width={labelWidth}>
<Text color={theme.text.secondary}>{t('Matcher:')}</Text>
</Box>
<Text color={theme.text.primary}>{hookConfig.matcher || '*'}</Text>
</Box>
)}
<Box>
<Box width={labelWidth}>
<Text color={theme.text.secondary}>{t('Type:')}</Text>
@ -106,18 +96,16 @@ export function HookConfigDetailStep({
<Text color={theme.text.primary}>{getHookTypeDisplay()}</Text>
</Box>
{/* Source */}
<Box>
<Box width={labelWidth}>
<Text color={theme.text.secondary}>{t('Source:')}</Text>
</Box>
<Text color={theme.text.primary}>{getSourceDisplay()}</Text>
<Text color={theme.text.primary}>{sourceDisplay}</Text>
{hookConfig.sourcePath && (
<Text color={theme.text.secondary}> ({hookConfig.sourcePath})</Text>
)}
</Box>
{/* Extension name (only for extensions) */}
{isFromExtension && hookConfig.sourceDisplay && (
<Box>
<Box width={labelWidth}>
@ -127,7 +115,6 @@ export function HookConfigDetailStep({
</Box>
)}
{/* Name (if exists) */}
{hookConfig.config.name && (
<Box>
<Box width={labelWidth}>
@ -137,7 +124,6 @@ export function HookConfigDetailStep({
</Box>
)}
{/* Description (if exists) */}
{hookConfig.config.description && (
<Box>
<Box width={labelWidth}>
@ -149,7 +135,6 @@ export function HookConfigDetailStep({
</Box>
)}
{/* Command / Prompt / URL - based on hook type */}
{hookConfig.config.type === 'command' && (
<>
<Box marginTop={1}>
@ -201,7 +186,6 @@ export function HookConfigDetailStep({
</>
)}
{/* Help text */}
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t(
@ -210,7 +194,6 @@ export function HookConfigDetailStep({
</Text>
</Box>
{/* Footer hint */}
<Box marginTop={1}>
<Text color={theme.text.secondary}>{t('Esc to go back')}</Text>
</Box>

View File

@ -12,19 +12,24 @@ import {
HookType,
} from '@qwen-code/qwen-code-core';
import { HookDetailStep } from './HookDetailStep.js';
import type { HookEventDisplayInfo } from './types.js';
import type { HookConfigDisplayInfo, HookEventDisplayInfo } from './types.js';
// Mock i18n module
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
t: vi.fn((key: string, options?: { count?: string }) => {
if (key === '{{count}} hook' && options?.count) {
return `${options.count} hook`;
}
if (key === '{{count}} hooks' && options?.count) {
return `${options.count} hooks`;
}
return key;
}),
}));
// Mock useTerminalSize
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 100, rows: 24 })),
}));
// Mock semantic-colors
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: {
@ -39,190 +44,282 @@ vi.mock('../../semantic-colors.js', () => ({
},
}));
describe('HookDetailStep', () => {
const createMockHookInfo = (
event: HookEventName,
configCount = 0,
hasDescription = true,
): HookEventDisplayInfo => ({
event,
shortDescription: `Short description for ${event}`,
description: hasDescription ? `Detailed description for ${event}` : '',
exitCodes: [
function makeConfig(
command: string,
source: HooksConfigSource = HooksConfigSource.User,
matcher = '*',
): HookConfigDisplayInfo {
return {
config: { command, type: HookType.Command },
source,
sourceDisplay:
source === HooksConfigSource.User ? 'User Settings' : 'Local Settings',
matcher,
enabled: true,
};
}
function makeHookInfo(
groups: Array<{
matcher: string;
configs: HookConfigDisplayInfo[];
sequential?: boolean;
}>,
opts: {
event?: HookEventName;
description?: string;
exitCodes?: HookEventDisplayInfo['exitCodes'];
flatConfigs?: HookConfigDisplayInfo[];
} = {},
): HookEventDisplayInfo {
const matcherGroups = opts.flatConfigs
? [{ matcher: '*', configs: opts.flatConfigs, sequential: false }]
: groups;
return {
event: opts.event ?? HookEventName.PreToolUse,
shortDescription: 'short',
description: opts.description ?? '',
exitCodes: opts.exitCodes ?? [
{ code: 0, description: 'Success' },
{ code: 2, description: 'Block' },
],
configs: Array(configCount)
.fill(null)
.map((_, i) => ({
config: { command: `hook-command-${i}`, type: HookType.Command },
source:
i % 2 === 0 ? HooksConfigSource.User : HooksConfigSource.Project,
sourceDisplay: i % 2 === 0 ? 'User Settings' : 'Local Settings',
enabled: true,
})),
});
matcherGroups,
};
}
describe('HookDetailStep', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('should render hook event name as title', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse);
it('renders the "Event - Matchers" title', () => {
const hook = makeHookInfo([
{ matcher: '*', configs: [makeConfig('/x.sh')] },
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
expect(lastFrame()).toContain(HookEventName.PreToolUse);
expect(lastFrame()).toContain(`${HookEventName.PreToolUse} - Matchers`);
});
it('should render description when present', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse, 0, true);
it('renders event description when present', () => {
const hook = makeHookInfo(
[{ matcher: '*', configs: [makeConfig('/x.sh')] }],
{ description: 'desc-for-event' },
);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
expect(lastFrame()).toContain('Detailed description for PreToolUse');
expect(lastFrame()).toContain('desc-for-event');
});
it('should not render description section when empty', () => {
const hook = createMockHookInfo(HookEventName.Stop, 0, false);
it('renders inline exit code descriptions', () => {
const hook = makeHookInfo([
{ matcher: '*', configs: [makeConfig('/x.sh')] },
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('Exit code');
expect(out).toContain('Success');
expect(out).toContain('Block');
const hook2 = makeHookInfo(
[{ matcher: '*', configs: [makeConfig('/x.sh')] }],
{
exitCodes: [{ code: 'Other', description: 'other-desc' }],
},
);
// Stop event has empty description
const output = lastFrame();
expect(output).toContain(HookEventName.Stop);
const out2 =
render(<HookDetailStep hook={hook2} selectedIndex={0} />).lastFrame() ??
'';
expect(out2).toContain('Other exit codes');
expect(out2).toContain('other-desc');
});
it('should render exit codes', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse);
it('shows empty state when no matcher groups', () => {
const hook = makeHookInfo([]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('Exit codes');
expect(output).toContain('0');
expect(output).toContain('Success');
expect(output).toContain('2');
expect(output).toContain('Block');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('No hooks configured for this event');
expect(out).toContain('Esc to go back');
});
it('should show empty state when no configs', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse, 0);
it('renders matcher rows with [Source] label and matcher', () => {
const hook = makeHookInfo([
{
matcher: '*',
configs: [makeConfig('/star.sh', HooksConfigSource.User, '*')],
},
{
matcher: 'Bash',
configs: [makeConfig('/bash.sh', HooksConfigSource.User, 'Bash')],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('No hooks configured for this event');
expect(output).toContain('To add hooks, edit settings.json');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('[User] *');
expect(out).toContain('[User] Bash');
});
it('should show configured hooks list when configs exist', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse, 2);
it('uses Project label for workspace-source matcher groups', () => {
const hook = makeHookInfo([
{
matcher: 'Bash',
configs: [makeConfig('/bash.sh', HooksConfigSource.Project, 'Bash')],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('Configured hooks');
expect(output).toContain('[command]');
expect(output).toContain('hook-command-0');
expect(output).toContain('hook-command-1');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('[Project] Bash');
});
it('should show source display for each config', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse, 2);
it('renders all unique source labels for mixed-source matcher groups', () => {
const hook = makeHookInfo([
{
matcher: 'Bash',
configs: [
makeConfig('/user.sh', HooksConfigSource.User, 'Bash'),
makeConfig('/project.sh', HooksConfigSource.Project, 'Bash'),
makeConfig('/user-two.sh', HooksConfigSource.User, 'Bash'),
],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('User Settings');
expect(output).toContain('Local Settings');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('[User, Project] Bash');
});
it('should show selection indicator for first config', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse, 3);
it('renders singular "1 hook" and plural "N hooks"', () => {
const hook = makeHookInfo([
{
matcher: '*',
configs: [makeConfig('/a.sh', HooksConfigSource.User, '*')],
},
{
matcher: 'Bash',
configs: [
makeConfig('/b.sh', HooksConfigSource.User, 'Bash'),
makeConfig('/c.sh', HooksConfigSource.User, 'Bash'),
],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('❯');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('1 hook');
expect(out).toContain('2 hooks');
});
it('should show keyboard hint for going back', () => {
const hook = createMockHookInfo(HookEventName.PreToolUse);
it('does not render specific command text on the matcher list page', () => {
const hook = makeHookInfo([
{
matcher: 'Bash',
configs: [
makeConfig(
'/very-specific-command.sh',
HooksConfigSource.User,
'Bash',
),
],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
expect(lastFrame()).toContain('Esc to go back');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).not.toContain('/very-specific-command.sh');
});
it('should render with multiple configs', () => {
const hook = createMockHookInfo(HookEventName.PostToolUse, 5);
it('places the selection arrow on the selected matcher row', () => {
const hook = makeHookInfo([
{
matcher: '*',
configs: [makeConfig('/a.sh', HooksConfigSource.User, '*')],
},
{
matcher: 'Bash',
configs: [makeConfig('/b.sh', HooksConfigSource.User, 'Bash')],
},
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).toContain('1.');
expect(output).toContain('2.');
expect(output).toContain('3.');
expect(output).toContain('4.');
expect(output).toContain('5.');
const out =
render(<HookDetailStep hook={hook} selectedIndex={1} />).lastFrame() ??
'';
const arrowLine = out.split('\n').find((line) => line.includes('❯'));
expect(arrowLine).toBeDefined();
expect(arrowLine).toContain('Bash');
});
it('should handle hook with no exit codes', () => {
const hook: HookEventDisplayInfo = {
event: HookEventName.PreToolUse,
shortDescription: 'Test',
description: 'Test description',
exitCodes: [],
configs: [],
};
it('renders the Enter/Esc footer hint', () => {
const hook = makeHookInfo([
{ matcher: '*', configs: [makeConfig('/x.sh')] },
]);
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
const output = lastFrame();
expect(output).not.toContain('Exit codes');
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('Enter to select');
expect(out).toContain('Esc to go back');
});
it('should handle different hook event types', () => {
const events = [
HookEventName.Stop,
HookEventName.PreToolUse,
HookEventName.PostToolUse,
HookEventName.UserPromptSubmit,
HookEventName.SessionStart,
HookEventName.SessionEnd,
];
describe('non-matcher events (e.g. Stop)', () => {
it('does not append " - Matchers" to the title', () => {
const hook = makeHookInfo([], {
event: HookEventName.Stop,
flatConfigs: [makeConfig('/stop.sh', HooksConfigSource.User, '*')],
});
for (const event of events) {
const hook = createMockHookInfo(event, 1);
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain(HookEventName.Stop);
expect(out).not.toContain('- Matchers');
});
const { lastFrame } = render(
<HookDetailStep hook={hook} selectedIndex={0} />,
);
it('renders the handler list directly (with command and source)', () => {
const hook = makeHookInfo([], {
event: HookEventName.Stop,
flatConfigs: [
makeConfig('/stop-one.sh', HooksConfigSource.User, '*'),
makeConfig('/stop-two.sh', HooksConfigSource.Project, '*'),
],
});
expect(lastFrame()).toContain(event);
}
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('[command]');
expect(out).toContain('/stop-one.sh');
expect(out).toContain('/stop-two.sh');
expect(out).toContain('User Settings');
expect(out).toContain('Local Settings');
expect(out).toContain('Enter to select');
});
it('shows empty state when a non-matcher event has no handlers', () => {
const hook = makeHookInfo([], {
event: HookEventName.Stop,
flatConfigs: [],
});
const out =
render(<HookDetailStep hook={hook} selectedIndex={0} />).lastFrame() ??
'';
expect(out).toContain('No hooks configured for this event');
});
});
});

View File

@ -4,13 +4,10 @@
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import type { HookEventDisplayInfo } from './types.js';
import { HooksConfigSource, HookType } from '@qwen-code/qwen-code-core';
import { getTranslatedSourceDisplayMap } from './constants.js';
import { t } from '../../../i18n/index.js';
import { supportsMatchers } from './constants.js';
import { HookEventMatcherListStep } from './HookEventMatcherListStep.js';
import { HookEventHandlerListStep } from './HookEventHandlerListStep.js';
interface HookDetailStepProps {
hook: HookEventDisplayInfo;
@ -21,159 +18,10 @@ export function HookDetailStep({
hook,
selectedIndex,
}: HookDetailStepProps): React.JSX.Element {
const hasConfigs = hook.configs.length > 0;
const { columns: terminalWidth } = useTerminalSize();
// Get translated source display map
const sourceDisplayMap = getTranslatedSourceDisplayMap();
// Calculate column widths (command: 70%, source: 30%)
const commandWidth = Math.floor(terminalWidth * 0.65);
const sourceWidth = Math.floor(terminalWidth * 0.3);
// Get source display for config list
const getConfigSourceDisplay = (config: {
source: HooksConfigSource;
sourceDisplay: string;
}): string => {
if (config.source === HooksConfigSource.Extensions) {
// For extensions, sourceDisplay is the extension name
return `${sourceDisplayMap[HooksConfigSource.Extensions]} (${config.sourceDisplay})`;
}
return sourceDisplayMap[config.source] || config.source;
};
return (
<Box flexDirection="column" paddingX={1}>
{/* Title */}
<Box marginBottom={1}>
<Text bold color={theme.text.primary}>
{hook.event}
</Text>
</Box>
{/* Description */}
{hook.description && (
<Box marginBottom={1}>
<Text color={theme.text.secondary}>{hook.description}</Text>
</Box>
)}
{/* Exit codes */}
{hook.exitCodes.length > 0 && (
<Box flexDirection="column" marginBottom={1}>
<Text bold color={theme.text.primary}>
{t('Exit codes:')}
</Text>
{hook.exitCodes.map((ec, index) => (
<Box key={index}>
<Text color={theme.text.secondary}>
{` ${ec.code}: ${ec.description}`}
</Text>
</Box>
))}
</Box>
)}
<Box marginTop={1} />
{/* Configs or empty state */}
{hasConfigs ? (
<>
<Text bold color={theme.text.primary}>
{t('Configured hooks:')}
</Text>
{hook.configs.map((config, index) => {
const isSelected = index === selectedIndex;
const sourceDisplay = getConfigSourceDisplay(config);
// Get display text based on hook type
let hookDisplay = '';
const hookType = config.config.type;
if (hookType === HookType.Command) {
// For command hook, show command (truncate if too long)
hookDisplay = config.config.command || '';
} else if (hookType === HookType.Http) {
// For http hook, show name or url
hookDisplay = config.config.name || config.config.url || '';
} else if (hookType === HookType.Function) {
// For function hook, show name or id
hookDisplay =
config.config.name || config.config.id || 'function-hook';
} else if (hookType === HookType.Prompt) {
// For prompt hook, show name or prompt content (truncated)
const promptText = config.config.prompt || '';
const maxLength = 50;
hookDisplay =
config.config.name ||
(promptText.length > maxLength
? promptText.slice(0, maxLength) + '...'
: promptText);
}
// Check if this is an async hook (only command hooks support async)
const isAsync =
hookType === HookType.Command && config.config.async === true;
const typeDisplay = isAsync
? `${hookType} async`
: String(hookType);
return (
<Box key={index}>
{/* Left column: selector + display */}
<Box width={commandWidth}>
<Box minWidth={2}>
<Text
color={
isSelected ? theme.text.accent : theme.text.primary
}
>
{isSelected ? '❯' : ' '}
</Text>
</Box>
<Text
color={isSelected ? theme.text.accent : theme.text.primary}
bold={isSelected}
wrap="wrap"
>
{`${index + 1}. [${typeDisplay}] ${hookDisplay}`}
</Text>
</Box>
{/* Spacer between columns */}
<Box width={2} />
{/* Right column: source */}
<Box width={sourceWidth}>
<Text color={theme.text.secondary} wrap="wrap">
{sourceDisplay}
</Text>
</Box>
</Box>
);
})}
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('Enter to select · Esc to go back')}
</Text>
</Box>
</>
) : (
<>
<Box>
<Text color={theme.text.secondary}>
{t('No hooks configured for this event.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('To add hooks, edit settings.json directly or ask Qwen.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>{t('Esc to go back')}</Text>
</Box>
</>
)}
</Box>
);
if (supportsMatchers(hook.event)) {
return (
<HookEventMatcherListStep hook={hook} selectedIndex={selectedIndex} />
);
}
return <HookEventHandlerListStep hook={hook} selectedIndex={selectedIndex} />;
}

View File

@ -0,0 +1,56 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import type { HookEventDisplayInfo } from './types.js';
import { HookEventHeader } from './HookEventHeader.js';
import { HandlerListBody } from './HandlerListBody.js';
import { getAllConfigs } from './matcherGrouping.js';
import { t } from '../../../i18n/index.js';
interface HookEventHandlerListStepProps {
hook: HookEventDisplayInfo;
selectedIndex: number;
}
export function HookEventHandlerListStep({
hook,
selectedIndex,
}: HookEventHandlerListStepProps): React.JSX.Element {
const flatConfigs = getAllConfigs(hook);
const hasConfigs = flatConfigs.length > 0;
return (
<Box flexDirection="column" paddingX={1}>
<HookEventHeader
title={hook.event}
description={hook.description}
exitCodes={hook.exitCodes}
/>
{hasConfigs ? (
<HandlerListBody configs={flatConfigs} selectedIndex={selectedIndex} />
) : (
<>
<Box>
<Text color={theme.text.secondary}>
{t('No hooks configured for this event.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('To add hooks, edit settings.json directly or ask Qwen.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>{t('Esc to go back')}</Text>
</Box>
</>
)}
</Box>
);
}

View File

@ -0,0 +1,65 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import type { HookEventDisplayInfo } from './types.js';
import { t } from '../../../i18n/index.js';
interface HookEventHeaderProps {
title: string;
description: string;
exitCodes: HookEventDisplayInfo['exitCodes'];
}
export function HookEventHeader({
title,
description,
exitCodes,
}: HookEventHeaderProps): React.JSX.Element {
return (
<>
<Box marginBottom={1}>
<Text bold color={theme.text.primary}>
{title}
</Text>
</Box>
{description && (
<Box marginBottom={1}>
<Text color={theme.text.secondary}>{description}</Text>
</Box>
)}
<ExitCodesBlock exitCodes={exitCodes} />
</>
);
}
function ExitCodesBlock({
exitCodes,
}: {
exitCodes: HookEventDisplayInfo['exitCodes'];
}): React.JSX.Element | null {
if (exitCodes.length === 0) return null;
return (
<Box flexDirection="column" marginBottom={1}>
{exitCodes.map((ec, index) => {
const label =
typeof ec.code === 'number'
? `${t('Exit code')} ${ec.code}`
: `${t('Other exit codes')}`;
return (
<Box key={index}>
<Text color={theme.text.secondary}>
{label} - {ec.description}
</Text>
</Box>
);
})}
</Box>
);
}

View File

@ -0,0 +1,95 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import type { HookEventDisplayInfo } from './types.js';
import { HookEventHeader } from './HookEventHeader.js';
import { formatSourceLabels } from './sourceLabels.js';
import { t } from '../../../i18n/index.js';
interface HookEventMatcherListStepProps {
hook: HookEventDisplayInfo;
selectedIndex: number;
}
export function HookEventMatcherListStep({
hook,
selectedIndex,
}: HookEventMatcherListStepProps): React.JSX.Element {
const { columns: terminalWidth } = useTerminalSize();
const leftWidth = Math.floor(terminalWidth * 0.6);
const hasMatchers = hook.matcherGroups.length > 0;
return (
<Box flexDirection="column" paddingX={1}>
<HookEventHeader
title={`${hook.event} - ${t('Matchers')}`}
description={hook.description}
exitCodes={hook.exitCodes}
/>
{hasMatchers ? (
<>
{hook.matcherGroups.map((group, index) => {
const isSelected = index === selectedIndex;
const sourceLabel = formatSourceLabels(group.configs);
const count = group.configs.length;
const countLabel =
count === 1
? t('{{count}} hook', { count: String(count) })
: t('{{count}} hooks', { count: String(count) });
const rowText = `${index + 1}. [${sourceLabel}] ${group.matcher}`;
return (
<Box key={`${group.matcher}-${index}`}>
<Box minWidth={2}>
<Text
color={isSelected ? theme.text.accent : theme.text.primary}
>
{isSelected ? '❯' : ' '}
</Text>
</Box>
<Box width={leftWidth}>
<Text
color={isSelected ? theme.text.accent : theme.text.primary}
bold={isSelected}
wrap="wrap"
>
{rowText}
</Text>
</Box>
<Text color={theme.text.secondary}>{countLabel}</Text>
</Box>
);
})}
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('Enter to select · Esc to go back')}
</Text>
</Box>
</>
) : (
<>
<Box>
<Text color={theme.text.secondary}>
{t('No hooks configured for this event.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>
{t('To add hooks, edit settings.json directly or ask Qwen.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>{t('Esc to go back')}</Text>
</Box>
</>
)}
</Box>
);
}

View File

@ -0,0 +1,252 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { render } from 'ink-testing-library';
import {
HookEventName,
HooksConfigSource,
HookType,
} from '@qwen-code/qwen-code-core';
import { HookMatcherDetailStep } from './HookMatcherDetailStep.js';
import type {
HookConfigDisplayInfo,
HookEventDisplayInfo,
HookMatcherDisplayInfo,
} from './types.js';
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
}));
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 100, rows: 24 })),
}));
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: {
primary: 'white',
secondary: 'gray',
accent: 'cyan',
},
status: {
success: 'green',
error: 'red',
},
},
}));
function makeEvent(
overrides: Partial<HookEventDisplayInfo> = {},
): HookEventDisplayInfo {
return {
event: HookEventName.PreToolUse,
shortDescription: 'short',
description: 'Input to command is JSON of tool call arguments.',
exitCodes: [
{ code: 0, description: 'stdout/stderr not shown' },
{ code: 2, description: 'show stderr to model and block tool call' },
{
code: 'Other',
description: 'show stderr to user only but continue with tool call',
},
],
matcherGroups: [],
...overrides,
};
}
function makeConfig(
command: string,
source: HooksConfigSource = HooksConfigSource.User,
): HookConfigDisplayInfo {
return {
config: { command, type: HookType.Command },
source,
sourceDisplay:
source === HooksConfigSource.User ? 'User Settings' : 'Local Settings',
matcher: 'Bash',
enabled: true,
};
}
describe('HookMatcherDetailStep', () => {
beforeEach(() => {
vi.clearAllMocks();
});
it('renders the "Event - Matcher: <value>" title', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [makeConfig('/x.sh')],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
);
expect(lastFrame()).toContain(
`${HookEventName.PreToolUse} - Matcher: Bash`,
);
});
it('keeps the "Matcher:" prefix when the matcher is the * fallback', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: '*',
configs: [makeConfig('/x.sh')],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
);
expect(lastFrame()).toContain(`${HookEventName.PreToolUse} - Matcher: *`);
});
it('keeps the event description visible on the matcher detail page', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [makeConfig('/x.sh')],
};
const out =
render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
).lastFrame() ?? '';
expect(out).toContain('Input to command is JSON of tool call arguments.');
});
it('renders inline exit code descriptions on the matcher detail page', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [makeConfig('/x.sh')],
};
const out =
render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
).lastFrame() ?? '';
expect(out).toContain('Exit code 0');
expect(out).toContain('stdout/stderr not shown');
expect(out).toContain('Exit code 2');
expect(out).toContain('show stderr to model and block tool call');
expect(out).toContain('Other exit codes');
expect(out).toContain(
'show stderr to user only but continue with tool call',
);
});
it('renders the handler command for command hooks', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [makeConfig('/check.sh')],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('[command]');
expect(out).toContain('/check.sh');
});
it('renders multiple handler rows with numbering', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Edit|Write',
configs: [
makeConfig('/first.sh'),
makeConfig('/second.sh', HooksConfigSource.Project),
],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={1}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('1.');
expect(out).toContain('2.');
expect(out).toContain('/first.sh');
expect(out).toContain('/second.sh');
expect(out).toContain('User Settings');
expect(out).toContain('Local Settings');
});
it('places the selection arrow on the selected handler row', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [makeConfig('/first.sh'), makeConfig('/second.sh')],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={1}
/>,
);
const out = lastFrame() ?? '';
const arrowLine = out.split('\n').find((line) => line.includes('❯'));
expect(arrowLine).toBeDefined();
expect(arrowLine).toContain('/second.sh');
});
it('renders empty state when the matcher group has no handlers', () => {
const hookEvent = makeEvent();
const matcherGroup: HookMatcherDisplayInfo = {
matcher: 'Bash',
configs: [],
};
const { lastFrame } = render(
<HookMatcherDetailStep
hookEvent={hookEvent}
matcherGroup={matcherGroup}
selectedIndex={0}
/>,
);
const out = lastFrame() ?? '';
expect(out).toContain('No hooks configured for this matcher');
expect(out).toContain('Esc to go back');
});
});

View File

@ -0,0 +1,54 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { Box, Text } from 'ink';
import { theme } from '../../semantic-colors.js';
import type { HookEventDisplayInfo, HookMatcherDisplayInfo } from './types.js';
import { HookEventHeader } from './HookEventHeader.js';
import { HandlerListBody } from './HandlerListBody.js';
import { t } from '../../../i18n/index.js';
interface HookMatcherDetailStepProps {
hookEvent: HookEventDisplayInfo;
matcherGroup: HookMatcherDisplayInfo;
selectedIndex: number;
}
export function HookMatcherDetailStep({
hookEvent,
matcherGroup,
selectedIndex,
}: HookMatcherDetailStepProps): React.JSX.Element {
const hasConfigs = matcherGroup.configs.length > 0;
return (
<Box flexDirection="column" paddingX={1}>
<HookEventHeader
title={`${hookEvent.event} - ${t('Matcher:')} ${matcherGroup.matcher}`}
description={hookEvent.description}
exitCodes={hookEvent.exitCodes}
/>
{hasConfigs ? (
<HandlerListBody
configs={matcherGroup.configs}
selectedIndex={selectedIndex}
/>
) : (
<>
<Box>
<Text color={theme.text.secondary}>
{t('No hooks configured for this matcher.')}
</Text>
</Box>
<Box marginTop={1}>
<Text color={theme.text.secondary}>{t('Esc to go back')}</Text>
</Box>
</>
)}
</Box>
);
}

View File

@ -14,10 +14,8 @@ import {
import { HooksListStep } from './HooksListStep.js';
import type { HookEventDisplayInfo } from './types.js';
// Mock i18n module
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string, options?: { count?: string }) => {
// Handle pluralization
if (key === '{{count}} hook configured' && options?.count) {
return `${options.count} hook configured`;
}
@ -28,12 +26,10 @@ vi.mock('../../../i18n/index.js', () => ({
}),
}));
// Mock useTerminalSize
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 120, rows: 24 })),
}));
// Mock semantic-colors
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: {
@ -52,23 +48,30 @@ describe('HooksListStep', () => {
const createMockHookInfo = (
event: HookEventName,
configCount = 0,
): HookEventDisplayInfo => ({
event,
shortDescription: `Description for ${event}`,
description: `Detailed description for ${event}`,
exitCodes: [
{ code: 0, description: 'Success' },
{ code: 2, description: 'Block' },
],
configs: Array(configCount)
): HookEventDisplayInfo => {
const configs = Array(configCount)
.fill(null)
.map((_, i) => ({
config: { command: `hook-${i}`, type: HookType.Command },
config: {
command: `hook-${i}`,
type: HookType.Command as const,
},
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
matcher: '*',
enabled: true,
})),
});
}));
return {
event,
shortDescription: `Description for ${event}`,
description: `Detailed description for ${event}`,
exitCodes: [
{ code: 0, description: 'Success' },
{ code: 2, description: 'Block' },
],
matcherGroups: configs.length > 0 ? [{ matcher: '*', configs }] : [],
};
};
beforeEach(() => {
vi.clearAllMocks();

View File

@ -10,6 +10,13 @@ import { useTerminalSize } from '../../hooks/useTerminalSize.js';
import type { HookEventDisplayInfo } from './types.js';
import { t } from '../../../i18n/index.js';
function configCountFor(hook: HookEventDisplayInfo): number {
return hook.matcherGroups.reduce(
(sum, group) => sum + group.configs.length,
0,
);
}
interface HooksListStepProps {
hooks: HookEventDisplayInfo[];
selectedIndex: number;
@ -21,7 +28,6 @@ export function HooksListStep({
}: HooksListStepProps): React.JSX.Element {
const { columns: terminalWidth } = useTerminalSize();
// Calculate responsive width for hook name column (min 20, max 35)
const hookNameWidth = Math.min(
35,
Math.max(20, Math.floor(terminalWidth * 0.25)),
@ -35,13 +41,11 @@ export function HooksListStep({
);
}
// Calculate total configured hooks
const totalConfigured = hooks.reduce(
(sum, hook) => sum + hook.configs.length,
(sum, hook) => sum + configCountFor(hook),
0,
);
// Get the correct plural/singular form
const hooksConfiguredText =
totalConfigured === 1
? t('{{count}} hook configured', { count: String(totalConfigured) })
@ -66,7 +70,7 @@ export function HooksListStep({
{hooks.map((hook, index) => {
const isSelected = index === selectedIndex;
const configCount = hook.configs.length;
const configCount = configCountFor(hook);
const maxDigits = String(hooks.length).length;
const paddedIndex = String(index + 1).padStart(maxDigits);

View File

@ -5,22 +5,46 @@
*/
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { cleanup } from 'ink-testing-library';
import { HooksManagementDialog } from './HooksManagementDialog.js';
import { renderWithProviders } from '../../../test-utils/render.js';
import { useKeypress } from '../../hooks/useKeypress.js';
import { useConfig } from '../../contexts/ConfigContext.js';
import { loadSettings, SettingScope } from '../../../config/settings.js';
import type { Key } from '../../contexts/KeypressContext.js';
// Mock useKeypress
vi.mock('../../hooks/useKeypress.js', () => ({
useKeypress: vi.fn(),
}));
const mockedUseKeypress = vi.mocked(useKeypress);
const mockedUseConfig = vi.mocked(useConfig);
const mockedLoadSettings = vi.mocked(loadSettings);
let keypressHandler: ((key: Key) => void) | null = null;
/**
* Returns a `useConfig` return value with `disableAllHooks` flipped on, while
* keeping every other method shaped like the default mock at the top of this
* file. Used with `mockReturnValueOnce` for the initial render — the dialog's
* navigation stack is seeded in a `useState` initializer that only consults
* `disableAllHooks` once, so subsequent renders falling back to the default
* mock is fine.
*/
function disabledHooksConfig(): ReturnType<typeof useConfig> {
return {
getExtensions: vi.fn(() => []),
getDisableAllHooks: vi.fn(() => true),
getHookSystem: vi.fn(() => ({
getSessionHooksManager: vi.fn(() => ({
getAllSessionHooks: vi.fn(() => []),
})),
})),
getSessionId: vi.fn(() => 'test-session-id'),
} as unknown as ReturnType<typeof useConfig>;
}
// Mock i18n module
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string, options?: { count?: string }) => {
// Handle pluralization
if (key === '{{count}} hook configured' && options?.count) {
return `${options.count} hook configured`;
}
@ -33,7 +57,6 @@ vi.mock('../../../i18n/index.js', () => ({
if (key === '{{count}} configured hooks' && options?.count) {
return `${options.count} configured hooks`;
}
// Handle interpolation for disabled message
if (
key ===
'All hooks are currently disabled. You have {{count}} that are not running.' &&
@ -45,12 +68,10 @@ vi.mock('../../../i18n/index.js', () => ({
}),
}));
// Mock useTerminalSize
vi.mock('../../hooks/useTerminalSize.js', () => ({
useTerminalSize: vi.fn(() => ({ columns: 120, rows: 24 })),
}));
// Mock useConfig
vi.mock('../../contexts/ConfigContext.js', async (importOriginal) => {
const actual =
await importOriginal<typeof import('../../contexts/ConfigContext.js')>();
@ -69,7 +90,6 @@ vi.mock('../../contexts/ConfigContext.js', async (importOriginal) => {
};
});
// Mock loadSettings
vi.mock('../../../config/settings.js', async (importOriginal) => {
const actual =
await importOriginal<typeof import('../../../config/settings.js')>();
@ -81,7 +101,6 @@ vi.mock('../../../config/settings.js', async (importOriginal) => {
};
});
// Mock semantic-colors
vi.mock('../../semantic-colors.js', () => ({
theme: {
text: {
@ -100,7 +119,6 @@ vi.mock('../../semantic-colors.js', () => ({
},
}));
// Mock createDebugLogger
vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
const actual =
await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
@ -108,12 +126,13 @@ vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
...actual,
createDebugLogger: vi.fn(() => ({
log: vi.fn(),
debug: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
})),
};
});
// Helper to create a key object
function createKey(name: string, sequence = ''): Key {
return {
name,
@ -125,15 +144,28 @@ function createKey(name: string, sequence = ''): Key {
};
}
function mockSettingsHooks(userHooks: Record<string, unknown>): void {
mockedLoadSettings.mockReturnValue({
forScope: vi.fn((scope: SettingScope) => ({
settings:
scope === SettingScope.User ? { hooks: userHooks } : { hooks: {} },
})),
} as unknown as ReturnType<typeof loadSettings>);
}
function pressKey(name: string, sequence = ''): void {
const latestHandler = mockedUseKeypress.mock.calls.at(-1)?.[0];
expect(latestHandler).toBeDefined();
latestHandler!(createKey(name, sequence));
}
describe('HooksManagementDialog', () => {
const mockOnClose = vi.fn();
let keypressHandler: ((key: Key) => void) | null = null;
beforeEach(() => {
vi.clearAllMocks();
keypressHandler = null;
// Mock useKeypress to capture the handler
mockedUseKeypress.mockImplementation((handler) => {
keypressHandler = handler;
});
@ -141,119 +173,195 @@ describe('HooksManagementDialog', () => {
afterEach(() => {
keypressHandler = null;
cleanup();
});
describe('Initial rendering', () => {
it('should render loading state initially', () => {
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
it('should render loading state initially', () => {
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
expect(lastFrame()).toContain('Loading hooks');
expect(lastFrame()).toContain('Loading hooks');
});
it('should allow Escape to close during loading state', () => {
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
expect(keypressHandler).not.toBeNull();
keypressHandler!(createKey('escape', '\x1b'));
expect(mockOnClose).toHaveBeenCalledTimes(1);
});
it('should register the keypress handler with isActive: true', () => {
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
expect(mockedUseKeypress).toHaveBeenCalled();
expect(mockedUseKeypress.mock.calls[0][1]).toEqual({ isActive: true });
});
it('should render HOOKS_DISABLED step on first render when disableAllHooks is true', () => {
// `renderContent` checks the HOOKS_DISABLED branch before the isLoading
// branch, so the disabled view is visible synchronously on the initial
// render — no need to wait for the hooks-loading effect.
mockedUseConfig.mockReturnValueOnce(disabledHooksConfig());
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
expect(lastFrame()).toContain('Hook Configuration - Disabled');
});
it('should close dialog on Escape when disableAllHooks is true', () => {
mockedUseConfig.mockReturnValueOnce(disabledHooksConfig());
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
expect(keypressHandler).not.toBeNull();
keypressHandler!(createKey('escape', '\x1b'));
expect(mockOnClose).toHaveBeenCalledTimes(1);
});
it('should navigate from a matcher hook to matcher detail', async () => {
mockSettingsHooks({
PreToolUse: [
{
matcher: 'Read',
hooks: [{ type: 'command', command: 'echo read' }],
},
{
matcher: 'Bash',
hooks: [{ type: 'command', command: 'echo bash' }],
},
],
});
it('should render with border', async () => {
const { lastFrame, unmount } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
await new Promise((resolve) => setTimeout(resolve, 100));
await vi.waitFor(() => {
expect(lastFrame()).toContain('Hooks');
});
// The dialog should have a border (rendered as box-drawing characters)
const output = lastFrame();
expect(output).toBeTruthy();
pressKey('return');
await vi.waitFor(() => {
expect(lastFrame()).toContain('[User] Read');
});
unmount();
pressKey('down');
await vi.waitFor(() => {
expect(lastFrame()).toContain('❯ 2. [User] Bash');
});
pressKey('return');
await vi.waitFor(() => {
expect(lastFrame()).toContain('PreToolUse - Matcher: Bash');
expect(lastFrame()).toContain('echo bash');
});
pressKey('escape', '\x1b');
await vi.waitFor(() => {
expect(lastFrame()).toContain('PreToolUse - Matchers');
});
});
describe('Keyboard navigation - HOOKS_LIST step', () => {
it('should register keypress handler with isActive: true', async () => {
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
await new Promise((resolve) => setTimeout(resolve, 100));
expect(mockedUseKeypress).toHaveBeenCalled();
const options = mockedUseKeypress.mock.calls[0][1];
expect(options).toEqual({ isActive: true });
it('should navigate from matcher detail to config detail', async () => {
mockSettingsHooks({
PreToolUse: [
{
matcher: 'Read',
hooks: [{ type: 'command', command: 'echo read' }],
},
{
matcher: 'Bash',
hooks: [
{ type: 'command', command: 'echo first' },
{ type: 'command', command: 'echo second' },
],
},
],
});
it('should close dialog on Escape key', async () => {
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
await new Promise((resolve) => setTimeout(resolve, 100));
expect(keypressHandler).not.toBeNull();
keypressHandler!(createKey('escape', '\x1b'));
expect(mockOnClose).toHaveBeenCalledTimes(1);
await vi.waitFor(() => {
expect(lastFrame()).toContain('Hooks');
});
it('should not go above first item when pressing up', async () => {
const { unmount } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
pressKey('return');
await vi.waitFor(() => {
expect(lastFrame()).toContain('[User] Read');
});
pressKey('down');
await vi.waitFor(() => {
expect(lastFrame()).toContain('❯ 2. [User] Bash');
});
pressKey('return');
await vi.waitFor(() => {
expect(lastFrame()).toContain('PreToolUse - Matcher: Bash');
});
await new Promise((resolve) => setTimeout(resolve, 100));
pressKey('down');
await vi.waitFor(() => {
expect(lastFrame()).toContain('❯ 2. [command] echo second');
});
pressKey('return');
// Press up multiple times from first item
keypressHandler!(createKey('up'));
keypressHandler!(createKey('up'));
keypressHandler!(createKey('up'));
// Should still be at first item (no crash)
unmount();
await vi.waitFor(() => {
expect(lastFrame()).toContain('Hook details');
expect(lastFrame()).toContain('echo second');
});
});
describe('Keyboard navigation - HOOKS_DISABLED step', () => {
it('should show disabled state when disableAllHooks is true', async () => {
// Override the mock for this test
const configContext = await import('../../contexts/ConfigContext.js');
vi.mocked(configContext.useConfig).mockReturnValue({
getExtensions: vi.fn(() => []),
getDisableAllHooks: vi.fn(() => true),
} as unknown as ReturnType<typeof configContext.useConfig>);
const { lastFrame, unmount } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
await new Promise((resolve) => setTimeout(resolve, 100));
const output = lastFrame();
expect(output).toContain('Hook Configuration - Disabled');
unmount();
it('should navigate directly from a non-matcher hook to config detail', async () => {
mockSettingsHooks({
Stop: [
{
hooks: [{ type: 'command', command: 'echo stop one' }],
},
{
hooks: [{ type: 'command', command: 'echo stop two' }],
},
],
});
it('should close dialog on Escape key when hooks are disabled', async () => {
const configContext = await import('../../contexts/ConfigContext.js');
vi.mocked(configContext.useConfig).mockReturnValue({
getExtensions: vi.fn(() => []),
getDisableAllHooks: vi.fn(() => true),
} as unknown as ReturnType<typeof configContext.useConfig>);
const { lastFrame } = renderWithProviders(
<HooksManagementDialog onClose={mockOnClose} />,
);
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
await new Promise((resolve) => setTimeout(resolve, 100));
expect(keypressHandler).not.toBeNull();
keypressHandler!(createKey('escape', '\x1b'));
expect(mockOnClose).toHaveBeenCalledTimes(1);
await vi.waitFor(() => {
expect(lastFrame()).toContain('Hooks');
});
});
describe('Loading and error states', () => {
it('should allow Escape to close during loading state', () => {
renderWithProviders(<HooksManagementDialog onClose={mockOnClose} />);
for (let i = 0; i < 6; i++) {
pressKey('down');
await vi.waitFor(() => {
expect(lastFrame()).toContain(`❯ ${i + 2}.`);
});
}
await vi.waitFor(() => {
expect(lastFrame()).toContain('❯ 7. Stop');
});
pressKey('return');
await vi.waitFor(() => {
expect(lastFrame()).toContain('Stop');
expect(lastFrame()).toContain('echo stop one');
});
// Don't wait for loading to complete
expect(keypressHandler).not.toBeNull();
keypressHandler!(createKey('escape', '\x1b'));
pressKey('down');
await vi.waitFor(() => {
expect(lastFrame()).toContain('❯ 2. [command] echo stop two');
});
pressKey('return');
expect(mockOnClose).toHaveBeenCalledTimes(1);
await vi.waitFor(() => {
expect(lastFrame()).toContain('Hook details');
expect(lastFrame()).toContain('echo stop two');
});
});
});

View File

@ -25,28 +25,27 @@ import type {
HookEventDisplayInfo,
} from './types.js';
import { HOOKS_MANAGEMENT_STEPS } from './types.js';
import { addConfigToMatcherGroup, getAllConfigs } from './matcherGrouping.js';
import { HooksListStep } from './HooksListStep.js';
import { HookDetailStep } from './HookDetailStep.js';
import { HookMatcherDetailStep } from './HookMatcherDetailStep.js';
import { HookConfigDetailStep } from './HookConfigDetailStep.js';
import { HooksDisabledStep } from './HooksDisabledStep.js';
import {
DISPLAY_HOOK_EVENTS,
getTranslatedSourceDisplayMap,
createEmptyHookEventInfo,
supportsMatchers,
} from './constants.js';
import { t } from '../../../i18n/index.js';
const debugLogger = createDebugLogger('HOOKS_DIALOG');
/**
* Type guard to check if a value is a valid HookConfig
*/
function isValidHookConfig(config: unknown): config is HookConfig {
if (typeof config !== 'object' || config === null || !('type' in config)) {
return false;
}
const obj = config as Record<string, unknown>;
// Check based on type
if (obj['type'] === 'command') {
return 'command' in obj && typeof obj['command'] === 'string';
}
@ -62,52 +61,37 @@ function isValidHookConfig(config: unknown): config is HookConfig {
return false;
}
/**
* Type guard to check if a value is a valid HookDefinition
*/
function isValidHookDefinition(def: unknown): def is HookDefinition {
if (typeof def !== 'object' || def === null) {
return false;
}
const obj = def as Record<string, unknown>;
// hooks array is required
if (!('hooks' in obj) || !Array.isArray(obj['hooks'])) {
return false;
}
// Validate each hook config in the array
for (const hook of obj['hooks']) {
if (!isValidHookConfig(hook)) {
return false;
}
}
// matcher is optional but must be a string if present
if ('matcher' in obj && typeof obj['matcher'] !== 'string') {
return false;
}
// sequential is optional but must be a boolean if present
if ('sequential' in obj && typeof obj['sequential'] !== 'boolean') {
return false;
}
return true;
}
/**
* Type guard to check if a value is a valid hooks record
* Note: This validates the structure but allows individual events to have
* invalid configs - those will be filtered out during processing.
*/
function isValidHooksRecord(hooks: unknown): hooks is Record<string, unknown> {
if (typeof hooks !== 'object' || hooks === null) {
return false;
}
// Basic structure check - must be a record with array values for event keys
const record = hooks as Record<string, unknown>;
for (const [key, value] of Object.entries(record)) {
// Skip non-event configuration fields
if (HOOKS_CONFIG_FIELDS.includes(key)) {
continue;
}
// Event values should be arrays (even if contents are invalid)
if (!Array.isArray(value)) {
return false;
}
@ -115,10 +99,6 @@ function isValidHooksRecord(hooks: unknown): hooks is Record<string, unknown> {
return true;
}
/**
* Safely extract hook definitions for a specific event
* Returns empty array if the definitions are invalid
*/
function getValidHookDefinitions(
hooksRecord: Record<string, unknown>,
eventName: string,
@ -148,11 +128,6 @@ export function HooksManagementDialog({
const { columns: width } = useTerminalSize();
const boxWidth = width - 4;
// Check if hooks are disabled
// Note: This value is captured at dialog open time. If disableAllHooks
// changes while the dialog is open (e.g., via settings.json edit),
// the dialog will not react to the change until it's closed and reopened.
// This is intentional - the dialog represents a snapshot of the current state.
const disableAllHooks = config?.getDisableAllHooks() ?? false;
const [navigationStack, setNavigationStack] = useState<string[]>([
@ -161,20 +136,19 @@ export function HooksManagementDialog({
: HOOKS_MANAGEMENT_STEPS.HOOKS_LIST,
]);
const [selectedHookIndex, setSelectedHookIndex] = useState<number>(-1);
const [selectedMatcherIndex, setSelectedMatcherIndex] = useState<number>(-1);
const [selectedConfigIndex, setSelectedConfigIndex] = useState<number>(-1);
// Track selected index within each step for keyboard navigation
const [listSelectedIndex, setListSelectedIndex] = useState<number>(0);
const [detailSelectedIndex, setDetailSelectedIndex] = useState<number>(0);
const [matcherSelectedIndex, setMatcherSelectedIndex] = useState<number>(0);
const [hooks, setHooks] = useState<HookEventDisplayInfo[]>([]);
const [isLoading, setIsLoading] = useState(true);
const [loadError, setLoadError] = useState<string | null>(null);
// Current step
const currentStep =
navigationStack[navigationStack.length - 1] ||
HOOKS_MANAGEMENT_STEPS.HOOKS_LIST;
// Selected hook event
const selectedHook = useMemo(() => {
if (selectedHookIndex >= 0 && selectedHookIndex < hooks.length) {
return hooks[selectedHookIndex];
@ -182,11 +156,20 @@ export function HooksManagementDialog({
return null;
}, [hooks, selectedHookIndex]);
// Centralized keyboard handler
const selectedMatcher = useMemo(() => {
if (
selectedHook &&
selectedMatcherIndex >= 0 &&
selectedMatcherIndex < selectedHook.matcherGroups.length
) {
return selectedHook.matcherGroups[selectedMatcherIndex];
}
return null;
}, [selectedHook, selectedMatcherIndex]);
useKeypress(
(key) => {
if (isLoading || loadError) {
// Allow Escape to close even during loading/error states
if (key.name === 'escape') {
onClose();
}
@ -210,8 +193,10 @@ export function HooksManagementDialog({
} else if (key.name === 'return') {
if (hooks.length > 0 && listSelectedIndex >= 0) {
setSelectedHookIndex(listSelectedIndex);
setSelectedMatcherIndex(-1);
setSelectedConfigIndex(-1);
setDetailSelectedIndex(0);
setMatcherSelectedIndex(0);
setNavigationStack((prev) => [
...prev,
HOOKS_MANAGEMENT_STEPS.HOOK_DETAIL,
@ -225,15 +210,62 @@ export function HooksManagementDialog({
case HOOKS_MANAGEMENT_STEPS.HOOK_DETAIL:
if (key.name === 'escape') {
handleNavigateBack();
} else if (selectedHook && selectedHook.configs.length > 0) {
} else if (selectedHook) {
const matcherMode = supportsMatchers(selectedHook.event);
if (matcherMode) {
if (selectedHook.matcherGroups.length === 0) {
break;
}
if (keyMatchers[Command.SELECTION_UP](key)) {
setDetailSelectedIndex((prev) => Math.max(0, prev - 1));
} else if (keyMatchers[Command.SELECTION_DOWN](key)) {
setDetailSelectedIndex((prev) =>
Math.min(selectedHook.matcherGroups.length - 1, prev + 1),
);
} else if (key.name === 'return') {
setSelectedMatcherIndex(detailSelectedIndex);
setMatcherSelectedIndex(0);
setSelectedConfigIndex(-1);
setNavigationStack((prev) => [
...prev,
HOOKS_MANAGEMENT_STEPS.HOOK_MATCHER_DETAIL,
]);
}
} else {
const flatConfigs = getAllConfigs(selectedHook);
if (flatConfigs.length === 0) {
break;
}
if (keyMatchers[Command.SELECTION_UP](key)) {
setDetailSelectedIndex((prev) => Math.max(0, prev - 1));
} else if (keyMatchers[Command.SELECTION_DOWN](key)) {
setDetailSelectedIndex((prev) =>
Math.min(flatConfigs.length - 1, prev + 1),
);
} else if (key.name === 'return') {
setSelectedMatcherIndex(-1);
setSelectedConfigIndex(detailSelectedIndex);
setNavigationStack((prev) => [
...prev,
HOOKS_MANAGEMENT_STEPS.HOOK_CONFIG_DETAIL,
]);
}
}
}
break;
case HOOKS_MANAGEMENT_STEPS.HOOK_MATCHER_DETAIL:
if (key.name === 'escape') {
handleNavigateBack();
} else if (selectedMatcher && selectedMatcher.configs.length > 0) {
if (keyMatchers[Command.SELECTION_UP](key)) {
setDetailSelectedIndex((prev) => Math.max(0, prev - 1));
setMatcherSelectedIndex((prev) => Math.max(0, prev - 1));
} else if (keyMatchers[Command.SELECTION_DOWN](key)) {
setDetailSelectedIndex((prev) =>
Math.min(selectedHook.configs.length - 1, prev + 1),
setMatcherSelectedIndex((prev) =>
Math.min(selectedMatcher.configs.length - 1, prev + 1),
);
} else if (key.name === 'return') {
setSelectedConfigIndex(detailSelectedIndex);
setSelectedConfigIndex(matcherSelectedIndex);
setNavigationStack((prev) => [
...prev,
HOOKS_MANAGEMENT_STEPS.HOOK_CONFIG_DETAIL,
@ -249,14 +281,12 @@ export function HooksManagementDialog({
break;
default:
// No action for unknown steps
break;
}
},
{ isActive: true },
);
// Load hooks data
const fetchHooksData = useCallback((): HookEventDisplayInfo[] => {
if (!config) return [];
@ -266,32 +296,36 @@ export function HooksManagementDialog({
SettingScope.Workspace,
).settings;
// Get translated source display map
const sourceDisplayMap = getTranslatedSourceDisplayMap();
const result: HookEventDisplayInfo[] = [];
for (const eventName of DISPLAY_HOOK_EVENTS) {
const hookInfo = createEmptyHookEventInfo(eventName);
const groupByMatcher = supportsMatchers(eventName);
// Get hooks from user settings (with per-event validation)
const userSettingsRecord = userSettings as Record<string, unknown>;
const userHooksRaw = userSettingsRecord?.['hooks'];
if (isValidHooksRecord(userHooksRaw)) {
const userDefs = getValidHookDefinitions(userHooksRaw, eventName);
for (const def of userDefs) {
for (const hookConfig of def.hooks) {
hookInfo.configs.push({
config: hookConfig,
source: HooksConfigSource.User,
sourceDisplay: sourceDisplayMap[HooksConfigSource.User],
enabled: true,
});
addConfigToMatcherGroup(
hookInfo,
def.matcher,
def.sequential,
{
config: hookConfig,
source: HooksConfigSource.User,
sourceDisplay: sourceDisplayMap[HooksConfigSource.User],
enabled: true,
},
groupByMatcher,
);
}
}
}
// Get hooks from workspace settings (with per-event validation)
const workspaceSettingsRecord = workspaceSettings as Record<
string,
unknown
@ -304,17 +338,22 @@ export function HooksManagementDialog({
);
for (const def of workspaceDefs) {
for (const hookConfig of def.hooks) {
hookInfo.configs.push({
config: hookConfig,
source: HooksConfigSource.Project,
sourceDisplay: sourceDisplayMap[HooksConfigSource.Project],
enabled: true,
});
addConfigToMatcherGroup(
hookInfo,
def.matcher,
def.sequential,
{
config: hookConfig,
source: HooksConfigSource.Project,
sourceDisplay: sourceDisplayMap[HooksConfigSource.Project],
enabled: true,
},
groupByMatcher,
);
}
}
}
// Get hooks from extensions (with type validation)
const extensions = config.getExtensions() || [];
for (const extension of extensions) {
if (extension.isActive && extension.hooks?.[eventName]) {
@ -323,13 +362,19 @@ export function HooksManagementDialog({
for (const def of extensionHooks) {
if (isValidHookDefinition(def)) {
for (const hookConfig of def.hooks) {
hookInfo.configs.push({
config: hookConfig,
source: HooksConfigSource.Extensions,
sourceDisplay: extension.name,
sourcePath: extension.path,
enabled: true,
});
addConfigToMatcherGroup(
hookInfo,
def.matcher,
def.sequential,
{
config: hookConfig,
source: HooksConfigSource.Extensions,
sourceDisplay: extension.name,
sourcePath: extension.path,
enabled: true,
},
groupByMatcher,
);
}
}
}
@ -337,7 +382,6 @@ export function HooksManagementDialog({
}
}
// Get session hooks from SessionHooksManager
const hookSystem = config.getHookSystem();
if (hookSystem) {
const sessionId = config.getSessionId();
@ -346,20 +390,23 @@ export function HooksManagementDialog({
const allSessionHooks =
sessionHooksManager.getAllSessionHooks(sessionId);
// Filter hooks for this event
const eventSessionHooks = allSessionHooks.filter(
(hook: SessionHookEntry) => hook.eventName === eventName,
);
for (const sessionHook of eventSessionHooks) {
// Session hooks have matcher stored separately from config
hookInfo.configs.push({
config: sessionHook.config as HookConfig,
source: HooksConfigSource.Session,
sourceDisplay: t('Session (temporary)'),
matcher: sessionHook.matcher,
enabled: true,
});
addConfigToMatcherGroup(
hookInfo,
sessionHook.matcher,
sessionHook.sequential,
{
config: sessionHook.config as HookConfig,
source: HooksConfigSource.Session,
sourceDisplay: t('Session (temporary)'),
enabled: true,
},
groupByMatcher,
);
}
}
}
@ -370,7 +417,6 @@ export function HooksManagementDialog({
return result;
}, [config]);
// Load hooks data on initial render
useEffect(() => {
let cancelled = false;
setIsLoading(true);
@ -399,7 +445,6 @@ export function HooksManagementDialog({
};
}, [fetchHooksData]);
// Navigation handler for going back
const handleNavigateBack = useCallback(() => {
setNavigationStack((prev) => {
if (prev.length <= 1) {
@ -410,27 +455,39 @@ export function HooksManagementDialog({
});
}, [onClose]);
// Selected hook config
const selectedConfig = useMemo(() => {
if (!selectedHook) return null;
if (!supportsMatchers(selectedHook.event)) {
const flatConfigs = getAllConfigs(selectedHook);
if (
selectedConfigIndex >= 0 &&
selectedConfigIndex < flatConfigs.length
) {
return flatConfigs[selectedConfigIndex];
}
return null;
}
if (
selectedHook &&
selectedMatcher &&
selectedConfigIndex >= 0 &&
selectedConfigIndex < selectedHook.configs.length
selectedConfigIndex < selectedMatcher.configs.length
) {
return selectedHook.configs[selectedConfigIndex];
return selectedMatcher.configs[selectedConfigIndex];
}
return null;
}, [selectedHook, selectedConfigIndex]);
}, [selectedHook, selectedMatcher, selectedConfigIndex]);
// Calculate total configured hooks count
const configuredHooksCount = useMemo(
() => hooks.reduce((sum, hook) => sum + hook.configs.length, 0),
() =>
hooks.reduce(
(sum, hook) =>
sum + hook.matcherGroups.reduce((s, g) => s + g.configs.length, 0),
0,
),
[hooks],
);
// Render based on current step
const renderContent = () => {
// Show disabled state first (before loading check)
if (currentStep === HOOKS_MANAGEMENT_STEPS.HOOKS_DISABLED) {
return <HooksDisabledStep configuredHooksCount={configuredHooksCount} />;
}
@ -478,6 +535,22 @@ export function HooksManagementDialog({
</Box>
);
case HOOKS_MANAGEMENT_STEPS.HOOK_MATCHER_DETAIL:
if (selectedHook && selectedMatcher) {
return (
<HookMatcherDetailStep
hookEvent={selectedHook}
matcherGroup={selectedMatcher}
selectedIndex={matcherSelectedIndex}
/>
);
}
return (
<Box flexDirection="column" paddingX={1}>
<Text color={theme.text.secondary}>{t('No matcher selected')}</Text>
</Box>
);
case HOOKS_MANAGEMENT_STEPS.HOOK_CONFIG_DETAIL:
if (selectedHook && selectedConfig) {
return (

View File

@ -5,14 +5,16 @@
*/
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { HookEventName, HooksConfigSource } from '@qwen-code/qwen-code-core';
import {
HookEventName,
HooksConfigSource,
hookEventSupportsMatcher,
} from '@qwen-code/qwen-code-core';
// Mock i18n module
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
}));
// Import after mocking
import {
getHookExitCodes,
getHookShortDescription,
@ -20,6 +22,7 @@ import {
getTranslatedSourceDisplayMap,
createEmptyHookEventInfo,
DISPLAY_HOOK_EVENTS,
supportsMatchers,
} from './constants.js';
describe('hooks constants', () => {
@ -83,9 +86,22 @@ describe('hooks constants', () => {
expect(exitCodes).toHaveLength(3);
});
it('should return exit codes for InstructionsLoaded event', () => {
const exitCodes = getHookExitCodes(HookEventName.InstructionsLoaded);
it('should return exit codes for PostCompact event', () => {
const exitCodes = getHookExitCodes(HookEventName.PostCompact);
expect(exitCodes).toHaveLength(2);
expect(exitCodes[0].code).toBe(0);
expect(exitCodes[1].code).toBe('Other');
});
it('should return exit codes for StopFailure event', () => {
// Fire-and-forget per hookAggregator — both rows are documented as ignored.
const exitCodes = getHookExitCodes(HookEventName.StopFailure);
expect(exitCodes).toHaveLength(2);
expect(exitCodes[0].code).toBe(0);
expect(exitCodes[1].code).toBe('Other');
for (const row of exitCodes) {
expect(row.description).toContain('fire-and-forget');
}
});
it('should return empty array for unknown event', () => {
@ -115,9 +131,15 @@ describe('hooks constants', () => {
expect(desc).toBe('When a new session is started');
});
it('should return description for InstructionsLoaded', () => {
const desc = getHookShortDescription(HookEventName.InstructionsLoaded);
expect(desc).toBe('When instruction files are loaded');
it('should return description for PostCompact', () => {
const desc = getHookShortDescription(HookEventName.PostCompact);
expect(desc).toBe('After conversation compaction');
});
it('should return description for StopFailure', () => {
const desc = getHookShortDescription(HookEventName.StopFailure);
expect(desc).toContain('API error');
expect(desc).toContain('Stop');
});
it('should return empty string for unknown event', () => {
@ -143,11 +165,17 @@ describe('hooks constants', () => {
expect(desc).toBe('');
});
it('should return description for InstructionsLoaded', () => {
const desc = getHookDescription(HookEventName.InstructionsLoaded);
expect(desc).toContain('file_path');
expect(desc).toContain('memory_type');
expect(desc).toContain('load_reason');
it('should return description for PostCompact', () => {
const desc = getHookDescription(HookEventName.PostCompact);
expect(desc).toContain('trigger');
expect(desc).toContain('compact_summary');
});
it('should return description for StopFailure', () => {
const desc = getHookDescription(HookEventName.StopFailure);
expect(desc).toContain('error');
expect(desc).toContain('rate_limit');
expect(desc).toContain('Fire-and-forget');
});
it('should return empty string for unknown event', () => {
@ -169,7 +197,6 @@ describe('hooks constants', () => {
it('should return translated strings', () => {
const map = getTranslatedSourceDisplayMap();
// All values should be strings (translated)
Object.values(map).forEach((value) => {
expect(typeof value).toBe('string');
expect(value.length).toBeGreaterThan(0);
@ -196,11 +223,44 @@ describe('hooks constants', () => {
expect(DISPLAY_HOOK_EVENTS).toContain(HookEventName.PermissionDenied);
expect(DISPLAY_HOOK_EVENTS).toContain(HookEventName.TodoCreated);
expect(DISPLAY_HOOK_EVENTS).toContain(HookEventName.TodoCompleted);
expect(DISPLAY_HOOK_EVENTS).toContain(HookEventName.InstructionsLoaded);
});
it('should have 18 events', () => {
expect(DISPLAY_HOOK_EVENTS).toHaveLength(18);
it('should have 17 events', () => {
expect(DISPLAY_HOOK_EVENTS).toHaveLength(17);
});
});
describe('supportsMatchers', () => {
it('returns true for events with meaningful matchers', () => {
expect(supportsMatchers(HookEventName.PreToolUse)).toBe(true);
expect(supportsMatchers(HookEventName.PostToolUse)).toBe(true);
expect(supportsMatchers(HookEventName.PostToolUseFailure)).toBe(true);
expect(supportsMatchers(HookEventName.PermissionRequest)).toBe(true);
expect(supportsMatchers(HookEventName.Notification)).toBe(true);
expect(supportsMatchers(HookEventName.SessionStart)).toBe(true);
expect(supportsMatchers(HookEventName.SessionEnd)).toBe(true);
expect(supportsMatchers(HookEventName.SubagentStart)).toBe(true);
expect(supportsMatchers(HookEventName.SubagentStop)).toBe(true);
expect(supportsMatchers(HookEventName.PreCompact)).toBe(true);
expect(supportsMatchers(HookEventName.PostCompact)).toBe(true);
expect(supportsMatchers(HookEventName.StopFailure)).toBe(true);
});
it('returns false for events without matchers', () => {
expect(supportsMatchers(HookEventName.Stop)).toBe(false);
expect(supportsMatchers(HookEventName.UserPromptSubmit)).toBe(false);
expect(supportsMatchers(HookEventName.TodoCreated)).toBe(false);
expect(supportsMatchers(HookEventName.TodoCompleted)).toBe(false);
});
it('returns false for unknown events', () => {
expect(supportsMatchers('unknown_event' as HookEventName)).toBe(false);
});
it('covers every HookEventName value and matches core dispatch', () => {
for (const event of Object.values(HookEventName)) {
expect(supportsMatchers(event)).toBe(hookEventSupportsMatcher(event));
}
});
});
@ -214,7 +274,7 @@ describe('hooks constants', () => {
'Input to command is JSON of tool call arguments.',
);
expect(info.exitCodes).toHaveLength(3);
expect(info.configs).toEqual([]);
expect(info.matcherGroups).toEqual([]);
});
it('should create empty info for Stop', () => {
@ -226,7 +286,7 @@ describe('hooks constants', () => {
);
expect(info.description).toBe('');
expect(info.exitCodes).toHaveLength(3);
expect(info.configs).toEqual([]);
expect(info.matcherGroups).toEqual([]);
});
it('should create empty info for unknown event', () => {
@ -236,7 +296,7 @@ describe('hooks constants', () => {
expect(info.shortDescription).toBe('');
expect(info.description).toBe('');
expect(info.exitCodes).toEqual([]);
expect(info.configs).toEqual([]);
expect(info.matcherGroups).toEqual([]);
});
it('should create empty info for TodoCreated', () => {
@ -246,7 +306,7 @@ describe('hooks constants', () => {
expect(info.shortDescription).toBe('When a new todo item is created');
expect(info.description).toContain('todo_id');
expect(info.exitCodes).toHaveLength(3);
expect(info.configs).toEqual([]);
expect(info.matcherGroups).toEqual([]);
});
it('should create empty info for TodoCompleted', () => {
@ -258,17 +318,7 @@ describe('hooks constants', () => {
);
expect(info.description).toContain('previous_status');
expect(info.exitCodes).toHaveLength(3);
expect(info.configs).toEqual([]);
});
it('should create empty info for InstructionsLoaded', () => {
const info = createEmptyHookEventInfo(HookEventName.InstructionsLoaded);
expect(info.event).toBe(HookEventName.InstructionsLoaded);
expect(info.shortDescription).toBe('When instruction files are loaded');
expect(info.description).toContain('file_path');
expect(info.exitCodes).toHaveLength(2);
expect(info.configs).toEqual([]);
expect(info.matcherGroups).toEqual([]);
});
});
});

View File

@ -4,7 +4,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
import { HooksConfigSource, HookEventName } from '@qwen-code/qwen-code-core';
import {
HooksConfigSource,
HookEventName,
hookEventSupportsMatcher,
} from '@qwen-code/qwen-code-core';
import type { HookExitCode, HookEventDisplayInfo } from './types.js';
import { t } from '../../../i18n/index.js';
@ -43,10 +47,6 @@ export function getHookExitCodes(eventName: string): HookExitCode[] {
{ code: 0, description: t('stdout/stderr not shown') },
{ code: 'Other', description: t('show stderr to user only') },
],
[HookEventName.InstructionsLoaded]: [
{ code: 0, description: t('stdout/stderr not shown') },
{ code: 'Other', description: t('show stderr to user only') },
],
[HookEventName.UserPromptSubmit]: [
{ code: 0, description: t('stdout shown to Qwen') },
{
@ -94,6 +94,20 @@ export function getHookExitCodes(eventName: string): HookExitCode[] {
description: t('show stderr to user only but continue with compaction'),
},
],
[HookEventName.PostCompact]: [
{ code: 0, description: t('stdout/stderr not shown') },
{ code: 'Other', description: t('show stderr to user only') },
],
[HookEventName.StopFailure]: [
{
code: 0,
description: t('fire-and-forget; exit status is ignored'),
},
{
code: 'Other',
description: t('fire-and-forget; exit status is ignored'),
},
],
[HookEventName.PermissionRequest]: [
{ code: 0, description: t('use hook decision if provided') },
{ code: 'Other', description: t('show stderr to user only') },
@ -131,7 +145,6 @@ export function getHookShortDescription(eventName: string): string {
[HookEventName.PostToolUse]: t('After tool execution'),
[HookEventName.PostToolUseFailure]: t('After tool execution fails'),
[HookEventName.Notification]: t('When notifications are sent'),
[HookEventName.InstructionsLoaded]: t('When instruction files are loaded'),
[HookEventName.UserPromptSubmit]: t('When the user submits a prompt'),
[HookEventName.SessionStart]: t('When a new session is started'),
[HookEventName.Stop]: t('Right before Qwen Code concludes its response'),
@ -142,6 +155,10 @@ export function getHookShortDescription(eventName: string): string {
'Right before a subagent concludes its response',
),
[HookEventName.PreCompact]: t('Before conversation compaction'),
[HookEventName.PostCompact]: t('After conversation compaction'),
[HookEventName.StopFailure]: t(
'When the turn ends due to an API error (fires instead of Stop)',
),
[HookEventName.SessionEnd]: t('When a session is ending'),
[HookEventName.PermissionRequest]: t(
'When a permission dialog is displayed',
@ -173,9 +190,6 @@ export function getHookDescription(eventName: string): string {
[HookEventName.Notification]: t(
'Input to command is JSON with notification message and type.',
),
[HookEventName.InstructionsLoaded]: t(
'Input to command is JSON with file_path, memory_type, load_reason, and optional globs, trigger_file_path, and parent_file_path.',
),
[HookEventName.UserPromptSubmit]: t(
'Input to command is JSON with original user prompt text.',
),
@ -194,6 +208,12 @@ export function getHookDescription(eventName: string): string {
[HookEventName.PreCompact]: t(
'Input to command is JSON with compaction details.',
),
[HookEventName.PostCompact]: t(
'Input to command is JSON with trigger (manual/auto) and compact_summary. Output is ignored for control purposes.',
),
[HookEventName.StopFailure]: t(
'Input to command is JSON with error (rate_limit, authentication_failed, billing_error, invalid_request, server_error, max_output_tokens, unknown) and optional error_details. Fire-and-forget: output and exit status are ignored.',
),
[HookEventName.PermissionRequest]: t(
'Input to command is JSON with tool_name, tool_input, and tool_use_id. Output JSON with hookSpecificOutput containing decision to allow or deny.',
),
@ -226,19 +246,13 @@ export function getTranslatedSourceDisplayMap(): Record<
};
}
/**
* List of hook events to display in the UI
* Automatically synced with HookEventName enum from core.
* Note: Order follows the enum definition order. If UI presentation order
* needs to be different (e.g., grouped by lifecycle phase), consider using
* an explicit sorted array instead. Current enum order is acceptable for display.
*/
export const DISPLAY_HOOK_EVENTS: HookEventName[] =
Object.values(HookEventName);
/**
* Create empty hook event display info
*/
export function supportsMatchers(eventName: HookEventName): boolean {
return hookEventSupportsMatcher(eventName);
}
export function createEmptyHookEventInfo(
eventName: HookEventName,
): HookEventDisplayInfo {
@ -247,6 +261,6 @@ export function createEmptyHookEventInfo(
shortDescription: getHookShortDescription(eventName),
description: getHookDescription(eventName),
exitCodes: getHookExitCodes(eventName),
configs: [],
matcherGroups: [],
};
}

View File

@ -0,0 +1,244 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { describe, it, expect } from 'vitest';
import {
HookEventName,
HooksConfigSource,
HookType,
} from '@qwen-code/qwen-code-core';
import type { HookEventDisplayInfo } from './types.js';
import {
addConfigToMatcherGroup,
getAllConfigs,
normalizeMatcher,
} from './matcherGrouping.js';
function emptyHookInfo(): HookEventDisplayInfo {
return {
event: HookEventName.PreToolUse,
shortDescription: '',
description: '',
exitCodes: [],
matcherGroups: [],
};
}
describe('normalizeMatcher', () => {
it('returns "*" when matcher is undefined', () => {
expect(normalizeMatcher(undefined)).toBe('*');
});
it('returns "*" when matcher is empty string', () => {
expect(normalizeMatcher('')).toBe('*');
});
it('returns "*" when matcher is only whitespace', () => {
expect(normalizeMatcher(' ')).toBe('*');
});
it('returns the trimmed matcher when set', () => {
expect(normalizeMatcher(' Bash ')).toBe('Bash');
});
it('preserves regex-style matchers', () => {
expect(normalizeMatcher('Edit|Write')).toBe('Edit|Write');
});
});
describe('addConfigToMatcherGroup', () => {
it('creates a new group for an unseen matcher', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, 'Bash', undefined, {
config: { type: HookType.Command, command: '/x.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(info.matcherGroups).toHaveLength(1);
expect(info.matcherGroups[0].matcher).toBe('Bash');
expect(info.matcherGroups[0].configs).toHaveLength(1);
expect(getAllConfigs(info)).toHaveLength(1);
});
it('reuses the existing group for the same matcher', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, 'Bash', undefined, {
config: { type: HookType.Command, command: '/a.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, 'Bash', undefined, {
config: { type: HookType.Command, command: '/b.sh' },
source: HooksConfigSource.Project,
sourceDisplay: 'Local Settings',
enabled: true,
});
expect(info.matcherGroups).toHaveLength(1);
expect(info.matcherGroups[0].configs).toHaveLength(2);
expect(getAllConfigs(info)).toHaveLength(2);
});
it('buckets undefined / empty matchers into "*"', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, undefined, undefined, {
config: { type: HookType.Command, command: '/a.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, '', undefined, {
config: { type: HookType.Command, command: '/b.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(info.matcherGroups).toHaveLength(1);
expect(info.matcherGroups[0].matcher).toBe('*');
expect(info.matcherGroups[0].configs).toHaveLength(2);
});
it('writes the normalized matcher onto the stored config', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, undefined, undefined, {
config: { type: HookType.Command, command: '/x.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(getAllConfigs(info)[0].matcher).toBe('*');
expect(info.matcherGroups[0].configs[0].matcher).toBe('*');
});
it('promotes group.sequential to true when any handler is sequential', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, 'Bash', false, {
config: { type: HookType.Command, command: '/a.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, 'Bash', true, {
config: { type: HookType.Command, command: '/b.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(info.matcherGroups[0].sequential).toBe(true);
});
it('normalizes missing sequential to a false boolean, not undefined', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, 'Bash', undefined, {
config: { type: HookType.Command, command: '/a.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, 'Bash', false, {
config: { type: HookType.Command, command: '/b.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(info.matcherGroups[0].sequential).toBe(false);
expect(info.matcherGroups[0].sequential).not.toBe(undefined);
const flat = getAllConfigs(info);
expect(flat[0].sequential).toBe(false);
expect(flat[1].sequential).toBe(false);
});
it('preserves insertion order across matchers', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(info, 'Bash', undefined, {
config: { type: HookType.Command, command: '/a.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, 'Edit|Write', undefined, {
config: { type: HookType.Command, command: '/b.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
addConfigToMatcherGroup(info, undefined, undefined, {
config: { type: HookType.Command, command: '/c.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
});
expect(info.matcherGroups.map((g) => g.matcher)).toEqual([
'Bash',
'Edit|Write',
'*',
]);
});
it('keeps non-matcher events in original handler order', () => {
const info = emptyHookInfo();
addConfigToMatcherGroup(
info,
'A',
undefined,
{
config: { type: HookType.Command, command: '/first.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
},
false,
);
addConfigToMatcherGroup(
info,
'B',
undefined,
{
config: { type: HookType.Command, command: '/second.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
},
false,
);
addConfigToMatcherGroup(
info,
'A',
undefined,
{
config: { type: HookType.Command, command: '/third.sh' },
source: HooksConfigSource.User,
sourceDisplay: 'User Settings',
enabled: true,
},
false,
);
expect(info.matcherGroups).toHaveLength(1);
expect(info.matcherGroups[0].matcher).toBe('*');
expect(
getAllConfigs(info).map((config) =>
config.config.type === HookType.Command ? config.config.command : '',
),
).toEqual(['/first.sh', '/second.sh', '/third.sh']);
});
});

View File

@ -0,0 +1,50 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import type { HookConfigDisplayInfo, HookEventDisplayInfo } from './types.js';
export function normalizeMatcher(matcher?: string): string {
const trimmed = matcher?.trim();
return trimmed ? trimmed : '*';
}
export function addConfigToMatcherGroup(
hookInfo: HookEventDisplayInfo,
matcher: string | undefined,
sequential: boolean | undefined,
configInfo: HookConfigDisplayInfo,
groupByMatcher = true,
): void {
const normalizedMatcher = groupByMatcher ? normalizeMatcher(matcher) : '*';
const normalizedSequential = sequential ?? false;
const normalizedConfig: HookConfigDisplayInfo = {
...configInfo,
matcher: normalizedMatcher,
sequential: normalizedSequential,
};
let group = hookInfo.matcherGroups.find(
(candidate) => candidate.matcher === normalizedMatcher,
);
if (!group) {
group = {
matcher: normalizedMatcher,
sequential: normalizedSequential,
configs: [],
};
hookInfo.matcherGroups.push(group);
} else if (normalizedSequential) {
group.sequential = true;
}
group.configs.push(normalizedConfig);
}
export function getAllConfigs(
hookInfo: HookEventDisplayInfo,
): HookConfigDisplayInfo[] {
return hookInfo.matcherGroups.flatMap((group) => group.configs);
}

View File

@ -0,0 +1,115 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { HooksConfigSource, HookType } from '@qwen-code/qwen-code-core';
vi.mock('../../../i18n/index.js', () => ({
t: vi.fn((key: string) => key),
}));
import {
formatSourceLabel,
formatSourceLabels,
getConfigSourceDisplay,
} from './sourceLabels.js';
import type { HookConfigDisplayInfo } from './types.js';
function makeConfig(
source: HooksConfigSource,
sourceDisplay = '',
): HookConfigDisplayInfo {
return {
config: { type: HookType.Command, command: '/x.sh' },
source,
sourceDisplay,
enabled: true,
};
}
describe('sourceLabels', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('formatSourceLabel', () => {
it('returns short label for each known source', () => {
expect(formatSourceLabel(HooksConfigSource.User)).toBe('User');
expect(formatSourceLabel(HooksConfigSource.Project)).toBe('Project');
expect(formatSourceLabel(HooksConfigSource.System)).toBe('System');
expect(formatSourceLabel(HooksConfigSource.Extensions)).toBe('Extension');
expect(formatSourceLabel(HooksConfigSource.Session)).toBe('Session');
});
it('falls back to the raw source string for unknown values', () => {
expect(formatSourceLabel('mystery' as HooksConfigSource)).toBe('mystery');
});
});
describe('formatSourceLabels', () => {
it('returns a single label for a single-source group', () => {
const configs = [
makeConfig(HooksConfigSource.User),
makeConfig(HooksConfigSource.User),
];
expect(formatSourceLabels(configs)).toBe('User');
});
it('joins distinct labels with comma + space for multi-source groups', () => {
const configs = [
makeConfig(HooksConfigSource.User),
makeConfig(HooksConfigSource.Project),
makeConfig(HooksConfigSource.Extensions),
];
expect(formatSourceLabels(configs)).toBe('User, Project, Extension');
});
it('preserves insertion order across distinct sources', () => {
const configs = [
makeConfig(HooksConfigSource.Project),
makeConfig(HooksConfigSource.User),
];
expect(formatSourceLabels(configs)).toBe('Project, User');
});
it('returns empty string when there are no configs', () => {
expect(formatSourceLabels([])).toBe('');
});
});
describe('getConfigSourceDisplay', () => {
it('returns the translated long label for non-extension sources', () => {
expect(getConfigSourceDisplay(makeConfig(HooksConfigSource.User))).toBe(
'User Settings',
);
expect(
getConfigSourceDisplay(makeConfig(HooksConfigSource.Project)),
).toBe('Local Settings');
expect(getConfigSourceDisplay(makeConfig(HooksConfigSource.System))).toBe(
'System Settings',
);
});
it('appends the extension name for Extensions-source configs', () => {
expect(
getConfigSourceDisplay(
makeConfig(HooksConfigSource.Extensions, 'my-ext'),
),
).toBe('Extensions (my-ext)');
});
it('uses the long "Session (temporary)" label for session-source configs', () => {
expect(
getConfigSourceDisplay(makeConfig(HooksConfigSource.Session)),
).toBe('Session (temporary)');
});
it('falls back to the raw source string for unknown sources', () => {
const config = makeConfig('mystery' as HooksConfigSource);
expect(getConfigSourceDisplay(config)).toBe('mystery');
});
});
});

View File

@ -0,0 +1,44 @@
/**
* @license
* Copyright 2026 Qwen Team
* SPDX-License-Identifier: Apache-2.0
*/
import { HooksConfigSource } from '@qwen-code/qwen-code-core';
import type { HookConfigDisplayInfo } from './types.js';
import { getTranslatedSourceDisplayMap } from './constants.js';
import { t } from '../../../i18n/index.js';
export function formatSourceLabel(source: HooksConfigSource): string {
switch (source) {
case HooksConfigSource.User:
return t('User');
case HooksConfigSource.Project:
return t('Project');
case HooksConfigSource.System:
return t('System');
case HooksConfigSource.Extensions:
return t('Extension');
case HooksConfigSource.Session:
return t('Session');
default:
return source;
}
}
export function formatSourceLabels(configs: HookConfigDisplayInfo[]): string {
return Array.from(
new Set(configs.map((config) => formatSourceLabel(config.source))),
).join(', ');
}
export function getConfigSourceDisplay(config: {
source: HooksConfigSource;
sourceDisplay: string;
}): string {
const sourceDisplayMap = getTranslatedSourceDisplayMap();
if (config.source === HooksConfigSource.Extensions) {
return `${sourceDisplayMap[HooksConfigSource.Extensions]} (${config.sourceDisplay})`;
}
return sourceDisplayMap[config.source] || config.source;
}

View File

@ -10,53 +10,46 @@ import type {
HookEventName,
} from '@qwen-code/qwen-code-core';
/**
* Exit code description for hooks
*/
export interface HookExitCode {
code: number | string;
description: string;
}
/**
* UI display information for a hook event
*/
export interface HookEventDisplayInfo {
event: HookEventName;
shortDescription: string;
description: string;
exitCodes: HookExitCode[];
matcherGroups: HookMatcherDisplayInfo[];
}
export interface HookMatcherDisplayInfo {
matcher: string;
sequential?: boolean;
configs: HookConfigDisplayInfo[];
}
/**
* UI display information for a hook configuration
*/
export interface HookConfigDisplayInfo {
config: HookConfig;
source: HooksConfigSource;
sourceDisplay: string;
sourcePath?: string;
matcher?: string;
sequential?: boolean;
enabled: boolean;
}
/**
* Hook management dialog step names
*/
export const HOOKS_MANAGEMENT_STEPS = {
HOOKS_DISABLED: 'hooks_disabled',
HOOKS_LIST: 'hooks_list',
HOOK_DETAIL: 'hook_detail',
HOOK_MATCHER_DETAIL: 'hook_matcher_detail',
HOOK_CONFIG_DETAIL: 'hook_config_detail',
} as const;
export type HooksManagementStep =
(typeof HOOKS_MANAGEMENT_STEPS)[keyof typeof HOOKS_MANAGEMENT_STEPS];
/**
* Props for HooksManagementDialog
*/
export interface HooksManagementDialogProps {
onClose: () => void;
}

View File

@ -2462,7 +2462,7 @@ export const useGeminiStream = (
const toolName = toolCall.request.name;
const fileName = path.basename(filePath);
const toolCallWithSnapshotFileName = `${timestamp}-${fileName}-${toolName}.json`;
const clientHistory = await geminiClient?.getHistory();
const clientHistory = geminiClient?.getHistoryShallow();
const toolCallWithSnapshotFilePath = path.join(
checkpointDir,
toolCallWithSnapshotFileName,

View File

@ -49,7 +49,6 @@ import { ToolNames } from '../tools/tool-names.js';
import { fireNotificationHook } from '../core/toolHookTriggers.js';
import type { MessageBus } from '../confirmation-bus/message-bus.js';
import { loadServerHierarchicalMemory } from '../utils/memoryDiscovery.js';
import type { LoadServerHierarchicalMemoryOptions } from '../utils/memoryDiscovery.js';
import { readAutoMemoryIndex } from '../memory/store.js';
import { ExtensionManager } from '../extension/extensionManager.js';
import { SkillManager } from '../skills/skill-manager.js';
@ -1441,7 +1440,7 @@ describe('Server Config (config.ts)', () => {
await config.refreshHierarchicalMemory();
const lastCall = vi.mocked(loadServerHierarchicalMemory).mock.calls.at(-1);
expect(lastCall?.at(-1)).toMatchObject({ explicitOnly: true });
expect(lastCall?.at(-1)).toEqual({ explicitOnly: true });
expect(lastCall?.[1]).toEqual([]);
expect(readAutoMemoryIndex).not.toHaveBeenCalled();
expect(config.getUserMemory()).toContain('Project rules');
@ -1469,51 +1468,7 @@ describe('Server Config (config.ts)', () => {
const lastCall = vi.mocked(loadServerHierarchicalMemory).mock.calls.at(-1);
expect(lastCall?.[1]).toEqual([explicitDir]);
expect(lastCall?.at(-1)).toMatchObject({ explicitOnly: true });
});
it('refreshHierarchicalMemory should fire InstructionsLoaded hooks from memory notifications', async () => {
const config = new Config(baseParams);
const fireInstructionsLoadedEvent = vi.fn().mockResolvedValue(undefined);
config['hookSystem'] = {
fireInstructionsLoadedEvent,
} as unknown as HookSystem;
vi.mocked(loadServerHierarchicalMemory).mockResolvedValue({
memoryContent: '--- Context from: QWEN.md ---\nProject rules',
fileCount: 1,
ruleCount: 0,
conditionalRules: [],
projectRoot: '/tmp',
});
await config.refreshHierarchicalMemory();
const lastCall = vi.mocked(loadServerHierarchicalMemory).mock.calls.at(-1);
const options = lastCall?.at(-1) as
| LoadServerHierarchicalMemoryOptions
| undefined;
expect(options?.onInstructionsLoaded).toEqual(expect.any(Function));
await options?.onInstructionsLoaded?.({
filePath: '/tmp/project/QWEN.md',
memoryType: 'project',
loadReason: 'include',
globs: ['**/*.ts'],
triggerFilePath: '/tmp/project/AGENTS.md',
parentFilePath: '/tmp/project/AGENTS.md',
});
expect(fireInstructionsLoadedEvent).toHaveBeenCalledWith(
'/tmp/project/QWEN.md',
'project',
'include',
{
globs: ['**/*.ts'],
triggerFilePath: '/tmp/project/AGENTS.md',
parentFilePath: '/tmp/project/AGENTS.md',
},
);
expect(lastCall?.at(-1)).toEqual({ explicitOnly: true });
});
it('Config constructor should call setGeminiMdFilename with contextFileName if provided', () => {

View File

@ -1848,21 +1848,7 @@ export class Config {
this.isTrustedFolder(),
this.getImportFormat(),
this.contextRuleExcludes,
{
explicitOnly: this.getBareMode(),
onInstructionsLoaded: async (notification) => {
await this.hookSystem?.fireInstructionsLoadedEvent(
notification.filePath,
notification.memoryType,
notification.loadReason,
{
globs: notification.globs,
triggerFilePath: notification.triggerFilePath,
parentFilePath: notification.parentFilePath,
},
);
},
},
{ explicitOnly: this.getBareMode() },
);
if (this.getManagedAutoMemoryEnabled()) {
const managedAutoMemoryIndex = await readAutoMemoryIndex(

View File

@ -168,52 +168,6 @@ describe('HookEventHandler', () => {
});
});
describe('fireInstructionsLoadedEvent', () => {
it('should include instruction load metadata in hook input', async () => {
const mockPlan = createMockExecutionPlan([
{
type: HookType.Command,
command: 'echo test',
source: HooksConfigSource.Project,
},
]);
vi.mocked(mockHookPlanner.createExecutionPlan).mockReturnValue(mockPlan);
vi.mocked(mockHookRunner.executeHooksParallel).mockResolvedValue([]);
vi.mocked(mockHookAggregator.aggregateResults).mockReturnValue(
createMockAggregatedResult(true),
);
await hookEventHandler.fireInstructionsLoadedEvent(
'/repo/.qwen/QWEN.local.md',
'local',
'include',
{
parentFilePath: '/repo/QWEN.md',
},
);
expect(mockHookPlanner.createExecutionPlan).toHaveBeenCalledWith(
HookEventName.InstructionsLoaded,
{
filePath: '/repo/.qwen/QWEN.local.md',
},
);
const mockCalls = (mockHookRunner.executeHooksParallel as Mock).mock
.calls;
const input = mockCalls[0][2] as {
file_path: string;
memory_type: string;
load_reason: string;
parent_file_path?: string;
};
expect(input.file_path).toBe('/repo/.qwen/QWEN.local.md');
expect(input.memory_type).toBe('local');
expect(input.load_reason).toBe('include');
expect(input.parent_file_path).toBe('/repo/QWEN.md');
});
});
describe('fireStopEvent', () => {
it('should execute hooks for Stop event', async () => {
const mockPlan = createMockExecutionPlan([]);

View File

@ -45,9 +45,6 @@ import type {
TodoCompletedInput,
TodoItem,
TodoStatus,
InstructionsLoadedInput,
InstructionMemoryType,
InstructionLoadReason,
} from './types.js';
import { HookPhase, PermissionMode } from './types.js';
import { createDebugLogger } from '../utils/debugLogger.js';
@ -119,37 +116,6 @@ export class HookEventHandler {
);
}
async fireInstructionsLoadedEvent(
filePath: string,
memoryType: InstructionMemoryType,
loadReason: InstructionLoadReason,
options: {
globs?: string[];
triggerFilePath?: string;
parentFilePath?: string;
} = {},
signal?: AbortSignal,
): Promise<AggregatedHookResult> {
const input: InstructionsLoadedInput = {
...this.createBaseInput(HookEventName.InstructionsLoaded),
file_path: filePath,
memory_type: memoryType,
load_reason: loadReason,
globs: options.globs,
trigger_file_path: options.triggerFilePath,
parent_file_path: options.parentFilePath,
};
return this.executeHooks(
HookEventName.InstructionsLoaded,
input,
{
filePath,
},
signal,
);
}
/**
* Fire a Stop event
* Called by handleHookExecutionRequest - executes hooks directly

View File

@ -83,17 +83,6 @@ describe('HookPlanner', () => {
});
});
it('returns file path targets for instruction load events', () => {
expect(
getHookMatcherTarget(HookEventName.InstructionsLoaded, {
filePath: '/repo/.qwen/QWEN.local.md',
}),
).toEqual({
kind: 'filePath',
target: '/repo/.qwen/QWEN.local.md',
});
});
it('returns undefined for events without matcher semantics', () => {
expect(getHookMatcherTarget(HookEventName.UserPromptSubmit)).toBe(
undefined,
@ -529,46 +518,6 @@ describe('HookPlanner', () => {
expect(result).not.toBeNull();
});
it('should match instruction loaded file paths with regex', () => {
const entry: HookRegistryEntry = {
config: { type: HookType.Command, command: 'echo test' },
source: HooksConfigSource.Project,
eventName: HookEventName.InstructionsLoaded,
matcher: '\\.qwen/QWEN\\.local\\.md$',
enabled: true,
};
vi.mocked(mockRegistry.getHooksForEvent).mockReturnValue([entry]);
const result = planner.createExecutionPlan(
HookEventName.InstructionsLoaded,
{
filePath: '/repo/.qwen/QWEN.local.md',
},
);
expect(result).not.toBeNull();
});
it('should not match unrelated instruction loaded file paths', () => {
const entry: HookRegistryEntry = {
config: { type: HookType.Command, command: 'echo test' },
source: HooksConfigSource.Project,
eventName: HookEventName.InstructionsLoaded,
matcher: '\\.qwen/QWEN\\.local\\.md$',
enabled: true,
};
vi.mocked(mockRegistry.getHooksForEvent).mockReturnValue([entry]);
const result = planner.createExecutionPlan(
HookEventName.InstructionsLoaded,
{
filePath: '/repo/QWEN.md',
},
);
expect(result).toBeNull();
});
it('should match auth_success notification type', () => {
const entry: HookRegistryEntry = {
config: { type: HookType.Command, command: 'echo test' },

View File

@ -17,8 +17,7 @@ type HookMatcherTargetKind =
| 'trigger'
| 'sessionTrigger'
| 'error'
| 'notificationType'
| 'filePath';
| 'notificationType';
interface HookMatcherTarget {
kind: HookMatcherTargetKind;
@ -58,9 +57,6 @@ export function getHookMatcherTarget(
target: context?.notificationType ?? '',
};
case HookEventName.InstructionsLoaded:
return { kind: 'filePath', target: context?.filePath ?? '' };
case HookEventName.UserPromptSubmit:
case HookEventName.Stop:
case HookEventName.TodoCreated:
@ -74,6 +70,11 @@ export function getHookMatcherTarget(
}
}
export function hookEventSupportsMatcher(eventName: HookEventName): boolean {
const target = getHookMatcherTarget(eventName);
return typeof target === 'object' && target !== null;
}
/**
* Hook planner that selects matching hooks and creates execution plans
*/
@ -166,9 +167,6 @@ export class HookPlanner {
case 'notificationType':
return this.matchesNotificationType(matcher, matcherTarget.target);
case 'filePath':
return this.matchesFilePath(matcher, matcherTarget.target);
case 'sessionTrigger':
return this.matchesSessionTrigger(matcher, matcherTarget.target);
@ -189,21 +187,6 @@ export class HookPlanner {
return matcher === notificationType;
}
/**
* Match loaded instruction file path against matcher pattern.
*/
private matchesFilePath(matcher: string, filePath: string): boolean {
try {
const regex = new RegExp(matcher);
return regex.test(filePath);
} catch (error) {
debugLogger.warn(
`Invalid regex in hook matcher "${matcher}" for file path "${filePath}", falling back to exact match: ${error}`,
);
return matcher === filePath;
}
}
/**
* Match session source or end reason against matcher pattern
*/
@ -292,6 +275,4 @@ export interface HookEventContext {
agentType?: string;
/** Error type for StopFailure matcher filtering (fieldToMatch: 'error') */
error?: string;
/** Loaded instruction/context file path for InstructionsLoaded matcher filtering */
filePath?: string;
}

View File

@ -34,8 +34,6 @@ import type {
StopFailureErrorType,
TodoItem,
TodoStatus,
InstructionMemoryType,
InstructionLoadReason,
} from './types.js';
import { SessionHooksManager } from './sessionHooksManager.js';
import type { AsyncHookRegistry } from './asyncHookRegistry.js';
@ -154,29 +152,6 @@ export class HookSystem {
: undefined;
}
async fireInstructionsLoadedEvent(
filePath: string,
memoryType: InstructionMemoryType,
loadReason: InstructionLoadReason,
options: {
globs?: string[];
triggerFilePath?: string;
parentFilePath?: string;
} = {},
signal?: AbortSignal,
): Promise<DefaultHookOutput | undefined> {
const result = await this.hookEventHandler.fireInstructionsLoadedEvent(
filePath,
memoryType,
loadReason,
options,
signal,
);
return result.finalOutput
? createHookOutput('InstructionsLoaded', result.finalOutput)
: undefined;
}
async fireStopEvent(
stopHookActive: boolean = false,
lastAssistantMessage: string = '',

View File

@ -12,7 +12,7 @@ export { HookSystem } from './hookSystem.js';
export { HookRegistry } from './hookRegistry.js';
export { HookRunner } from './hookRunner.js';
export { HookAggregator } from './hookAggregator.js';
export { HookPlanner } from './hookPlanner.js';
export { HookPlanner, hookEventSupportsMatcher } from './hookPlanner.js';
export { HookEventHandler } from './hookEventHandler.js';
// Export new hook runners

View File

@ -54,8 +54,6 @@ export enum HookEventName {
TodoCreated = 'TodoCreated',
// TodoCompleted - When a todo item's status changes to 'completed' (Qwen Code specific)
TodoCompleted = 'TodoCompleted',
// InstructionsLoaded - When an instruction or context file is loaded
InstructionsLoaded = 'InstructionsLoaded',
}
/**
@ -255,22 +253,6 @@ export interface HookInput {
timestamp: string;
}
export type InstructionMemoryType = 'user' | 'project' | 'local' | 'extension';
export type InstructionLoadReason = 'session_start' | 'include';
/**
* Input for InstructionsLoaded hook events
*/
export interface InstructionsLoadedInput extends HookInput {
file_path: string;
memory_type: InstructionMemoryType;
load_reason: InstructionLoadReason;
globs?: string[];
trigger_file_path?: string;
parent_file_path?: string;
}
/**
* Base hook output - common fields for all events
*/

View File

@ -388,7 +388,11 @@ export * from './test-utils/index.js';
// ============================================================================
export * from './hooks/types.js';
export { HookSystem, HookRegistry } from './hooks/index.js';
export {
HookSystem,
HookRegistry,
hookEventSupportsMatcher,
} from './hooks/index.js';
export type { HookRegistryEntry, SessionHookEntry } from './hooks/index.js';
export {
DEFAULT_STOP_HOOK_BLOCK_CAP,

View File

@ -49,7 +49,7 @@ export async function generateSessionRecap(
const geminiClient = config.getGeminiClient();
if (!geminiClient) return null;
const fullHistory = geminiClient.getChat().getHistory();
const fullHistory = geminiClient.getHistoryShallow();
if (fullHistory.length < 2) return null;
const dialog = filterToDialog(fullHistory);

View File

@ -31,6 +31,7 @@ function makeConfig(opts: MockOptions): {
getFastModel: vi.fn(() => opts.fastModel ?? undefined),
getModel: vi.fn(() => 'qwen-plus'),
getGeminiClient: vi.fn(() => ({
getHistoryShallow: () => opts.history ?? [],
getChat: () => ({
getHistory: () => opts.history ?? [],
}),
@ -202,7 +203,10 @@ describe('tryGenerateSessionTitle', () => {
getFastModel: vi.fn(() => 'qwen-turbo'),
getModel: vi.fn(() => 'qwen-plus'),
getGeminiClient: vi.fn(() => ({
getChat: () => ({ getHistory: () => history }),
getHistoryShallow: () => history,
getChat: () => ({
getHistory: () => history,
}),
})),
getBaseLlmClient: vi.fn(() => ({ generateJson })),
} as unknown as Config;
@ -240,7 +244,10 @@ describe('tryGenerateSessionTitle', () => {
getFastModel: vi.fn(() => 'qwen-turbo'),
getModel: vi.fn(() => 'qwen-plus'),
getGeminiClient: vi.fn(() => ({
getChat: () => ({ getHistory: () => history }),
getHistoryShallow: () => history,
getChat: () => ({
getHistory: () => history,
}),
})),
getBaseLlmClient: vi.fn(() => ({ generateJson })),
} as unknown as Config;

View File

@ -113,7 +113,7 @@ export async function tryGenerateSessionTitle(
const geminiClient = config.getGeminiClient();
if (!geminiClient) return { ok: false, reason: 'no_client' };
const fullHistory = geminiClient.getChat().getHistory();
const fullHistory = geminiClient.getHistoryShallow();
if (fullHistory.length < 2) return { ok: false, reason: 'empty_history' };
const dialog = filterToDialog(fullHistory);

View File

@ -102,11 +102,7 @@ export async function readWorktreeSession(
return parsed;
}
/**
* Atomically writes the sidecar. Uses `atomicWriteJSON` (write-to-temp +
* rename) so a crash mid-write can never leave a half-written file that
* subsequent reads would reject as malformed.
*/
/** Writes the worktree session sidecar via `atomicWriteJSON`. */
export async function writeWorktreeSession(
filePath: string,
session: WorktreeSession,

View File

@ -269,4 +269,160 @@ describe('atomicWriteFile', () => {
path.normalize('../otherDir/target.txt'),
);
});
it.skipIf(process.platform === 'win32')(
'should use atomic rename when ownership matches (inode changes)',
async () => {
const filePath = path.join(tmpDir, 'mine.txt');
await fs.writeFile(filePath, 'original');
const inoBefore = (await fs.stat(filePath)).ino;
await atomicWriteFile(filePath, 'updated');
const statAfter = await fs.stat(filePath);
// Atomic rename produces a new inode.
expect(statAfter.ino).not.toBe(inoBefore);
expect(await fs.readFile(filePath, 'utf-8')).toBe('updated');
},
);
it.skipIf(
process.platform === 'win32' || typeof process.geteuid !== 'function',
)(
'should fall back to in-place write when atomic rename would change ownership',
async () => {
// Simulate a file owned by a different user by replacing process.geteuid
// so it reports a uid that doesn't match the file's real uid. The code
// should detect rename would strip ownership and fall back to in-place
// writeFile, which preserves the inode — our signal that fallback ran.
const filePath = path.join(tmpDir, 'shared.txt');
await fs.writeFile(filePath, 'original');
await fs.chmod(filePath, 0o664);
const realStat = await fs.stat(filePath);
const inoBefore = realStat.ino;
const realGeteuid = process.geteuid!;
process.geteuid = () => realStat.uid + 1;
try {
await atomicWriteFile(filePath, 'updated');
} finally {
process.geteuid = realGeteuid;
}
expect(await fs.readFile(filePath, 'utf-8')).toBe('updated');
const statAfter = await fs.stat(filePath);
// In-place write preserves the inode — proves rename was skipped.
expect(statAfter.ino).toBe(inoBefore);
// Permissions preserved.
expect(statAfter.mode & 0o777).toBe(0o664);
// No leftover temp file.
expect(await fs.readdir(tmpDir)).toEqual(['shared.txt']);
},
);
it.skipIf(
process.platform === 'win32' || typeof process.geteuid !== 'function',
)(
'should skip in-place fallback for non-regular files and use atomic replace',
async () => {
// FIFO + ownership mismatch must NOT take the in-place fallback —
// open(O_WRONLY|O_TRUNC) against a FIFO would block forever
// waiting for a reader. The atomic rename path instead replaces
// the FIFO with a regular file, which is the only sane behavior
// for "write to this path" semantics on a special file.
const { execSync } = await import('node:child_process');
const fifoPath = path.join(tmpDir, 'pipe.fifo');
execSync(`mkfifo "${fifoPath}"`);
const realStat = await fs.stat(fifoPath);
expect(realStat.isFIFO()).toBe(true);
const realGeteuid = process.geteuid!;
process.geteuid = () => realStat.uid + 1;
try {
// If the in-place fallback were taken, this would hang
// indefinitely. Vitest's default timeout will catch that.
await atomicWriteFile(fifoPath, 'content');
} finally {
process.geteuid = realGeteuid;
}
// Atomic path replaced the FIFO with a regular file.
const statAfter = await fs.stat(fifoPath);
expect(statAfter.isFile()).toBe(true);
expect(await fs.readFile(fifoPath, 'utf-8')).toBe('content');
},
);
it.skipIf(
process.platform === 'win32' || typeof process.geteuid !== 'function',
)(
'should write via in-place fallback through a resolved symlink when ownership differs',
async () => {
// atomicWriteFile resolves the symlink via resolveSymlinkChain
// before stat, so the in-place write targets the real file.
// Verifies the symlink itself is preserved.
const realFile = path.join(tmpDir, 'real.txt');
const symlinkAt = path.join(tmpDir, 'attacker-symlink.txt');
await fs.writeFile(realFile, 'real-content');
await fs.symlink(realFile, symlinkAt);
const realGeteuid = process.geteuid!;
const realStat = await fs.stat(realFile);
const inoBefore = realStat.ino;
process.geteuid = () => realStat.uid + 1;
try {
await atomicWriteFile(symlinkAt, 'updated');
} finally {
process.geteuid = realGeteuid;
}
// The real file is updated; the symlink itself is preserved.
expect(await fs.readFile(realFile, 'utf-8')).toBe('updated');
expect((await fs.stat(realFile)).ino).toBe(inoBefore);
expect((await fs.lstat(symlinkAt)).isSymbolicLink()).toBe(true);
},
);
it.skipIf(
process.platform === 'win32' ||
typeof process.geteuid !== 'function' ||
// chmod 0o000 against the file's real owner still succeeds via
// POSIX rename in CI/sandbox setups where the user is effectively
// root; only assert real EACCES when we own and can be denied.
process.geteuid() === 0,
)(
'should surface EACCES when in-place fallback hits an unwritable file',
async () => {
// Atomic rename used to silently replace files the calling user
// has no write permission on (rename only needs parent-dir write).
// The in-place fallback respects the file's mode and surfaces
// EACCES — the correct behavior for "you don't own this, you
// shouldn't be replacing it" scenarios.
const filePath = path.join(tmpDir, 'readonly.txt');
await fs.writeFile(filePath, 'original');
await fs.chmod(filePath, 0o444);
const realStat = await fs.stat(filePath);
const realGeteuid = process.geteuid!;
process.geteuid = () => realStat.uid + 1;
try {
await expect(atomicWriteFile(filePath, 'updated')).rejects.toThrow(
/EACCES/,
);
} finally {
process.geteuid = realGeteuid;
// Restore mode so afterEach's rm can clean up.
await fs.chmod(filePath, 0o644);
}
// Original content untouched.
expect(await fs.readFile(filePath, 'utf-8')).toBe('original');
},
);
});

View File

@ -5,6 +5,7 @@
*/
import * as crypto from 'node:crypto';
import type { Stats } from 'node:fs';
import * as fs from 'node:fs/promises';
import * as path from 'node:path';
import { isNodeError } from './errors.js';
@ -94,19 +95,12 @@ async function resolveSymlinkChain(filePath: string): Promise<string> {
}
/**
* Atomically write arbitrary content (string or Buffer) to a file.
* Atomically write content to a file (write-to-temp + rename).
*
* 1. Resolve symlinks (including broken ones) so the temp file lives
* next to the real target.
* 2. Write to a temporary file with fsync (`flush: true` by default).
* 3. Preserve the original file's permissions (or apply `options.mode`).
* 4. Atomic rename (POSIX) with retry (Windows).
* 5. On EXDEV (cross-device rename), fall back to direct write.
* **Note:** the EXDEV fallback is non-atomic — a crash mid-write
* can leave a partially-written file. EXDEV only occurs when the
* resolved target path is on a different filesystem than its parent
* directory, which is rare in practice.
* 6. Always clean up the temp file on failure.
* Falls back to in-place write when the existing file's uid differs
* from the process's euid — POSIX rename would reset ownership.
* Also falls back on EXDEV (cross-device). Both fallbacks lose crash
* atomicity but preserve the existing inode's uid.
*
* The parent directory of `filePath` must already exist.
*/
@ -122,19 +116,20 @@ export async function atomicWriteFile(
const targetPath = await resolveSymlinkChain(filePath);
const tmpPath = `${targetPath}.${crypto.randomBytes(6).toString('hex')}.tmp`;
// Stat the target to preserve existing permissions (mask out file-type bits).
let existingMode: number | undefined;
// Stat the target to preserve existing permissions and detect
// ownership-changing renames (see the ownership-preservation note in
// the function doc).
let existingStat: Stats | undefined;
try {
const stat = await fs.stat(targetPath);
existingMode = stat.mode & 0o7777;
existingStat = await fs.stat(targetPath);
} catch (err) {
if (!isNodeError(err) || err.code !== 'ENOENT') {
throw err;
}
}
const existingMode =
existingStat !== undefined ? existingStat.mode & 0o7777 : undefined;
const desiredMode = existingMode ?? options?.mode;
const writeOptions: {
@ -156,6 +151,33 @@ export async function atomicWriteFile(
}
};
// Detect when atomic rename would silently change ownership. POSIX
// rename creates a new inode owned by the process's euid:egid; if the
// existing file has a different uid, fall back to in-place write which
// preserves the inode and therefore uid. Only uid is compared — gid
// is intentionally skipped because macOS inherits the parent
// directory's GID for new files, making egid !== file.gid a
// false positive on the most common dev platform.
const ownershipWouldChange = (): boolean => {
if (existingStat === undefined) return false;
if (process.platform === 'win32') return false;
const euid = process.geteuid?.();
if (euid === undefined) return false;
return existingStat.uid !== euid;
};
if (
existingStat !== undefined &&
existingStat.isFile() &&
ownershipWouldChange()
) {
await fs.writeFile(targetPath, data, writeOptions);
await tryChmod(targetPath);
return;
}
const tmpPath = `${targetPath}.${crypto.randomBytes(6).toString('hex')}.tmp`;
try {
await fs.writeFile(tmpPath, data, writeOptions);
await tryChmod(tmpPath);
@ -179,17 +201,7 @@ export async function atomicWriteFile(
}
}
/**
* Atomically write a JSON value to a file.
*
* Delegates to {@link atomicWriteFile} for the actual atomic
* write-to-temp + rename flow.
*
* Note: if `filePath` is a symlink, the write resolves the chain
* and updates the real target file — the symlink itself is preserved.
*
* The parent directory of `filePath` must already exist.
*/
/** Atomically write a JSON value to a file. Delegates to {@link atomicWriteFile}. */
export async function atomicWriteJSON(
filePath: string,
data: unknown,

View File

@ -12,11 +12,9 @@ import { loadServerHierarchicalMemory } from './memoryDiscovery.js';
import {
setGeminiMdFilename,
DEFAULT_CONTEXT_FILENAME,
LOCAL_CONTEXT_FILENAME,
} from '../memory/const.js';
import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
import { QWEN_DIR } from './paths.js';
import type { InstructionsLoadedNotification } from './memoryDiscovery.js';
vi.mock('os', async (importOriginal) => {
const actualOs = await importOriginal<typeof os>();
@ -440,162 +438,6 @@ describe('loadServerHierarchicalMemory', () => {
});
});
it('notifies when startup instruction files are loaded', async () => {
const globalFile = await createTestFile(
path.join(homedir, QWEN_DIR, DEFAULT_CONTEXT_FILENAME),
'global context',
);
const projectFile = await createTestFile(
path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),
'project context',
);
const extensionFile = await createTestFile(
path.join(testRootDir, 'extensions/ext1/QWEN.md'),
'extension context',
);
const notifications: InstructionsLoadedNotification[] = [];
await loadServerHierarchicalMemory(
cwd,
[],
new FileDiscoveryService(projectRoot),
[extensionFile],
DEFAULT_FOLDER_TRUST,
'tree',
[],
{
onInstructionsLoaded: (notification) => {
notifications.push(notification);
},
},
);
expect(notifications).toEqual(
expect.arrayContaining([
{
filePath: globalFile,
memoryType: 'user',
loadReason: 'session_start',
},
{
filePath: projectFile,
memoryType: 'project',
loadReason: 'session_start',
},
{
filePath: extensionFile,
memoryType: 'extension',
loadReason: 'session_start',
},
]),
);
});
it('notifies when imported instruction files are loaded', async () => {
await createEmptyDir(path.join(projectRoot, '.git'));
const importedFile = await createTestFile(
path.join(projectRoot, 'included.md'),
'included content',
);
const projectFile = await createTestFile(
path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),
'project context @./included.md',
);
const notifications: InstructionsLoadedNotification[] = [];
await loadServerHierarchicalMemory(
cwd,
[],
new FileDiscoveryService(projectRoot),
[],
DEFAULT_FOLDER_TRUST,
'tree',
[],
{
onInstructionsLoaded: (notification) => {
notifications.push(notification);
},
},
);
expect(notifications).toEqual(
expect.arrayContaining([
expect.objectContaining({
filePath: importedFile,
memoryType: 'project',
loadReason: 'include',
parentFilePath: projectFile,
}),
]),
);
});
it('classifies extension-owned imports as extension memory', async () => {
const extensionDir = path.join(testRootDir, 'extensions/ext1');
const importedFile = await createTestFile(
path.join(extensionDir, 'included.md'),
'extension included content',
);
const extensionFile = await createTestFile(
path.join(extensionDir, DEFAULT_CONTEXT_FILENAME),
'extension context @./included.md',
);
const notifications: InstructionsLoadedNotification[] = [];
await loadServerHierarchicalMemory(
cwd,
[],
new FileDiscoveryService(projectRoot),
[extensionFile],
DEFAULT_FOLDER_TRUST,
'tree',
[],
{
onInstructionsLoaded: (notification) => {
notifications.push(notification);
},
},
);
expect(notifications).toEqual(
expect.arrayContaining([
expect.objectContaining({
filePath: importedFile,
memoryType: 'extension',
loadReason: 'include',
parentFilePath: extensionFile,
}),
]),
);
});
it('still loads memory when instruction load notification fails', async () => {
const projectFile = await createTestFile(
path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),
'project context',
);
const result = await loadServerHierarchicalMemory(
cwd,
[],
new FileDiscoveryService(projectRoot),
[],
DEFAULT_FOLDER_TRUST,
'tree',
[],
{
onInstructionsLoaded: () => {
throw new Error('hook failed');
},
},
);
expect(result.fileCount).toBe(1);
expect(result.memoryContent).toContain(
`--- Context from: ${path.relative(cwd, projectFile)} ---\nproject context`,
);
});
it('should load memory from included directories', async () => {
const includedDir = await createEmptyDir(
path.join(testRootDir, 'included'),
@ -725,39 +567,6 @@ describe('loadServerHierarchicalMemory', () => {
);
});
it('notifies when QWEN.local.md is loaded', async () => {
const localFile = await createTestFile(
path.join(projectRoot, QWEN_DIR, LOCAL_CONTEXT_FILENAME),
'local context content',
);
const notifications: InstructionsLoadedNotification[] = [];
await loadServerHierarchicalMemory(
cwd,
[],
new FileDiscoveryService(projectRoot),
[],
DEFAULT_FOLDER_TRUST,
'tree',
[],
{
onInstructionsLoaded: (notification) => {
notifications.push(notification);
},
},
);
expect(notifications).toEqual(
expect.arrayContaining([
{
filePath: localFile,
memoryType: 'local',
loadReason: 'session_start',
},
]),
);
});
it('orders QWEN.local.md after the project-root QWEN.md', async () => {
const projectFile = await createTestFile(
path.join(projectRoot, DEFAULT_CONTEXT_FILENAME),

View File

@ -14,15 +14,11 @@ import {
} from '../memory/const.js';
import type { FileDiscoveryService } from '../services/fileDiscoveryService.js';
import { processImports } from './memoryImportProcessor.js';
import { isSubpath, QWEN_DIR } from './paths.js';
import { QWEN_DIR } from './paths.js';
import { Storage } from '../config/storage.js';
import { createDebugLogger } from './debugLogger.js';
import { findProjectRoot } from './projectRoot.js';
import { loadRules, type RuleFile } from './rulesDiscovery.js';
import type {
InstructionLoadReason,
InstructionMemoryType,
} from '../hooks/types.js';
const logger = createDebugLogger('MEMORY_DISCOVERY');
@ -31,15 +27,6 @@ interface GeminiFileContent {
content: string | null;
}
export interface InstructionsLoadedNotification {
filePath: string;
memoryType: InstructionMemoryType;
loadReason: InstructionLoadReason;
globs?: string[];
triggerFilePath?: string;
parentFilePath?: string;
}
async function getGeminiMdFilePathsInternal(
currentWorkingDirectory: string,
includeDirectoriesToReadGemini: readonly string[],
@ -216,24 +203,10 @@ async function getGeminiMdFilePathsInternalForEachDir(
async function readGeminiMdFiles(
filePaths: string[],
importFormat: 'flat' | 'tree' = 'tree',
getMemoryType: (filePath: string) => InstructionMemoryType,
onInstructionsLoaded?: (
notification: InstructionsLoadedNotification,
) => void | Promise<void>,
): Promise<GeminiFileContent[]> {
// Process files in parallel with concurrency limit to prevent EMFILE errors
const CONCURRENT_LIMIT = 20; // Higher limit for file reads as they're typically faster
const results: GeminiFileContent[] = [];
const notifyInstructionsLoaded = async (
notification: InstructionsLoadedNotification,
) => {
try {
await onInstructionsLoaded?.(notification);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
logger.warn(`InstructionsLoaded notification failed: ${message}`);
}
};
for (let i = 0; i < filePaths.length; i += CONCURRENT_LIMIT) {
const batch = filePaths.slice(i, i + CONCURRENT_LIMIT);
@ -246,34 +219,13 @@ async function readGeminiMdFiles(
const processedResult = await processImports(
content,
path.dirname(filePath),
{
processedFiles: new Set([path.resolve(filePath)]),
maxDepth: 5,
currentDepth: 0,
currentFile: path.resolve(filePath),
},
undefined,
undefined,
importFormat,
{
onFileImported: async (notification) => {
await notifyInstructionsLoaded({
filePath: notification.filePath,
memoryType: getMemoryType(notification.filePath),
loadReason: 'include',
triggerFilePath: notification.parentFilePath,
parentFilePath: notification.parentFilePath,
});
},
},
);
logger.debug(
`Successfully read and processed imports: ${filePath} (Length: ${processedResult.content.length})`,
);
await notifyInstructionsLoaded({
filePath,
memoryType: getMemoryType(filePath),
loadReason: 'session_start',
});
return { filePath, content: processedResult.content };
} catch (error: unknown) {
@ -344,52 +296,6 @@ export interface LoadServerHierarchicalMemoryResponse {
export interface LoadServerHierarchicalMemoryOptions {
explicitOnly?: boolean;
onInstructionsLoaded?: (
notification: InstructionsLoadedNotification,
) => void | Promise<void>;
}
function createMemoryTypeClassifier(
userHomePath: string,
foundRoot: string | null,
extensionContextFilePaths: string[],
): (filePath: string) => InstructionMemoryType {
const resolvedHome = path.resolve(userHomePath);
const globalQwenDir = path.resolve(Storage.getGlobalQwenDir());
const resolvedRoot = foundRoot ? path.resolve(foundRoot) : undefined;
const extensionPaths = new Set(
extensionContextFilePaths.map((filePath) => path.resolve(filePath)),
);
const extensionRoots = extensionContextFilePaths.map((filePath) =>
path.dirname(path.resolve(filePath)),
);
return (filePath) => {
const resolvedPath = path.resolve(filePath);
if (
extensionPaths.has(resolvedPath) ||
extensionRoots.some((root) => isSubpath(root, resolvedPath))
) {
return 'extension';
}
if (
resolvedRoot &&
resolvedPath === path.join(resolvedRoot, QWEN_DIR, LOCAL_CONTEXT_FILENAME)
) {
return 'local';
}
if (
resolvedPath.startsWith(`${globalQwenDir}${path.sep}`) ||
path.dirname(resolvedPath) === resolvedHome
) {
return 'user';
}
return 'project';
};
}
/**
@ -468,16 +374,7 @@ export async function loadServerHierarchicalMemory(
let fileCount = 0;
if (filePaths.length > 0) {
const contentsWithPaths = await readGeminiMdFiles(
filePaths,
importFormat,
createMemoryTypeClassifier(
userHomePath,
foundRoot,
extensionContextFilePaths,
),
options.onInstructionsLoaded,
);
const contentsWithPaths = await readGeminiMdFiles(filePaths, importFormat);
// Pass CWD for relative path display in concatenated content
combinedInstructions = concatenateInstructions(
contentsWithPaths,

View File

@ -144,45 +144,6 @@ describe('memoryImportProcessor', () => {
);
});
it('notifies after importing a file', async () => {
const content = 'Some content @./test.md more content';
const basePath = testPath('test', 'path');
const parentFile = path.resolve(basePath, 'QWEN.md');
const importedFile = path.resolve(basePath, 'test.md');
const importedFiles: Array<{
filePath: string;
parentFilePath: string;
}> = [];
mockedFs.access.mockResolvedValue(undefined);
mockedFs.readFile.mockResolvedValue('# Imported Content');
await processImports(
content,
basePath,
{
processedFiles: new Set(),
maxDepth: 5,
currentDepth: 0,
currentFile: parentFile,
},
undefined,
'tree',
{
onFileImported: (event) => {
importedFiles.push(event);
},
},
);
expect(importedFiles).toEqual([
{
filePath: importedFile,
parentFilePath: parentFile,
},
]);
});
it('should import non-md files just like md files', async () => {
const content = 'Some content @./instructions.txt more content';
const basePath = testPath('test', 'path');

View File

@ -39,17 +39,6 @@ export interface ProcessImportsResult {
importTree: MemoryFile;
}
export interface ImportedFileNotification {
filePath: string;
parentFilePath: string;
}
export interface ProcessImportsOptions {
onFileImported?: (
notification: ImportedFileNotification,
) => void | Promise<void>;
}
// `findProjectRoot` now lives in `./projectRoot.ts` and is shared with
// memoryDiscovery. It returns `string | null`; `processImports` below
// preserves the previous "fall back to startDir" contract at the call
@ -201,7 +190,6 @@ export async function processImports(
},
projectRoot?: string,
importFormat: 'flat' | 'tree' = 'tree',
options: ProcessImportsOptions = {},
): Promise<ProcessImportsResult> {
if (!projectRoot) {
// Preserve the previous local helper's contract: if no `.git`
@ -280,10 +268,6 @@ export async function processImports(
try {
await fs.access(fullPath);
const importedContent = await fs.readFile(fullPath, 'utf-8');
await options.onFileImported?.({
filePath: normalizedFullPath,
parentFilePath: normalizedPath,
});
// Process the imported file
await processFlat(
@ -355,10 +339,6 @@ export async function processImports(
try {
await fs.access(fullPath);
const fileContent = await fs.readFile(fullPath, 'utf-8');
await options.onFileImported?.({
filePath: fullPath,
parentFilePath: importState.currentFile ?? path.resolve(basePath),
});
// Mark this file as processed for this import chain
const newImportState: ImportState = {
...importState,
@ -373,7 +353,6 @@ export async function processImports(
newImportState,
projectRoot,
importFormat,
options,
);
result += `<!-- Imported from: ${importPath} -->\n${imported.content}\n<!-- End of import from: ${importPath} -->`;
imports.push(imported.importTree);

View File

@ -29,9 +29,10 @@
* keeps running while no longer serving the recorded session
* (e.g. a hypothetical future mode-switch). Not currently invoked.
*
* The file is written atomically (tmp-file + rename) and contains a
* small, stable schema. External consumers should treat unknown fields
* as forward-compatible additions.
* The file is written via `atomicWriteJSON` (write-to-temp + rename,
* with in-place fallback when ownership differs).
* The schema is small and stable; external consumers should treat
* unknown fields as forward-compatible additions.
*/
import * as fs from 'node:fs/promises';
@ -78,17 +79,11 @@ export interface WriteRuntimeStatusFields {
}
/**
* Atomically write the runtime status file at `filePath`.
* Write the runtime status file at `filePath`.
*
* Writes via tmp-file + rename so an external observer never sees a
* partially written file: it sees either the previous contents or the
* fully committed new contents.
*
* The parent directory of `filePath` is created on demand. Exceptions
* from the underlying I/O propagate to the caller; this function does
* not log or swallow them. Callers that want best-effort semantics
* should wrap the call in a try/catch. On failure no leftover `.tmp`
* file is kept on disk.
* The parent directory is created on demand. Exceptions propagate to
* the caller; callers that want best-effort semantics should wrap in
* a try/catch.
*/
export async function writeRuntimeStatus(
filePath: string,