nastechai-desktop 18.1.0

package/src/lib/desktop-fs.ts

@@ -0,0 +1,113 @@
+import type {
+  NasTechConnection,
+  NasTechReadDirResult,
+  NasTechReadFileTextResult,
+  NasTechSelectPathsOptions,
+  NasTechWorktreeInfo
+} from '@/global'
+import { $connection } from '@/store/session'
+
+export interface DesktopFsRemotePicker {
+  selectPaths: (options?: NasTechSelectPathsOptions) => Promise<string[]>
+}
+
+let remotePicker: DesktopFsRemotePicker | null = null
+
+export function setDesktopFsRemotePicker(next: DesktopFsRemotePicker | null) {
+  remotePicker = next
+}
+
+function connectionCacheKey(connection: NasTechConnection | null) {
+  if (!connection) {
+    return 'local:'
+  }
+  return `${connection.mode || 'local'}:${connection.profile || ''}:${connection.baseUrl || ''}`
+}
+
+export function desktopFsCacheKey() {
+  return connectionCacheKey($connection.get())
+}
+
+export function isDesktopFsRemoteMode() {
+  return $connection.get()?.mode === 'remote'
+}
+
+function fsPath(endpoint: string, filePath: string) {
+  return `/api/fs/${endpoint}?path=${encodeURIComponent(filePath)}`
+}
+
+function bridge() {
+  const desktop = window.NASTECHDesktop
+  if (!desktop) {
+    throw new Error('NasTech Desktop bridge is unavailable')
+  }
+  return desktop
+}
+
+export async function readDesktopDir(path: string): Promise<NasTechReadDirResult> {
+  const desktop = bridge()
+  if (!isDesktopFsRemoteMode()) {
+    return desktop.readDir(path)
+  }
+  return desktop.api<NasTechReadDirResult>({ path: fsPath('list', path) })
+}
+
+export async function readDesktopFileText(path: string): Promise<NasTechReadFileTextResult> {
+  const desktop = bridge()
+  if (!isDesktopFsRemoteMode()) {
+    return desktop.readFileText(path)
+  }
+  return desktop.api<NasTechReadFileTextResult>({ path: fsPath('read-text', path) })
+}
+
+export async function readDesktopFileDataUrl(path: string): Promise<string> {
+  const desktop = bridge()
+  if (!isDesktopFsRemoteMode()) {
+    return desktop.readFileDataUrl(path)
+  }
+
+  const result = await desktop.api<string | { dataUrl?: string }>({ path: fsPath('read-data-url', path) })
+  return typeof result === 'string' ? result : result.dataUrl || ''
+}
+
+export async function desktopGitRoot(path: string): Promise<string | null> {
+  const desktop = bridge()
+  if (!isDesktopFsRemoteMode()) {
+    return desktop.gitRoot ? desktop.gitRoot(path) : null
+  }
+
+  const result = await desktop.api<{ root: string | null }>({ path: fsPath('git-root', path) })
+  return result.root
+}
+
+// Worktree detection runs against the LOCAL filesystem (the electron main
+// process). For a remote backend the session cwds live on another machine, so
+// we can't resolve them here — callers fall back to the path-name heuristic.
+export async function desktopWorktrees(cwds: string[]): Promise<Record<string, NasTechWorktreeInfo | null>> {
+  if (isDesktopFsRemoteMode()) {
+    return {}
+  }
+
+  const desktop = bridge()
+
+  return desktop.worktrees ? desktop.worktrees(cwds) : {}
+}
+
+export async function desktopDefaultCwd(): Promise<{ branch: string; cwd: string } | null> {
+  if (!isDesktopFsRemoteMode()) {
+    return null
+  }
+
+  return bridge().api<{ branch: string; cwd: string }>({ path: '/api/fs/default-cwd' })
+}
+
+export async function selectDesktopPaths(options?: NasTechSelectPathsOptions): Promise<string[]> {
+  const desktop = bridge()
+  if (!isDesktopFsRemoteMode()) {
+    return desktop.selectPaths(options)
+  }
+  if (!options?.directories || options.multiple !== false) {
+    return []
+  }
+  return remotePicker ? remotePicker.selectPaths(options) : []
+}

