@neurocode-ai/app 1.18.8

package/src/desktop-menu.ts

@@ -0,0 +1,223 @@
+export type DesktopMenuPlatform = "macos" | "windows"
+
+export type DesktopMenuAction =
+  | "app.checkForUpdates"
+  | "app.relaunch"
+  | "edit.undo"
+  | "edit.redo"
+  | "edit.cut"
+  | "edit.copy"
+  | "edit.paste"
+  | "edit.delete"
+  | "edit.selectAll"
+  | "view.reload"
+  | "view.toggleDevTools"
+  | "view.resetZoom"
+  | "view.zoomIn"
+  | "view.zoomOut"
+  | "view.toggleFullscreen"
+  | "window.new"
+  | "window.close"
+  | "window.minimize"
+  | "window.toggleMaximize"
+
+export type DesktopMenuRole =
+  | "about"
+  | "close"
+  | "copy"
+  | "cut"
+  | "hide"
+  | "hideOthers"
+  | "paste"
+  | "quit"
+  | "redo"
+  | "reload"
+  | "resetZoom"
+  | "selectAll"
+  | "toggleDevTools"
+  | "togglefullscreen"
+  | "undo"
+  | "unhide"
+  | "windowMenu"
+  | "zoomIn"
+  | "zoomOut"
+
+export type DesktopMenuItem = {
+  type: "item"
+  label?: string
+  command?: string
+  action?: DesktopMenuAction
+  role?: DesktopMenuRole
+  href?: string
+  accelerator?: Partial<Record<DesktopMenuPlatform, string>>
+  enabled?: "updater"
+  platforms?: DesktopMenuPlatform[]
+}
+
+export type DesktopMenuSeparator = {
+  type: "separator"
+  platforms?: DesktopMenuPlatform[]
+}
+
+export type DesktopMenuEntry = DesktopMenuItem | DesktopMenuSeparator
+
+export type DesktopMenu = {
+  id: string
+  label: string
+  role?: DesktopMenuRole
+  items?: DesktopMenuEntry[]
+  platforms?: DesktopMenuPlatform[]
+}
+
+export const DESKTOP_MENU: DesktopMenu[] = [
+  {
+    id: "app",
+    label: "NeuroCode",
+    platforms: ["macos"],
+    items: [
+      { type: "item", role: "about" },
+      { type: "item", label: "Check for Updates...", action: "app.checkForUpdates", enabled: "updater" },
+      { type: "item", label: "Settings", command: "settings.open", accelerator: { macos: "Cmd+," } },
+      { type: "item", label: "Reload Webview", action: "view.reload" },
+      { type: "item", label: "Restart", action: "app.relaunch" },
+      { type: "item", label: "Export Logs...", command: "logs.export" },
+      { type: "separator" },
+      { type: "item", role: "hide" },
+      { type: "item", role: "hideOthers" },
+      { type: "item", role: "unhide" },
+      { type: "separator" },
+      { type: "item", role: "quit" },
+    ],
+  },
+  {
+    id: "file",
+    label: "File",
+    items: [
+      {
+        type: "item",
+        label: "New Session",
+        command: "session.new",
+        accelerator: { macos: "Shift+Cmd+S" },
+      },
+      { type: "item", label: "Open Project...", command: "project.open", accelerator: { macos: "Cmd+O" } },
+      {
+        type: "item",
+        label: "Settings",
+        command: "settings.open",
+        accelerator: { windows: "Ctrl+," },
+        platforms: ["windows"],
+      },
+      {
+        type: "item",
+        label: "New Window",
+        action: "window.new",
+        accelerator: { macos: "Cmd+Shift+N", windows: "Ctrl+Shift+N" },
+      },
+      { type: "separator" },
+      { type: "item", label: "Close Window", action: "window.close", role: "close" },
+    ],
+  },
+  {
+    id: "edit",
+    label: "Edit",
+    items: [
+      { type: "item", label: "Undo", action: "edit.undo", role: "undo", accelerator: { windows: "Ctrl+Z" } },
+      { type: "item", label: "Redo", action: "edit.redo", role: "redo", accelerator: { windows: "Ctrl+Y" } },
+      { type: "separator" },
+      { type: "item", label: "Cut", action: "edit.cut", role: "cut", accelerator: { windows: "Ctrl+X" } },
+      { type: "item", label: "Copy", action: "edit.copy", role: "copy", accelerator: { windows: "Ctrl+C" } },
+      { type: "item", label: "Paste", action: "edit.paste", role: "paste", accelerator: { windows: "Ctrl+V" } },
+      { type: "item", label: "Delete", action: "edit.delete" },
+      {
+        type: "item",
+        label: "Select All",
+        action: "edit.selectAll",
+        role: "selectAll",
+        accelerator: { windows: "Ctrl+A" },
+      },
+    ],
+  },
+  {
+    id: "view",
+    label: "View",
+    items: [
+      { type: "item", label: "Toggle Sidebar", command: "sidebar.toggle" },
+      { type: "item", label: "Toggle Terminal", command: "terminal.toggle", accelerator: { macos: "Ctrl+`" } },
+      { type: "item", label: "Toggle File Tree", command: "fileTree.toggle" },
+      { type: "separator" },
+      { type: "item", label: "Reload", action: "view.reload", role: "reload" },
+      { type: "item", label: "Toggle Developer Tools", action: "view.toggleDevTools", role: "toggleDevTools" },
+      { type: "separator" },
+      {
+        type: "item",
+        label: "Actual Size",
+        action: "view.resetZoom",
+        role: "resetZoom",
+        accelerator: { windows: "Ctrl+0" },
+      },
+      { type: "item", label: "Zoom In", action: "view.zoomIn", role: "zoomIn", accelerator: { windows: "Ctrl++" } },
+      { type: "item", label: "Zoom Out", action: "view.zoomOut", role: "zoomOut", accelerator: { windows: "Ctrl+-" } },
+      { type: "separator" },
+      { type: "item", label: "Toggle Full Screen", action: "view.toggleFullscreen", role: "togglefullscreen" },
+    ],
+  },
+  {
+    id: "go",
+    label: "Go",
+    items: [
+      { type: "item", label: "Back", command: "common.goBack", accelerator: { macos: "Cmd+[" } },
+      { type: "item", label: "Forward", command: "common.goForward", accelerator: { macos: "Cmd+]" } },
+      { type: "separator" },
+      { type: "item", label: "Previous Session", command: "session.previous", accelerator: { macos: "Option+Up" } },
+      { type: "item", label: "Next Session", command: "session.next", accelerator: { macos: "Option+Down" } },
+      { type: "separator" },
+      {
+        type: "item",
+        label: "Previous Project",
+        command: "project.previous",
+        accelerator: { macos: "Cmd+Option+Up" },
+      },
+      {
+        type: "item",
+        label: "Next Project",
+        command: "project.next",
+        accelerator: { macos: "Cmd+Option+Down" },
+      },
+    ],
+  },
+  {
+    id: "window",
+    label: "Window",
+    role: "windowMenu",
+    items: [
+      { type: "item", label: "Minimize", action: "window.minimize" },
+      { type: "item", label: "Maximize", action: "window.toggleMaximize" },
+      { type: "separator" },
+      { type: "item", label: "Close Window", action: "window.close" },
+    ],
+  },
+  {
+    id: "help",
+    label: "Help",
+    items: [
+      { type: "item", label: "NeuroCode Documentation", href: "https://neurocode.ai/docs" },
+      { type: "item", label: "Support Forum", href: "https://discord.com/invite/neurocode" },
+      { type: "item", label: "Export Logs...", command: "logs.export" },
+      { type: "separator" },
+      {
+        type: "item",
+        label: "Share Feedback",
+        href: "https://github.com/bjlamprea12-wq/NeuroAgent/issues/new?template=feature_request.yml",
+      },
+      {
+        type: "item",
+        label: "Report a Bug",
+        href: "https://github.com/bjlamprea12-wq/NeuroAgent/issues/new?template=bug_report.yml",
+      },
+    ],
+  },
+]
+
+export function desktopMenuVisible(item: { platforms?: DesktopMenuPlatform[] }, platform: DesktopMenuPlatform) {
+  return !item.platforms || item.platforms.includes(platform)
+}

