nastechai-desktop 18.1.0

package/src/global.d.ts

@@ -0,0 +1,457 @@
+export {}
+
+declare global {
+  interface Window {
+    NASTECHDesktop: {
+      // Resolve a backend connection. Omit `profile` (or pass the primary) for
+      // the window's backend; pass a named profile to lazily spawn/reuse that
+      // profile's backend from the pool.
+      getConnection: (profile?: string | null) => Promise<NasTechConnection>
+      // Keepalive: mark a pool profile backend as recently used so the idle
+      // reaper spares it while its chat is active.
+      touchBackend: (profile?: string | null) => Promise<{ ok: boolean }>
+      getGatewayWsUrl: (profile?: null | string) => Promise<string>
+      getBootProgress: () => Promise<DesktopBootProgress>
+      getConnectionConfig: (profile?: null | string) => Promise<DesktopConnectionConfig>
+      saveConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise<DesktopConnectionConfig>
+      applyConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise<DesktopConnectionConfig>
+      testConnectionConfig: (payload: DesktopConnectionConfigInput) => Promise<DesktopConnectionTestResult>
+      probeConnectionConfig: (remoteUrl: string) => Promise<DesktopConnectionProbeResult>
+      oauthLoginConnectionConfig: (remoteUrl: string) => Promise<DesktopOauthLoginResult>
+      oauthLogoutConnectionConfig: (remoteUrl?: string) => Promise<DesktopOauthLogoutResult>
+      profile: {
+        get: () => Promise<DesktopActiveProfile>
+        // Persists the desktop's profile choice and relaunches the local
+        // backend under the new NASTECH_HOME (reloads the window). Pass null to
+        // clear the preference.
+        set: (name: string | null) => Promise<DesktopActiveProfile>
+      }
+      api: <T>(request: NasTechApiRequest) => Promise<T>
+      notify: (payload: NasTechNotification) => Promise<boolean>
+      requestMicrophoneAccess: () => Promise<boolean>
+      readFileDataUrl: (filePath: string) => Promise<string>
+      readFileText: (filePath: string) => Promise<NasTechReadFileTextResult>
+      selectPaths: (options?: NasTechSelectPathsOptions) => Promise<string[]>
+      writeClipboard: (text: string) => Promise<boolean>
+      saveImageFromUrl: (url: string) => Promise<boolean>
+      saveImageBuffer: (data: ArrayBuffer | Uint8Array, ext: string) => Promise<string>
+      saveClipboardImage: () => Promise<string>
+      getPathForFile: (file: File) => string
+      normalizePreviewTarget: (target: string, baseDir?: string) => Promise<NasTechPreviewTarget | null>
+      watchPreviewFile: (url: string) => Promise<NasTechPreviewWatch>
+      stopPreviewFileWatch: (id: string) => Promise<boolean>
+      setTitleBarTheme?: (payload: NasTechTitleBarTheme) => void
+      setPreviewShortcutActive?: (active: boolean) => void
+      openExternal: (url: string) => Promise<void>
+      fetchLinkTitle: (url: string) => Promise<string>
+      settings: {
+        getDefaultProjectDir: () => Promise<{ defaultLabel: string; dir: null | string }>
+        pickDefaultProjectDir: () => Promise<{ canceled: boolean; dir: null | string }>
+        setDefaultProjectDir: (dir: null | string) => Promise<{ dir: null | string }>
+      }
+      revealLogs: () => Promise<{ ok: boolean; path: string; error?: string }>
+      getRecentLogs: () => Promise<{ path: string; lines: string[] }>
+      readDir: (path: string) => Promise<NasTechReadDirResult>
+      gitRoot?: (path: string) => Promise<string | null>
+      terminal: {
+        dispose: (id: string) => Promise<boolean>
+        onData: (id: string, callback: (payload: string) => void) => () => void
+        onExit: (id: string, callback: (payload: NasTechTerminalExit) => void) => () => void
+        resize: (id: string, size: { cols: number; rows: number }) => Promise<boolean>
+        start: (options?: { cols?: number; cwd?: string; rows?: number }) => Promise<NasTechTerminalSession>
+        write: (id: string, data: string) => Promise<boolean>
+      }
+      onClosePreviewRequested?: (callback: () => void) => () => void
+      onOpenUpdatesRequested?: (callback: () => void) => () => void
+      onWindowStateChanged?: (callback: (payload: NasTechWindowState) => void) => () => void
+      onPreviewFileChanged: (callback: (payload: NasTechPreviewFileChanged) => void) => () => void
+      onBackendExit: (callback: (payload: BackendExit) => void) => () => void
+      onPowerResume?: (callback: () => void) => () => void
+      onBootProgress: (callback: (payload: DesktopBootProgress) => void) => () => void
+      getBootstrapState: () => Promise<DesktopBootstrapState>
+      resetBootstrap: () => Promise<{ ok: boolean }>
+      repairBootstrap: () => Promise<{ ok: boolean }>
+      cancelBootstrap: () => Promise<{ ok: boolean; cancelled: boolean }>
+      onBootstrapEvent: (callback: (payload: DesktopBootstrapEvent) => void) => () => void
+      getVersion: () => Promise<DesktopVersionInfo>
+      updates: {
+        check: () => Promise<DesktopUpdateStatus>
+        apply: (opts?: DesktopUpdateApplyOptions) => Promise<DesktopUpdateApplyResult>
+        getBranch: () => Promise<{ branch: string }>
+        setBranch: (name: string) => Promise<{ branch: string }>
+        onProgress: (callback: (payload: DesktopUpdateProgress) => void) => () => void
+      }
+      uninstall: {
+        summary: () => Promise<DesktopUninstallSummary>
+        run: (mode: DesktopUninstallMode) => Promise<DesktopUninstallResult>
+      }
+      openSessionWindow: (sessionId: string, opts?: { watch?: boolean }) => Promise<{ ok: boolean; error?: string }>
+      setTranslucency?: (payload: { intensity: number }) => void
+      sanitizeWorkspaceCwd?: (cwd?: null | string) => Promise<{ cwd: string; sanitized: boolean }>
+      worktrees?: (cwds: string[]) => Promise<Record<string, NasTechWorktreeInfo | null>>
+      themes?: {
+        fetchMarketplace: (id: string) => Promise<DesktopMarketplaceThemeResult>
+        searchMarketplace: (query: string) => Promise<DesktopMarketplaceSearchItem[]>
+      }
+    }
+  }
+}
+
+export interface NasTechTerminalSession {
+  cwd: string
+  id: string
+  shell: string
+}
+
+export interface NasTechTerminalExit {
+  code: number | null
+  signal: string | null
+}
+
+export interface DesktopVersionInfo {
+  appVersion: string
+  electronVersion: string
+  nodeVersion: string
+  platform: string
+  NASTECHRoot: string
+}
+
+export type DesktopUninstallMode = 'full' | 'gui' | 'lite'
+
+export interface DesktopUninstallSummary {
+  NASTECH_HOME: string
+  agent_installed: boolean
+  gui_installed: boolean
+  source_built_artifacts: string[]
+  packaged_app_paths: string[]
+  userdata_dir: string
+  userdata_exists: boolean
+  platform: string
+  running_app_path?: null | string
+  probe?: string
+}
+
+export interface DesktopUninstallResult {
+  ok: boolean
+  mode?: DesktopUninstallMode
+  willRemoveAppBundle?: boolean
+  scriptPath?: string
+  error?: string
+  message?: string
+}
+
+export interface DesktopUpdateCommit {
+  sha: string
+  summary: string
+  author: string
+  at: number
+}
+
+export interface DesktopUpdateStatus {
+  supported: boolean
+  branch?: string
+  currentBranch?: string
+  reason?: string
+  message?: string
+  error?: string
+  behind?: number
+  currentSha?: string
+  targetSha?: string
+  commits?: DesktopUpdateCommit[]
+  dirty?: boolean
+  fetchedAt?: number
+}
+
+export type DesktopUpdateDirtyStrategy = 'abort' | 'stash' | 'force'
+
+export interface DesktopUpdateApplyOptions {
+  dirtyStrategy?: DesktopUpdateDirtyStrategy
+}
+
+export interface DesktopUpdateApplyResult {
+  ok: boolean
+  branch?: string
+  error?: string
+  message?: string
+  /** True when no staged updater exists (CLI install) and the user should run
+   *  `NASTECH update` themselves. `command` is the exact line to run. */
+  manual?: boolean
+  command?: string
+  NASTECHRoot?: string
+}
+
+export type DesktopUpdateStage = 'idle' | 'prepare' | 'fetch' | 'pull' | 'pydeps' | 'restart' | 'manual' | 'error'
+
+export interface DesktopUpdateProgress {
+  stage: DesktopUpdateStage
+  message: string
+  percent: number | null
+  error: string | null
+  at: number
+}
+
+export interface NasTechConnection {
+  baseUrl: string
+  isFullscreen: boolean
+  mode?: 'local' | 'remote'
+  authMode?: 'oauth' | 'token'
+  nativeOverlayWidth: number
+  source?: 'env' | 'local' | 'settings'
+  token: string
+  wsUrl: string
+  logs: string[]
+  // Set for pool (non-primary) backends so the renderer knows which profile a
+  // connection belongs to.
+  profile?: string
+  windowButtonPosition: { x: number; y: number } | null
+}
+
+export interface NasTechTitleBarTheme {
+  background: string
+  foreground: string
+}
+
+export interface NasTechWindowState {
+  isFullscreen: boolean
+  nativeOverlayWidth: number
+  windowButtonPosition: { x: number; y: number } | null
+}
+
+export interface DesktopActiveProfile {
+  // The desktop's stored profile preference, or null when unset (legacy launch
+  // that defers to the sticky active_profile / default).
+  profile: string | null
+}
+
+export interface DesktopConnectionConfig {
+  envOverride: boolean
+  mode: 'local' | 'remote'
+  // The profile this config describes, or null for the global/default
+  // connection. Per-profile entries let a profile point at its own backend.
+  profile: null | string
+  remoteAuthMode: 'oauth' | 'token'
+  remoteOauthConnected: boolean
+  remoteTokenPreview: string | null
+  remoteTokenSet: boolean
+  remoteUrl: string
+}
+
+export interface DesktopConnectionConfigInput {
+  mode: 'local' | 'remote'
+  // When set, the save/apply/test targets this profile's per-profile remote
+  // override instead of the global connection.
+  profile?: null | string
+  remoteAuthMode?: 'oauth' | 'token'
+  remoteToken?: string
+  remoteUrl?: string
+}
+
+export interface DesktopConnectionTestResult {
+  baseUrl: string
+  ok: boolean
+  version: string | null
+}
+
+export interface DesktopAuthProvider {
+  name: string
+  displayName: string
+  // True when this provider authenticates with a username + password
+  // (the gateway's /login page renders a credential form) rather than an
+  // OAuth redirect. The session/cookie/ws-ticket machinery is identical;
+  // only the login-page form and the desktop's button copy differ.
+  supportsPassword?: boolean
+}
+
+export interface DesktopConnectionProbeResult {
+  baseUrl: string
+  reachable: boolean
+  authMode: 'oauth' | 'token' | 'unknown'
+  providers: DesktopAuthProvider[]
+  version: string | null
+  error: string | null
+}
+
+export interface DesktopOauthLoginResult {
+  ok: boolean
+  baseUrl: string
+  connected: boolean
+}
+
+export interface DesktopOauthLogoutResult {
+  ok: boolean
+  connected: boolean
+}
+
+export interface DesktopBootProgress {
+  error: string | null
+  fakeMode: boolean
+  message: string
+  phase: string
+  progress: number
+  running: boolean
+  timestamp: number
+}
+
+// First-launch install ("bootstrap") event types -- emitted by
+// electron/bootstrap-runner.cjs and observed by the renderer install overlay.
+// Mirrors the event shapes emitted by runBootstrap()'s onEvent callback.
+
+export interface DesktopBootstrapStageDescriptor {
+  name: string
+  title?: string
+  category?: string
+  needs_user_input?: boolean
+}
+
+export type DesktopBootstrapStageState = 'pending' | 'running' | 'succeeded' | 'skipped' | 'failed'
+
+export interface DesktopBootstrapStageResult {
+  state: DesktopBootstrapStageState
+  durationMs: number | null
+  startedAt: number | null
+  json: { ok: boolean; skipped?: boolean; reason?: string | null; stage: string } | null
+  error: string | null
+}
+
+export interface DesktopBootstrapUnsupportedPlatform {
+  platform: string
+  activeRoot: string
+  installCommand: string
+  docsUrl: string
+}
+
+export interface DesktopBootstrapState {
+  active: boolean
+  manifest: { type: 'manifest'; stages: DesktopBootstrapStageDescriptor[]; protocolVersion: number | null } | null
+  stages: Record<string, DesktopBootstrapStageResult>
+  error: string | null
+  log: Array<{ ts: number; stage: string | null; line: string; stream?: 'stdout' | 'stderr' }>
+  startedAt: number | null
+  completedAt: number | null
+  unsupportedPlatform: DesktopBootstrapUnsupportedPlatform | null
+}
+
+export type DesktopBootstrapEvent =
+  | { type: 'manifest'; stages: DesktopBootstrapStageDescriptor[]; protocolVersion: number | null }
+  | {
+      type: 'stage'
+      name: string
+      state: DesktopBootstrapStageState
+      durationMs?: number
+      json?: DesktopBootstrapStageResult['json']
+      error?: string | null
+    }
+  | { type: 'log'; stage?: string | null; line: string; stream?: 'stdout' | 'stderr' }
+  | { type: 'complete'; marker: Record<string, unknown> }
+  | { type: 'failed'; stage?: string | null; error: string }
+  | {
+      type: 'unsupported-platform'
+      platform: string
+      activeRoot: string
+      installCommand: string
+      docsUrl: string
+    }
+
+export interface NasTechApiRequest {
+  path: string
+  method?: string
+  body?: unknown
+  timeoutMs?: number
+  // Route this REST call to a specific profile's backend. Omit for the primary
+  // (window) backend. Read-only cross-profile data is served by the primary, so
+  // this is only needed for profile-scoped live/settings calls.
+  profile?: string | null
+}
+
+export interface NasTechNotification {
+  title?: string
+  body?: string
+  silent?: boolean
+}
+
+export interface NasTechPreviewTarget {
+  binary?: boolean
+  byteSize?: number
+  kind: 'file' | 'url'
+  label: string
+  large?: boolean
+  language?: string
+  mimeType?: string
+  path?: string
+  previewKind?: 'binary' | 'html' | 'image' | 'text'
+  renderMode?: 'preview' | 'source'
+  source: string
+  url: string
+}
+
+export interface NasTechReadFileTextResult {
+  binary?: boolean
+  byteSize?: number
+  language?: string
+  mimeType?: string
+  path: string
+  text: string
+  truncated?: boolean
+}
+
+export interface NasTechPreviewWatch {
+  id: string
+  path: string
+}
+
+export interface NasTechReadDirEntry {
+  name: string
+  path: string
+  isDirectory: boolean
+}
+
+export interface NasTechReadDirResult {
+  entries: NasTechReadDirEntry[]
+  error?: string
+}
+
+export interface NasTechPreviewFileChanged {
+  id: string
+  path: string
+  url: string
+}
+
+export interface NasTechSelectPathsOptions {
+  title?: string
+  defaultPath?: string
+  directories?: boolean
+  multiple?: boolean
+  filters?: Array<{ name: string; extensions: string[] }>
+}
+
+export interface BackendExit {
+  code: number | null
+  signal: string | null
+}
+
+export interface NasTechWorktreeInfo {
+  repoRoot: string
+  worktreeRoot: string
+  isMainWorktree: boolean
+  branch: null | string
+}
+
+export interface DesktopMarketplaceSearchItem {
+  extensionId: string
+  displayName: string
+  publisher: string
+  description: string
+  installs: number
+}
+
+export interface DesktopMarketplaceThemeFile {
+  label: string
+  uiTheme?: string
+  contents: string
+}
+
+export interface DesktopMarketplaceThemeResult {
+  extensionId: string
+  displayName: string
+  themes: DesktopMarketplaceThemeFile[]
+}