package/src/lib/desktop-slash-commands.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  desktopSkinSlashCompletions,
+  desktopSlashDescription,
+  desktopSlashUnavailableMessage,
+  filterDesktopCommandsCatalog,
+  isDesktopSlashCommand,
+  isDesktopSlashSuggestion,
+  isModelPickerCommand
+} from './desktop-slash-commands'
+
+describe('desktop slash command curation', () => {
+  it('keeps core desktop chat commands in suggestions', () => {
+    expect(isDesktopSlashSuggestion('/new')).toBe(true)
+    expect(isDesktopSlashSuggestion('/branch')).toBe(true)
+    expect(isDesktopSlashSuggestion('/skin')).toBe(true)
+    expect(isDesktopSlashSuggestion('/usage')).toBe(true)
+    expect(isDesktopSlashSuggestion('/version')).toBe(true)
+    expect(isDesktopSlashSuggestion('/yolo')).toBe(true)
+    expect(isDesktopSlashCommand('/yolo')).toBe(true)
+  })
+
+  it('surfaces skill and quick commands (extensions) in suggestions and lets them run', () => {
+    expect(isDesktopSlashSuggestion('/my-skill')).toBe(true)
+    expect(isDesktopSlashSuggestion('/gif-search')).toBe(true)
+    expect(isDesktopSlashCommand('/my-skill')).toBe(true)
+  })
+
+  it('hides terminal, messaging, and dedicated-UI commands from suggestions', () => {
+    expect(isDesktopSlashSuggestion('/clear')).toBe(false)
+    expect(isDesktopSlashSuggestion('/compact')).toBe(false)
+    expect(isDesktopSlashSuggestion('/redraw')).toBe(false)
+    expect(isDesktopSlashSuggestion('/approve')).toBe(false)
+    expect(isDesktopSlashSuggestion('/model')).toBe(false)
+    expect(isDesktopSlashSuggestion('/skills')).toBe(false)
+    expect(isDesktopSlashSuggestion('/voice')).toBe(false)
+    expect(isDesktopSlashSuggestion('/curator')).toBe(false)
+  })
+
+  it('allows aliases to execute without cluttering the popover', () => {
+    expect(isDesktopSlashSuggestion('/reset')).toBe(false)
+    expect(isDesktopSlashCommand('/reset')).toBe(true)
+  })
+
+  it('filters built-in catalog noise but keeps skill / quick-command extensions', () => {
+    const filtered = filterDesktopCommandsCatalog({
+      categories: [
+        {
+          name: 'Session',
+          pairs: [
+            ['/new', 'Start a new session'],
+            ['/clear', 'Clear terminal screen']
+          ]
+        },
+        {
+          name: 'User commands',
+          pairs: [['/ship-it', 'Run release checklist']]
+        }
+      ],
+      pairs: [
+        ['/new', 'Start a new session'],
+        ['/model', 'Switch model'],
+        ['/ship-it', 'Run release checklist']
+      ],
+      skill_count: 2
+    })
+
+    expect(filtered.categories).toEqual([
+      { name: 'Session', pairs: [['/new', 'Start a new desktop chat']] },
+      { name: 'User commands', pairs: [['/ship-it', 'Run release checklist']] }
+    ])
+    expect(filtered.pairs).toEqual([
+      ['/new', 'Start a new desktop chat'],
+      ['/ship-it', 'Run release checklist']
+    ])
+    expect(filtered.skill_count).toBe(2)
+  })
+
+  it('uses desktop-specific labels for commands with different UI behavior', () => {
+    expect(desktopSlashDescription('/branch', 'Branch the current session')).toBe(
+      'Branch the latest message into a new chat'
+    )
+    expect(desktopSlashDescription('/skin', 'Show or change the display skin/theme')).toBe(
+      'Switch desktop theme or cycle to the next one'
+    )
+  })
+
+  it('builds /skin completions from desktop themes', () => {
+    const completions = desktopSkinSlashCompletions(
+      [
+        { name: 'mono', label: 'Mono', description: 'Clean grayscale' },
+        { name: 'midnight', label: 'Midnight', description: 'Deep blue' },
+        { name: 'slate', label: 'Slate', description: 'Cool slate blue' }
+      ],
+      'mono',
+      'm'
+    )
+
+    expect(completions).toEqual([
+      {
+        text: '/skin mono',
+        display: '/skin mono',
+        meta: 'Mono (current) - Clean grayscale'
+      },
+      {
+        text: '/skin midnight',
+        display: '/skin midnight',
+        meta: 'Midnight - Deep blue'
+      }
+    ])
+  })
+
+  it('explains known commands that desktop owns elsewhere', () => {
+    expect(desktopSlashUnavailableMessage('/model sonnet')).toContain('model picker')
+    expect(desktopSlashUnavailableMessage('/skills')).toContain('desktop sidebar')
+    expect(desktopSlashUnavailableMessage('/clear')).toContain('terminal interface')
+  })
+
+  it('flags /model as a picker-owned command so the desktop opens the overlay', () => {
+    expect(isModelPickerCommand('/model')).toBe(true)
+    expect(isModelPickerCommand('/model sonnet')).toBe(true)
+    expect(isModelPickerCommand('/new')).toBe(false)
+    expect(isModelPickerCommand('/skills')).toBe(false)
+  })
+})

