nastechai-desktop 18.1.0

package/src/lib/preview-targets.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractPreviewTargets, previewTargetFromMarkdownHref, stripPreviewTargets } from './preview-targets'
+
+describe('preview target detection', () => {
+  it('does not infer preview targets from raw paths or URLs', () => {
+    expect(extractPreviewTargets('Preview: http://localhost:5173/')).toEqual([])
+    expect(extractPreviewTargets('Open index.html\n/tmp/demo.html\nhttp://localhost:5173/')).toEqual([])
+  })
+
+  it('decodes preview markdown hrefs', () => {
+    expect(previewTargetFromMarkdownHref('#preview/%2Ftmp%2Fdemo.html')).toBe('/tmp/demo.html')
+    expect(previewTargetFromMarkdownHref('#preview:%2Ftmp%2Fdemo.html')).toBe('/tmp/demo.html')
+    expect(previewTargetFromMarkdownHref('#media:%2Ftmp%2Fdemo.mp4')).toBeNull()
+  })
+
+  it('extracts preview targets from already-rendered preview markers', () => {
+    expect(extractPreviewTargets('[Preview: demo.html](#preview:%2Ftmp%2Fdemo.html)')).toEqual(['/tmp/demo.html'])
+  })
+
+  it('strips preview targets from visible assistant text', () => {
+    expect(stripPreviewTargets('ready\n/tmp/mycelium-bunnies.html\nopen it')).toBe(
+      'ready\n/tmp/mycelium-bunnies.html\nopen it'
+    )
+    expect(stripPreviewTargets('[Preview: demo.html](#preview:%2Ftmp%2Fdemo.html)\nopen it')).toBe('open it')
+  })
+})

package/src/lib/preview-targets.ts

