fix(agent): codex review fixes

- agentStore: useIDBKeyval is async; the previous code seeded `messages`
  with an empty snapshot then enabled the write-back watcher immediately,
  so any send before the IDB read settled would clobber stored history
  with []. Gate the watcher on `persisted.isFinished` and merge the
  hydrated entries when they arrive.
- FoldablePanel: dropping `/` from the shell-operator regex. The
  attachment flow prefills the composer with paths like /input/foo.png,
  and the previous regex routed those to direct exec instead of the LLM.
- coreutils grep: drain stdin eagerly so the no-match case can return
  exit code 1. The previous generator-based version always returned 0,
  breaking `grep ... && ...` and `grep ... || ...` decision flows the
  agent relies on.
- registrySearch: stop advertising a non-existent `install-pack`
  command. Direct the user to ComfyUI-Manager UI instead until a real
  install-pack shell command exists.
- agentTerminal.spec: rewrite for the textarea-based panel; the old
  `.xterm-rows` / `.xterm-helper-textarea` locators no longer resolve.
  Drops the Tab-completion test (useCompletion was deleted) and adds a
  Ctrl+O fold/unfold smoke test.

Author: snomiao

browser_tests/tests/agentTerminal.spec.ts

@@ -4,15 +4,14 @@ import type { ComfyPage } from '@e2e/fixtures/ComfyPage'
 import { comfyPageFixture as test } from '@e2e/fixtures/ComfyPage'
 
 /**
- * E2E coverage for the in-browser agent terminal (AgentFab + XtermPanel).
+ * E2E coverage for the in-browser agent terminal (AgentFab + FoldablePanel).
  *
- * We exercise the deterministic surface: FAB → open/close, the solid-block
- * ASCII banner, the "COMFY-AI" title pill, keyboard affordances
- * (Enter submits, Shift+Enter inserts a literal newline, Tab completes),
- * and a representative slice of shell commands that back the examples
- * documented in the LLM system prompt. We intentionally do NOT drive the
- * LLM itself — typing into xterm runs the shell directly, which is what
- * the model ends up calling via the `run_shell` tool.
+ * The panel is now a Vue-native scrollback (no xterm.js), so the tests
+ * target the plain DOM directly: the input is a `<textarea>` inside
+ * `[data-testid="agent-terminal"]`, and the scrollback lives in the same
+ * container as a list of message blocks. We exercise the deterministic
+ * shell surface — typing into the textarea runs commands directly through
+ * the runtime, which is what the LLM ends up calling via `run_shell`.
  */
 
 async function openPanel(comfyPage: ComfyPage): Promise<void> {
@@ -23,18 +22,12 @@ async function openPanel(comfyPage: ComfyPage): Promise<void> {
 }
 
 async function readTerminalText(comfyPage: ComfyPage): Promise<string> {
-  // xterm renders into rows under .xterm-rows; concatenate the text content.
-  return await comfyPage.page
-    .getByTestId('agent-terminal')
-    .locator('.xterm-rows')
-    .innerText()
+  return await comfyPage.page.getByTestId('agent-terminal').innerText()
 }
 
 async function typeAndEnter(comfyPage: ComfyPage, text: string): Promise<void> {
-  const helper = comfyPage.page
-    .getByTestId('agent-terminal')
-    .locator('.xterm-helper-textarea')
-  await helper.focus()
+  const input = comfyPage.page.getByTestId('agent-terminal').locator('textarea')
+  await input.focus()
   await comfyPage.page.keyboard.type(text)
   await comfyPage.page.keyboard.press('Enter')
 }
@@ -48,9 +41,6 @@ test.describe('Agent terminal', { tag: '@ui' }, () => {
     await expect(comfyPage.page.getByTestId('agent-panel-title')).toHaveText(
       'COMFY-AI'
     )
-
-    // Banner is suppressed for token efficiency — only the shell prompt
-    // should be rendered once the terminal is ready.
     await expect.poll(() => readTerminalText(comfyPage)).toMatch(/comfy>/)
   })
 
@@ -72,39 +62,22 @@ test.describe('Agent terminal', { tag: '@ui' }, () => {
     comfyPage
   }) => {
     await openPanel(comfyPage)
-    const helper = comfyPage.page
+    const input = comfyPage.page
       .getByTestId('agent-terminal')
-      .locator('.xterm-helper-textarea')
-    await helper.focus()
+      .locator('textarea')
+    await input.focus()
     await comfyPage.page.keyboard.type('echo one')
     await comfyPage.page.keyboard.press('Shift+Enter')
     await comfyPage.page.keyboard.type('echo two')
-    // Still not submitted → now submit the whole multiline buffer.
+    // Single submission should run BOTH lines as one multi-line script.
     await comfyPage.page.keyboard.press('Enter')
 
     const out = await readTerminalText(comfyPage)
-    // Both commands ran sequentially via the runtime.
     expect(out).toContain('one')
     expect(out).toContain('two')
   })
 
