nastechai-desktop 18.1.0

package/src/lib/gateway-ws-url.ts

@@ -0,0 +1,91 @@
+import type { NasTechConnection } from '@/global'
+
+/**
+ * The desktop main process exposes `getGatewayWsUrl()` to re-mint a WebSocket
+ * URL immediately before every `gateway.connect()`. For OAuth-gated remote
+ * gateways the WS ticket is single-use with a ~30s TTL, so the ticket baked
+ * into the cached `conn.wsUrl` is stale (and, after the first connect, already
+ * consumed). For local/token gateways the URL carries a long-lived token and
+ * never needs re-minting.
+ *
+ * Resolution rules:
+ *
+ * - OAuth: the fresh mint is the *only* viable URL. If it fails, do NOT fall
+ *   back to `conn.wsUrl` — that ticket is dead and the connect is guaranteed to
+ *   fail with an opaque "connection closed" error. Instead, let the mint error
+ *   propagate so the caller can surface the gateway's reauth message
+ *   ("session has expired… Sign in again").
+ *
+ * - token / local, or when the preload method is genuinely absent (older
+ *   preload shapes): fall back to `conn.wsUrl`. The token URL is long-lived, so
+ *   the fallback is safe and preserves compatibility.
+ *
+ * The error thrown for OAuth mint failures is tagged with `needsOauthLogin` so
+ * callers can distinguish "the user must re-authenticate" from a generic
+ * transport failure.
+ */
+export interface ResolveGatewayWsUrlDeps {
+  /** `window.NASTECHDesktop.getGatewayWsUrl`, if the preload exposes it. The
+   *  optional profile selects which backend to mint for — critical when swapping
+   *  to a pooled profile, since the default mint resolves the primary backend. */
+  getGatewayWsUrl?: (profile?: null | string) => Promise<string>
+}
+
+export class GatewayReauthRequiredError extends Error {
+  readonly needsOauthLogin = true
+
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message, options)
+    this.name = 'GatewayReauthRequiredError'
+  }
+}
+
+export function isGatewayReauthRequired(error: unknown): error is GatewayReauthRequiredError {
+  return (
+    error instanceof GatewayReauthRequiredError ||
+    (typeof error === 'object' && error !== null && (error as { needsOauthLogin?: unknown }).needsOauthLogin === true)
+  )
+}
+
+export async function resolveGatewayWsUrl(
+  desktop: ResolveGatewayWsUrlDeps,
+  conn: Pick<NasTechConnection, 'authMode' | 'profile' | 'wsUrl'>
+): Promise<string> {
+  const mint = desktop.getGatewayWsUrl
+  // Mint for THIS connection's profile, not the primary. Without it a pooled
+  // profile swap re-mints the default backend's URL and connects to the wrong
+  // backend.
+  const profile = conn.profile ?? null
+
+  if (conn.authMode === 'oauth') {
+    if (!mint) {
+      // OAuth gateway but no way to mint a fresh ticket: the cached ticket is
+      // dead, so connecting with it cannot succeed. Surface a reauth error
+      // rather than silently attempting a doomed connect.
+      throw new GatewayReauthRequiredError(
+        'Your remote gateway session needs to be refreshed. Open Settings → Gateway and click "Sign in" again.'
+      )
+    }
+
+    try {
+      return await mint(profile)
+    } catch (error) {
+      throw new GatewayReauthRequiredError(
+        'Your remote gateway session has expired. Open Settings → Gateway and click "Sign in" again.',
+        { cause: error }
+      )
+    }
+  }
+
+  // token / local: the URL carries a long-lived token. Re-mint when available
+  // (cheap, keeps parity), but the cached URL is a safe fallback.
+  if (mint) {
+    const fresh = await mint(profile).catch(() => null)
+
+    if (fresh) {
+      return fresh
+    }
+  }
+
+  return conn.wsUrl
+}