package/src/lib/desktop-slash-commands.ts

@@ -0,0 +1,286 @@
+export interface CommandsCatalogSection {
+  name: string
+  pairs: [string, string][]
+}
+
+export interface CommandsCatalogLike {
+  categories?: CommandsCatalogSection[]
+  pairs?: [string, string][]
+  skill_count?: number
+  warning?: string
+}
+
+export interface DesktopSlashCompletion {
+  display: string
+  meta: string
+  text: string
+}
+
+export interface DesktopThemeCommandOption {
+  description: string
+  label: string
+  name: string
+}
+
+const DESKTOP_COMMAND_META = [
+  ['/agents', 'Show active desktop sessions and running tasks'],
+  ['/background', 'Run a prompt in the background'],
+  ['/branch', 'Branch the latest message into a new chat'],
+  ['/compress', 'Compress this conversation context'],
+  ['/debug', 'Create a debug report'],
+  ['/goal', 'Manage the standing goal for this session'],
+  ['/help', 'Show desktop slash commands'],
+  ['/new', 'Start a new desktop chat'],
+  ['/profile', 'Switch the active NasTech profile'],
+  ['/queue', 'Queue a prompt for the next turn'],
+  ['/resume', 'Resume a saved session'],
+  ['/retry', 'Retry the last user message'],
+  ['/rollback', 'List or restore filesystem checkpoints'],
+  ['/skin', 'Switch desktop theme or cycle to the next one'],
+  ['/status', 'Show current session status'],
+  ['/steer', 'Steer the current run after the next tool call'],
+  ['/stop', 'Stop running background processes'],
+  ['/title', 'Rename the current session'],
+  ['/undo', 'Remove the last user/assistant exchange'],
+  ['/usage', 'Show token usage for this session'],
+  ['/version', 'Show NasTech Agent version'],
+  ['/yolo', 'Toggle YOLO — auto-approve dangerous commands']
+] as const
+
+const DESKTOP_COMMANDS: ReadonlySet<string> = new Set(DESKTOP_COMMAND_META.map(([command]) => command))
+
+const DESKTOP_ALIASES = new Map([
+  ['/bg', '/background'],
+  ['/btw', '/background'],
+  ['/fork', '/branch'],
+  ['/q', '/queue'],
+  ['/reload_mcp', '/reload-mcp'],
+  ['/reload_skills', '/reload-skills'],
+  ['/reset', '/new'],
+  ['/tasks', '/agents']
+])
+
+const DESKTOP_COMMAND_DESCRIPTIONS: ReadonlyMap<string, string> = new Map(DESKTOP_COMMAND_META)
+
+const PICKER_OWNED_COMMANDS = new Set(['/model'])
+
+const TERMINAL_ONLY_COMMANDS = new Set([
+  '/browser',
+  '/busy',
+  '/clear',
+  '/commands',
+  '/compact',
+  '/config',
+  '/copy',
+  '/cron',
+  '/details',
+  '/exit',
+  '/footer',
+  '/gateway',
+  '/gquota',
+  '/history',
+  '/image',
+  '/indicator',
+  '/logs',
+  '/mouse',
+  '/paste',
+  '/platforms',
+  '/plugins',
+  '/quit',
+  '/redraw',
+  '/reload',
+  '/restart',
+  '/save',
+  '/sb',
+  '/set-home',
+  '/sethome',
+  '/snap',
+  '/snapshot',
+  '/statusbar',
+  '/toolsets',
+  '/tools',
+  '/update',
+  '/verbose'
+])
+
+const MESSAGING_ONLY_COMMANDS = new Set(['/approve', '/deny'])
+
+const SETTINGS_OWNED_COMMANDS = new Set(['/skills'])
+
+const ADVANCED_COMMANDS = new Set([
+  '/curator',
+  '/fast',
+  '/insights',
+  '/kanban',
+  '/personality',
+  '/reasoning',
+  '/reload-mcp',
+  '/reload-skills',
+  '/voice'
+])
+
+const BLOCKED_COMMANDS = new Set([
+  ...PICKER_OWNED_COMMANDS,
+  ...TERMINAL_ONLY_COMMANDS,
+  ...MESSAGING_ONLY_COMMANDS,
+  ...SETTINGS_OWNED_COMMANDS,
+  ...ADVANCED_COMMANDS
+])
+
+function normalizeCommand(command: string): string {
+  const trimmed = command.trim()
+  const base = (trimmed.startsWith('/') ? trimmed : `/${trimmed}`).split(/\s+/, 1)[0]?.toLowerCase() || ''
+
+  return base
+}
+
+export function canonicalDesktopSlashCommand(command: string): string {
+  const normalized = normalizeCommand(command)
+
+  return DESKTOP_ALIASES.get(normalized) || normalized
+}
+
+export function isDesktopSlashCommand(command: string): boolean {
+  const normalized = normalizeCommand(command)
+  const canonical = canonicalDesktopSlashCommand(normalized)
+
+  if (BLOCKED_COMMANDS.has(normalized) || BLOCKED_COMMANDS.has(canonical)) {
+    return false
+  }
+
+  return DESKTOP_COMMANDS.has(canonical) || !isKnownNasTechSlashCommand(normalized)
+}
+
+/**
+ * An "extension" command is anything the backend surfaces that is NOT one of
+ * NasTech' built-in slash commands — i.e. skill commands (`/gif-search`,
+ * `/codex`, …) and user-defined quick commands. These are user-activated, so
+ * they should appear in the desktop slash palette even though they aren't in
+ * the curated `DESKTOP_COMMANDS` allow-list. This mirrors the predicate in
+ * `isDesktopSlashCommand` that already lets them EXECUTE when typed.
+ */
+export function isDesktopSlashExtensionCommand(command: string): boolean {
+  const normalized = normalizeCommand(command)
+
+  if (!normalized || normalized === '/') {
+    return false
+  }
+
+  return !isKnownNasTechSlashCommand(normalized)
+}
+
+export function isDesktopSlashSuggestion(command: string): boolean {
+  const normalized = normalizeCommand(command)
+  const canonical = canonicalDesktopSlashCommand(normalized)
+
+  // Surface skill / quick commands (extensions the backend provides) alongside
+  // the curated built-ins. Built-in aliases stay hidden so the popover isn't
+  // cluttered with duplicates.
+  if (isDesktopSlashExtensionCommand(normalized)) {
+    return true
+  }
+
+  return DESKTOP_COMMANDS.has(canonical) && !DESKTOP_ALIASES.has(normalized)
+}
+
+/**
+ * True for commands the desktop fulfils by opening the model picker overlay
+ * (e.g. `/model`) rather than executing a slash command. The caller opens the
+ * picker UI instead of printing the "uses the desktop model picker" notice.
+ */
+export function isModelPickerCommand(command: string): boolean {
+  const normalized = normalizeCommand(command)
+  const canonical = canonicalDesktopSlashCommand(normalized)
+
+  return PICKER_OWNED_COMMANDS.has(canonical)
+}
+
+export function desktopSlashUnavailableMessage(command: string): string | null {
+  const normalized = normalizeCommand(command)
+  const canonical = canonicalDesktopSlashCommand(normalized)
+
+  if (PICKER_OWNED_COMMANDS.has(canonical)) {
+    return `/${canonical.slice(1)} uses the desktop model picker instead of a slash command.`
+  }
+
+  if (SETTINGS_OWNED_COMMANDS.has(canonical)) {
+    return `/${canonical.slice(1)} is managed from the desktop sidebar.`
+  }
+
+  if (MESSAGING_ONLY_COMMANDS.has(canonical)) {
+    return `/${canonical.slice(1)} is only used from messaging platforms.`
+  }
+
+  if (ADVANCED_COMMANDS.has(canonical)) {
+    return `/${canonical.slice(1)} is not shown in the desktop slash palette. Use the relevant desktop control or terminal interface instead.`
+  }
+
+  if (TERMINAL_ONLY_COMMANDS.has(normalized) || TERMINAL_ONLY_COMMANDS.has(canonical)) {
+    return `/${canonical.slice(1)} is only available in the terminal interface.`
+  }
+
+  return null
+}
+
+export function desktopSlashDescription(command: string, fallback = ''): string {
+  const canonical = canonicalDesktopSlashCommand(command)
+
+  return DESKTOP_COMMAND_DESCRIPTIONS.get(canonical) || fallback
+}
+
+export function desktopSkinSlashCompletions(
+  themes: DesktopThemeCommandOption[],
+  activeThemeName: string,
+  argPrefix: string
+): DesktopSlashCompletion[] {
+  const prefix = argPrefix.trim().toLowerCase()
+
+  const commands: DesktopSlashCompletion[] = [
+    {
+      text: '/skin list',
+      display: '/skin list',
+      meta: 'Show available desktop themes'
+    },
+    {
+      text: '/skin next',
+      display: '/skin next',
+      meta: 'Cycle to the next desktop theme'
+    },
+    ...themes.map(theme => ({
+      text: `/skin ${theme.name}`,
+      display: `/skin ${theme.name}`,
+      meta: `${theme.label}${theme.name === activeThemeName ? ' (current)' : ''} - ${theme.description}`
+    }))
+  ]
+
+  if (!prefix) {
+    return commands
+  }
+
+  return commands.filter(item => item.text.slice('/skin '.length).toLowerCase().startsWith(prefix))
+}
+
+export function filterDesktopCommandsCatalog(catalog: CommandsCatalogLike): CommandsCatalogLike {
+  const categories = catalog.categories
+    ?.map(section => ({
+      ...section,
+      pairs: section.pairs
+        .filter(([command]) => isDesktopSlashSuggestion(command))
+        .map(([command, description]) => [command, desktopSlashDescription(command, description)] as [string, string])
+    }))
+    .filter(section => section.pairs.length > 0)
+
+  const pairs = catalog.pairs
+    ?.filter(([command]) => isDesktopSlashSuggestion(command))
+    .map(([command, description]) => [command, desktopSlashDescription(command, description)] as [string, string])
+
+  return {
+    ...catalog,
+    ...(categories ? { categories } : {}),
+    ...(pairs ? { pairs } : {})
+  }
+}
+
+function isKnownNasTechSlashCommand(command: string): boolean {
+  return DESKTOP_COMMANDS.has(command) || DESKTOP_ALIASES.has(command) || BLOCKED_COMMANDS.has(command)
+}

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractEmbeddedImages } from './embedded-images'
+
+const SAMPLE_PNG_DATA_URL = 'data:image/png;base64,' + 'A'.repeat(120)
+
+describe('extractEmbeddedImages', () => {
+  it('returns text untouched when no data URL is present', () => {
+    expect(extractEmbeddedImages('describe this')).toEqual({ cleanedText: 'describe this', images: [] })
+  })
+
+  it('lifts a bare data:image URL out of prose', () => {
+    const result = extractEmbeddedImages(`describe this ${SAMPLE_PNG_DATA_URL}`)
+
+    expect(result.cleanedText).toBe('describe this')
+    expect(result.images).toEqual([SAMPLE_PNG_DATA_URL])
+  })
+
+  it('lifts a JSON-wrapped image_url envelope out of prose', () => {
+    const result = extractEmbeddedImages(
+      `describe this{"type":"image_url","image_url":{"url":"${SAMPLE_PNG_DATA_URL}"}}`
+    )
+
+    expect(result.cleanedText).toBe('describe this')
+    expect(result.images).toEqual([SAMPLE_PNG_DATA_URL])
+  })
+
+  it('extracts multiple embedded images', () => {
+    const second = 'data:image/jpeg;base64,' + 'B'.repeat(96)
+    const result = extractEmbeddedImages(`first ${SAMPLE_PNG_DATA_URL} mid ${second} tail`)
+
+    expect(result.cleanedText).toBe('first  mid  tail')
+    expect(result.images).toEqual([SAMPLE_PNG_DATA_URL, second])
+  })
+})