package/src/hooks/use-image-download.ts

@@ -0,0 +1,85 @@
+import { useCallback, useState } from 'react'
+
+import { useI18n } from '@/i18n'
+import { notify, notifyError } from '@/store/notifications'
+
+export function imageFilename(src?: string): string {
+  if (!src) {
+    return 'image'
+  }
+
+  try {
+    return new URL(src, window.location.href).pathname.split('/').filter(Boolean).pop() || 'image'
+  } catch {
+    return src.split(/[\\/]/).filter(Boolean).pop() || 'image'
+  }
+}
+
+function isMissingIpcHandler(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : typeof error === 'string' ? error : ''
+
+  return message.includes("No handler registered for 'nastech:saveImageFromUrl'")
+}
+
+async function startBrowserDownload(src: string) {
+  const response = await fetch(src)
+
+  if (!response.ok) {
+    throw new Error(`Could not fetch image: ${response.status}`)
+  }
+
+  const blobUrl = URL.createObjectURL(await response.blob())
+  const link = document.createElement('a')
+  link.href = blobUrl
+  link.download = imageFilename(src)
+  link.rel = 'noopener noreferrer'
+  document.body.appendChild(link)
+  link.click()
+  link.remove()
+  window.setTimeout(() => URL.revokeObjectURL(blobUrl), 30_000)
+}
+
+/** Save an image to disk via the desktop IPC bridge, falling back to a browser
+ *  download when the handler is unavailable (older shell / web preview). */
+export function useImageDownload(src?: string) {
+  const { t } = useI18n()
+  const copy = t.desktop
+  const [saving, setSaving] = useState(false)
+
+  const download = useCallback(async () => {
+    if (!src || saving) {
+      return
+    }
+
+    setSaving(true)
+
+    try {
+      if (window.NASTECHDesktop?.saveImageFromUrl) {
+        if (await window.NASTECHDesktop.saveImageFromUrl(src)) {
+          notify({ kind: 'success', title: copy.imageSaved, message: imageFilename(src) })
+        }
+
+        return
+      }
+
+      await startBrowserDownload(src)
+    } catch (error) {
+      if (isMissingIpcHandler(error)) {
+        try {
+          await startBrowserDownload(src)
+          notify({ kind: 'info', title: copy.downloadStarted, message: copy.restartToUseSaveImage })
+        } catch (fallbackError) {
+          notifyError(fallbackError, copy.restartToSaveImages)
+        }
+
+        return
+      }
+
+      notifyError(error, copy.imageDownloadFailed)
+    } finally {
+      setSaving(false)
+    }
+  }, [copy, saving, src])
+
+  return { download, saving }
+}