-  test('Tab completes a partial command', async ({ comfyPage }) => {
-    await openPanel(comfyPage)
-    const helper = comfyPage.page
-      .getByTestId('agent-terminal')
-      .locator('.xterm-helper-textarea')
-    await helper.focus()
-    // "des" → unique prefix of `describe`
-    await comfyPage.page.keyboard.type('des')
-    await comfyPage.page.keyboard.press('Tab')
-    // Submit; describe w/o arg yields usage text on stderr.
-    await comfyPage.page.keyboard.press('Enter')
-    await expect
-      .poll(() => readTerminalText(comfyPage))
-      .toMatch(/usage: describe/)
-  })
-
-  test('coreutils: pwd / echo / true / false', async ({ comfyPage }) => {
+  test('coreutils: pwd / echo', async ({ comfyPage }) => {
     await openPanel(comfyPage)
     await typeAndEnter(comfyPage, 'pwd')
     await expect.poll(() => readTerminalText(comfyPage)).toMatch(/^\//m)
@@ -169,4 +142,21 @@ test.describe('Agent terminal', { tag: '@ui' }, () => {
       .poll(() => readTerminalText(comfyPage))
       .toMatch(/not found|unknown|no such/i)
   })
+
+  test('Ctrl+O folds and unfolds tool blocks', async ({ comfyPage }) => {
+    await openPanel(comfyPage)
+    await typeAndEnter(comfyPage, 'graph summary')
+    // Tool blocks default to folded — body shouldn't be visible yet.
+    const panel = comfyPage.page.getByTestId('agent-panel')
+    await expect(
+      panel.locator('button:has-text("graph summary")')
+    ).toBeVisible()
+
+    // Ctrl+O expands all
+    await comfyPage.page.keyboard.press('Control+o')
+    await expect.poll(() => readTerminalText(comfyPage)).toMatch(/nodes|types/i)
+
+    // Ctrl+O folds all back — `nodes:` from the body should be hidden again.
+    await comfyPage.page.keyboard.press('Control+o')
+  })
 })

src/agent/shell/commands/coreutils.ts

@@ -109,17 +109,21 @@ const grep: Command = async (ctx) => {
   const pattern = ctx.argv[1]
   if (!pattern) return err('usage: grep <pattern>')
   const re = new RegExp(pattern)
-  async function* gen(): AsyncIterable<string> {
-    let matched = false
-    for await (const line of lines(ctx.stdin)) {
-      if (re.test(line)) {
-        yield line + '\n'
-        matched = true
-      }
+  // POSIX grep returns 1 when nothing matched. To honour that we have to
+  // drain stdin eagerly — exit codes are set on the Command return, but a
+  // generator can't change them after the fact. The agent relies on this
+  // for `grep ... && ...` / `grep ... || ...` flows; without the right
+  // exit code the LLM would conclude evidence existed when stdout was
+  // actually empty.
+  let matched = false
+  let out = ''
+  for await (const line of lines(ctx.stdin)) {
+    if (re.test(line)) {
+      out += line + '\n'
+      matched = true
     }
-    void matched
   }
-  return ok(gen())
+  return ok(stringIter(out), matched ? 0 : 1)
 }
 
 const trueCmd: Command = async () => ok(emptyIter(), 0)

src/agent/shell/commands/registrySearch.ts

@@ -63,12 +63,12 @@ const nodeSearchRegistry: Command = async (ctx) => {
   }
   const total = res?.total ?? packs.length
   const lines = packs.map(
-    (p) => packLine(p) + (p.id ? '\n  install: install-pack ' + p.id : '')
+    (p) => packLine(p) + (p.id ? '\n  inspect: pack-info ' + p.id : '')
   )
   const header =
     packs.length < total
-      ? `${packs.length} of ${total} pack(s) expose a node matching "${pattern}":\n`
-      : `${packs.length} pack(s) expose a node matching "${pattern}":\n`
+      ? `${packs.length} of ${total} pack(s) expose a node matching "${pattern}". To install one, ask the user to use ComfyUI-Manager (Settings → Extensions) — there is no shell command for pack installs yet.\n`
+      : `${packs.length} pack(s) expose a node matching "${pattern}". To install one, ask the user to use ComfyUI-Manager (Settings → Extensions) — there is no shell command for pack installs yet.\n`
   return {
     stdout: stringIter(header + lines.join('\n') + '\n'),
     exitCode: 0

src/agent/stores/agentStore.ts

@@ -49,16 +49,43 @@ const MAX_PERSISTED_MESSAGES = 300
 export const useAgentStore = defineStore('agent', () => {
   // IndexedDB-backed: survives reloads, larger quota than localStorage,
   // doesn't block the main thread like localStorage sync-writes would.
+  // Note: useIDBKeyval populates `data` asynchronously, so the initial
+  // `data.value` is `[]` until the read resolves. We seed `messages` with
+  // whatever's already there (cheap if it's empty) and then hydrate from
+  // the DB once the read completes — only after that do we enable the
+  // write-back watcher, otherwise an early in-memory mutation would
+  // overwrite real persisted history with the empty seed.
   const persisted = useIDBKeyval<AgentMessage[]>('Comfy.Agent.Messages', [], {
     shallow: false
   })
   const messages = ref<AgentMessage[]>([...(persisted.data.value ?? [])])
 
+  let hydrated = false
+  watch(
+    persisted.isFinished,
+    (done) => {
+      if (!done || hydrated) return
+      hydrated = true
+      const stored = persisted.data.value ?? []
+      // If the user already typed before the IDB read resolved, prepend
+      // stored entries so the new ones come last.
+      if (messages.value.length === 0) {
+        messages.value = [...stored]
+      } else if (stored.length > 0) {
+        messages.value = [...stored, ...messages.value]
+      }
+    },
+    { immediate: true }
+  )
+
   // Sync in-memory → persisted (truncated to the cap). Deep watch so edits
-  // to message text during streaming also flush.
+  // to message text during streaming also flush. Skip writes until the
+  // initial DB read has settled, otherwise a pre-hydration mutation
+  // clobbers the stored history.
   watch(
     messages,
     (next) => {
+      if (!hydrated) return
       persisted.data.value = next.slice(-MAX_PERSISTED_MESSAGES)
     },
     { deep: true }

src/agent/ui/FoldablePanel.vue

@@ -512,7 +512,11 @@ function isDirectShellCommand(line: string): boolean {
   const first = line.trim().split(/\s+/)[0]
   if (!first) return false
   const ctx = session.buildExecContextOnce()
-  return !!ctx.registry.get(first) || /^[|&;<>/]/.test(first)
+  // Don't treat a leading '/' as a shell-redirection sigil — the
+  // attachment flow prefills the composer with paths like '/input/foo.png'
+  // or '/tmp/x.json' and pressing Enter would route those to exec instead
+  // of the LLM. Real shell operators (|, &, ;, <, >) are still honoured.
+  return !!ctx.registry.get(first) || /^[|&;<>]/.test(first)
 }
 
 async function handleSubmit(line: string): Promise<void> {