@@ -0,0 +1,63 @@
+const PREVIEW_MARKDOWN_RE = /\[Preview:[^\]]+\]\((?<href>#preview[:/][^)]+)\)/gi
+
+export function stripPreviewTargets(text: string): string {
+  return text
+    .replace(PREVIEW_MARKDOWN_RE, '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+export function extractPreviewTargets(text: string): string[] {
+  const targets: string[] = []
+  const seen = new Set<string>()
+
+  for (const match of text.matchAll(PREVIEW_MARKDOWN_RE)) {
+    const target = previewTargetFromMarkdownHref(match.groups?.href)
+
+    if (target && !seen.has(target)) {
+      seen.add(target)
+      targets.push(target)
+    }
+  }
+
+  return targets
+}
+
+export function previewMarkdownHref(target: string): string {
+  return `#preview/${encodeURIComponent(target)}`
+}
+
+export function previewTargetFromMarkdownHref(href?: string): string | null {
+  if (!href?.startsWith('#preview:') && !href?.startsWith('#preview/')) {
+    return null
+  }
+
+  try {
+    return decodeURIComponent(href.slice('#preview'.length + 1))
+  } catch {
+    return null
+  }
+}
+
+export function previewName(target: string): string {
+  try {
+    const url = new URL(target)
+
+    if (url.protocol === 'file:') {
+      return decodeURIComponent(url.pathname).split(/[\\/]/).filter(Boolean).pop() || target
+    }
+
+    const file = url.pathname.split('/').filter(Boolean).pop()
+
+    return file || url.host
+  } catch {
+    return target.split(/[\\/]/).filter(Boolean).pop() || target
+  }
+}
+
+export function previewDisplayLabel(target: string): string {
+  const escaped = previewName(target).replace(/[[\]\\]/g, '\\$&')
+
+  return `Preview: ${escaped}`
+}

package/src/lib/profile-color.ts

@@ -0,0 +1,58 @@
+// Deterministic per-profile color so a profile is glanceable across the app
+// (the sidebar profile rail). The default/root profile has no color — named
+// profiles get a stable hue derived from the name, so the same profile always
+// reads the same color without persisting anything.
+
+const PROFILE_TAG_SATURATION = 68
+const PROFILE_TAG_LIGHTNESS = 58
+
+function hashString(value: string): number {
+  let hash = 0
+
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash * 31 + value.charCodeAt(index)) >>> 0
+  }
+
+  return hash
+}
+
+// Returns an hsl() string for a named profile, or null for default/empty
+// (rendered neutral / untagged).
+export function profileColor(name: null | string | undefined): null | string {
+  const key = (name ?? '').trim()
+
+  if (!key || key === 'default') {
+    return null
+  }
+
+  const hue = hashString(key) % 360
+
+  return `hsl(${hue} ${PROFILE_TAG_SATURATION}% ${PROFILE_TAG_LIGHTNESS}%)`
+}
+
+// A profile's effective color: a user-picked override wins, else the
+// deterministic hue. Default/empty stays neutral (null) regardless.
+export function resolveProfileColor(
+  name: null | string | undefined,
+  overrides: Record<string, string>
+): null | string {
+  const key = (name ?? '').trim()
+
+  if (!key || key === 'default') {
+    return null
+  }
+
+  return overrides[key] ?? profileColor(key)
+}
+
+// Curated swatches for the rail color picker — evenly spaced hues at the same
+// saturation/lightness as the deterministic palette, so picks stay cohesive.
+export const PROFILE_SWATCHES: readonly string[] = Array.from(
+  { length: 12 },
+  (_, index) => `hsl(${index * 30} ${PROFILE_TAG_SATURATION}% ${PROFILE_TAG_LIGHTNESS}%)`
+)
+
+// Translucent fill derived from a profile color, for tag backgrounds.
+export function profileColorSoft(color: string, percent = 16): string {
+  return `color-mix(in srgb, ${color} ${percent}%, transparent)`
+}

package/src/lib/provider-setup-errors.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+
+import { isProviderSetupErrorMessage } from './provider-setup-errors'
+
+describe('isProviderSetupErrorMessage', () => {
+  it('matches generic missing-provider copy', () => {
+    expect(isProviderSetupErrorMessage('No inference provider configured. Run `NASTECH model` to choose one.')).toBe(
+      true
+    )
+    expect(isProviderSetupErrorMessage('No inference provider is configured.')).toBe(true)
+    expect(isProviderSetupErrorMessage('No NasTech provider is configured.')).toBe(true)
+    expect(isProviderSetupErrorMessage('set an API key (OPENROUTER_API_KEY) in ~/.NASTECH/.env')).toBe(true)
+  })
+
+  it('does not match non-provider runtime failures', () => {
+    expect(
+      isProviderSetupErrorMessage('Selected runtime is not available. setup.status reports configured credentials.')
+    ).toBe(false)
+  })
+
+  it('returns false for empty input', () => {
+    expect(isProviderSetupErrorMessage('')).toBe(false)
+    expect(isProviderSetupErrorMessage(null)).toBe(false)
+    expect(isProviderSetupErrorMessage(undefined)).toBe(false)
+  })
+})

package/src/lib/provider-setup-errors.ts

@@ -0,0 +1,12 @@
+const PROVIDER_SETUP_ERROR_RE =
+  /No (?:inference|NasTech) provider(?: is)? configured|no_provider_configured|OPENROUTER_API_KEY|OPENAI_API_KEY|ANTHROPIC_API_KEY|set an API key/i
+
+export function isProviderSetupErrorMessage(message: null | string | undefined): boolean {
+  const text = message?.trim()
+
+  if (!text) {
+    return false
+  }
+
+  return PROVIDER_SETUP_ERROR_RE.test(text)
+}

package/src/lib/query-client.ts

@@ -0,0 +1,13 @@
+import { QueryClient } from '@tanstack/react-query'
+
+// Shared React Query client. Lives in its own module (not main.tsx) so non-React
+// code — e.g. the profile store on a gateway swap — can invalidate cached,
+// profile-scoped settings without importing the app entry point.
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      staleTime: 60_000
+    }
+  }
+})

package/src/lib/remend-tail.test.ts