package/src/hooks/use-media-query.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react'
+
+export const matchesQuery = (query: string) =>
+  typeof window !== 'undefined' && !!window.matchMedia && window.matchMedia(query).matches
+
+export function useMediaQuery(query: string): boolean {
+  const [matches, setMatches] = useState(() => matchesQuery(query))
+
+  useEffect(() => {
+    if (typeof window === 'undefined' || !window.matchMedia) {
+      return
+    }
+
+    const mql = window.matchMedia(query)
+    const onChange = () => setMatches(mql.matches)
+
+    setMatches(mql.matches)
+    mql.addEventListener('change', onChange)
+
+    return () => mql.removeEventListener('change', onChange)
+  }, [query])
+
+  return matches
+}

package/src/hooks/use-mobile.ts

@@ -0,0 +1,3 @@
+import { useMediaQuery } from './use-media-query'
+
+export const useIsMobile = () => useMediaQuery(`(max-width: ${768 / 16 - 1 / 16}rem)`)

package/src/hooks/use-resize-observer.ts

@@ -0,0 +1,38 @@
+import { type RefObject, useLayoutEffect, useRef } from 'react'
+
+export function useResizeObserver(onResize: () => void, ...refs: readonly RefObject<Element | null>[]) {
+  const refsRef = useRef(refs)
+  refsRef.current = refs
+
+  useLayoutEffect(() => {
+    if (typeof ResizeObserver === 'undefined') {
+      onResize()
+
+      return
+    }
+
+    const observer = new ResizeObserver(() => onResize())
+    let observed = false
+
+    for (const ref of refsRef.current) {
+      const element = ref.current
+
+      if (!element) {
+        continue
+      }
+
+      observer.observe(element)
+      observed = true
+    }
+
+    if (!observed) {
+      observer.disconnect()
+
+      return
+    }
+
+    onResize()
+
+    return () => observer.disconnect()
+  }, [onResize])
+}

