nastech-tui 0.0.1

package/src/app/overlayStore.ts

@@ -0,0 +1,53 @@
+import { atom, computed } from 'nanostores'
+
+import type { OverlayState } from './interfaces.js'
+
+const buildOverlayState = (): OverlayState => ({
+  agents: false,
+  agentsInitialHistoryIndex: 0,
+  approval: null,
+  clarify: null,
+  confirm: null,
+  modelPicker: false,
+  pager: null,
+  picker: false,
+  secret: null,
+  sessions: false,
+  skillsHub: false,
+  sudo: null
+})
+
+export const $overlayState = atom<OverlayState>(buildOverlayState())
+
+export const $isBlocked = computed(
+  $overlayState,
+  ({ agents, approval, clarify, confirm, modelPicker, pager, picker, secret, sessions, skillsHub, sudo }) =>
+    Boolean(agents || approval || clarify || confirm || modelPicker || pager || picker || secret || sessions || skillsHub || sudo)
+)
+
+export const getOverlayState = () => $overlayState.get()
+
+export const patchOverlayState = (next: Partial<OverlayState> | ((state: OverlayState) => OverlayState)) =>
+  $overlayState.set(typeof next === 'function' ? next($overlayState.get()) : { ...$overlayState.get(), ...next })
+
+/** Full reset — used by session/turn teardown and tests. */
+export const resetOverlayState = () => $overlayState.set(buildOverlayState())
+
+/**
+ * Soft reset: drop FLOW-scoped overlays (approval / clarify / confirm / sudo
+ * / secret / pager) but PRESERVE user-toggled ones — agents dashboard, model
+ * picker, skills hub, session picker.  Those are opened deliberately and
+ * shouldn't vanish when a turn ends.  Called from turnController.idle() on
+ * every turn completion / interrupt; the old "reset everything" behaviour
+ * silently closed /agents the moment delegation finished.
+ */
+export const resetFlowOverlays = () =>
+  $overlayState.set({
+    ...buildOverlayState(),
+    agents: $overlayState.get().agents,
+    agentsInitialHistoryIndex: $overlayState.get().agentsInitialHistoryIndex,
+    modelPicker: $overlayState.get().modelPicker,
+    picker: $overlayState.get().picker,
+    sessions: $overlayState.get().sessions,
+    skillsHub: $overlayState.get().skillsHub
+  })

package/src/app/scroll.ts

@@ -0,0 +1,71 @@
+import type { ScrollBoxHandle } from '@nastechai/ink'
+
+import type { SelectionApi } from './interfaces.js'
+
+export interface SelectionSnap {
+  anchor?: { row: number } | null
+  focus?: { row: number } | null
+  isDragging?: boolean
+}
+
+export interface ScrollWithSelectionOptions {
+  readonly scrollRef: { readonly current: ScrollBoxHandle | null }
+  readonly selection: SelectionApi
+}
+
+function scrollBoundsForDelta(s: ScrollBoxHandle, cur: number, delta: number) {
+  const viewport = Math.max(0, s.getViewportHeight())
+  const cachedHeight = Math.max(viewport, s.getScrollHeight())
+  let max = Math.max(0, cachedHeight - viewport)
+
+  // getScrollHeight() is render-time cached. After the streaming tail is
+  // committed into virtual history, the Yoga height can be fresher than the
+  // cached value; if we clamp only against the cached fake bottom, wheel-down
+  // becomes a no-op and no render is scheduled to reveal the real tail.
+  if (delta > 0 && cur + delta >= max - 1) {
+    const freshHeight = Math.max(viewport, s.getFreshScrollHeight())
+    max = Math.max(0, freshHeight - viewport)
+  }
+
+  return { max, viewport }
+}
+
+export function scrollWithSelectionBy(delta: number, { scrollRef, selection }: ScrollWithSelectionOptions): void {
+  const s = scrollRef.current
+
+  if (!s) {
+    return
+  }
+
+  const cur = s.getScrollTop() + s.getPendingDelta()
+  const { max, viewport } = scrollBoundsForDelta(s, cur, delta)
+  const actual = Math.max(0, Math.min(max, cur + delta)) - cur
+
+  if (actual === 0) {
+    return
+  }
+
+  const sel = selection.getState() as null | SelectionSnap
+  const top = s.getViewportTop()
+  const bottom = top + viewport - 1
+
+  if (
+    sel?.anchor &&
+    sel.focus &&
+    sel.anchor.row >= top &&
+    sel.anchor.row <= bottom &&
+    (sel.isDragging || (sel.focus.row >= top && sel.focus.row <= bottom))
+  ) {
+    const shift = sel.isDragging ? selection.shiftAnchor : selection.shiftSelection
+
+    if (actual > 0) {
+      selection.captureScrolledRows(top, top + actual - 1, 'above')
+    } else {
+      selection.captureScrolledRows(bottom + actual + 1, bottom, 'below')
+    }
+
+    shift(-actual, top, bottom)
+  }
+
+  s.scrollBy(actual)
+}

package/src/app/setupHandoff.ts

@@ -0,0 +1,54 @@
+import type { RunExternalProcess } from '@nastechai/ink'
+
+import type { SetupStatusResponse } from '../gatewayTypes.js'
+import type { LaunchResult } from '../lib/externalCli.js'
+
+import type { SlashHandlerContext } from './interfaces.js'
+import { patchUiState } from './uiStore.js'
+
+export interface RunExternalSetupOptions {
+  args: string[]
+  ctx: Pick<SlashHandlerContext, 'gateway' | 'session' | 'transcript'>
+  done: string
+  launcher: (args: string[]) => Promise<LaunchResult>
+  suspend: (run: RunExternalProcess) => Promise<void>
+}
+
+export async function runExternalSetup({ args, ctx, done, launcher, suspend }: RunExternalSetupOptions) {
+  const { gateway, session, transcript } = ctx
+
+  transcript.sys(`launching \`nastech ${args.join(' ')}\`…`)
+  patchUiState({ status: 'setup running…' })
+
+  let result: LaunchResult = { code: null }
+
+  await suspend(async () => {
+    result = await launcher(args)
+  })
+
+  if (result.error) {
+    transcript.sys(`error launching nastech: ${result.error}`)
+    patchUiState({ status: 'setup required' })
+
+    return
+  }
+
+  if (result.code !== 0) {
+    transcript.sys(`nastech ${args[0]} exited with code ${result.code}`)
+    patchUiState({ status: 'setup required' })
+
+    return
+  }
+
+  const setup = await gateway.rpc<SetupStatusResponse>('setup.status', {})
+
+  if (setup?.provider_configured === false) {
+    transcript.sys('still no provider configured')
+    patchUiState({ status: 'setup required' })
+
+    return
+  }
+
+  transcript.sys(done)
+  session.newSession()
+}