@neurocode-ai/enterprise 1.18.8

package/README.md

@@ -0,0 +1,32 @@
+# SolidStart
+
+Everything you need to build a Solid project, powered by [`solid-start`](https://start.solidjs.com);
+
+## Creating a project
+
+```bash
+# create a new project in the current directory
+npm init solid@latest
+
+# create a new project in my-app
+npm init solid@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+## Building
+
+Solid apps are built with _presets_, which optimise your project for deployment to different environments.
+
+By default, `npm run build` will generate a Node app that you can run with `npm start`. To use a different preset, add it to the `devDependencies` in `package.json` and specify in your `app.config.js`.
+
+## This project was created with the [Solid CLI](https://github.com/solidjs-community/solid-cli)

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@neurocode-ai/enterprise",
+  "version": "1.18.8",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "dev": "vite dev",
+    "build": "vite build",
+    "build:cloudflare": "OPENCODE_DEPLOYMENT_TARGET=cloudflare vite build",
+    "start": "vite start",
+    "shell-prod": "sst shell --target Teams --stage production"
+  },
+  "dependencies": {
+    "@neurocode-ai/core": "1.18.8",
+    "@neurocode-ai/session-ui": "1.18.8",
+    "@neurocode-ai/ui": "1.18.8",
+    "aws4fetch": "^1.0.20",
+    "@pierre/diffs": "1.2.10",
+    "@solidjs/router": "0.15.4",
+    "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
+    "@solidjs/meta": "0.29.4",
+    "@hono/standard-validator": "0.2.0",
+    "hono": "4.10.7",
+    "hono-openapi": "1.1.2",
+    "js-base64": "3.7.7",
+    "luxon": "3.6.1",
+    "nitro": "3.0.1-alpha.1",
+    "solid-js": "1.9.10",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "4.20251008.0",
+    "@tailwindcss/vite": "4.1.11",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1",
+    "@types/bun": "1.3.13",
+    "@types/luxon": "3.7.1",
+    "tailwindcss": "4.1.11",
+    "typescript": "5.8.2",
+    "vite": "7.1.4"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

package/public/apple-touch-icon-v3.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/apple-touch-icon-v3.png

package/public/apple-touch-icon.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/apple-touch-icon.png

package/public/favicon-96x96-v3.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon-96x96-v3.png

package/public/favicon-96x96.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon-96x96.png

package/public/favicon-v3.ico

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon-v3.ico

package/public/favicon-v3.svg

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon-v3.svg

package/public/favicon.ico

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon.ico

package/public/favicon.svg

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/favicon.svg

package/public/site.webmanifest

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/site.webmanifest

package/public/social-share-zen.png

@@ -0,0 +1 @@
+../../ui/src/assets/images/social-share-zen.png

package/public/social-share.png

@@ -0,0 +1 @@
+../../ui/src/assets/images/social-share.png

package/public/web-app-manifest-192x192.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/web-app-manifest-192x192.png

package/public/web-app-manifest-512x512.png

@@ -0,0 +1 @@
+../../ui/src/assets/favicon/web-app-manifest-512x512.png

package/script/scrap.ts

@@ -0,0 +1,15 @@
+import { Storage } from "../src/core/storage"
+
+// read share id from args
+const args = process.argv.slice(2)
+if (args.length !== 1) {
+  console.error("Usage: bun script/scrap.ts <shareID>")
+  process.exit(1)
+}
+const shareID = args[0]
+
+await Storage.remove(["share", shareID])
+const list = await Storage.list({ prefix: ["share_data", shareID] })
+for (const item of list) {
+  await Storage.remove(item)
+}

package/src/app.css

@@ -0,0 +1,2 @@
+@import "@opencode-ai/ui/styles/tailwind";
+@import "@opencode-ai/session-ui/styles";

package/src/app.tsx

@@ -0,0 +1,94 @@
+import { Router } from "@solidjs/router"
+import { FileRoutes } from "@solidjs/start/router"
+import { Font } from "@neurocode-ai/ui/font"
+import { MetaProvider } from "@solidjs/meta"
+import { MarkedProvider } from "@neurocode-ai/ui/context/marked"
+import { DialogProvider } from "@neurocode-ai/ui/context/dialog"
+import { I18nProvider, type UiI18nParams } from "@neurocode-ai/ui/context"
+import { dict as uiEn } from "@neurocode-ai/ui/i18n/en"
+import { dict as uiZh } from "@neurocode-ai/ui/i18n/zh"
+import { createEffect, createMemo, Suspense, type ParentProps } from "solid-js"
+import { getRequestEvent } from "solid-js/web"
+import "./app.css"
+import { Favicon } from "@neurocode-ai/ui/favicon"
+
+function resolveTemplate(text: string, params?: UiI18nParams) {
+  if (!params) return text
+  return text.replace(/{{\s*([^}]+?)\s*}}/g, (_, rawKey) => {
+    const key = String(rawKey)
+    const value = params[key]
+    return value === undefined ? "" : String(value)
+  })
+}
+
+function detectLocaleFromHeader(header: string | null | undefined) {
+  if (!header) return
+  for (const item of header.split(",")) {
+    const value = item.trim().split(";")[0]?.toLowerCase()
+    if (!value) continue
+    if (value.startsWith("zh")) return "zh" as const
+    if (value.startsWith("en")) return "en" as const
+  }
+}
+
+function detectLocale() {
+  const event = getRequestEvent()
+  const header = event?.request.headers.get("accept-language")
+  const headerLocale = detectLocaleFromHeader(header)
+  if (headerLocale) return headerLocale
+
+  if (typeof document === "object") {
+    const value = document.documentElement.lang?.toLowerCase() ?? ""
+    if (value.startsWith("zh")) return "zh" as const
+    if (value.startsWith("en")) return "en" as const
+  }
+
+  if (typeof navigator === "object") {
+    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
+}
+
+function UiI18nBridge(props: ParentProps) {
+  const locale = createMemo(() => detectLocale())
+  const zh = uiZh as Partial<Record<string, string>>
+  const t = (key: keyof typeof uiEn, params?: UiI18nParams) => {
+    const value = locale() === "zh" ? (zh[key] ?? uiEn[key]) : uiEn[key]
+    const text = value ?? String(key)
+    return resolveTemplate(text, params)
+  }
+
+  createEffect(() => {
+    if (typeof document !== "object") return
+    document.documentElement.lang = locale()
+  })
+
+  return <I18nProvider value={{ locale, t }}>{props.children}</I18nProvider>
+}
+
+export default function App() {
+  return (
+    <Router
+      root={(props) => (
+        <MetaProvider>
+          <DialogProvider>
+            <MarkedProvider>
+              <Favicon />
+              <Font />
+              <UiI18nBridge>
+                <Suspense>{props.children}</Suspense>
+              </UiI18nBridge>
+            </MarkedProvider>
+          </DialogProvider>
+        </MetaProvider>
+      )}
+    >
+      <FileRoutes />
+    </Router>
+  )
+}

package/src/core/share.ts

@@ -0,0 +1,232 @@
+import { Message, Model, Part, Session, SnapshotFileDiff } from "@neurocode-ai/sdk/v2"
+import { iife } from "@neurocode-ai/core/util/iife"
+import z from "zod"
+import { Storage } from "./storage"
+
+function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
+  return (input: z.infer<T>) => cb(schema.parse(input))
+}
+
+export namespace Share {
+  export const Info = z.object({
+    id: z.string(),
+    secret: z.string(),
+    sessionID: z.string(),
+  })
+  export type Info = z.infer<typeof Info>
+
+  export const Data = z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("session"),
+      data: z.custom<Session>(),
+    }),
+    z.object({
+      type: z.literal("message"),
+      data: z.custom<Message>(),
+    }),
+    z.object({
+      type: z.literal("part"),
+      data: z.custom<Part>(),
+    }),
+    z.object({
+      type: z.literal("session_diff"),
+      data: z.custom<SnapshotFileDiff[]>(),
+    }),
+    z.object({
+      type: z.literal("model"),
+      data: z.custom<Model[]>(),
+    }),
+  ])
+  export type Data = z.infer<typeof Data>
+
+  type Snapshot = {
+    data: Data[]
+  }
+
+  type Compaction = {
+    event?: string
+    data: Data[]
+  }
+
+  function key(item: Data) {
+    switch (item.type) {
+      case "session":
+        return "session"
+      case "message":
+        return `message/${item.data.id}`
+      case "part":
+        return `part/${item.data.messageID}/${item.data.id}`
+      case "session_diff":
+        return "session_diff"
+      case "model":
+        return "model"
+    }
+  }
+
+  function merge(...items: Data[][]) {
+    const map = new Map<string, Data>()
+    for (const list of items) {
+      for (const item of list) {
+        map.set(key(item), item)
+      }
+    }
+    return Array.from(map.entries())
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([, item]) => item)
+  }
+
+  async function readSnapshot(shareID: string) {
+    return (await Storage.read<Snapshot>(["share_snapshot", shareID]))?.data
+  }
+
+  async function writeSnapshot(shareID: string, data: Data[]) {
+    await Storage.write<Snapshot>(["share_snapshot", shareID], { data })
+  }
+
+  async function legacy(shareID: string) {
+    const compaction: Compaction = (await Storage.read<Compaction>(["share_compaction", shareID])) ?? {
+      data: [],
+      event: undefined,
+    }
+    const list = await Storage.list({
+      prefix: ["share_event", shareID],
+      before: compaction.event,
+    }).then((x) => x.toReversed())
+    if (list.length === 0) {
+      if (compaction.data.length > 0) await writeSnapshot(shareID, compaction.data)
+      return compaction.data
+    }
+
+    const next = merge(
+      compaction.data,
+      await Promise.all(list.map(async (event) => await Storage.read<Data[]>(event))).then((x) =>
+        x.flatMap((item) => item ?? []),
+      ),
+    )
+
+    await Promise.all([
+      Storage.write(["share_compaction", shareID], {
+        event: list.at(-1)?.at(-1),
+        data: next,
+      }),
+      writeSnapshot(shareID, next),
+    ])
+    return next
+  }
+
+  export const create = fn(z.object({ sessionID: z.string() }), async (body) => {
+    const isTest = process.env.NODE_ENV === "test" || body.sessionID.startsWith("test_")
+    const info: Info = {
+      id: (isTest ? "test_" : "") + body.sessionID.slice(-8),
+      sessionID: body.sessionID,
+      secret: crypto.randomUUID(),
+    }
+    const exists = await get(info.id)
+    if (exists) throw new Errors.AlreadyExists(info.id)
+    await Promise.all([Storage.write(["share", info.id], info), writeSnapshot(info.id, [])])
+    return info
+  })
+
+  export async function get(id: string) {
+    return Storage.read<Info>(["share", id])
+  }
+
+  export const remove = fn(Info.pick({ id: true, secret: true }), async (body) => {
+    const share = await get(body.id)
+    if (!share) throw new Errors.NotFound(body.id)
+    if (share.secret !== body.secret) throw new Errors.InvalidSecret(body.id)
+    await Storage.remove(["share", body.id])
+    const groups = await Promise.all([
+      Storage.list({ prefix: ["share_snapshot", body.id] }),
+      Storage.list({ prefix: ["share_compaction", body.id] }),
+      Storage.list({ prefix: ["share_event", body.id] }),
+      Storage.list({ prefix: ["share_data", body.id] }),
+    ])
+    for (const item of groups.flat()) {
+      await Storage.remove(item)
+    }
+  })
+
+  export const removeAdmin = fn(Info.pick({ id: true }), async (body) => {
+    const share = await get(body.id)
+    if (!share) throw new Errors.NotFound(body.id)
+    await remove({ id: share.id, secret: share.secret })
+  })
+
+  export const sync = fn(
+    z.object({
+      share: Info.pick({ id: true, secret: true }),
+      data: Data.array(),
+    }),
+    async (input) => {
+      const share = await get(input.share.id)
+      if (!share) throw new Errors.NotFound(input.share.id)
+      if (share.secret !== input.share.secret) throw new Errors.InvalidSecret(input.share.id)
+      const data = (await readSnapshot(input.share.id)) ?? (await legacy(input.share.id))
+      await writeSnapshot(input.share.id, merge(data, input.data))
+    },
+  )
+
+  export async function data(shareID: string) {
+    return (await readSnapshot(shareID)) ?? legacy(shareID)
+  }
+
+  export const syncOld = fn(
+    z.object({
+      share: Info.pick({ id: true, secret: true }),
+      data: Data.array(),
+    }),
+    async (input) => {
+      const share = await get(input.share.id)
+      if (!share) throw new Errors.NotFound(input.share.id)
+      if (share.secret !== input.share.secret) throw new Errors.InvalidSecret(input.share.id)
+      const promises = []
+      for (const item of input.data) {
+        promises.push(
+          iife(async () => {
+            switch (item.type) {
+              case "session":
+                await Storage.write(["share_data", input.share.id, "session"], item.data)
+                break
+              case "message": {
+                const data = item.data as Message
+                await Storage.write(["share_data", input.share.id, "message", data.id], item.data)
+                break
+              }
+              case "part": {
+                const data = item.data as Part
+                await Storage.write(["share_data", input.share.id, "part", data.messageID, data.id], item.data)
+                break
+              }
+              case "session_diff":
+                await Storage.write(["share_data", input.share.id, "session_diff"], item.data)
+                break
+              case "model":
+                await Storage.write(["share_data", input.share.id, "model"], item.data)
+                break
+            }
+          }),
+        )
+      }
+      await Promise.all(promises)
+    },
+  )
+
+  export const Errors = {
+    NotFound: class extends Error {
+      constructor(public id: string) {
+        super(`Share not found: ${id}`)
+      }
+    },
+    InvalidSecret: class extends Error {
+      constructor(public id: string) {
+        super(`Share secret invalid: ${id}`)
+      }
+    },
+    AlreadyExists: class extends Error {
+      constructor(public id: string) {
+        super(`Share already exists: ${id}`)
+      }
+    },
+  }
+}

package/src/core/storage.ts

@@ -0,0 +1,129 @@
+import { AwsClient } from "aws4fetch"
+import { lazy } from "@neurocode-ai/core/util/lazy"
+
+export namespace Storage {
+  export interface Adapter {
+    read(path: string): Promise<string | undefined>
+    write(path: string, value: string): Promise<void>
+    remove(path: string): Promise<void>
+    list(options?: { prefix?: string; limit?: number; after?: string; before?: string }): Promise<string[]>
+  }
+
+  function createAdapter(client: AwsClient, endpoint: string, bucket: string): Adapter {
+    const base = `${endpoint}/${bucket}`
+    return {
+      async read(path: string): Promise<string | undefined> {
+        const response = await client.fetch(`${base}/${path}`)
+        if (response.status === 404) return undefined
+        if (!response.ok) throw new Error(`Failed to read ${path}: ${response.status}`)
+        return response.text()
+      },
+
+      async write(path: string, value: string): Promise<void> {
+        const response = await client.fetch(`${base}/${path}`, {
+          method: "PUT",
+          body: value,
+          headers: {
+            "Content-Type": "application/json",
+          },
+        })
+        if (!response.ok) throw new Error(`Failed to write ${path}: ${response.status}`)
+      },
+
+      async remove(path: string): Promise<void> {
+        const response = await client.fetch(`${base}/${path}`, {
+          method: "DELETE",
+        })
+        if (!response.ok) throw new Error(`Failed to remove ${path}: ${response.status}`)
+      },
+
+      async list(options?: { prefix?: string; limit?: number; after?: string; before?: string }): Promise<string[]> {
+        const prefix = options?.prefix || ""
+        const params = new URLSearchParams({ "list-type": "2", prefix })
+        if (options?.limit) params.set("max-keys", options.limit.toString())
+        if (options?.after) {
+          const afterPath = prefix + options.after + ".json"
+          params.set("start-after", afterPath)
+        }
+        const response = await client.fetch(`${base}?${params}`)
+        if (!response.ok) throw new Error(`Failed to list ${prefix}: ${response.status}`)
+        const xml = await response.text()
+        const keys: string[] = []
+        const regex = /<Key>([^<]+)<\/Key>/g
+        let match
+        while ((match = regex.exec(xml)) !== null) {
+          keys.push(match[1])
+        }
+        if (options?.before) {
+          const beforePath = prefix + options.before + ".json"
+          return keys.filter((key) => key < beforePath)
+        }
+        return keys
+      },
+    }
+  }
+
+  function s3(): Adapter {
+    const bucket = process.env.NEUROCODE_STORAGE_BUCKET!
+    const region = process.env.NEUROCODE_STORAGE_REGION || "us-east-1"
+    const client = new AwsClient({
+      region,
+      accessKeyId: process.env.NEUROCODE_STORAGE_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.NEUROCODE_STORAGE_SECRET_ACCESS_KEY!,
+    })
+    return createAdapter(client, `https://s3.${region}.amazonaws.com`, bucket)
+  }
+
+  function r2() {
+    const accountId = process.env.NEUROCODE_STORAGE_ACCOUNT_ID!
+    const client = new AwsClient({
+      accessKeyId: process.env.NEUROCODE_STORAGE_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.NEUROCODE_STORAGE_SECRET_ACCESS_KEY!,
+    })
+    return createAdapter(client, `https://${accountId}.r2.cloudflarestorage.com`, process.env.NEUROCODE_STORAGE_BUCKET!)
+  }
+
+  const adapter = lazy(() => {
+    const type = process.env.NEUROCODE_STORAGE_ADAPTER
+    if (type === "r2") return r2()
+    if (type === "s3") return s3()
+    throw new Error("No storage adapter configured")
+  })
+
+  function resolve(key: string[]) {
+    return key.join("/") + ".json"
+  }
+
+  export async function read<T>(key: string[]) {
+    const result = await adapter().read(resolve(key))
+    if (!result) return undefined
+    return JSON.parse(result) as T
+  }
+
+  export function write<T>(key: string[], value: T) {
+    return adapter().write(resolve(key), JSON.stringify(value))
+  }
+
+  export function remove(key: string[]) {
+    return adapter().remove(resolve(key))
+  }
+
+  export async function list(options?: { prefix?: string[]; limit?: number; after?: string; before?: string }) {
+    const p = options?.prefix ? options.prefix.join("/") + (options.prefix.length ? "/" : "") : ""
+    const result = await adapter().list({
+      prefix: p,
+      limit: options?.limit,
+      after: options?.after,
+      before: options?.before,
+    })
+    return result.map((x) => x.replace(/\.json$/, "").split("/"))
+  }
+
+  export async function update<T>(key: string[], fn: (draft: T) => void) {
+    const val = await read<T>(key)
+    if (!val) throw new Error("Not found")
+    fn(val)
+    await write(key, val)
+    return val
+  }
+}