package/src/lib/generated-images.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  dedupeGeneratedImageEchoesInParts,
+  generatedImageEchoSources,
+  generatedImageFromResult,
+  stripGeneratedImageEchoes
+} from './generated-images'
+
+describe('generatedImageFromResult', () => {
+  it('prefers the host-visible image path', () => {
+    expect(
+      generatedImageFromResult({
+        agent_visible_image: '/container/cache/cat.png',
+        host_image: '/Users/me/.nastech/cache/images/cat.png',
+        image: '/Users/me/.nastech/cache/images/cat.png',
+        success: true
+      })
+    ).toBe('/Users/me/.nastech/cache/images/cat.png')
+  })
+
+  it('ignores failed image generation results', () => {
+    expect(generatedImageFromResult({ image: 'https://cdn.example/cat.png', success: false })).toBeNull()
+  })
+})
+
+describe('stripGeneratedImageEchoes', () => {
+  it('removes repeated generated image markdown without removing prose', () => {
+    expect(
+      stripGeneratedImageEchoes('Here you go.\n\n![Generated image](https://cdn.example/cat.png)', [
+        'https://cdn.example/cat.png'
+      ])
+    ).toBe('Here you go.')
+  })
+
+  it('removes media links for generated local image paths', () => {
+    expect(
+      stripGeneratedImageEchoes('Saved image: [Image: cat.png](#media:%2Ftmp%2Fcat.png)', ['/tmp/cat.png'])
+    ).toBe('Saved image:')
+  })
+})
+
+describe('generatedImageEchoSources', () => {
+  it('collects every path variant the model might restate', () => {
+    expect(
+      generatedImageEchoSources([
+        {
+          result: { agent_visible_image: '/sandbox/cat.png', host_image: '/host/cat.png', image: '/host/cat.png', success: true },
+          toolName: 'image_generate',
+          type: 'tool-call'
+        }
+      ])
+    ).toEqual(['/host/cat.png', '/sandbox/cat.png'])
+  })
+})
+
+describe('dedupeGeneratedImageEchoesInParts', () => {
+  it('keeps the agent prose while removing the duplicated image', () => {
+    expect(
+      dedupeGeneratedImageEchoesInParts([
+        { text: 'Here is your peacock! ![peacock](/host/p.png) Enjoy.', type: 'text' },
+        { result: { host_image: '/host/p.png', image: '/host/p.png', success: true }, toolName: 'image_generate', type: 'tool-call' }
+      ])
+    ).toEqual([
+      { text: 'Here is your peacock! Enjoy.', type: 'text' },
+      { result: { host_image: '/host/p.png', image: '/host/p.png', success: true }, toolName: 'image_generate', type: 'tool-call' }
+    ])
+  })
+
+  it('strips a sandbox path the model restated instead of the host path', () => {
+    expect(
+      dedupeGeneratedImageEchoesInParts([
+        { text: '![cat](/sandbox/cat.png)', type: 'text' },
+        {
+          result: { agent_visible_image: '/sandbox/cat.png', host_image: '/host/cat.png', image: '/host/cat.png', success: true },
+          toolName: 'image_generate',
+          type: 'tool-call'
+        }
+      ])
+    ).toEqual([
+      {
+        result: { agent_visible_image: '/sandbox/cat.png', host_image: '/host/cat.png', image: '/host/cat.png', success: true },
+        toolName: 'image_generate',
+        type: 'tool-call'
+      }
+    ])
+  })
+
+  it('leaves pending generations untouched so the agent prose survives', () => {
+    const parts = [
+      { text: 'Another peacock, coming up!', type: 'text' },
+      { result: undefined, toolName: 'image_generate', type: 'tool-call' }
+    ]
+
+    expect(dedupeGeneratedImageEchoesInParts(parts)).toEqual(parts)
+  })
+})

package/src/lib/generated-images.ts