package/src/entry.tsx

@@ -0,0 +1,182 @@
+// @refresh reload
+
+import * as Sentry from "@sentry/solid"
+import { render } from "solid-js/web"
+import { AppBaseProviders, AppInterface } from "@/app"
+import { type Platform, PlatformProvider } from "@/context/platform"
+import { dict as en } from "@/i18n/en"
+import { dict as zh } from "@/i18n/zh"
+import { handleNotificationClick } from "@/utils/notification-click"
+import { authFromToken } from "@/utils/server"
+import pkg from "../package.json"
+import { ServerConnection } from "./context/server"
+
+const DEFAULT_SERVER_URL_KEY = "neurocode.settings.dat:defaultServerUrl"
+
+const getLocale = () => {
+  if (typeof navigator !== "object") return "en" as const
+  const languages = navigator.languages?.length ? navigator.languages : [navigator.language]
+  for (const language of languages) {
+    if (!language) continue
+    if (language.toLowerCase().startsWith("zh")) return "zh" as const
+  }
+  return "en" as const
+}
+
+const getRootNotFoundError = () => {
+  const key = "error.dev.rootNotFound" as const
+  const locale = getLocale()
+  return locale === "zh" ? (zh[key] ?? en[key]) : en[key]
+}
+
+const getStorage = (key: string) => {
+  if (typeof localStorage === "undefined") return null
+  try {
+    return localStorage.getItem(key)
+  } catch {
+    return null
+  }
+}
+
+const setStorage = (key: string, value: string | null) => {
+  if (typeof localStorage === "undefined") return
+  try {
+    if (value !== null) {
+      localStorage.setItem(key, value)
+      return
+    }
+    localStorage.removeItem(key)
+  } catch {
+    return
+  }
+}
+
+const readDefaultServerUrl = () => getStorage(DEFAULT_SERVER_URL_KEY)
+const writeDefaultServerUrl = (url: string | null) => setStorage(DEFAULT_SERVER_URL_KEY, url)
+
+const notify: Platform["notify"] = async (title, description, href) => {
+  if (!("Notification" in window)) return
+
+  const permission =
+    Notification.permission === "default"
+      ? await Notification.requestPermission().catch(() => "denied")
+      : Notification.permission
+
+  if (permission !== "granted") return
+
+  const inView = document.visibilityState === "visible" && document.hasFocus()
+  if (inView) return
+
+  const notification = new Notification(title, {
+    body: description ?? "",
+    icon: "https://neurocode.ai/favicon-96x96-v3.png",
+  })
+
+  notification.onclick = () => {
+    handleNotificationClick(href)
+    notification.close()
+  }
+}
+
+const openLink: Platform["openLink"] = (url) => {
+  window.open(url, "_blank")
+}
+
+const back: Platform["back"] = () => {
+  window.history.back()
+}
+
+const forward: Platform["forward"] = () => {
+  window.history.forward()
+}
+
+const restart: Platform["restart"] = async () => {
+  window.location.reload()
+}
+
+const root = document.getElementById("root")
+if (!(root instanceof HTMLElement) && import.meta.env.DEV) {
+  throw new Error(getRootNotFoundError())
+}
+
+const getCurrentUrl = () => {
+  if (location.hostname.includes("neurocode.ai")) return "http://localhost:4096"
+  if (import.meta.env.DEV)
+    return `http://${import.meta.env.VITE_NEUROCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_NEUROCODE_SERVER_PORT ?? "4096"}`
+  return location.origin
+}
+
+const getDefaultUrl = () => {
+  const lsDefault = readDefaultServerUrl()
+  if (lsDefault) return lsDefault
+  return getCurrentUrl()
+}
+
+const clearAuthToken = () => {
+  const params = new URLSearchParams(location.search)
+  if (!params.has("auth_token")) return
+  params.delete("auth_token")
+  history.replaceState(null, "", location.pathname + (params.size ? `?${params}` : "") + location.hash)
+}
+
+const platform: Platform = {
+  platform: "web",
+  version: pkg.version,
+  openLink,
+  back,
+  forward,
+  restart,
+  notify,
+  getDefaultServer: async () => {
+    const stored = readDefaultServerUrl()
+    return stored ? ServerConnection.Key.make(stored) : null
+  },
+  setDefaultServer: writeDefaultServerUrl,
+}
+
+if (import.meta.env.VITE_SENTRY_DSN) {
+  Sentry.init({
+    dsn: import.meta.env.VITE_SENTRY_DSN,
+    environment: import.meta.env.VITE_SENTRY_ENVIRONMENT ?? import.meta.env.MODE,
+    release: import.meta.env.VITE_SENTRY_RELEASE ?? `web@${pkg.version}`,
+    initialScope: {
+      tags: {
+        platform: "web",
+      },
+    },
+    integrations: (integrations) => {
+      return integrations.filter(
+        (i) =>
+          i.name !== "Breadcrumbs" && !(import.meta.env.NEUROCODE_CHANNEL === "prod" && i.name === "GlobalHandlers"),
+      )
+    },
+  })
+}
+
+if (root instanceof HTMLElement) {
+  const auth = authFromToken(new URLSearchParams(location.search).get("auth_token"))
+  clearAuthToken()
+  const server: ServerConnection.Http = {
+    type: "http",
+    authToken: !!auth,
+    http: {
+      url: getCurrentUrl(),
+      ...auth,
+    },
+  }
+  render(
+    () => (
+      <PlatformProvider value={platform}>
+        <AppBaseProviders>
+          <AppInterface
+            defaultServer={ServerConnection.Key.make(getDefaultUrl())}
+            canonicalLocalServer={ServerConnection.key(server)}
+            servers={[server]}
+            disableHealthCheck
+          />
+        </AppBaseProviders>
+      </PlatformProvider>
+    ),
+    root,
+  )
+}

