tulingcode 0.1.0

package/src/plugin/meta.ts

@@ -0,0 +1,188 @@
+import path from "path"
+import { fileURLToPath } from "url"
+
+import { Flag } from "@/flag/flag"
+import { Global } from "@/global"
+import { Filesystem } from "@/util"
+import { Flock } from "@tuling-ai/shared/util/flock"
+
+import { parsePluginSpecifier, pluginSource } from "./shared"
+
+type Source = "file" | "npm"
+
+export type Theme = {
+  src: string
+  dest: string
+  mtime?: number
+  size?: number
+}
+
+export type Entry = {
+  id: string
+  source: Source
+  spec: string
+  target: string
+  requested?: string
+  version?: string
+  modified?: number
+  first_time: number
+  last_time: number
+  time_changed: number
+  load_count: number
+  fingerprint: string
+  themes?: Record<string, Theme>
+}
+
+export type State = "first" | "updated" | "same"
+
+export type Touch = {
+  spec: string
+  target: string
+  id: string
+}
+
+type Store = Record<string, Entry>
+type Core = Omit<Entry, "first_time" | "last_time" | "time_changed" | "load_count" | "fingerprint" | "themes">
+type Row = Touch & { core: Core }
+
+function storePath() {
+  return Flag.tulingcode_PLUGIN_META_FILE ?? path.join(Global.Path.state, "plugin-meta.json")
+}
+
+function lock(file: string) {
+  return `plugin-meta:${file}`
+}
+
+function fileTarget(spec: string, target: string) {
+  if (spec.startsWith("file://")) return fileURLToPath(spec)
+  if (target.startsWith("file://")) return fileURLToPath(target)
+  return
+}
+
+async function modifiedAt(file: string) {
+  const stat = await Filesystem.statAsync(file)
+  if (!stat) return
+  const mtime = stat.mtimeMs
+  return Math.floor(typeof mtime === "bigint" ? Number(mtime) : mtime)
+}
+
+function resolvedTarget(target: string) {
+  if (target.startsWith("file://")) return fileURLToPath(target)
+  return target
+}
+
+async function npmVersion(target: string) {
+  const resolved = resolvedTarget(target)
+  const stat = await Filesystem.statAsync(resolved)
+  const dir = stat?.isDirectory() ? resolved : path.dirname(resolved)
+  return Filesystem.readJson<{ version?: string }>(path.join(dir, "package.json"))
+    .then((item) => item.version)
+    .catch(() => undefined)
+}
+
+async function entryCore(item: Touch): Promise<Core> {
+  const spec = item.spec
+  const target = item.target
+  const source = pluginSource(spec)
+  if (source === "file") {
+    const file = fileTarget(spec, target)
+    return {
+      id: item.id,
+      source,
+      spec,
+      target,
+      modified: file ? await modifiedAt(file) : undefined,
+    }
+  }
+
+  return {
+    id: item.id,
+    source,
+    spec,
+    target,
+    requested: parsePluginSpecifier(spec).version,
+    version: await npmVersion(target),
+  }
+}
+
+function fingerprint(value: Core) {
+  if (value.source === "file") return [value.target, value.modified ?? ""].join("|")
+  return [value.target, value.requested ?? "", value.version ?? ""].join("|")
+}
+
+async function read(file: string): Promise<Store> {
+  return Filesystem.readJson<Store>(file).catch(() => ({}) as Store)
+}
+
+async function row(item: Touch): Promise<Row> {
+  return {
+    ...item,
+    core: await entryCore(item),
+  }
+}
+
+function next(prev: Entry | undefined, core: Core, now: number): { state: State; entry: Entry } {
+  const entry: Entry = {
+    ...core,
+    first_time: prev?.first_time ?? now,
+    last_time: now,
+    time_changed: prev?.time_changed ?? now,
+    load_count: (prev?.load_count ?? 0) + 1,
+    fingerprint: fingerprint(core),
+    themes: prev?.themes,
+  }
+  const state: State = !prev ? "first" : prev.fingerprint === entry.fingerprint ? "same" : "updated"
+  if (state === "updated") entry.time_changed = now
+  return {
+    state,
+    entry,
+  }
+}
+
+export async function touchMany(items: Touch[]): Promise<Array<{ state: State; entry: Entry }>> {
+  if (!items.length) return []
+  const file = storePath()
+  const rows = await Promise.all(items.map((item) => row(item)))
+
+  return Flock.withLock(lock(file), async () => {
+    const store = await read(file)
+    const now = Date.now()
+    const out: Array<{ state: State; entry: Entry }> = []
+    for (const item of rows) {
+      const hit = next(store[item.id], item.core, now)
+      store[item.id] = hit.entry
+      out.push(hit)
+    }
+    await Filesystem.writeJson(file, store)
+    return out
+  })
+}
+
+export async function touch(spec: string, target: string, id: string): Promise<{ state: State; entry: Entry }> {
+  return touchMany([{ spec, target, id }]).then((item) => {
+    const hit = item[0]
+    if (hit) return hit
+    throw new Error("Failed to touch plugin metadata.")
+  })
+}
+
+export async function setTheme(id: string, name: string, theme: Theme): Promise<void> {
+  const file = storePath()
+  await Flock.withLock(lock(file), async () => {
+    const store = await read(file)
+    const entry = store[id]
+    if (!entry) return
+    entry.themes = {
+      ...entry.themes,
+      [name]: theme,
+    }
+    await Filesystem.writeJson(file, store)
+  })
+}
+
+export async function list(): Promise<Store> {
+  const file = storePath()
+  return Flock.withLock(lock(file), async () => read(file))
+}
+
+export * as PluginMeta from "./meta"