@@ -0,0 +1,116 @@
+type ToolLike = {
+  result?: unknown
+  toolName?: unknown
+  type?: unknown
+}
+
+type TextLike = {
+  text?: unknown
+  type?: unknown
+}
+
+// Path-ish result fields the model may echo into its prose. Display prefers the
+// host path (gateway-deliverable); stripping must catch every variant so a
+// sandbox path the model restated doesn't slip through as a duplicate image.
+const DISPLAY_KEYS = ['host_image', 'image'] as const
+const ECHO_KEYS = ['host_image', 'image', 'agent_visible_image'] as const
+
+function recordFromUnknown(value: unknown): Record<string, unknown> | null {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+
+  if (typeof value !== 'string' || !value.trim()) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(value)
+
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : null
+  } catch {
+    return null
+  }
+}
+
+function stringFields(record: Record<string, unknown>, keys: readonly string[]): string[] {
+  return keys.map(key => record[key]).filter((v): v is string => typeof v === 'string' && v.trim().length > 0)
+}
+
+function regexEscape(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))]
+}
+
+function imageResult(part: ToolLike): Record<string, unknown> | null {
+  if (part.type !== 'tool-call' || part.toolName !== 'image_generate') {
+    return null
+  }
+
+  const record = recordFromUnknown(part.result)
+
+  return record && record.success !== false ? record : null
+}
+
+/** Display source for a completed `image_generate` result (host path wins). */
+export function generatedImageFromResult(result: unknown): string | null {
+  const record = recordFromUnknown(result)
+
+  if (!record || record.success === false) {
+    return null
+  }
+
+  return stringFields(record, DISPLAY_KEYS)[0] ?? null
+}
+
+/** Every path/URL a generated image might appear as in prose, for de-duping. */
+export function generatedImageEchoSources(parts: readonly ToolLike[]): string[] {
+  return unique(parts.flatMap(part => stringFields(imageResult(part) ?? {}, ECHO_KEYS)))
+}
+
+/** Strip a generated image out of prose so it only ever shows in the tool slot.
+ *  Once a generation succeeded (`sources` is non-empty) we drop every embedded
+ *  image and media link from that message — the model frequently restates the
+ *  remote URL while the result holds the local path, so matching the exact
+ *  source is not enough. Bare occurrences of the known paths/URLs are removed
+ *  too. Surrounding prose is preserved. */
+export function stripGeneratedImageEchoes(text: string, sources: readonly string[]): string {
+  if (!text || sources.length === 0) {
+    return text
+  }
+
+  let next = text
+    .replace(/!\[[^\]\n]*\]\([^)\n]*\)/g, '')
+    .replace(/\[[^\]\n]*\]\(\s*#media:[^)\n]*\)/g, '')
+
+  for (const source of unique([...sources])) {
+    next = next.replace(new RegExp(String.raw`(^|[\s([{])<?${regexEscape(source)}>?(?=$|[\s)\]},.!?])`, 'g'), '$1')
+  }
+
+  return next
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim()
+}
+
+/** Strip generated-image echoes from text parts, dropping any part left empty.
+ *  The image lives in the tool slot; prose keeps the agent's actual words. */
+export function dedupeGeneratedImageEchoesInParts<T extends TextLike & ToolLike>(parts: readonly T[]): T[] {
+  const sources = generatedImageEchoSources(parts)
+
+  if (!sources.length) {
+    return [...parts]
+  }
+
+  return parts
+    .map(part =>
+      part.type === 'text' && typeof part.text === 'string'
+        ? { ...part, text: stripGeneratedImageEchoes(part.text, sources) }
+        : part
+    )
+    .filter(part => part.type !== 'text' || (typeof part.text === 'string' && part.text.trim().length > 0))
+}

package/src/lib/haptics.ts