package/src/env.d.ts

@@ -0,0 +1,31 @@
+interface ImportMetaEnv {
+  readonly VITE_NEUROCODE_SERVER_HOST: string
+  readonly VITE_NEUROCODE_SERVER_PORT: string
+  readonly VITE_NEUROCODE_CHANNEL?: "dev" | "beta" | "prod"
+
+  readonly VITE_SENTRY_DSN?: string
+  readonly VITE_SENTRY_ENVIRONMENT?: string
+  readonly VITE_SENTRY_RELEASE?: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+declare module "*.png" {
+  const src: string
+  export default src
+}
+
+declare module "*.mp4" {
+  const src: string
+  export default src
+}
+
+export declare module "solid-js" {
+  namespace JSX {
+    interface Directives {
+      sortable: true
+    }
+  }
+}

package/src/hooks/provider-catalog.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test"
+import type { NormalizedProviderListResponse } from "@neurocode-ai/session-ui/context"
+import { selectProviderCatalog } from "./provider-catalog"
+
+const catalog = (id: string): NormalizedProviderListResponse => ({
+  all: new Map([[id, { id, name: id, source: "api", env: [], options: {}, models: {} }]]),
+  connected: [id],
+  default: { [id]: `${id}-model` },
+})
+
+test("selects the ready catalog for an explicit directory", () => {
+  const directory = catalog("directory")
+
+  expect(
+    selectProviderCatalog({
+      explicit: true,
+      directory: "/repo",
+      catalog: { ready: true, providers: directory },
+    }),
+  ).toBe(directory)
+})
+
+test("returns an empty catalog while an explicit directory is unresolved", () => {
+  expect(selectProviderCatalog({ explicit: true })).toEqual({ all: new Map(), connected: [], default: {} })
+  expect(
+    selectProviderCatalog({
+      explicit: true,
+      directory: "/repo",
+      catalog: { ready: false, providers: catalog("directory") },
+    }),
+  ).toEqual({ all: new Map(), connected: [], default: {} })
+})
+
+test("uses the route catalog when it is ready", () => {
+  const directory = catalog("directory")
+
+  expect(
+    selectProviderCatalog({
+      explicit: false,
+      directory: "/repo",
+      catalog: { ready: true, providers: directory },
+      global: catalog("global"),
+    }),
+  ).toBe(directory)
+})
+
+test("falls back to the global catalog for route consumers", () => {
+  const global = catalog("global")
+
+  expect(selectProviderCatalog({ explicit: false, global })).toBe(global)
+  expect(
+    selectProviderCatalog({
+      explicit: false,
+      directory: "/repo",
+      catalog: { ready: false, providers: catalog("directory") },
+      global,
+    }),
+  ).toBe(global)
+})

package/src/hooks/provider-catalog.ts

@@ -0,0 +1,27 @@
+import type { NormalizedProviderListResponse } from "@neurocode-ai/session-ui/context"
+
+const emptyProviderCatalog: NormalizedProviderListResponse = { all: new Map(), connected: [], default: {} }
+
+type DirectoryCatalog = {
+  ready: boolean
+  providers: NormalizedProviderListResponse
+}
+
+type ProviderCatalogInput =
+  | {
+      explicit: true
+      directory?: string
+      catalog?: DirectoryCatalog
+    }
+  | {
+      explicit: false
+      directory?: string
+      catalog?: DirectoryCatalog
+      global: NormalizedProviderListResponse
+    }
+
+export function selectProviderCatalog(input: ProviderCatalogInput) {
+  if (input.directory && input.catalog?.ready) return input.catalog.providers
+  if (input.explicit) return emptyProviderCatalog
+  return input.global
+}

package/src/hooks/use-providers.ts

@@ -0,0 +1,71 @@
+import { useServerSync } from "@/context/server-sync"
+import { decode64 } from "@/utils/base64"
+import { useParams } from "@solidjs/router"
+import { Iterable, pipe } from "effect"
+import type { Accessor } from "solid-js"
+import { selectProviderCatalog } from "./provider-catalog"
+
+export const popularProviders = [
+  "neurocode",
+  "neurocode-go",
+  "anthropic",
+  "github-copilot",
+  "openai",
+  "google",
+  "openrouter",
+  "vercel",
+]
+const popularProviderSet = new Set(popularProviders)
+
+export function useProviders(directory?: Accessor<string | undefined>) {
+  const serverSync = useServerSync()
+  const params = useParams()
+  const dir = () => (directory ? directory() : decode64(params.dir))
+  const providers = () => {
+    const value = dir()
+    const projectStore = value ? serverSync().child(value)[0] : undefined
+    if (directory)
+      return selectProviderCatalog({
+        explicit: true,
+        directory: value,
+        catalog: projectStore && { ready: projectStore.provider_ready, providers: projectStore.provider },
+      })
+    return selectProviderCatalog({
+      explicit: false,
+      directory: value,
+      catalog: projectStore && { ready: projectStore.provider_ready, providers: projectStore.provider },
+      global: serverSync().data.provider,
+    })
+  }
+  return {
+    all: () => providers().all,
+    default: () => providers().default,
+    popular: () =>
+      pipe(
+        providers().all,
+        Iterable.map(([, p]) => p),
+        Iterable.filter((p) => popularProviderSet.has(p.id)),
+        (v) => Array.from(v),
+      ),
+    connected: () => {
+      const connected = new Set(providers().connected)
+      return pipe(
+        providers().all,
+        Iterable.map(([, p]) => p),
+        Iterable.filter((p) => connected.has(p.id)),
+        (v) => Array.from(v),
+      )
+    },
+    paid: () => {
+      const connected = new Set(providers().connected)
+      return [
+        ...Iterable.filter(
+          providers().all,
+          ([id]) =>
+            connected.has(id) &&
+            (id !== "neurocode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
+        ),
+      ]
+    },
+  }
+}