package/src/plugin/mimo-free.ts

@@ -0,0 +1,153 @@
+import type { Hooks, PluginInput } from "@tuling-ai/plugin"
+import { Log } from "../util"
+import { Global } from "../global"
+import crypto from "crypto"
+import os from "os"
+import path from "path"
+import fs from "fs"
+
+const log = Log.create({ service: "plugin.mimo-free" })
+
+const DEFAULT_BASE_URL = "https://api.xiaomimimo.com/"
+const BASE_URL = (process.env.MIMO_FREE_BASE_URL || DEFAULT_BASE_URL).replace(/\/+$/, "")
+const BOOTSTRAP_URL = `${BASE_URL}/api/free-ai/bootstrap`
+const CHAT_BASE_URL = `${BASE_URL}/api/free-ai/openai`
+
+let fingerprintCache: string | undefined
+function getClientFingerprint(): string {
+  if (fingerprintCache) return fingerprintCache
+  const file = path.join(Global.Path.data, "mimo-free-client")
+  try {
+    const existing = fs.readFileSync(file, "utf-8").trim()
+    if (existing) {
+      fingerprintCache = existing
+      return existing
+    }
+  } catch {}
+  const cpu = os.cpus()[0]?.model ?? "unknown-cpu"
+  const username = (() => {
+    try {
+      return os.userInfo().username
+    } catch {
+      return "unknown-user"
+    }
+  })()
+  const seed = [os.hostname(), process.platform, process.arch, cpu, username].join("|")
+  const fingerprint = crypto.createHash("sha256").update(seed).digest("hex")
+  try {
+    fs.writeFileSync(file, fingerprint, { mode: 0o600 })
+  } catch (err) {
+    log.warn("could not persist fingerprint", { error: err })
+  }
+  fingerprintCache = fingerprint
+  return fingerprint
+}
+
+let cached: { jwt: string; exp: number } | null = null
+let inflight: Promise<{ jwt: string; exp: number }> | null = null
+
+function parseExp(jwt: string): number {
+  const parts = jwt.split(".")
+  if (parts.length < 2) return Date.now() + 50 * 60_000
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf-8"))
+    if (typeof payload.exp === "number") return payload.exp * 1000
+  } catch {}
+  return Date.now() + 50 * 60_000
+}
+
+async function bootstrap(): Promise<{ jwt: string; exp: number }> {
+  const res = await fetch(BOOTSTRAP_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ client: getClientFingerprint() }),
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => "")
+    throw new Error(`mimo-free bootstrap failed: ${res.status} ${body.slice(0, 200)}`)
+  }
+  const data = (await res.json()) as { jwt?: string }
+  if (!data.jwt) throw new Error("mimo-free bootstrap response missing jwt")
+  return { jwt: data.jwt, exp: parseExp(data.jwt) }
+}
+
+const JWT_REFRESH_BUFFER_MS = 5 * 60_000
+
+async function getJwt(): Promise<string> {
+  if (cached && cached.exp - Date.now() > JWT_REFRESH_BUFFER_MS) return cached.jwt
+  if (inflight) return (await inflight).jwt
+  cached = null
+  inflight = bootstrap()
+  try {
+    cached = await inflight
+    return cached.jwt
+  } finally {
+    inflight = null
+  }
+}
+
+export const MimoFree = {
+  baseUrl: BASE_URL,
+  bootstrapUrl: BOOTSTRAP_URL,
+  chatBaseUrl: CHAT_BASE_URL,
+  fingerprint: () => getClientFingerprint(),
+  async verify() {
+    cached = null
+    const result = await bootstrap()
+    cached = result
+    return { jwt: result.jwt, exp: result.exp, fingerprint: getClientFingerprint() }
+  },
+}
+
+function buildHeaders(init: any, jwt: string): Headers {
+  const headers = new Headers(init?.headers)
+  headers.set("Authorization", `Bearer ${jwt}`)
+  headers.set("X-Mimo-Source", "tulingcode-cli-free")
+  return headers
+}
+
+async function wrappedFetch(input: any, init?: any): Promise<Response> {
+  const url = typeof input === "string" || input instanceof URL ? String(input) : input.url
+  const rewritten = url.replace(/\/chat\/completions(\?|$)/, "/chat$1")
+
+  const jwt = await getJwt()
+  const response = await fetch(rewritten, { ...init, headers: buildHeaders(init, jwt) })
+  if (response.status !== 401 && response.status !== 403) return response
+
+  cached = null
+  const retryJwt = await getJwt()
+  return fetch(rewritten, { ...init, headers: buildHeaders(init, retryJwt) })
+}
+
+export async function MimoFreeAuthPlugin(_input: PluginInput): Promise<Hooks> {
+  return {
+    config: async (input) => {
+      input.provider ??= {}
+      input.provider.mimo ??= {
+        name: "MiMo Auto (free)",
+        npm: "@ai-sdk/openai-compatible",
+        api: CHAT_BASE_URL,
+        options: {
+          apiKey: "anonymous",
+          fetch: wrappedFetch,
+        },
+        models: {
+          "mimo-auto": {
+            name: "MiMo Auto",
+            attachment: true,
+            reasoning: true,
+            tool_call: true,
+            temperature: true,
+            modalities: { input: ["text", "image"], output: ["text"] },
+            limit: { context: 1_000_000, output: 128_000 },
+            cost: { input: 0, output: 0 },
+          },
+        },
+      }
+      input.disabled_providers ??= []
+      for (const id of ["opencode", "tulingcode-go"]) {
+        if (!input.disabled_providers.includes(id)) input.disabled_providers.push(id)
+      }
+    },
+  }
+}