@@ -0,0 +1,129 @@
+import type { HapticInput, TriggerOptions } from 'web-haptics'
+
+import { $hapticsMuted } from '@/store/haptics'
+
+export type HapticIntent =
+  | 'cancel'
+  | 'close'
+  | 'crisp'
+  | 'error'
+  | 'open'
+  | 'selection'
+  | 'streamDone'
+  | 'streamStart'
+  | 'submit'
+  | 'success'
+  | 'tap'
+  | 'warning'
+
+interface HapticConfig {
+  options?: TriggerOptions
+  pattern: HapticInput
+}
+
+const airyTap = [{ duration: 16, intensity: 0.52 }]
+
+const crispTap = [{ duration: 10, intensity: 0.92 }]
+
+const friendlySuccess = [
+  { duration: 28, intensity: 0.5 },
+  { delay: 42, duration: 30, intensity: 0.68 },
+  { delay: 48, duration: 38, intensity: 0.86 }
+]
+
+const softArrive = [
+  { duration: 18, intensity: 0.42 },
+  { delay: 36, duration: 22, intensity: 0.66 }
+]
+
+const softLeave = [
+  { duration: 22, intensity: 0.58 },
+  { delay: 32, duration: 16, intensity: 0.34 }
+]
+
+const HAPTIC_INTENTS: Record<HapticIntent, HapticConfig> = {
+  cancel: {
+    pattern: [
+      { duration: 34, intensity: 0.72 },
+      { delay: 54, duration: 26, intensity: 0.38 }
+    ]
+  },
+  close: { pattern: softLeave },
+  crisp: { pattern: crispTap },
+  error: {
+    pattern: [
+      { duration: 34, intensity: 0.82 },
+      { delay: 42, duration: 34, intensity: 0.72 },
+      { delay: 58, duration: 44, intensity: 0.86 }
+    ]
+  },
+  open: { pattern: softArrive },
+  selection: { pattern: airyTap },
+  streamDone: { pattern: friendlySuccess },
+  streamStart: { pattern: [{ duration: 10, intensity: 0.32 }] },
+  submit: {
+    pattern: [
+      { duration: 24, intensity: 0.58 },
+      { delay: 48, duration: 36, intensity: 0.82 }
+    ]
+  },
+  success: { pattern: friendlySuccess },
+  tap: {
+    pattern: [
+      { duration: 14, intensity: 0.58 },
+      { delay: 30, duration: 12, intensity: 0.42 }
+    ]
+  },
+  warning: {
+    pattern: [
+      { duration: 34, intensity: 0.64 },
+      { delay: 84, duration: 42, intensity: 0.5 }
+    ]
+  }
+}
+
+export type HapticTrigger = (input?: HapticInput, options?: TriggerOptions) => Promise<void> | undefined
+
+let registeredTrigger: HapticTrigger | null = null
+let lastSelectionAt = 0
+
+// Global rolling rate-limit. A runaway upstream loop (auth-expiry error-toast
+// storms, reconnect flaps) can request dozens of haptics a second, which the
+// trackpad actuator renders as a frantic "clickity" buzz. Cap firings to
+// RATE_LIMIT per RATE_WINDOW so no source can machine-gun the actuator;
+// intentional UI haptics are human-paced and never approach the ceiling.
+const RATE_WINDOW = 1000
+const RATE_LIMIT = 5
+let recentFires: number[] = []
+
+export function registerHapticTrigger(trigger: HapticTrigger | null) {
+  registeredTrigger = trigger
+}
+
+export function triggerHaptic(intent: HapticIntent = 'selection') {
+  if ($hapticsMuted.get() || !registeredTrigger) {
+    return
+  }
+
+  const now = performance.now()
+
+  if (intent === 'selection') {
+    if (now - lastSelectionAt < 50) {
+      return
+    }
+
+    lastSelectionAt = now
+  }
+
+  recentFires = recentFires.filter(t => now - t < RATE_WINDOW)
+
+  if (recentFires.length >= RATE_LIMIT) {
+    return
+  }
+
+  recentFires.push(now)
+
+  const config = HAPTIC_INTENTS[intent]
+
+  void registeredTrigger(config.pattern, config.options)?.catch(() => undefined)
+}

package/src/lib/icons.ts

