@songtonyli/dsh-cli 0.1.72 → 0.1.74
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/bin/dsh.mjs +1 -1
- package/node_modules/@deepseek-ai/dsh-client-ui-sidebar/lib/client.js +1 -1
- package/node_modules/@deepseek-ai/dsh-tui-app/README.i18n.yaml +4 -4
- package/node_modules/@deepseek-ai/dsh-tui-app/README.md +3 -3
- package/node_modules/@deepseek-ai/dsh-tui-app/README.zh.md +3 -3
- package/node_modules/@deepseek-ai/dsh-tui-app/lib/index.js +24 -8
- package/node_modules/zod/package.json +1 -1
- package/node_modules/zod/src/v4/classic/tests/array.test.ts +27 -0
- package/node_modules/zod/src/v4/classic/tests/map.test.ts +7 -0
- package/node_modules/zod/src/v4/classic/tests/set.test.ts +6 -0
- package/node_modules/zod/src/v4/core/compile.ts +9 -0
- package/node_modules/zod/src/v4/core/schemas.ts +35 -1
- package/node_modules/zod/src/v4/core/util.ts +13 -0
- package/node_modules/zod/src/v4/core/versions.ts +1 -1
- package/node_modules/zod/v4/core/compile.cjs +8 -0
- package/node_modules/zod/v4/core/compile.js +8 -0
- package/node_modules/zod/v4/core/schemas.cjs +30 -0
- package/node_modules/zod/v4/core/schemas.js +30 -0
- package/node_modules/zod/v4/core/util.cjs +15 -0
- package/node_modules/zod/v4/core/util.js +14 -0
- package/node_modules/zod/v4/core/versions.cjs +1 -1
- package/node_modules/zod/v4/core/versions.js +1 -1
- package/package.json +2 -2
package/README.md
CHANGED
|
@@ -26,7 +26,7 @@ workspace and no build step. Native packages that ship one build per platform
|
|
|
26
26
|
ripgrep, the PTY backend's addons, sharp, koffi, and the Landlock launcher — are
|
|
27
27
|
ordinary optional dependencies, so npm resolves the right one for your machine.
|
|
28
28
|
|
|
29
|
-
Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.
|
|
29
|
+
Requires Node `^22.19.0 || >=24.0.0`. Version 0.1.74; `dsh --version`
|
|
30
30
|
also reports the harness build the package was assembled from.
|
|
31
31
|
|
|
32
32
|
## License
|
package/bin/dsh.mjs
CHANGED
|
@@ -18,7 +18,7 @@ const argv = process.argv.slice(2)
|
|
|
18
18
|
// version this package publishes. Reporting only one of the two would make an
|
|
19
19
|
// ordinary `npm install @songtonyli/dsh-cli@x` look like it installed something else.
|
|
20
20
|
if (argv.length === 1 && (argv[0] === '--version' || argv[0] === '-V')) {
|
|
21
|
-
console.log('@songtonyli/dsh-cli 0.1.
|
|
21
|
+
console.log('@songtonyli/dsh-cli 0.1.74 (deepseek-harness 0.2.1-alpha.2)')
|
|
22
22
|
process.exit(0)
|
|
23
23
|
}
|
|
24
24
|
|
|
@@ -167,7 +167,7 @@ window.__ModuleLoader__.load({
|
|
|
167
167
|
const SCROLLBAR_LINGER_MS = 2e3;
|
|
168
168
|
/** Format complete-build metadata for the local brand badge. */
|
|
169
169
|
function localBuildVersion() {
|
|
170
|
-
return `0.2.1-alpha.2-
|
|
170
|
+
return `0.2.1-alpha.2-6bbe5c1` + ({}.DSH_CLIENT_GIT_DIRTY === "true" ? "-dirty" : "");
|
|
171
171
|
}
|
|
172
172
|
/** Each panel row subscribes only to its own selection state. */
|
|
173
173
|
function PanelRow({ id, label, wide, usePanelInfo, selectPanel, renderSlot }) {
|
|
@@ -18,11 +18,11 @@
|
|
|
18
18
|
en: 192bbbb187278f91
|
|
19
19
|
zh: 1f7e5632c15bdcf7
|
|
20
20
|
/deepseek-ai-dsh-tui-app/use-this-package/starting-and-resuming:
|
|
21
|
-
en:
|
|
22
|
-
zh:
|
|
21
|
+
en: 58a8cf392bd6a90b
|
|
22
|
+
zh: ff147492c5baf643
|
|
23
23
|
/deepseek-ai-dsh-tui-app/use-this-package/the-screen:
|
|
24
|
-
en:
|
|
25
|
-
zh:
|
|
24
|
+
en: 7c7e0622465bd9dd
|
|
25
|
+
zh: 4bada28f846ad050
|
|
26
26
|
/deepseek-ai-dsh-tui-app/use-this-package/keys-and-commands:
|
|
27
27
|
en: e3650a069cc84840
|
|
28
28
|
zh: b8428946ec8beab1
|
|
@@ -36,7 +36,7 @@ dsh tui --resume <session-id> # continue an earlier session
|
|
|
36
36
|
dsh tui --no-open # print sign-in URLs without opening a browser
|
|
37
37
|
```
|
|
38
38
|
|
|
39
|
-
On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>` on stderr for the session bound at that moment. A resumed session redraws its persisted history before accepting input and continues with that session's last model, or the launch default when the log has no request header; inside the terminal, `/resume` and `/sessions` open the same picker over
|
|
39
|
+
On quit the app prints `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>` on stderr for the session bound at that moment. A resumed session redraws its persisted history before accepting input and continues with that session's last model, or the launch default when the log has no request header; inside the terminal, `/resume` and `/sessions` open the same picker over persisted root sessions other than the current session, newest first, and resume the selected previous session, `/new` starts a fresh empty session with the launch default model, while `/clear` starts a fresh empty session that retains the current model and reasoning effort; the previous session stays on disk for `/resume`, and `/fork` copies the current session up to its last completed turn into a new one, the same cut the browser's fork takes. Switching releases the previous Agent and redraws the transcript of the next.
|
|
40
40
|
|
|
41
41
|
### The screen
|
|
42
42
|
|
|
@@ -54,9 +54,9 @@ Transient key feedback floats as a dim framed line in the top-right corner of th
|
|
|
54
54
|
|
|
55
55
|
Motion reaches past streamed text: every lift and float rides the same fade tick, and every working animation one spinner tick. The keyboard landing on the conversation, the subagent panel, or the status bar lifts that surface's frame, its chip, and the mark it holds for twelve ticks of `streamFadeStepMs`; a step of the conversation walk lifts the newly focused gutter for six; and a step along the bar lifts the selected label for eight. A new or status-changed activity-board todo row, and a replaced descendant line, float out on the fade tick the same way a tool card does; replay and `reducedMotion` draw the settled board. Every working animation has eight frames, takes the one it draws from the clock, and steps on the spinner tick of `spinnerMs`, 100 ms by default, so everything that spins advances at the same instant and speed, a label change keeps the beat, and the tick is armed only while one of them is drawn. The working spinner alone draws braille, its animation following its status, so it never repeats a card's glyph. A running tool card and a folded subagent row draw the animation of that tool's family, and an in-progress todo row draws the planning family's. Each of those animations mixes flowers, blooms, and stars, no two families share a glyph, and every frame of one family is different, so two indicators of one family at different phases never draw the same glyph. An indicator that starts while others of its family spin takes a phase at which it never draws their glyph at the same instant, for up to eight of that family spinning together; beyond eight, it takes the phase the fewest indicators of that family hold. A card whose header has scrolled above the part of the screen the renderer can repaint draws the static `◆` from then on, and `reducedMotion` draws every one of them still — the card's `◆`, the todo's `▸`, and the working spinner's label without a glyph — with no spinner tick. The reader arrives complete on the screen it owns, and what it newly shows floats out on the fade tick the way a tool card does: opening it and showing another turn float out the whole turn, and stepping the list to another section of the same turn floats out that section, over `streamFadeSteps` ticks; scrolling, live growth, and a rewrap float nothing out. No lift changes how many lines anything draws, and `reducedMotion` — like `NO_COLOR`, a disabled palette, and `TERM=dumb` — turns every lift and float off and arms no repaint for them.
|
|
56
56
|
|
|
57
|
-
The subagent panel is drawn while a local subagent session under the bound one is resident, or the listing carries a candidate it could not read; an external task has no local session and stays out of the panel. Unfocused it is one summary line with the listed count and the first child's key label; focused, its heading counts what it lists and ends on the keys it answers, `↑↓ children · Enter opens · Tab regions · Esc input`, narrowed to `↑↓ children · Esc input` and then to `Esc input` on a terminal that cannot hold them, and each row gives the child's depth indent, its label or id, its mode (`one-shot` or `continuable`), `resident`, whether its agent is `running`, `completed` after its latest settled turn, or `idle`, its elapsed time — the open turn's, else the total its settled turns took — and its token usage, as far as this process's own view of that child and the composed projections carry them. Six rows are drawn at most, with `+<n> more · /subagents lists them all` under them; `/subagents` shows an external task as `external task · no local session` and shows its no-local-session detail instead of opening a Session, a candidate the listing could not interpret draws as `unreadable: <reason>` and shows its reason instead of opening a Session, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row. `Enter` or `Right` on a readable row, like `Enter` on a readable `/subagents` row, opens that child as a subagent view: the terminal draws the child session in place of the bound one — its transcript, live stream, conversation walk, inspector, reader, and its own subagent panel — while the session it was entered from stays open. A resident child is read live, and any other is resumed. The entry's detail rows print as notices under `subagent <label> · Ctrl+P or /parent returns to session <id>`, the header ends on `◆ subagent view ›` with one `›` per level entered and `· Ctrl+P returns`, a shaded line directly above the input reads `◆ subagent view · main › <label> · Ctrl+P back to <parent>` for as long as the view is open, whatever the transcript has scrolled to, and `Ctrl+P` or `/parent` goes back one level, redrawing the parent from its log as it stands then. A one-shot child opens read-only: its banner opens with `◆ subagent view · one-shot, read-only`, a prompt or `!` line typed there is refused with a notice and stays in the editor, `Esc` does not stop its turn, and commands such as `/parent` still run, while a continuable child takes prompts and a stop as any session does. `/new`, `/clear`, `/resume`, `/sessions`, and `/fork` refuse while any session in that chain runs a turn, and otherwise release every view with the session they leave; quitting releases every view and saves the root session.
|
|
57
|
+
The subagent panel is drawn while a local subagent session under the bound one is resident, or the listing carries a candidate it could not read; an external task has no local session and stays out of the panel. Unfocused it is one summary line with the listed count and the first child's key label; focused, its heading counts what it lists and ends on the keys it answers, `↑↓ children · Enter opens · Tab regions · Esc input`, narrowed to `↑↓ children · Esc input` and then to `Esc input` on a terminal that cannot hold them, and each row gives the child's depth indent, its label or id, its mode (`one-shot` or `continuable`), `resident`, whether its agent is `running`, `completed` after its latest settled turn, or `idle`, its elapsed time — the open turn's, else the total its settled turns took — and its token usage, as far as this process's own view of that child and the composed projections carry them. Six rows are drawn at most, with `+<n> more · /subagents lists them all` under them; `/subagents` shows an external task as `external task · no local session` and shows its no-local-session detail instead of opening a Session, a candidate the listing could not interpret draws as `unreadable: <reason>` and shows its reason instead of opening a Session, and a failed listing keeps the rows the last good one produced with `listing failed: <reason>` beneath. The panel disappears with its last row. `Enter` or `Right` on a readable row, like `Enter` on a readable `/subagents` row, opens that child as a subagent view: the terminal draws the child session in place of the bound one — its transcript, live stream, conversation walk, inspector, reader, and its own subagent panel — while the session it was entered from stays open. A resident child is read live, and any other is resumed. The entry's detail rows print as notices under `subagent <label> · Ctrl+P or /parent returns to session <id>`, the header ends on `◆ subagent view ›` with one `›` per level entered and `· Ctrl+P returns`, a shaded line directly above the input reads `◆ subagent view · main › <label> · Ctrl+P back to <parent>` for as long as the view is open, whatever the transcript has scrolled to, and `Ctrl+P` or `/parent` goes back one level, redrawing the parent from its log as it stands then. A one-shot child opens read-only: its banner opens with `◆ subagent view · one-shot, read-only`, a prompt or `!` line typed there is refused with a notice and stays in the editor, `Esc` does not stop its turn, and commands such as `/parent` still run, while a continuable child takes prompts and a stop as any session does. `/new`, `/clear`, `/resume`, `/sessions`, and `/fork` refuse while any session in that chain runs a turn or a background job, since releasing a session ends its jobs, and otherwise release every view with the session they leave; quitting releases every view and saves the root session.
|
|
58
58
|
|
|
59
|
-
`/btw` opens a temporary side agent as a view over the session on screen, so the user can ask questions while that session's agent keeps working. The side agent is a new Agent seeded with every event the session has logged so far, an unfinished turn included: a tool call still waiting for its result gets the fork's error result, and reply text that is still streaming is not included. It runs on the session's last logged model, else its current selection, and it can only read: its session runs in the `read-only` sandbox mode with the `never` approval policy, so a write fails and cannot be approved, and it sees only the tools named in `btwTools`, plus the command tools in `btwSandboxedTools` when the command executor confines commands. Every other tool is hidden from it and refused if called. It runs its own turns: the question after `/btw` is its first prompt, and every line typed while it is on screen goes to it, `/btw <question>` included. The view is drawn like a subagent view: the header ends on `◆ btw side agent · Ctrl+P ends it and returns`, the shaded line above the input reads `◆ btw side agent · main › btw · Ctrl+P back to main`, and the transcript starts empty instead of repeating the inherited conversation. `Ctrl+P` or `/parent` ends the side agent, cancelling a turn it is running, and redraws the session it was opened from under `btw ended · back in session <id>`. The working session is only read: nothing is appended to its log, its inbox is untouched, and neither its subagent panel, `/subagents`, nor its model-facing subagent listing shows the side agent, which also cannot message it. An approval or question that a session held behind any view raises is shown on screen after `session <id>, behind this view, asks:` instead of being refused.
|
|
59
|
+
`/btw` opens a temporary side agent as a view over the session on screen, so the user can ask questions while that session's agent keeps working. The side agent is a new Agent seeded with every event the session has logged so far, an unfinished turn included: a tool call still waiting for its result gets the fork's error result, and reply text that is still streaming is not included. Input still queued for the session, prompts and next-step context alike, stays with that session's agent and is not carried into the side agent. It runs on the session's last logged model, else its current selection, and it can only read: its session runs in the `read-only` sandbox mode with the `never` approval policy, so a write fails and cannot be approved, and it sees only the tools named in `btwTools`, plus the command tools in `btwSandboxedTools` when the command executor confines commands. Every other tool is hidden from it and refused if called. It runs its own turns: the question after `/btw` is its first prompt, and every line typed while it is on screen goes to it, `/btw <question>` included. The view is drawn like a subagent view: the header ends on `◆ btw side agent · Ctrl+P ends it and returns`, the shaded line above the input reads `◆ btw side agent · main › btw · Ctrl+P back to main`, and the transcript starts empty instead of repeating the inherited conversation. `Ctrl+P` or `/parent` ends the side agent, cancelling a turn it is running, and redraws the session it was opened from under `btw ended · back in session <id>`. The working session is only read: nothing is appended to its log, its inbox is untouched, and neither its subagent panel, `/subagents`, nor its model-facing subagent listing shows the side agent, which also cannot message it. An approval or question that a session held behind any view raises is shown on screen after `session <id>, behind this view, asks:` instead of being refused.
|
|
60
60
|
|
|
61
61
|
### Keys and commands
|
|
62
62
|
|
|
@@ -36,7 +36,7 @@ dsh tui --resume <session-id> # continue an earlier session
|
|
|
36
36
|
dsh tui --no-open # print sign-in URLs without opening a browser
|
|
37
37
|
```
|
|
38
38
|
|
|
39
|
-
退出时应用在 stderr 为当时绑定的会话打印 `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>`。恢复的会话会在接受输入前先重绘其持久化历史,并沿用该会话上次使用的模型;日志里还没有请求头时则使用启动默认模型。在终端内,`/resume` 与 `/sessions`
|
|
39
|
+
退出时应用在 stderr 为当时绑定的会话打印 `dsh: session <id> saved; resume with: dsh --profile tui --resume <id>`。恢复的会话会在接受输入前先重绘其持久化历史,并沿用该会话上次使用的模型;日志里还没有请求头时则使用启动默认模型。在终端内,`/resume` 与 `/sessions` 打开同一个选择器,按从新到旧列出当前会话以外的持久化根会话,并恢复选中的先前会话,`/new` 使用启动默认模型开始新的空会话,而 `/clear` 开始新的空会话并保留当前模型和推理强度;先前会话仍留在磁盘上可用 `/resume` 恢复,`/fork` 把当前会话复制到其最后一个完成轮次并作为新会话,切割点与浏览器的 fork 相同。切换会释放先前的 Agent 并重绘下一个会话的对话记录。
|
|
40
40
|
|
|
41
41
|
### 屏幕布局
|
|
42
42
|
|
|
@@ -54,9 +54,9 @@ dsh tui --no-open # print sign-in URLs without opening a
|
|
|
54
54
|
|
|
55
55
|
动效不止于流式文本:每种抬亮与浮出都乘着同一个淡入时钟,每种工作动画则乘着同一个旋转时钟。键盘落到对话记录、子 agent 面板或状态栏上时,会把该表层的边框、其徽标与它持有的标记抬亮十二拍(每拍一个 `streamFadeStepMs`);对话记录走查中的一步把新聚焦的标记条抬亮六拍;状态栏上的一步把所选标签抬亮八拍。活动板上新出现或状态已变的 todo 行,以及被替换的后代行,也在淡入时钟上像工具卡片一样浮出;重放与 `reducedMotion` 则画出已稳定的活动板。每种工作动画都有八帧,由时钟决定当前画哪一帧,并在周期为 `spinnerMs`(默认 100 ms)的旋转时钟上步进,因此一切旋转中的指示都在同一时刻、以同一速度前进,标签变化也不打乱节拍,而该时钟只在其中之一被绘制时才启动。只有工作时的旋转指示画盲文,其动画随状态而变,因此它从不与卡片的符号重复。运行中的工具卡片与折叠的子 agent 行画该工具族的动画,进行中的 todo 行画规划族的动画。这些动画都把花朵、绽放与星形混在同一组帧里,族与族之间不共用符号,同一族的每一帧也各不相同,因此同一族里相位不同的两个指示在任何时刻都不会画出相同的符号。某个指示开始旋转时若同族已有其他指示在转,它会取一个相位,使它在任何时刻都不与它们画出相同的符号,同族同时旋转的不超过八个时都能做到;超过八个后,它取同族中被持有指示最少的那个相位。标题行已滚动到渲染器可重绘区域之上的卡片自此画出静态的 `◆`,而 `reducedMotion` 把它们全部画成静止的——卡片的 `◆`、todo 的 `▸`,以及不带符号、只剩标签的工作旋转指示——且不启动旋转时钟。阅读器在自己占据的屏幕上一次性完整出现,而它新显示的内容会像工具卡片一样在淡入时钟上浮出:打开它与显示另一个轮次时浮出整个轮次,在列表中步进到同一轮次的另一个小节时浮出该小节,历时 `streamFadeSteps` 拍;滚动、实时增长与重新换行都不浮出任何内容。任何抬亮都不改变任何东西绘制的行数,而 `reducedMotion`——与 `NO_COLOR`、被禁用的调色板和 `TERM=dumb` 一样——会关闭每一种抬亮与浮出,并且不为它们安排任何重绘。
|
|
56
56
|
|
|
57
|
-
子 agent 面板在绑定会话之下有常驻的本地子 agent 会话、或列表中带有无法读取的候选者时绘制;外部任务没有本地会话,因此不在面板中出现。未聚焦时它是一行摘要,含列出的数量与第一个子会话的关键标签;聚焦时其标题统计所列出的条目,并以它所应答的按键 `↑↓ children · Enter opens · Tab regions · Esc input` 结尾,在容纳不下时收缩为 `↑↓ children · Esc input`,再收缩为 `Esc input`;每一行给出该子会话的层级缩进、其标签或 id、其模式(`one-shot` 或 `continuable`)、`resident`、其 agent 处于 `running`、最新已结束轮次后为 `completed`,还是 `idle`、其已用时间——进行中轮次的用时,否则是已结束轮次的合计——以及其 token 用量,以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行,其下是 `+<n> more · /subagents lists them all`;`/subagents` 把外部任务显示为 `external task · no local session`,并显示其没有本地会话的详情而不打开会话,列表无法解读的候选者绘制为 `unreadable: <reason>`,并显示其原因而不打开会话,读取失败的列表则保留上一次成功读取产生的各行,并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。在可读的行上按 `Enter` 或 `Right`,与在可读的 `/subagents` 行上按 `Enter` 一样,会把该子会话作为子 agent 视图打开:终端在已绑定会话的位置绘制子会话——其对话记录、实时流、对话记录走查、检查器、阅读器以及它自己的子 agent 面板——而进入它之前的会话保持打开。常驻的子会话被实时读取,其他子会话则被恢复。条目的详情行作为通知打印在 `subagent <label> · Ctrl+P or /parent returns to session <id>` 之下,页眉以 `◆ subagent view ›`(每进入一层一个 `›`)与 `· Ctrl+P returns` 结尾,只要视图打开,输入框正上方就有一条着色行写着 `◆ subagent view · main › <label> · Ctrl+P back to <parent>`,无论对话记录滚动到哪里,`Ctrl+P` 或 `/parent` 返回上一层,并按父会话此刻的日志重绘它。`one-shot` 子会话以只读方式打开:其横幅以 `◆ subagent view · one-shot, read-only` 开头,在其中输入的提示词或 `!` 行会被通知拒绝并留在编辑器中,`Esc` 不会停止它的轮次,而 `/parent` 等命令仍可运行;`continuable`
|
|
57
|
+
子 agent 面板在绑定会话之下有常驻的本地子 agent 会话、或列表中带有无法读取的候选者时绘制;外部任务没有本地会话,因此不在面板中出现。未聚焦时它是一行摘要,含列出的数量与第一个子会话的关键标签;聚焦时其标题统计所列出的条目,并以它所应答的按键 `↑↓ children · Enter opens · Tab regions · Esc input` 结尾,在容纳不下时收缩为 `↑↓ children · Esc input`,再收缩为 `Esc input`;每一行给出该子会话的层级缩进、其标签或 id、其模式(`one-shot` 或 `continuable`)、`resident`、其 agent 处于 `running`、最新已结束轮次后为 `completed`,还是 `idle`、其已用时间——进行中轮次的用时,否则是已结束轮次的合计——以及其 token 用量,以本进程对该子会话的可见程度与已组合的投影所能提供的为限。最多绘制六行,其下是 `+<n> more · /subagents lists them all`;`/subagents` 把外部任务显示为 `external task · no local session`,并显示其没有本地会话的详情而不打开会话,列表无法解读的候选者绘制为 `unreadable: <reason>`,并显示其原因而不打开会话,读取失败的列表则保留上一次成功读取产生的各行,并在其下写出 `listing failed: <reason>`。面板随其最后一行一同消失。在可读的行上按 `Enter` 或 `Right`,与在可读的 `/subagents` 行上按 `Enter` 一样,会把该子会话作为子 agent 视图打开:终端在已绑定会话的位置绘制子会话——其对话记录、实时流、对话记录走查、检查器、阅读器以及它自己的子 agent 面板——而进入它之前的会话保持打开。常驻的子会话被实时读取,其他子会话则被恢复。条目的详情行作为通知打印在 `subagent <label> · Ctrl+P or /parent returns to session <id>` 之下,页眉以 `◆ subagent view ›`(每进入一层一个 `›`)与 `· Ctrl+P returns` 结尾,只要视图打开,输入框正上方就有一条着色行写着 `◆ subagent view · main › <label> · Ctrl+P back to <parent>`,无论对话记录滚动到哪里,`Ctrl+P` 或 `/parent` 返回上一层,并按父会话此刻的日志重绘它。`one-shot` 子会话以只读方式打开:其横幅以 `◆ subagent view · one-shot, read-only` 开头,在其中输入的提示词或 `!` 行会被通知拒绝并留在编辑器中,`Esc` 不会停止它的轮次,而 `/parent` 等命令仍可运行;`continuable` 子会话则像任何会话一样接受提示词与停止。只要这条链中任一会话正在运行轮次或后台任务,`/new`、`/clear`、`/resume`、`/sessions` 与 `/fork` 都会拒绝(释放会话会结束它的后台任务),否则它们会随所离开的会话释放每一个视图;退出会释放每一个视图并保存根会话。
|
|
58
58
|
|
|
59
|
-
`/btw` 在屏幕上的会话之上打开一个临时的旁路 agent 视图,让用户在该会话的 agent 继续工作时提问。旁路 agent 是一个新的 Agent
|
|
59
|
+
`/btw` 在屏幕上的会话之上打开一个临时的旁路 agent 视图,让用户在该会话的 agent 继续工作时提问。旁路 agent 是一个新的 Agent,以该会话迄今记录的全部事件为种子,包括尚未结束的轮次:仍在等待结果的工具调用会得到分叉产生的错误结果,仍在流式输出的回复文本不包含在内。该会话仍在排队的输入,无论是提示还是下一步上下文,都留给该会话的 agent,不会带进旁路 agent。它使用该会话最后记录的模型(否则使用其当前选择),并且只能读取:它的会话运行在 `read-only` 沙箱模式与 `never` 审批策略下,因此写入会失败且无法获批;它只看得到 `btwTools` 中列出的工具,以及在命令执行器会约束命令时 `btwSandboxedTools` 中的命令工具。其他工具对它隐藏,被调用时也会被拒绝。它运行自己的轮次:`/btw` 之后的问题是它的第一条提示,它在屏幕上时输入的每一行都交给它,`/btw <question>` 也一样。该视图的绘制方式与子 agent 视图相同:页眉以 `◆ btw side agent · Ctrl+P ends it and returns` 结尾,输入框上方的着色行写着 `◆ btw side agent · main › btw · Ctrl+P back to main`,对话记录从空开始,而不是重复继承来的对话。`Ctrl+P` 或 `/parent` 结束旁路 agent(取消它正在运行的轮次),并在 `btw ended · back in session <id>` 之下重绘打开它之前的会话。工作中的会话只被读取:不向其日志追加任何内容,不触碰其收件箱,其子 agent 面板、`/subagents` 与面向模型的子 agent 列表都不显示旁路 agent,旁路 agent 也不能给它发消息。被任一视图挡在后面的会话发起的审批或提问,会在 `session <id>, behind this view, asks:` 之后显示在屏幕上,而不是被拒绝。
|
|
60
60
|
|
|
61
61
|
### 按键与命令
|
|
62
62
|
|
|
@@ -12531,7 +12531,7 @@ var GuardedMainScreen = class extends TuiMainScreen {
|
|
|
12531
12531
|
* @module @deepseek-ai/dsh-tui-app/sessions
|
|
12532
12532
|
*/
|
|
12533
12533
|
/**
|
|
12534
|
-
* List persisted sessions newest first, with their titles;
|
|
12534
|
+
* List persisted sessions newest first, with their titles; the current session and subagents are excluded.
|
|
12535
12535
|
*
|
|
12536
12536
|
* Titles come from the live `title` projection or the durable projection
|
|
12537
12537
|
* cache, the same values the browser list uses. The picker does not load
|
|
@@ -12540,19 +12540,18 @@ var GuardedMainScreen = class extends TuiMainScreen {
|
|
|
12540
12540
|
* listing after the cache has the row.
|
|
12541
12541
|
*
|
|
12542
12542
|
* @param ctx - plugin context carrying the session query engine.
|
|
12543
|
-
* @param currentId - the session the terminal drives,
|
|
12543
|
+
* @param currentId - the session the terminal drives, excluded from the result.
|
|
12544
12544
|
* @param signal - cancels the listing.
|
|
12545
12545
|
* @returns the choices, or an empty list when no query engine is composed.
|
|
12546
12546
|
*/
|
|
12547
12547
|
async function listSessionChoices(ctx, currentId, signal) {
|
|
12548
12548
|
const query = ctx.get("sessionQuery");
|
|
12549
12549
|
if (query === void 0) return [];
|
|
12550
|
-
return (await query.listSessions(signal)).filter((record) => record.header.origin === void 0).sort((left, right) => right.header.createdAt - left.header.createdAt).map((record) => ({
|
|
12550
|
+
return (await query.listSessions(signal)).filter((record) => record.header.origin === void 0 && record.header.id !== currentId).sort((left, right) => right.header.createdAt - left.header.createdAt).map((record) => ({
|
|
12551
12551
|
id: record.header.id,
|
|
12552
12552
|
title: sessionListTitle(ctx, record.header),
|
|
12553
12553
|
cwd: record.header.cwd,
|
|
12554
|
-
createdAt: record.header.createdAt
|
|
12555
|
-
current: record.header.id === currentId
|
|
12554
|
+
createdAt: record.header.createdAt
|
|
12556
12555
|
}));
|
|
12557
12556
|
}
|
|
12558
12557
|
/**
|
|
@@ -12563,7 +12562,6 @@ async function listSessionChoices(ctx, currentId, signal) {
|
|
|
12563
12562
|
function describeSession(choice) {
|
|
12564
12563
|
const parts = [formatTimestamp(choice.createdAt)];
|
|
12565
12564
|
if (choice.cwd !== void 0) parts.push(choice.cwd);
|
|
12566
|
-
if (choice.current) parts.push("current");
|
|
12567
12565
|
return {
|
|
12568
12566
|
label: choice.title ?? choice.id,
|
|
12569
12567
|
description: parts.join(" · ")
|
|
@@ -14149,6 +14147,11 @@ var TuiApp = class {
|
|
|
14149
14147
|
this.notice("stop the running turn (Esc twice) before switching sessions", "error");
|
|
14150
14148
|
return;
|
|
14151
14149
|
}
|
|
14150
|
+
const live = this.liveChainJobs();
|
|
14151
|
+
if (live.length > 0) {
|
|
14152
|
+
this.notice(`wait for or stop the background jobs still running (${live.map((job) => job.id).join(", ")}) before switching sessions · /jobs lists them`, "error");
|
|
14153
|
+
return;
|
|
14154
|
+
}
|
|
14152
14155
|
if (this.compacting !== void 0) {
|
|
14153
14156
|
this.notice(COMPACTION_SWITCH_WAIT, "error");
|
|
14154
14157
|
return;
|
|
@@ -14937,6 +14940,17 @@ var TuiApp = class {
|
|
|
14937
14940
|
this.showToast(settledToast(job, !event.awaited && event.cause === "producer"));
|
|
14938
14941
|
}
|
|
14939
14942
|
/**
|
|
14943
|
+
* The background jobs still running for the bound session and every session
|
|
14944
|
+
* its views were entered from. A job a running call registered for itself
|
|
14945
|
+
* is that call's own work and is left out.
|
|
14946
|
+
* @returns the live jobs, bound session first.
|
|
14947
|
+
*/
|
|
14948
|
+
liveChainJobs() {
|
|
14949
|
+
const jobs = this.deps.ctx.get("jobs");
|
|
14950
|
+
if (jobs === void 0) return [];
|
|
14951
|
+
return [this.bound, ...this.parents].flatMap((bound) => jobs.list(bound.agent.session.id)).filter((job) => isLive(job) && !this.backgrounder.isInner(job.id));
|
|
14952
|
+
}
|
|
14953
|
+
/**
|
|
14940
14954
|
* Re-read the bound session's background jobs and redraw the live line
|
|
14941
14955
|
* above the editor. A job a running call registered for itself is that
|
|
14942
14956
|
* call's own work, not background work, and is left out while it runs.
|
|
@@ -16978,7 +16992,7 @@ var TuiApp = class {
|
|
|
16978
16992
|
const picked = await this.showModal(new PickPrompt(this.deps.palette, "Switch to a session", items), signal);
|
|
16979
16993
|
if (picked === void 0 || this.operationAbandoned(bound, signal)) return;
|
|
16980
16994
|
const target = choices.find((choice) => choice.id === picked.value);
|
|
16981
|
-
if (target === void 0
|
|
16995
|
+
if (target === void 0) return;
|
|
16982
16996
|
await this.switchSession(() => this.deps.host.resume(target.id), "resumed");
|
|
16983
16997
|
}
|
|
16984
16998
|
renameSession(title) {
|
|
@@ -18543,7 +18557,7 @@ function sessionHost(ctx, core, cwd, btw) {
|
|
|
18543
18557
|
}
|
|
18544
18558
|
const { seed, inheritedEventCount } = btwSeed(events);
|
|
18545
18559
|
const model = resumeModelSelection(session.requestHeader(), parent.selection.current ?? defaultModel.currentSelection());
|
|
18546
|
-
|
|
18560
|
+
const aside = await bind((selection, installSelection) => {
|
|
18547
18561
|
selection.current = model;
|
|
18548
18562
|
/* v8 ignore next -- TUI sessions record cwd on create; process cwd is the fallback when a header omitted it */
|
|
18549
18563
|
const workdir = session.header.cwd ?? cwd;
|
|
@@ -18570,6 +18584,8 @@ function sessionHost(ctx, core, cwd, btw) {
|
|
|
18570
18584
|
}
|
|
18571
18585
|
});
|
|
18572
18586
|
}, []);
|
|
18587
|
+
aside.agent.inbox.clear();
|
|
18588
|
+
return aside;
|
|
18573
18589
|
},
|
|
18574
18590
|
observe: async (id, options) => {
|
|
18575
18591
|
const resident = agents.get(id);
|
|
@@ -140,6 +140,33 @@ test("continue parsing despite array size error", () => {
|
|
|
140
140
|
`);
|
|
141
141
|
});
|
|
142
142
|
|
|
143
|
+
test("an upper size bound fails before any element is parsed", () => {
|
|
144
|
+
let parsed = 0;
|
|
145
|
+
const el = z.string().refine(() => ++parsed);
|
|
146
|
+
let refined = 0;
|
|
147
|
+
const schema = z
|
|
148
|
+
.array(el)
|
|
149
|
+
.max(2, "too many")
|
|
150
|
+
.refine(() => ++refined);
|
|
151
|
+
expect(schema.safeParse([1, 2, 3]).error!.issues).toMatchObject([{ code: "too_big", path: [], message: "too many" }]);
|
|
152
|
+
expect(z.array(el).length(2).safeParse(["a", "b", "c"]).error!.issues).toMatchObject([
|
|
153
|
+
{ code: "too_big", exact: true },
|
|
154
|
+
]);
|
|
155
|
+
expect(z.object({ a: z.array(el).max(1) }).safeParse({ a: [1, 2] }).error!.issues).toMatchObject([
|
|
156
|
+
{ code: "too_big", path: ["a"] },
|
|
157
|
+
]);
|
|
158
|
+
expect([parsed, refined]).toEqual([0, 0]);
|
|
159
|
+
|
|
160
|
+
// a check that may rewrite the value ends the gate
|
|
161
|
+
expect(
|
|
162
|
+
z
|
|
163
|
+
.array(z.number())
|
|
164
|
+
.overwrite((a) => a.slice(0, 2))
|
|
165
|
+
.max(2)
|
|
166
|
+
.parse([1, 2, 3])
|
|
167
|
+
).toEqual([1, 2]);
|
|
168
|
+
});
|
|
169
|
+
|
|
143
170
|
test("parse should fail given sparse array", () => {
|
|
144
171
|
const schema = z.array(z.string()).nonempty().min(1).max(3);
|
|
145
172
|
const result = schema.safeParse(new Array(3));
|
|
@@ -97,6 +97,13 @@ test("failing when map is bigger than max() ", () => {
|
|
|
97
97
|
expect(result.success).toEqual(false);
|
|
98
98
|
expect(result.error!.issues.length).toEqual(1);
|
|
99
99
|
expect(result.error!.issues[0].code).toEqual("too_big");
|
|
100
|
+
const bad = new Map([
|
|
101
|
+
[1, 1],
|
|
102
|
+
[2, 2],
|
|
103
|
+
]);
|
|
104
|
+
const capped = z.map(z.string(), z.string()).max(1);
|
|
105
|
+
expect(capped.safeParse(bad).error!.issues).toMatchObject([{ code: "too_big" }]);
|
|
106
|
+
expect(capped.safeParse(new Set([1, 2])).error!.issues[0]).toMatchObject({ code: "invalid_type", expected: "map" });
|
|
100
107
|
});
|
|
101
108
|
|
|
102
109
|
test("failing when map does not match size() ", () => {
|
|
@@ -83,6 +83,12 @@ test("failing when set is bigger than max() ", () => {
|
|
|
83
83
|
expect(result.success).toEqual(false);
|
|
84
84
|
expect(result.error!.issues.length).toEqual(1);
|
|
85
85
|
expect(result.error!.issues[0].code).toEqual("too_big");
|
|
86
|
+
expect(
|
|
87
|
+
z
|
|
88
|
+
.set(z.string())
|
|
89
|
+
.max(1)
|
|
90
|
+
.safeParse(new Set([1, 2])).error!.issues
|
|
91
|
+
).toMatchObject([{ code: "too_big" }]);
|
|
86
92
|
});
|
|
87
93
|
|
|
88
94
|
test("failing when set does not match size() ", () => {
|
|
@@ -1551,6 +1551,12 @@ function generateNullableCheck(
|
|
|
1551
1551
|
return outputVar;
|
|
1552
1552
|
}
|
|
1553
1553
|
|
|
1554
|
+
function generateSizeGate(doc: Doc, schema: SomeType, size: string): void {
|
|
1555
|
+
for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
|
|
1556
|
+
doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
|
|
1557
|
+
}
|
|
1558
|
+
}
|
|
1559
|
+
|
|
1554
1560
|
function generateArrayCheck(
|
|
1555
1561
|
doc: Doc,
|
|
1556
1562
|
ctx: CompileContext,
|
|
@@ -1560,6 +1566,7 @@ function generateArrayCheck(
|
|
|
1560
1566
|
): string | null {
|
|
1561
1567
|
const def = schema._zod.def as unknown as { element: SomeType };
|
|
1562
1568
|
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
|
|
1569
|
+
generateSizeGate(doc, schema, `${accessor}.length`);
|
|
1563
1570
|
|
|
1564
1571
|
// Build a new array with validated/transformed elements.
|
|
1565
1572
|
const outputVar = buildsValue ? newVar(ctx) : null;
|
|
@@ -2094,6 +2101,7 @@ function generateMapCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
|
|
|
2094
2101
|
const def = schema._zod.def as unknown as { keyType: SomeType; valueType: SomeType };
|
|
2095
2102
|
|
|
2096
2103
|
doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
|
|
2104
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
2097
2105
|
|
|
2098
2106
|
const outputVar = newVar(ctx);
|
|
2099
2107
|
const kVar = newVar(ctx);
|
|
@@ -2115,6 +2123,7 @@ function generateSetCheck(doc: Doc, ctx: CompileContext, schema: SomeType, acces
|
|
|
2115
2123
|
const def = schema._zod.def as unknown as { valueType: SomeType };
|
|
2116
2124
|
|
|
2117
2125
|
doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
|
|
2126
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
2118
2127
|
|
|
2119
2128
|
const outputVar = newVar(ctx);
|
|
2120
2129
|
const valVar = newVar(ctx);
|
|
@@ -1844,6 +1844,34 @@ export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$Zod
|
|
|
1844
1844
|
|
|
1845
1845
|
export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {}
|
|
1846
1846
|
|
|
1847
|
+
// an oversized container fails its leading size checks before any element is parsed
|
|
1848
|
+
function capSize(inst: $ZodType, size: (input: any) => number): void {
|
|
1849
|
+
const caps = util.sizeCaps(inst._zod.def.checks);
|
|
1850
|
+
if (!caps.length) return;
|
|
1851
|
+
const cap = Math.min(...caps.map((c) => c[0]));
|
|
1852
|
+
const parse = inst._zod.parse;
|
|
1853
|
+
inst._zod.parse = (payload, ctx) => {
|
|
1854
|
+
const n = size(payload.value);
|
|
1855
|
+
if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
|
|
1856
|
+
for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
|
|
1857
|
+
if (n > max && ch._zod.def.when!(payload)) {
|
|
1858
|
+
const start = payload.issues.length;
|
|
1859
|
+
ch._zod.check(payload as ParsePayload<never>);
|
|
1860
|
+
// the value is still the raw input, so no later check may read it
|
|
1861
|
+
(payload.issues[start] as { continue?: boolean }).continue = false;
|
|
1862
|
+
util.attachSchema(payload.issues, start, inst);
|
|
1863
|
+
return payload;
|
|
1864
|
+
}
|
|
1865
|
+
}
|
|
1866
|
+
}
|
|
1867
|
+
return parse(payload, ctx);
|
|
1868
|
+
};
|
|
1869
|
+
}
|
|
1870
|
+
|
|
1871
|
+
const arraySize = (input: unknown): number => (Array.isArray(input) ? input.length : -1);
|
|
1872
|
+
const mapSize = (input: unknown): number => (input instanceof Map ? input.size : -1);
|
|
1873
|
+
const setSize = (input: unknown): number => (input instanceof Set ? input.size : -1);
|
|
1874
|
+
|
|
1847
1875
|
function handleArrayResult(result: ParsePayload<any>, final: ParsePayload<any[]>, index: number) {
|
|
1848
1876
|
if (result.issues.length) {
|
|
1849
1877
|
final.issues.push(...util.prefixIssues(index, result.issues));
|
|
@@ -1899,6 +1927,7 @@ export const $ZodArray: core.$constructor<$ZodArray> = /*@__PURE__*/ core.$const
|
|
|
1899
1927
|
|
|
1900
1928
|
return payload; //handleArrayResultsAsync(parseResults, final);
|
|
1901
1929
|
};
|
|
1930
|
+
capSize(inst, arraySize);
|
|
1902
1931
|
});
|
|
1903
1932
|
|
|
1904
1933
|
//////////////////////////////////////////
|
|
@@ -3218,8 +3247,11 @@ export type $InferZodRecordInput<
|
|
|
3218
3247
|
: Record<core.input<Key> & PropertyKey, core.input<Value>>;
|
|
3219
3248
|
|
|
3220
3249
|
export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType>
|
|
3221
|
-
extends $ZodTypeInternals
|
|
3250
|
+
extends $ZodTypeInternals {
|
|
3222
3251
|
def: $ZodRecordDef<Key, Value>;
|
|
3252
|
+
// members rather than base type arguments, which TypeScript 7.1 reports as circular for `z.json()`
|
|
3253
|
+
output: $InferZodRecordOutput<Key, Value>;
|
|
3254
|
+
input: $InferZodRecordInput<Key, Value>;
|
|
3223
3255
|
isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
|
|
3224
3256
|
optin?: "optional" | undefined;
|
|
3225
3257
|
optout?: "optional" | undefined;
|
|
@@ -3480,6 +3512,7 @@ export const $ZodMap: core.$constructor<$ZodMap> = /*@__PURE__*/ core.$construct
|
|
|
3480
3512
|
if (proms.length) return Promise.all(proms).then(() => payload);
|
|
3481
3513
|
return payload;
|
|
3482
3514
|
};
|
|
3515
|
+
capSize(inst, mapSize);
|
|
3483
3516
|
});
|
|
3484
3517
|
|
|
3485
3518
|
function handleMapResult(
|
|
@@ -3582,6 +3615,7 @@ export const $ZodSet: core.$constructor<$ZodSet> = /*@__PURE__*/ core.$construct
|
|
|
3582
3615
|
if (proms.length) return Promise.all(proms).then(() => payload);
|
|
3583
3616
|
return payload;
|
|
3584
3617
|
};
|
|
3618
|
+
capSize(inst, setSize);
|
|
3585
3619
|
});
|
|
3586
3620
|
|
|
3587
3621
|
function handleSetResult(result: ParsePayload, final: ParsePayload<Set<any>>) {
|
|
@@ -935,6 +935,19 @@ export function unwrapMessage(message: string | { message: string } | undefined
|
|
|
935
935
|
}
|
|
936
936
|
|
|
937
937
|
/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
|
|
938
|
+
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
|
939
|
+
export function sizeCaps(defChecks: checks.$ZodCheck<never>[] | undefined): [number, checks.$ZodCheck<never>][] {
|
|
940
|
+
const caps: [number, checks.$ZodCheck<never>][] = [];
|
|
941
|
+
for (const ch of defChecks ?? []) {
|
|
942
|
+
const d = ch._zod.def as any;
|
|
943
|
+
// a later check may rewrite the value
|
|
944
|
+
if (!/_(length|size)$|_equals$/.test(d.check)) break;
|
|
945
|
+
const max = d.maximum ?? d.length ?? d.size;
|
|
946
|
+
if (max >= 0) caps.push([max, ch]);
|
|
947
|
+
}
|
|
948
|
+
return caps;
|
|
949
|
+
}
|
|
950
|
+
|
|
938
951
|
export function attachSchema(issues: errors.$ZodRawIssue[], start: number, inst: schemas.$ZodType): void {
|
|
939
952
|
for (let i = start; i < issues.length; i++) {
|
|
940
953
|
(issues[i] as any).schema ??= inst;
|
|
@@ -1241,9 +1241,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
|
|
|
1241
1241
|
doc.write(`}`);
|
|
1242
1242
|
return outputVar;
|
|
1243
1243
|
}
|
|
1244
|
+
function generateSizeGate(doc, schema, size) {
|
|
1245
|
+
for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
|
|
1246
|
+
doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1244
1249
|
function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
|
|
1245
1250
|
const def = schema._zod.def;
|
|
1246
1251
|
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
|
|
1252
|
+
generateSizeGate(doc, schema, `${accessor}.length`);
|
|
1247
1253
|
// Build a new array with validated/transformed elements.
|
|
1248
1254
|
const outputVar = buildsValue ? newVar(ctx) : null;
|
|
1249
1255
|
const iVar = newVar(ctx);
|
|
@@ -1707,6 +1713,7 @@ function literalPropertyKey(ctx, key) {
|
|
|
1707
1713
|
function generateMapCheck(doc, ctx, schema, accessor) {
|
|
1708
1714
|
const def = schema._zod.def;
|
|
1709
1715
|
doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
|
|
1716
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
1710
1717
|
const outputVar = newVar(ctx);
|
|
1711
1718
|
const kVar = newVar(ctx);
|
|
1712
1719
|
const valVar = newVar(ctx);
|
|
@@ -1723,6 +1730,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
|
|
|
1723
1730
|
function generateSetCheck(doc, ctx, schema, accessor) {
|
|
1724
1731
|
const def = schema._zod.def;
|
|
1725
1732
|
doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
|
|
1733
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
1726
1734
|
const outputVar = newVar(ctx);
|
|
1727
1735
|
const valVar = newVar(ctx);
|
|
1728
1736
|
doc.write(`const ${outputVar} = new Set();`);
|
|
@@ -1210,9 +1210,15 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
|
|
|
1210
1210
|
doc.write(`}`);
|
|
1211
1211
|
return outputVar;
|
|
1212
1212
|
}
|
|
1213
|
+
function generateSizeGate(doc, schema, size) {
|
|
1214
|
+
for (const [max, check] of util.sizeCaps(schema._zod.def.checks)) {
|
|
1215
|
+
doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
|
|
1216
|
+
}
|
|
1217
|
+
}
|
|
1213
1218
|
function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
|
|
1214
1219
|
const def = schema._zod.def;
|
|
1215
1220
|
doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
|
|
1221
|
+
generateSizeGate(doc, schema, `${accessor}.length`);
|
|
1216
1222
|
// Build a new array with validated/transformed elements.
|
|
1217
1223
|
const outputVar = buildsValue ? newVar(ctx) : null;
|
|
1218
1224
|
const iVar = newVar(ctx);
|
|
@@ -1676,6 +1682,7 @@ function literalPropertyKey(ctx, key) {
|
|
|
1676
1682
|
function generateMapCheck(doc, ctx, schema, accessor) {
|
|
1677
1683
|
const def = schema._zod.def;
|
|
1678
1684
|
doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
|
|
1685
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
1679
1686
|
const outputVar = newVar(ctx);
|
|
1680
1687
|
const kVar = newVar(ctx);
|
|
1681
1688
|
const valVar = newVar(ctx);
|
|
@@ -1692,6 +1699,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
|
|
|
1692
1699
|
function generateSetCheck(doc, ctx, schema, accessor) {
|
|
1693
1700
|
const def = schema._zod.def;
|
|
1694
1701
|
doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
|
|
1702
|
+
generateSizeGate(doc, schema, `${accessor}.size`);
|
|
1695
1703
|
const outputVar = newVar(ctx);
|
|
1696
1704
|
const valVar = newVar(ctx);
|
|
1697
1705
|
doc.write(`const ${outputVar} = new Set();`);
|
|
@@ -860,6 +860,33 @@ exports.$ZodDate = core.$constructor("$ZodDate", (inst, def) => {
|
|
|
860
860
|
return payload;
|
|
861
861
|
};
|
|
862
862
|
});
|
|
863
|
+
// an oversized container fails its leading size checks before any element is parsed
|
|
864
|
+
function capSize(inst, size) {
|
|
865
|
+
const caps = util.sizeCaps(inst._zod.def.checks);
|
|
866
|
+
if (!caps.length)
|
|
867
|
+
return;
|
|
868
|
+
const cap = Math.min(...caps.map((c) => c[0]));
|
|
869
|
+
const parse = inst._zod.parse;
|
|
870
|
+
inst._zod.parse = (payload, ctx) => {
|
|
871
|
+
const n = size(payload.value);
|
|
872
|
+
if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
|
|
873
|
+
for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
|
|
874
|
+
if (n > max && ch._zod.def.when(payload)) {
|
|
875
|
+
const start = payload.issues.length;
|
|
876
|
+
ch._zod.check(payload);
|
|
877
|
+
// the value is still the raw input, so no later check may read it
|
|
878
|
+
payload.issues[start].continue = false;
|
|
879
|
+
util.attachSchema(payload.issues, start, inst);
|
|
880
|
+
return payload;
|
|
881
|
+
}
|
|
882
|
+
}
|
|
883
|
+
}
|
|
884
|
+
return parse(payload, ctx);
|
|
885
|
+
};
|
|
886
|
+
}
|
|
887
|
+
const arraySize = (input) => (Array.isArray(input) ? input.length : -1);
|
|
888
|
+
const mapSize = (input) => (input instanceof Map ? input.size : -1);
|
|
889
|
+
const setSize = (input) => (input instanceof Set ? input.size : -1);
|
|
863
890
|
function handleArrayResult(result, final, index) {
|
|
864
891
|
if (result.issues.length) {
|
|
865
892
|
final.issues.push(...util.prefixIssues(index, result.issues));
|
|
@@ -905,6 +932,7 @@ exports.$ZodArray = core.$constructor("$ZodArray", (inst, def) => {
|
|
|
905
932
|
}
|
|
906
933
|
return payload; //handleArrayResultsAsync(parseResults, final);
|
|
907
934
|
};
|
|
935
|
+
capSize(inst, arraySize);
|
|
908
936
|
});
|
|
909
937
|
function handlePropertyResult(result, final, key, input, optin, optout) {
|
|
910
938
|
const isPresent = key in input;
|
|
@@ -1942,6 +1970,7 @@ exports.$ZodMap = core.$constructor("$ZodMap", (inst, def) => {
|
|
|
1942
1970
|
return Promise.all(proms).then(() => payload);
|
|
1943
1971
|
return payload;
|
|
1944
1972
|
};
|
|
1973
|
+
capSize(inst, mapSize);
|
|
1945
1974
|
});
|
|
1946
1975
|
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
|
|
1947
1976
|
if (keyResult.issues.length) {
|
|
@@ -2011,6 +2040,7 @@ exports.$ZodSet = core.$constructor("$ZodSet", (inst, def) => {
|
|
|
2011
2040
|
return Promise.all(proms).then(() => payload);
|
|
2012
2041
|
return payload;
|
|
2013
2042
|
};
|
|
2043
|
+
capSize(inst, setSize);
|
|
2014
2044
|
});
|
|
2015
2045
|
function handleSetResult(result, final) {
|
|
2016
2046
|
if (result.issues.length) {
|
|
@@ -816,6 +816,33 @@ export const $ZodDate = /*@__PURE__*/ core.$constructor("$ZodDate", (inst, def)
|
|
|
816
816
|
return payload;
|
|
817
817
|
};
|
|
818
818
|
});
|
|
819
|
+
// an oversized container fails its leading size checks before any element is parsed
|
|
820
|
+
function capSize(inst, size) {
|
|
821
|
+
const caps = util.sizeCaps(inst._zod.def.checks);
|
|
822
|
+
if (!caps.length)
|
|
823
|
+
return;
|
|
824
|
+
const cap = Math.min(...caps.map((c) => c[0]));
|
|
825
|
+
const parse = inst._zod.parse;
|
|
826
|
+
inst._zod.parse = (payload, ctx) => {
|
|
827
|
+
const n = size(payload.value);
|
|
828
|
+
if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
|
|
829
|
+
for (const [max, ch] of util.sizeCaps(inst._zod.def.checks)) {
|
|
830
|
+
if (n > max && ch._zod.def.when(payload)) {
|
|
831
|
+
const start = payload.issues.length;
|
|
832
|
+
ch._zod.check(payload);
|
|
833
|
+
// the value is still the raw input, so no later check may read it
|
|
834
|
+
payload.issues[start].continue = false;
|
|
835
|
+
util.attachSchema(payload.issues, start, inst);
|
|
836
|
+
return payload;
|
|
837
|
+
}
|
|
838
|
+
}
|
|
839
|
+
}
|
|
840
|
+
return parse(payload, ctx);
|
|
841
|
+
};
|
|
842
|
+
}
|
|
843
|
+
const arraySize = (input) => (Array.isArray(input) ? input.length : -1);
|
|
844
|
+
const mapSize = (input) => (input instanceof Map ? input.size : -1);
|
|
845
|
+
const setSize = (input) => (input instanceof Set ? input.size : -1);
|
|
819
846
|
function handleArrayResult(result, final, index) {
|
|
820
847
|
if (result.issues.length) {
|
|
821
848
|
final.issues.push(...util.prefixIssues(index, result.issues));
|
|
@@ -861,6 +888,7 @@ export const $ZodArray = /*@__PURE__*/ core.$constructor("$ZodArray", (inst, def
|
|
|
861
888
|
}
|
|
862
889
|
return payload; //handleArrayResultsAsync(parseResults, final);
|
|
863
890
|
};
|
|
891
|
+
capSize(inst, arraySize);
|
|
864
892
|
});
|
|
865
893
|
function handlePropertyResult(result, final, key, input, optin, optout) {
|
|
866
894
|
const isPresent = key in input;
|
|
@@ -1898,6 +1926,7 @@ export const $ZodMap = /*@__PURE__*/ core.$constructor("$ZodMap", (inst, def) =>
|
|
|
1898
1926
|
return Promise.all(proms).then(() => payload);
|
|
1899
1927
|
return payload;
|
|
1900
1928
|
};
|
|
1929
|
+
capSize(inst, mapSize);
|
|
1901
1930
|
});
|
|
1902
1931
|
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
|
|
1903
1932
|
if (keyResult.issues.length) {
|
|
@@ -1967,6 +1996,7 @@ export const $ZodSet = /*@__PURE__*/ core.$constructor("$ZodSet", (inst, def) =>
|
|
|
1967
1996
|
return Promise.all(proms).then(() => payload);
|
|
1968
1997
|
return payload;
|
|
1969
1998
|
};
|
|
1999
|
+
capSize(inst, setSize);
|
|
1970
2000
|
});
|
|
1971
2001
|
function handleSetResult(result, final) {
|
|
1972
2002
|
if (result.issues.length) {
|
|
@@ -46,6 +46,7 @@ exports.aborted = aborted;
|
|
|
46
46
|
exports.explicitlyAborted = explicitlyAborted;
|
|
47
47
|
exports.prefixIssues = prefixIssues;
|
|
48
48
|
exports.unwrapMessage = unwrapMessage;
|
|
49
|
+
exports.sizeCaps = sizeCaps;
|
|
49
50
|
exports.attachSchema = attachSchema;
|
|
50
51
|
exports.finalizeIssue = finalizeIssue;
|
|
51
52
|
exports.getSizableOrigin = getSizableOrigin;
|
|
@@ -620,6 +621,20 @@ function unwrapMessage(message) {
|
|
|
620
621
|
return typeof message === "string" ? message : message?.message;
|
|
621
622
|
}
|
|
622
623
|
/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
|
|
624
|
+
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
|
625
|
+
function sizeCaps(defChecks) {
|
|
626
|
+
const caps = [];
|
|
627
|
+
for (const ch of defChecks ?? []) {
|
|
628
|
+
const d = ch._zod.def;
|
|
629
|
+
// a later check may rewrite the value
|
|
630
|
+
if (!/_(length|size)$|_equals$/.test(d.check))
|
|
631
|
+
break;
|
|
632
|
+
const max = d.maximum ?? d.length ?? d.size;
|
|
633
|
+
if (max >= 0)
|
|
634
|
+
caps.push([max, ch]);
|
|
635
|
+
}
|
|
636
|
+
return caps;
|
|
637
|
+
}
|
|
623
638
|
function attachSchema(issues, start, inst) {
|
|
624
639
|
var _a;
|
|
625
640
|
for (let i = start; i < issues.length; i++) {
|
|
@@ -550,6 +550,20 @@ export function unwrapMessage(message) {
|
|
|
550
550
|
return typeof message === "string" ? message : message?.message;
|
|
551
551
|
}
|
|
552
552
|
/* A check holds no link back to the schema it is attached to — the same check instance is shared by every clone of that schema — so the owner is stamped onto the issues a check just raised, at the only point where both are in scope. Runs on the failure path only; `start` is the issue count from before the check ran. */
|
|
553
|
+
/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
|
|
554
|
+
export function sizeCaps(defChecks) {
|
|
555
|
+
const caps = [];
|
|
556
|
+
for (const ch of defChecks ?? []) {
|
|
557
|
+
const d = ch._zod.def;
|
|
558
|
+
// a later check may rewrite the value
|
|
559
|
+
if (!/_(length|size)$|_equals$/.test(d.check))
|
|
560
|
+
break;
|
|
561
|
+
const max = d.maximum ?? d.length ?? d.size;
|
|
562
|
+
if (max >= 0)
|
|
563
|
+
caps.push([max, ch]);
|
|
564
|
+
}
|
|
565
|
+
return caps;
|
|
566
|
+
}
|
|
553
567
|
export function attachSchema(issues, start, inst) {
|
|
554
568
|
var _a;
|
|
555
569
|
for (let i = start; i < issues.length; i++) {
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@songtonyli/dsh-cli",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.74",
|
|
4
4
|
"description": "The dsh terminal agent: an interactive TUI over the DeepSeek Harness, with its whole Node runtime bundled in one install.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"type": "module",
|
|
@@ -602,7 +602,7 @@
|
|
|
602
602
|
"xmlchars": "2.2.0",
|
|
603
603
|
"yaml": "2.9.1",
|
|
604
604
|
"yoctocolors": "2.2.0",
|
|
605
|
-
"zod": "4.6.
|
|
605
|
+
"zod": "4.6.6",
|
|
606
606
|
"zwitch": "2.0.4"
|
|
607
607
|
},
|
|
608
608
|
"optionalDependencies": {
|