@@ -0,0 +1,105 @@
+import { parseMarkdownIntoBlocks } from '@assistant-ui/react-streamdown'
+import remend from 'remend'
+import { describe, expect, it } from 'vitest'
+
+import { findRemendWindowStart, tailBoundedRemend } from './remend-tail'
+
+const CORPUS = `# Heading one
+
+Intro paragraph with **bold**, *italic*, \`inline code\`, and a [link](https://example.com).
+
+## Code
+
+\`\`\`python
+def main():
+    cost = "$5"
+    print(f"total: $\{cost}")
+\`\`\`
+
+Some text after the fence with $x^2 + y^2$ inline math.
+
+$$
+\\int_0^1 f(x) dx
+$$
+
+- list item one with **bold**
+- list item two
+
+| col a | col b |
+| ----- | ----- |
+| 1     | 2     |
+
+~~~js
+const s = \`template \${value}\`
+~~~
+
+Final paragraph with ~~strike~~ and unfinished [link text](https://exa
+`
+
+/**
+ * Render-equivalence oracle: full-text remend and tail-bounded remend may
+ * differ in raw string output ONLY in ways that cannot affect rendering —
+ * i.e. after block splitting, every block must be identical. (Streamdown
+ * renders blocks independently, so block-level equality IS render equality.)
+ */
+function blocksOf(text: string): string[] {
+  return parseMarkdownIntoBlocks(text)
+}
+
+describe('tailBoundedRemend', () => {
+  it('matches full remend block output at every streaming prefix', () => {
+    for (let end = 1; end <= CORPUS.length; end++) {
+      const prefix = CORPUS.slice(0, end)
+      const full = blocksOf(remend(prefix))
+      const tail = blocksOf(tailBoundedRemend(prefix))
+
+      expect(tail, `prefix length ${end}: ${JSON.stringify(prefix.slice(-60))}`).toEqual(full)
+    }
+  })
+
+  it('repairs an unclosed fence opened early in a long message', () => {
+    const text = `intro\n\n\`\`\`python\n${'x = 1\n'.repeat(500)}print("$dollar")`
+    const repaired = tailBoundedRemend(text)
+
+    expect(blocksOf(repaired)).toEqual(blocksOf(remend(text)))
+    // the window must reach back to the fence opener
+    expect(findRemendWindowStart(text)).toBe(text.indexOf('```python'))
+  })
+
+  it('bounds the window to the tail paragraph when no fence is open', () => {
+    const text = `para one\n\npara two\n\npara three with **bold`
+    const start = findRemendWindowStart(text)
+
+    expect(start).toBe(text.indexOf('para three'))
+    expect(tailBoundedRemend(text)).toBe(remend(text))
+  })
+
+  it('widens the window across an open $$ math block', () => {
+    const text = `before\n\n$$\n\\frac{a}{b}`
+    const start = findRemendWindowStart(text)
+
+    expect(start).toBeLessThanOrEqual(text.indexOf('$$'))
+    expect(blocksOf(tailBoundedRemend(text))).toEqual(blocksOf(remend(text)))
+  })
+
+  it('handles closed constructs without modification', () => {
+    const text = `done **bold** and \`code\`\n\n\`\`\`js\nconst a = 1\n\`\`\`\n\nlast line.`
+
+    expect(tailBoundedRemend(text)).toBe(text)
+  })
+
+  it('intentionally diverges from full remend on cross-block dangling openers', () => {
+    // Full remend scans the whole document and appends `**` for an opener
+    // left dangling in an EARLIER block, dumping stray asterisks into the
+    // unrelated tail block ("|**"). Because Streamdown splits into blocks
+    // after the repair, that opener never renders as bold either way — the
+    // tail-bounded result is the cleaner of the two. This test documents
+    // the divergence so a future remend upgrade that changes the behavior
+    // gets noticed.
+    const text = `- item with **dangling\n- item two\n\n|`
+
+    expect(remend(text).endsWith('|**')).toBe(true)
+    expect(tailBoundedRemend(text).endsWith('|')).toBe(true)
+    expect(tailBoundedRemend(text).endsWith('|**')).toBe(false)
+  })
+})

package/src/lib/remend-tail.ts