@@ -0,0 +1,203 @@
+import {
+  IconActivity as Activity,
+  IconAlertCircle as AlertCircle,
+  IconAlertTriangle as AlertTriangle,
+  IconArchive as Archive,
+  IconArchiveOff as ArchiveOff,
+  IconArrowUp as ArrowUp,
+  IconArrowUpRight as ArrowUpRight,
+  IconAt as AtSign,
+  IconWaveSine as AudioLines,
+  IconChartBar as BarChart3,
+  IconBrain as Brain,
+  IconBug as Bug,
+  IconCheck as Check,
+  IconCircleCheck as CheckCircle2,
+  IconCheck as CheckIcon,
+  IconChevronDown as ChevronDown,
+  IconChevronDown as ChevronDownIcon,
+  IconChevronLeft as ChevronLeft,
+  IconChevronLeft as ChevronLeftIcon,
+  IconChevronRight as ChevronRight,
+  IconChevronRight as ChevronRightIcon,
+  IconCircle as CircleIcon,
+  IconClipboard as Clipboard,
+  IconClock as Clock,
+  IconCommand as Command,
+  IconCopy as Copy,
+  IconCopy as CopyIcon,
+  IconCpu as Cpu,
+  IconDownload as Download,
+  IconExternalLink as ExternalLink,
+  IconEye as Eye,
+  IconEyeOff as EyeOff,
+  IconPhoto as FileImage,
+  IconFileText as FileText,
+  IconFolderOpen as FolderOpen,
+  IconGitBranch as GitBranch,
+  IconGitBranch as GitBranchIcon,
+  IconGlobe as Globe,
+  IconHash as Hash,
+  IconHelpCircle as HelpCircle,
+  IconPhoto as ImageIcon,
+  IconInfoCircle as Info,
+  IconKey as KeyRound,
+  IconLayersIntersect2 as Layers3,
+  IconLink as Link,
+  IconLink as Link2,
+  IconLink as LinkIcon,
+  IconLoader2 as Loader2,
+  IconLoader2 as Loader2Icon,
+  IconLock as Lock,
+  IconLogin as LogIn,
+  IconMessageCircle as MessageCircle,
+  IconMessage2 as MessageSquareText,
+  IconMicrophone as Mic,
+  IconMicrophoneOff as MicOff,
+  IconDeviceDesktop as Monitor,
+  IconDeviceDesktopAnalytics as MonitorPlay,
+  IconMoon as Moon,
+  IconDots as MoreHorizontal,
+  IconDots as MoreHorizontalIcon,
+  IconDotsVertical as MoreVertical,
+  IconNotebook as NotebookTabs,
+  IconPackage as Package,
+  IconPalette as Palette,
+  IconLayoutBottombar as PanelBottom,
+  IconLayoutSidebar as PanelLeftIcon,
+  IconPlayerPause as Pause,
+  IconPencil as Pencil,
+  IconPencil as PencilIcon,
+  IconPencil as PencilLine,
+  IconPin as Pin,
+  IconPlayerPlay as Play,
+  IconPlus as Plus,
+  IconRefresh as RefreshCw,
+  IconRefresh as RefreshCwIcon,
+  IconDeviceFloppy as Save,
+  IconSearch as Search,
+  IconSearch as SearchIcon,
+  IconSend as Send,
+  IconSettings as Settings,
+  IconSettings2 as Settings2,
+  IconAdjustmentsHorizontal as SlidersHorizontal,
+  IconSparkles as Sparkles,
+  IconSquare as Square,
+  IconSteeringWheel as SteeringWheel,
+  IconSun as Sun,
+  IconTerminal2 as Terminal,
+  IconTrash as Trash2,
+  IconUsers as Users,
+  IconVolume2 as Volume2,
+  IconVolume2 as Volume2Icon,
+  IconVolumeOff as VolumeX,
+  IconVolumeOff as VolumeXIcon,
+  IconTool as Wrench,
+  IconX as X,
+  IconX as XIcon,
+  IconBolt as Zap,
+  IconBoltFilled as ZapFilled
+} from '@tabler/icons-react'
+
+export {
+  Activity,
+  AlertCircle,
+  AlertTriangle,
+  Archive,
+  ArchiveOff,
+  ArrowUp,
+  ArrowUpRight,
+  AtSign,
+  AudioLines,
+  BarChart3,
+  Brain,
+  Bug,
+  Check,
+  CheckCircle2,
+  CheckIcon,
+  ChevronDown,
+  ChevronDownIcon,
+  ChevronLeft,
+  ChevronLeftIcon,
+  ChevronRight,
+  ChevronRightIcon,
+  CircleIcon,
+  Clipboard,
+  Clock,
+  Command,
+  Copy,
+  CopyIcon,
+  Cpu,
+  Download,
+  ExternalLink,
+  Eye,
+  EyeOff,
+  FileImage,
+  FileText,
+  FolderOpen,
+  GitBranch,
+  GitBranchIcon,
+  Globe,
+  Hash,
+  HelpCircle,
+  ImageIcon,
+  Info,
+  KeyRound,
+  Layers3,
+  Link,
+  Link2,
+  LinkIcon,
+  Loader2,
+  Loader2Icon,
+  Lock,
+  LogIn,
+  MessageCircle,
+  MessageSquareText,
+  Mic,
+  MicOff,
+  Monitor,
+  MonitorPlay,
+  Moon,
+  MoreHorizontal,
+  MoreHorizontalIcon,
+  MoreVertical,
+  NotebookTabs,
+  Package,
+  Palette,
+  PanelBottom,
+  PanelLeftIcon,
+  Pause,
+  Pencil,
+  PencilIcon,
+  PencilLine,
+  Pin,
+  Play,
+  Plus,
+  RefreshCw,
+  RefreshCwIcon,
+  Save,
+  Search,
+  SearchIcon,
+  Send,
+  Settings,
+  Settings2,
+  SlidersHorizontal,
+  Sparkles,
+  Square,
+  SteeringWheel,
+  Sun,
+  Terminal,
+  Trash2,
+  Users,
+  Volume2,
+  Volume2Icon,
+  VolumeX,
+  VolumeXIcon,
+  Wrench,
+  X,
+  XIcon,
+  Zap,
+  ZapFilled
+}
+
+export type { Icon as IconComponent } from '@tabler/icons-react'