package/src/lib/embedded-images.ts

@@ -0,0 +1,60 @@
+const EMBEDDED_IMAGE_RE =
+  /(\{\s*"type"\s*:\s*"image_url"\s*,\s*"image_url"\s*:\s*\{\s*"url"\s*:\s*")?(data:image\/[\w.+-]+;base64,[A-Za-z0-9+/=]{64,})("\s*\}\s*\})?/g
+
+const DATA_URL_RE = /^data:([\w./+-]+);base64,(.*)$/i
+
+export const DATA_IMAGE_URL_RE = /^data:image\/[\w.+-]+;base64,/i
+
+export interface EmbeddedImageExtraction {
+  cleanedText: string
+  images: string[]
+}
+
+export function dataUrlToBlob(dataUrl: string): Blob | null {
+  const match = DATA_URL_RE.exec(dataUrl.trim())
+
+  if (!match) {
+    return null
+  }
+
+  try {
+    const bytes = atob(match[2])
+    const buffer = new Uint8Array(bytes.length)
+
+    for (let i = 0; i < bytes.length; i += 1) {
+      buffer[i] = bytes.charCodeAt(i)
+    }
+
+    return new Blob([buffer], { type: match[1] })
+  } catch {
+    return null
+  }
+}
+
+export function extractEmbeddedImages(text: string): EmbeddedImageExtraction {
+  if (!text || !text.includes('data:image/')) {
+    return { cleanedText: text, images: [] }
+  }
+
+  const images: string[] = []
+
+  const cleanedText = text
+    .replace(EMBEDDED_IMAGE_RE, (_match, _open, dataUrl: string) => {
+      images.push(dataUrl)
+
+      return ''
+    })
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+
+  return { cleanedText, images }
+}
+
+export function embeddedImageUrls(text: string): string[] {
+  return extractEmbeddedImages(text).images
+}
+
+export function textWithoutEmbeddedImages(text: string): string {
+  return extractEmbeddedImages(text).cleanedText
+}