@@ -0,0 +1,108 @@
+import remend from 'remend'
+
+// Tail-bounded incomplete-markdown repair.
+//
+// Streamdown's built-in `parseIncompleteMarkdown` runs `remend` over the whole
+// accumulated message on every streaming flush (~18% of script time on 50KB+
+// messages). But repairs only ever matter in the trailing block: inline
+// constructs can't cross a blank line, and Streamdown splits into blocks AFTER
+// the repair, so a dangling opener in an earlier block can't reach the tail.
+// We run `remend` on just that block instead.
+
+const BACKTICK = 96 // `
+const TILDE = 126 // ~
+const SPACE = 32
+const TAB = 9
+const BACKSLASH = 92
+
+const isSpace = (c: number) => c === SPACE || c === TAB
+
+/**
+ * Index of the last top-level block start — the char after the most recent
+ * blank line that sits outside any open code fence or `$$` math block. An
+ * unclosed fence/math always begins after that blank, so it stays wholly
+ * inside the window without separate tracking. One cheap char pass, no regex.
+ */
+export function findRemendWindowStart(text: string): number {
+  const n = text.length
+  let inFence = false
+  let fenceChar = 0
+  let fenceRun = 0
+  let inMath = false
+  let boundary = 0
+  let pending = -1 // a blank line, committed to `boundary` once content follows
+
+  for (let lineStart = 0; lineStart <= n; ) {
+    let lineEnd = text.indexOf('\n', lineStart)
+
+    if (lineEnd === -1) {
+      lineEnd = n
+    }
+
+    let i = lineStart
+
+    while (i < lineEnd && isSpace(text.charCodeAt(i))) {
+      i += 1
+    }
+
+    const first = i < lineEnd ? text.charCodeAt(i) : -1
+    let marker = false
+
+    // Fence open/close (``` or ~~~, ≤3 spaces indent).
+    if ((first === BACKTICK || first === TILDE) && i - lineStart <= 3) {
+      let run = i
+
+      while (run < lineEnd && text.charCodeAt(run) === first) {
+        run += 1
+      }
+
+      if (run - i >= 3) {
+        marker = true
+
+        if (!inFence) {
+          inFence = true
+          fenceChar = first
+          fenceRun = run - i
+        } else if (first === fenceChar && run - i >= fenceRun && onlyWhitespace(text, run, lineEnd)) {
+          inFence = false
+        }
+      }
+    }
+
+    // Toggle `$$` math state on plain lines ($$ inside a fence is literal).
+    if (!inFence && !marker) {
+      for (let s = text.indexOf('$$', lineStart); s !== -1 && s < lineEnd - 1; s = text.indexOf('$$', s + 2)) {
+        if (s === 0 || text.charCodeAt(s - 1) !== BACKSLASH) {
+          inMath = !inMath
+        }
+      }
+    }
+
+    if (first === -1 && !inFence && !inMath) {
+      pending = lineEnd + 1
+    } else if (pending !== -1) {
+      boundary = pending
+      pending = -1
+    }
+
+    lineStart = lineEnd + 1
+  }
+
+  return boundary
+}
+
+function onlyWhitespace(text: string, from: number, to: number): boolean {
+  for (let i = from; i < to; i += 1) {
+    if (!isSpace(text.charCodeAt(i))) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export function tailBoundedRemend(text: string): string {
+  const start = findRemendWindowStart(text)
+
+  return start <= 0 ? remend(text) : text.slice(0, start) + remend(text.slice(start))
+}

package/src/lib/runtime-readiness.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+
+import { interpretRuntimeReadiness } from './runtime-readiness'
+
+describe('interpretRuntimeReadiness', () => {
+  it('prefers runtime_check when both signals exist', () => {
+    const result = interpretRuntimeReadiness({
+      setup: { provider_configured: false },
+      setupError: null,
+      runtime: { ok: true },
+      runtimeError: null
+    })
+
+    expect(result).toEqual({
+      checksDisagree: true,
+      ready: true,
+      reason: null,
+      source: 'runtime_check'
+    })
+  })
+
+  it('surfaces runtime mismatch details when runtime_check fails', () => {
+    const result = interpretRuntimeReadiness({
+      setup: { provider_configured: true },
+      setupError: null,
+      runtime: { error: 'No provider can serve the selected model.', ok: false },
+      runtimeError: null
+    })
+
+    expect(result.ready).toBe(false)
+    expect(result.source).toBe('runtime_check')
+    expect(result.checksDisagree).toBe(true)
+    expect(result.reason).toContain('No provider can serve the selected model.')
+    expect(result.reason).toContain('setup.status reports configured credentials')
+  })
+
+  it('falls back to setup.status when runtime_check has no boolean result', () => {
+    const result = interpretRuntimeReadiness({
+      setup: { provider_configured: true },
+      setupError: null,
+      runtime: null,
+      runtimeError: 'runtime check RPC unavailable'
+    })
+
+    expect(result).toEqual({
+      checksDisagree: false,
+      ready: true,
+      reason: null,
+      source: 'setup_status'
+    })
+  })
+
+  it('uses explicit fallback when both checks are missing', () => {
+    const result = interpretRuntimeReadiness({
+      setup: null,
+      setupError: 'setup.status timeout',
+      runtime: null,
+      runtimeError: 'setup.runtime_check timeout'
+    })
+
+    expect(result.ready).toBe(false)
+    expect(result.source).toBe('fallback')
+    expect(result.reason).toBe('setup.runtime_check timeout')
+  })
+})

package/src/lib/runtime-readiness.ts

@@ -0,0 +1,147 @@
+export interface SetupStatusSnapshot {
+  provider_configured?: boolean
+}
+
+export interface RuntimeCheckSnapshot {
+  error?: string
+  ok?: boolean
+}
+
+export interface RuntimeReadinessSignals {
+  setup: null | SetupStatusSnapshot
+  setupError: null | string
+  runtime: null | RuntimeCheckSnapshot
+  runtimeError: null | string
+}
+
+export interface RuntimeReadinessOptions {
+  defaultReason?: string
+  unknownReady?: boolean
+}
+
+export interface RuntimeReadinessResult {
+  checksDisagree: boolean
+  ready: boolean
+  reason: null | string
+  source: 'fallback' | 'runtime_check' | 'setup_status'
+}
+
+export type RuntimeReadinessRequester = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>
+
+const DEFAULT_NOT_READY_REASON = 'Add a provider credential before sending your first message.'
+
+function toErrorMessage(error: unknown): null | string {
+  if (error instanceof Error) {
+    return error.message
+  }
+
+  if (typeof error === 'string') {
+    return error
+  }
+
+  if (error === null || error === undefined) {
+    return null
+  }
+
+  return String(error)
+}
+
+function normalizeMessage(value: null | string | undefined): null | string {
+  const next = value?.trim()
+
+  return next ? next : null
+}
+
+async function requestWithFallback<T>(
+  requestGateway: RuntimeReadinessRequester,
+  method: string
+): Promise<{ error: null | string; value: null | T }> {
+  try {
+    return { error: null, value: await requestGateway<T>(method) }
+  } catch (error) {
+    return { error: toErrorMessage(error), value: null }
+  }
+}
+
+export async function fetchRuntimeReadinessSignals(
+  requestGateway: RuntimeReadinessRequester
+): Promise<RuntimeReadinessSignals> {
+  const [setup, runtime] = await Promise.all([
+    requestWithFallback<SetupStatusSnapshot>(requestGateway, 'setup.status'),
+    requestWithFallback<RuntimeCheckSnapshot>(requestGateway, 'setup.runtime_check')
+  ])
+
+  return {
+    setup: setup.value,
+    setupError: setup.error,
+    runtime: runtime.value,
+    runtimeError: runtime.error
+  }
+}
+
+export function interpretRuntimeReadiness(
+  signals: RuntimeReadinessSignals,
+  options: RuntimeReadinessOptions = {}
+): RuntimeReadinessResult {
+  const defaultReason = options.defaultReason ?? DEFAULT_NOT_READY_REASON
+  const unknownReady = options.unknownReady ?? false
+
+  const setupConfigured =
+    typeof signals.setup?.provider_configured === 'boolean' ? Boolean(signals.setup.provider_configured) : undefined
+
+  const runtimeOk = typeof signals.runtime?.ok === 'boolean' ? Boolean(signals.runtime.ok) : undefined
+  const runtimeFailure = normalizeMessage(signals.runtime?.error) ?? normalizeMessage(signals.runtimeError)
+  const setupFailure = normalizeMessage(signals.setupError)
+
+  const checksDisagree =
+    typeof setupConfigured === 'boolean' && typeof runtimeOk === 'boolean' && setupConfigured !== runtimeOk
+
+  if (typeof runtimeOk === 'boolean') {
+    if (runtimeOk) {
+      return {
+        checksDisagree,
+        ready: true,
+        reason: null,
+        source: 'runtime_check'
+      }
+    }
+
+    let reason = runtimeFailure ?? defaultReason
+
+    if (checksDisagree && setupConfigured) {
+      reason = `${reason} setup.status reports configured credentials, but runtime resolution still failed.`
+    }
+
+    return {
+      checksDisagree,
+      ready: false,
+      reason,
+      source: 'runtime_check'
+    }
+  }
+
+  if (typeof setupConfigured === 'boolean') {
+    return {
+      checksDisagree: false,
+      ready: setupConfigured,
+      reason: setupConfigured ? null : (runtimeFailure ?? setupFailure ?? defaultReason),
+      source: 'setup_status'
+    }
+  }
+
+  return {
+    checksDisagree: false,
+    ready: unknownReady,
+    reason: unknownReady ? null : (runtimeFailure ?? setupFailure ?? defaultReason),
+    source: 'fallback'
+  }
+}
+
+export async function evaluateRuntimeReadiness(
+  requestGateway: RuntimeReadinessRequester,
+  options: RuntimeReadinessOptions = {}
+): Promise<RuntimeReadinessResult> {
+  const signals = await fetchRuntimeReadinessSignals(requestGateway)
+
+  return interpretRuntimeReadiness(signals, options)
+}

package/src/lib/session-export.ts

@@ -0,0 +1,57 @@
+import type { SessionInfo } from '@/nastech'
+import { getSessionMessages } from '@/nastech'
+import { translateNow } from '@/i18n'
+import { notify, notifyError } from '@/store/notifications'
+
+interface ExportSessionParams {
+  sessionId: string
+  title?: string | null
+  session?: SessionInfo
+}
+
+function sanitizeFilenamePart(value: string) {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 48)
+}
+
+function sessionExportFilename(sessionId: string, title?: string | null) {
+  const titlePart = title ? sanitizeFilenamePart(title) : ''
+  const idPart = sanitizeFilenamePart(sessionId).slice(0, 8) || 'session'
+
+  return `${titlePart || 'session'}-${idPart}.json`
+}
+
+export async function exportSession(sessionId: string, params: Omit<ExportSessionParams, 'sessionId'> = {}) {
+  if (!sessionId) {
+    return
+  }
+
+  try {
+    const { messages } = await getSessionMessages(sessionId)
+
+    const payload = {
+      exported_at: new Date().toISOString(),
+      session_id: sessionId,
+      title: params.title ?? null,
+      session: params.session ?? null,
+      message_count: messages.length,
+      messages
+    }
+
+    const blob = new Blob([JSON.stringify(payload, null, 2)], { type: 'application/json' })
+    const downloadUrl = URL.createObjectURL(blob)
+    const anchor = document.createElement('a')
+    anchor.href = downloadUrl
+    anchor.download = sessionExportFilename(sessionId, params.title)
+    anchor.click()
+    URL.revokeObjectURL(downloadUrl)
+
+    notify({ kind: 'success', message: translateNow('desktop.sessionExported'), durationMs: 2_000 })
+  } catch (err) {
+    notifyError(err, translateNow('desktop.sessionExportFailed'))
+  }
+}