package/src/plugin/mimo.ts

@@ -0,0 +1,124 @@
+import type { Hooks, PluginInput } from "@tuling-ai/plugin"
+import { Log } from "../util"
+import { createServer } from "http"
+import crypto from "crypto"
+import { exec } from "child_process"
+import { Global } from "../global"
+import path from "path"
+import fs from "fs"
+
+const log = Log.create({ service: "plugin.mimo" })
+
+const PLATFORM_URL = process.env.MIMO_PLATFORM_URL || "https://platform.xiaomimimo.com"
+
+function getKeyName(): string {
+  const filePath = path.join(Global.Path.data, "mimo-key-name")
+  try {
+    const existing = fs.readFileSync(filePath, "utf-8").trim()
+    if (existing) return existing
+  } catch {}
+  const name = `TulingCode-cli-key-${crypto.randomBytes(4).toString("hex")}`
+  fs.writeFileSync(filePath, name)
+  return name
+}
+
+function generateKeyPair() {
+  const keyPair = crypto.generateKeyPairSync("x25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" },
+  })
+  const publicKeyBase64 = Buffer.from(keyPair.publicKey).toString("base64url")
+  return { publicKey: publicKeyBase64, privateKeyDer: keyPair.privateKey }
+}
+
+function decrypt(privateKeyDer: Buffer, encryptedBase64: string): { sk?: string; uid: string; url?: string } {
+  const encrypted = Buffer.from(encryptedBase64, "base64url")
+  // Format: ephemeralPublicKey(32 bytes) + nonce(12 bytes) + ciphertext + tag(16 bytes)
+  const ephemeralPub = encrypted.subarray(0, 32)
+  const nonce = encrypted.subarray(32, 44)
+  const ciphertextAndTag = encrypted.subarray(44)
+  const tag = ciphertextAndTag.subarray(ciphertextAndTag.length - 16)
+  const ciphertext = ciphertextAndTag.subarray(0, ciphertextAndTag.length - 16)
+
+  const privateKey = crypto.createPrivateKey({ key: privateKeyDer, format: "der", type: "pkcs8" })
+  const ephemeralPublicKey = crypto.createPublicKey({
+    key: Buffer.concat([Buffer.from("302a300506032b656e032100", "hex"), ephemeralPub]),
+    format: "der",
+    type: "spki",
+  })
+
+  const sharedSecret = crypto.diffieHellman({ privateKey, publicKey: ephemeralPublicKey })
+  const derivedKey = crypto.createHash("sha256").update(sharedSecret).digest()
+
+  const decipher = crypto.createDecipheriv("aes-256-gcm", derivedKey, nonce)
+  decipher.setAuthTag(tag)
+  const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()])
+
+  return JSON.parse(decrypted.toString("utf-8"))
+}
+
+function openBrowser(url: string) {
+  const command =
+    process.platform === "darwin"
+      ? `open "${url}"`
+      : process.platform === "win32"
+        ? `start "" "${url}"`
+        : `xdg-open "${url}"`
+  exec(command, (error) => {
+    if (error) {
+      log.warn("could not open browser automatically", { error })
+    }
+  })
+}
+
+function buildAuthorizeUrl(publicKey: string, redirectUri: string): string {
+  const params = new URLSearchParams({
+    pk: publicKey,
+    redirect_uri: redirectUri,
+    kn: "tulingcode",
+    key_name: getKeyName(),
+  })
+  return `${PLATFORM_URL}/authorize?${params.toString()}`
+}
+
+export async function AnthropicProxyPlugin(_input: PluginInput): Promise<Hooks> {
+  return {
+    auth: {
+      provider: "anthropic",
+      async loader(_getAuth, provider) {
+        if (!provider?.options?.baseURL) return {}
+        return {
+          async fetch(url: any, init: any) {
+            if (init?.headers && typeof init.headers === "object" && !Array.isArray(init.headers)) {
+              delete init.headers["anthropic-beta"]
+            }
+            const res = await fetch(url, init)
+            if (!res.body || !res.headers.get("content-type")?.includes("text/event-stream")) return res
+            const reader = res.body.getReader()
+            const decoder = new TextDecoder()
+            let done = false
+            let buffer = ""
+            const body = new ReadableStream<Uint8Array>({
+              async pull(ctrl) {
+                if (done) { ctrl.close(); return }
+                const chunk = await reader.read()
+                if (chunk.done) { ctrl.close(); return }
+                ctrl.enqueue(chunk.value)
+                buffer += decoder.decode(chunk.value, { stream: true })
+                if (buffer.includes("\nevent: message_stop\n") || buffer.includes("\ndata: {\"type\":\"message_stop\"}")) {
+                  done = true
+                  void reader.cancel()
+                  ctrl.close()
+                }
+                if (buffer.length > 512) buffer = buffer.slice(-256)
+              },
+              cancel() { reader.cancel() },
+            })
+            return new Response(body, { headers: res.headers, status: res.status })
+          },
+        }
+      },
+      methods: [],
+    },
+  }
+}