package/src/custom-elements.d.ts

@@ -0,0 +1 @@
+../../ui/src/custom-elements.d.ts

package/src/entry-client.tsx

@@ -0,0 +1,4 @@
+// @refresh reload
+import { mount, StartClient } from "@solidjs/start/client"
+
+mount(() => <StartClient />, document.getElementById("app")!)

package/src/entry-server.tsx

@@ -0,0 +1,38 @@
+// @refresh reload
+import { createHandler, StartServer } from "@solidjs/start/server"
+import { getRequestEvent } from "solid-js/web"
+
+export default createHandler(() => (
+  <StartServer
+    document={({ assets, children, scripts }) => {
+      const lang = (() => {
+        const event = getRequestEvent()
+        const header = event?.request.headers.get("accept-language")
+        if (!header) return "en"
+        for (const item of header.split(",")) {
+          const value = item.trim().split(";")[0]?.toLowerCase()
+          if (!value) continue
+          if (value.startsWith("zh")) return "zh"
+          if (value.startsWith("en")) return "en"
+        }
+        return "en"
+      })()
+
+      return (
+        <html lang={lang}>
+          <head>
+            <meta charset="utf-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1" />
+            <title>OpenCode</title>
+            <meta name="theme-color" content="#F8F7F7" />
+            {assets}
+          </head>
+          <body class="antialiased overscroll-none text-12-regular">
+            <div id="app">{children}</div>
+            {scripts}
+          </body>
+        </html>
+      )
+    }}
+  />
+))

package/src/global.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="@solidjs/start/env" />
+
+export declare module "@solidjs/start/server" {
+  export type APIEvent = { request: Request }
+}

package/src/routes/[...404].tsx

@@ -0,0 +1,25 @@
+import { A } from "@solidjs/router"
+
+export default function NotFound() {
+  return (
+    <main class="text-center mx-auto text-gray-700 p-4">
+      <h1 class="max-6-xs text-6xl text-sky-700 font-thin uppercase my-16">Not Found</h1>
+      <p class="mt-8">
+        Visit{" "}
+        <a href="https://solidjs.com" target="_blank" class="text-sky-600 hover:underline">
+          solidjs.com
+        </a>{" "}
+        to learn how to build Solid apps.
+      </p>
+      <p class="my-4">
+        <A href="/" class="text-sky-600 hover:underline">
+          Home
+        </A>
+        {" - "}
+        <A href="/about" class="text-sky-600 hover:underline">
+          About Page
+        </A>
+      </p>
+    </main>
+  )
+}