package/src/hooks/use-worktree-info.ts

@@ -0,0 +1,68 @@
+import { useEffect, useMemo, useRef, useState } from 'react'
+
+import { uniqueCwds, type WorktreeResolver } from '@/app/chat/sidebar/workspace-groups'
+import type { NasTechWorktreeInfo } from '@/global'
+import type { SessionInfo } from '@/nastech'
+import { desktopFsCacheKey, desktopWorktrees } from '@/lib/desktop-fs'
+
+type WorktreeMap = Record<string, NasTechWorktreeInfo | null>
+
+/**
+ * Probe the local filesystem for the git-worktree identity of each session cwd
+ * and return a resolver the grouping uses to build `parent → worktree`. Results
+ * are cached per cwd (and reset when the backend connection changes), so a probe
+ * runs once per directory. Unresolved cwds (probe pending, remote backend, or
+ * non-git dirs) fall back to the path-name heuristic in `workspaceTreeFor`.
+ */
+export function useWorktreeInfo(sessions: SessionInfo[], enabled: boolean): WorktreeResolver {
+  const [map, setMap] = useState<WorktreeMap>({})
+  const cacheRef = useRef<{ data: WorktreeMap; key: string }>({ data: {}, key: '' })
+
+  useEffect(() => {
+    if (!enabled) {
+      return
+    }
+
+    const key = desktopFsCacheKey()
+
+    if (cacheRef.current.key !== key) {
+      cacheRef.current = { data: {}, key }
+      setMap({})
+    }
+
+    const missing = uniqueCwds(sessions).filter(cwd => !(cwd in cacheRef.current.data))
+
+    if (!missing.length) {
+      return
+    }
+
+    let cancelled = false
+
+    void desktopWorktrees(missing)
+      .then(result => {
+        if (cancelled) {
+          return
+        }
+
+        // Record every probed cwd (null when absent) so we never re-probe it.
+        const next: WorktreeMap = { ...cacheRef.current.data }
+
+        for (const cwd of missing) {
+          next[cwd] = result[cwd] ?? null
+        }
+
+        cacheRef.current = { data: next, key }
+        setMap(next)
+      })
+      .catch(() => {
+        // Bridge unavailable / probe failed — leave cwds unresolved so the
+        // heuristic fallback handles them.
+      })
+
+    return () => {
+      cancelled = true
+    }
+  }, [sessions, enabled])
+
+  return useMemo<WorktreeResolver>(() => (cwd: string) => map[cwd], [map])
+}

package/src/i18n/catalog.ts

@@ -0,0 +1,12 @@
+import { en } from './en'
+import { ja } from './ja'
+import type { Locale, Translations } from './types'
+import { zh } from './zh'
+import { zhHant } from './zh-hant'
+
+export const TRANSLATIONS: Record<Locale, Translations> = {
+  en,
+  zh,
+  'zh-hant': zhHant,
+  ja
+}