kaizenai 0.1.0

package/src/server/project-icon.ts

@@ -0,0 +1,344 @@
+import { readdirSync, readFileSync, statSync } from "node:fs"
+import path from "node:path"
+import { PROJECT_METADATA_DIR_NAME } from "../shared/branding"
+import { resolveLocalPath } from "./paths"
+import { getProjectMetadataCandidateRelativePath } from "./project-metadata"
+
+const MAX_ICON_BYTES = 128 * 1024
+const ICON_CANDIDATE_PATHS = [
+  "icon.svg",
+  "icon.png",
+  "icon.jpg",
+  "icon.jpeg",
+  "icon.webp",
+  "icon.gif",
+  "icon.avif",
+  "icon.ico",
+  getProjectMetadataCandidateRelativePath("icon.svg"),
+  getProjectMetadataCandidateRelativePath("icon.png"),
+  getProjectMetadataCandidateRelativePath("icon.jpg"),
+  getProjectMetadataCandidateRelativePath("icon.jpeg"),
+  getProjectMetadataCandidateRelativePath("icon.webp"),
+  getProjectMetadataCandidateRelativePath("icon.gif"),
+  getProjectMetadataCandidateRelativePath("icon.avif"),
+  getProjectMetadataCandidateRelativePath("icon.ico"),
+  "favicon.svg",
+  "favicon.png",
+  "favicon.jpg",
+  "favicon.jpeg",
+  "favicon.webp",
+  "favicon.gif",
+  "favicon.avif",
+  "favicon.ico",
+  "public/favicon.svg",
+  "public/favicon.png",
+  "public/favicon.jpg",
+  "public/favicon.jpeg",
+  "public/favicon.webp",
+  "public/favicon.gif",
+  "public/favicon.avif",
+  "public/favicon.ico",
+  "public/icon.svg",
+  "public/icon.png",
+  "public/icon.jpg",
+  "public/icon.jpeg",
+  "public/icon.webp",
+  "public/icon.gif",
+  "public/icon.avif",
+  "public/icon.ico",
+  "app/favicon.svg",
+  "app/favicon.png",
+  "app/favicon.jpg",
+  "app/favicon.jpeg",
+  "app/favicon.webp",
+  "app/favicon.gif",
+  "app/favicon.avif",
+  "app/favicon.ico",
+  "app/icon.svg",
+  "app/icon.png",
+  "app/icon.jpg",
+  "app/icon.jpeg",
+  "app/icon.webp",
+  "app/icon.gif",
+  "app/icon.avif",
+  "app/icon.ico",
+  "src/favicon.svg",
+  "src/favicon.png",
+  "src/favicon.jpg",
+  "src/favicon.jpeg",
+  "src/favicon.webp",
+  "src/favicon.gif",
+  "src/favicon.avif",
+  "src/favicon.ico",
+  "src/app/favicon.svg",
+  "src/app/favicon.png",
+  "src/app/favicon.jpg",
+  "src/app/favicon.jpeg",
+  "src/app/favicon.webp",
+  "src/app/favicon.gif",
+  "src/app/favicon.avif",
+  "src/app/favicon.ico",
+  "src/app/icon.svg",
+  "src/app/icon.png",
+  "src/app/icon.jpg",
+  "src/app/icon.jpeg",
+  "src/app/icon.webp",
+  "src/app/icon.gif",
+  "src/app/icon.avif",
+  "src/app/icon.ico",
+]
+const ICON_SOURCE_FILES = [
+  "index.html",
+  "public/index.html",
+  "app/root.tsx",
+  "src/root.tsx",
+  "app/routes/__root.tsx",
+  "src/routes/__root.tsx",
+]
+const LINK_ICON_HTML_RE = /<link[^>]*rel=["'](?:icon|shortcut icon)["'][^>]*href=["']([^"'?]+)/i
+const LINK_ICON_OBJ_RE = /rel:\s*["'](?:icon|shortcut icon)["'][^}]*href:\s*["']([^"'?]+)/i
+
+function getMimeType(extension: string) {
+  switch (extension) {
+    case ".svg":
+      return "image/svg+xml"
+    case ".png":
+      return "image/png"
+    case ".ico":
+      return "image/vnd.microsoft.icon"
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg"
+    case ".webp":
+      return "image/webp"
+    case ".gif":
+      return "image/gif"
+    case ".avif":
+      return "image/avif"
+    default:
+      return null
+  }
+}
+
+function compareIconNames(a: string, b: string) {
+  const aExt = path.extname(a).toLowerCase()
+  const bExt = path.extname(b).toLowerCase()
+  const aIndex = getExtensionPriority(aExt)
+  const bIndex = getExtensionPriority(bExt)
+  if (aIndex !== bIndex) return aIndex - bIndex
+  return a.localeCompare(b)
+}
+
+function getExtensionPriority(extension: string) {
+  switch (extension) {
+    case ".svg":
+      return 0
+    case ".png":
+      return 1
+    case ".jpg":
+    case ".jpeg":
+      return 2
+    case ".webp":
+      return 3
+    case ".gif":
+      return 4
+    case ".avif":
+      return 5
+    case ".ico":
+      return 6
+    default:
+      return Number.MAX_SAFE_INTEGER
+  }
+}
+
+function findFixedIconCandidates(projectPath: string) {
+  try {
+    const existingPaths = new Map<string, string>()
+
+    for (const relativePath of ICON_CANDIDATE_PATHS) {
+      const extension = path.extname(relativePath).toLowerCase()
+      if (getMimeType(extension) === null) continue
+
+      const absolutePath = resolveCaseInsensitiveProjectPath(projectPath, relativePath)
+      if (!absolutePath) continue
+      existingPaths.set(relativePath, absolutePath)
+    }
+
+    return [...existingPaths.entries()]
+      .sort((a, b) => {
+        const pathCompare = ICON_CANDIDATE_PATHS.indexOf(a[0]) - ICON_CANDIDATE_PATHS.indexOf(b[0])
+        if (pathCompare !== 0) return pathCompare
+        return compareIconNames(a[0], b[0])
+      })
+      .map(([, absolutePath]) => absolutePath)
+  } catch {
+    return []
+  }
+}
+
+function findAppWorkspaceIconCandidates(projectPath: string) {
+  const appsPath = path.join(projectPath, "apps")
+
+  try {
+    const appDirectories = readdirSync(appsPath, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort((a, b) => a.localeCompare(b))
+
+    const existingPaths = new Map<string, string>()
+
+    for (const appDirectory of appDirectories) {
+      for (const relativePath of ICON_CANDIDATE_PATHS) {
+        if (relativePath.startsWith(`${PROJECT_METADATA_DIR_NAME}/`)) continue
+        const appRelativePath = path.join("apps", appDirectory, relativePath)
+        const extension = path.extname(appRelativePath).toLowerCase()
+        if (getMimeType(extension) === null) continue
+
+        const absolutePath = resolveCaseInsensitiveProjectPath(projectPath, appRelativePath)
+        if (!absolutePath) continue
+        existingPaths.set(appRelativePath, absolutePath)
+      }
+    }
+
+    return [...existingPaths.entries()]
+      .sort((a, b) => {
+        const [aPath] = a
+        const [bPath] = b
+        const aRelative = aPath.replace(/^apps\/[^/]+\//, "")
+        const bRelative = bPath.replace(/^apps\/[^/]+\//, "")
+        const pathCompare = ICON_CANDIDATE_PATHS.indexOf(aRelative) - ICON_CANDIDATE_PATHS.indexOf(bRelative)
+        if (pathCompare !== 0) return pathCompare
+        return compareIconNames(aPath, bPath)
+      })
+      .map(([, absolutePath]) => absolutePath)
+  } catch {
+    return []
+  }
+}
+
+function resolveCaseInsensitiveProjectPath(projectPath: string, relativePath: string) {
+  const segments = relativePath.split("/").filter(Boolean)
+  let currentPath = projectPath
+
+  for (const [index, segment] of segments.entries()) {
+    let entries: string[]
+    try {
+      entries = readdirSync(currentPath)
+    } catch {
+      return null
+    }
+
+    const matchedEntry = entries.find((entry) => entry.toLowerCase() === segment.toLowerCase())
+    if (!matchedEntry) {
+      return null
+    }
+
+    currentPath = path.join(currentPath, matchedEntry)
+
+    try {
+      const stat = statSync(currentPath)
+      const isLast = index === segments.length - 1
+      if (isLast) {
+        return stat.isFile() ? currentPath : null
+      }
+      if (!stat.isDirectory()) {
+        return null
+      }
+    } catch {
+      return null
+    }
+  }
+
+  return null
+}
+
+function extractDeclaredIconHref(source: string) {
+  const htmlMatch = source.match(LINK_ICON_HTML_RE)
+  if (htmlMatch?.[1]) return htmlMatch[1]
+  const objMatch = source.match(LINK_ICON_OBJ_RE)
+  if (objMatch?.[1]) return objMatch[1]
+  return null
+}
+
+function resolveDeclaredIconCandidates(projectPath: string, href: string) {
+  const cleanHref = href.replace(/^\//, "")
+  return [
+    path.join(projectPath, "public", cleanHref),
+    path.join(projectPath, cleanHref),
+  ]
+}
+
+function findDeclaredIconCandidates(projectPath: string) {
+  const candidates: string[] = []
+
+  for (const sourceFile of ICON_SOURCE_FILES) {
+    const sourcePath = path.join(projectPath, sourceFile)
+
+    try {
+      const source = readFileSync(sourcePath, "utf8")
+      const href = extractDeclaredIconHref(source)
+      if (!href) continue
+
+      for (const candidatePath of resolveDeclaredIconCandidates(projectPath, href)) {
+        const extension = path.extname(candidatePath).toLowerCase()
+        if (getMimeType(extension) === null) continue
+        if (!candidates.includes(candidatePath)) {
+          candidates.push(candidatePath)
+        }
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return candidates
+}
+
+function tryReadImageDataUrl(filePath: string) {
+  try {
+    const stat = statSync(filePath)
+    if (!stat.isFile() || stat.size > MAX_ICON_BYTES) {
+      return null
+    }
+
+    const extension = path.extname(filePath).toLowerCase()
+    const mimeType = getMimeType(extension)
+    if (!mimeType) {
+      return null
+    }
+
+    if (extension === ".svg") {
+      const svg = readFileSync(filePath, "utf8").trim()
+      if (!svg.includes("<svg")) {
+        return null
+      }
+
+      return `data:${mimeType};utf8,${encodeURIComponent(svg)}`
+    }
+
+    const image = readFileSync(filePath)
+    return `data:${mimeType};base64,${image.toString("base64")}`
+  } catch {
+    return null
+  }
+
+  return null
+}
+
+export function resolveProjectIconDataUrl(localPath: string): string | null {
+  const projectPath = resolveLocalPath(localPath)
+  const candidatePaths = [
+    ...findFixedIconCandidates(projectPath),
+    ...findAppWorkspaceIconCandidates(projectPath),
+    ...findDeclaredIconCandidates(projectPath),
+  ]
+
+  for (const candidatePath of candidatePaths) {
+    const dataUrl = tryReadImageDataUrl(candidatePath)
+    if (dataUrl) {
+      return dataUrl
+    }
+  }
+
+  return null
+}

package/src/server/project-metadata.ts

@@ -0,0 +1,10 @@
+import path from "node:path"
+import { PROJECT_METADATA_DIR_NAME } from "../shared/branding"
+
+export function getProjectMetadataDirPath(localPath: string) {
+  return path.join(localPath, PROJECT_METADATA_DIR_NAME)
+}
+
+export function getProjectMetadataCandidateRelativePath(fileName: string) {
+  return path.posix.join(PROJECT_METADATA_DIR_NAME, fileName)
+}

package/src/server/provider-catalog.ts

@@ -0,0 +1,85 @@
+import type {
+  AgentProvider,
+  ClaudeModelOptions,
+  ClaudeContextWindow,
+  CodexModelOptions,
+  CursorModelOptions,
+  GeminiModelOptions,
+  ModelOptions,
+  ProviderCatalogEntry,
+  ServiceTier,
+} from "../shared/types"
+import {
+  getProviderCatalog,
+  getProviderDefaultModelOptions,
+  DEFAULT_CLAUDE_MODEL_OPTIONS,
+  normalizeClaudeContextWindow,
+  isClaudeReasoningEffort,
+  isCodexReasoningEffort,
+  isGeminiThinkingMode,
+  normalizeCursorModelId,
+} from "../shared/types"
+
+export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+  return getProviderCatalog(provider)
+}
+
+export function normalizeServerModel(provider: AgentProvider, model?: string): string {
+  if (provider === "cursor") {
+    return normalizeCursorModelId(model)
+  }
+  const catalog = getServerProviderCatalog(provider)
+  if (model && catalog.models.some((candidate) => candidate.id === model)) {
+    return model
+  }
+  return catalog.defaultModel
+}
+
+export function normalizeClaudeModelOptions(
+  model: string,
+  modelOptions?: ModelOptions,
+  legacyEffort?: string
+): ClaudeModelOptions {
+  const reasoningEffort = modelOptions?.claude?.reasoningEffort
+  return {
+    reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isClaudeReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+    contextWindow: normalizeClaudeContextWindow(model, modelOptions?.claude?.contextWindow as ClaudeContextWindow | undefined),
+  }
+}
+
+export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
+  const defaultOptions = getProviderDefaultModelOptions("codex")
+  const reasoningEffort = modelOptions?.codex?.reasoningEffort
+  return {
+    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isCodexReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : defaultOptions.reasoningEffort,
+    fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
+      ? modelOptions.codex.fastMode
+      : defaultOptions.fastMode,
+  }
+}
+
+export function normalizeGeminiModelOptions(modelOptions?: ModelOptions): GeminiModelOptions {
+  const defaultOptions = getProviderDefaultModelOptions("gemini")
+  return {
+    thinkingMode: isGeminiThinkingMode(modelOptions?.gemini?.thinkingMode)
+      ? modelOptions.gemini.thinkingMode
+      : defaultOptions.thinkingMode,
+  }
+}
+
+export function normalizeCursorModelOptions(modelOptions?: ModelOptions): CursorModelOptions {
+  void modelOptions
+  return { ...getProviderDefaultModelOptions("cursor") }
+}
+
+export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
+  return modelOptions.fastMode ? "fast" : undefined
+}

package/src/server/provider-settings.ts

@@ -0,0 +1,155 @@
+import { watch, type FSWatcher } from "node:fs"
+import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import path from "node:path"
+import { getProviderSettingsFilePath, LOG_PREFIX } from "../shared/branding"
+import {
+  DEFAULT_PROVIDER_SETTINGS,
+  type AgentProvider,
+  type ProviderSettingsEntry,
+  type ProviderSettingsSnapshot,
+} from "../shared/types"
+
+const PROVIDER_IDS = Object.keys(DEFAULT_PROVIDER_SETTINGS) as AgentProvider[]
+
+type ProviderSettingsFile = Partial<Record<AgentProvider, Partial<ProviderSettingsEntry>>>
+
+export class ProviderSettingsManager {
+  readonly filePath: string
+  private watcher: FSWatcher | null = null
+  private snapshot: ProviderSettingsSnapshot
+  private readonly listeners = new Set<(snapshot: ProviderSettingsSnapshot) => void>()
+
+  constructor(filePath = getProviderSettingsFilePath(homedir())) {
+    this.filePath = filePath
+    this.snapshot = createDefaultSnapshot(this.filePath)
+  }
+
+  async initialize() {
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    const file = Bun.file(this.filePath)
+    if (!(await file.exists())) {
+      await writeFile(this.filePath, `${JSON.stringify(DEFAULT_PROVIDER_SETTINGS, null, 2)}\n`, "utf8")
+    }
+    await this.reload()
+    this.startWatching()
+  }
+
+  dispose() {
+    this.watcher?.close()
+    this.watcher = null
+    this.listeners.clear()
+  }
+
+  getSnapshot() {
+    return this.snapshot
+  }
+
+  onChange(listener: (snapshot: ProviderSettingsSnapshot) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  async reload() {
+    const nextSnapshot = await readProviderSettingsSnapshot(this.filePath)
+    this.setSnapshot(nextSnapshot)
+  }
+
+  async write(settings: ProviderSettingsSnapshot["settings"]) {
+    const nextSnapshot = normalizeProviderSettings(settings, this.filePath)
+    await mkdir(path.dirname(this.filePath), { recursive: true })
+    await writeFile(this.filePath, `${JSON.stringify(nextSnapshot.settings, null, 2)}\n`, "utf8")
+    this.setSnapshot(nextSnapshot)
+    return nextSnapshot
+  }
+
+  private setSnapshot(snapshot: ProviderSettingsSnapshot) {
+    this.snapshot = snapshot
+    for (const listener of this.listeners) {
+      listener(snapshot)
+    }
+  }
+
+  private startWatching() {
+    this.watcher?.close()
+    try {
+      this.watcher = watch(path.dirname(this.filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path.basename(this.filePath)) {
+          return
+        }
+        void this.reload().catch((error: unknown) => {
+          console.warn(`${LOG_PREFIX} Failed to reload provider settings:`, error)
+        })
+      })
+    } catch (error) {
+      console.warn(`${LOG_PREFIX} Failed to watch provider settings file:`, error)
+      this.watcher = null
+    }
+  }
+}
+
+export async function readProviderSettingsSnapshot(filePath: string): Promise<ProviderSettingsSnapshot> {
+  try {
+    const text = await readFile(filePath, "utf8")
+    if (!text.trim()) {
+      return createDefaultSnapshot(filePath, "Provider settings file was empty. Using defaults.")
+    }
+    const parsed = JSON.parse(text) as ProviderSettingsFile
+    return normalizeProviderSettings(parsed, filePath)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === "ENOENT") {
+      return createDefaultSnapshot(filePath)
+    }
+    if (error instanceof SyntaxError) {
+      return createDefaultSnapshot(filePath, "Provider settings file is invalid JSON. Using defaults.")
+    }
+    throw error
+  }
+}
+
+export function normalizeProviderSettings(
+  value: ProviderSettingsFile | null | undefined,
+  filePath = getProviderSettingsFilePath(homedir())
+): ProviderSettingsSnapshot {
+  const source = value && typeof value === "object" && !Array.isArray(value) ? value : {}
+
+  const settings = {} as ProviderSettingsSnapshot["settings"]
+  for (const provider of PROVIDER_IDS) {
+    const rawValue = source[provider]
+    const defaultValue = DEFAULT_PROVIDER_SETTINGS[provider]
+
+    settings[provider] = {
+      active: typeof rawValue?.active === "boolean" ? rawValue.active : defaultValue.active,
+    }
+  }
+
+  return {
+    settings,
+    warning: null,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function createDefaultSnapshot(filePath: string, warning: string | null = null): ProviderSettingsSnapshot {
+  return {
+    settings: {
+      claude: { ...DEFAULT_PROVIDER_SETTINGS.claude },
+      codex: { ...DEFAULT_PROVIDER_SETTINGS.codex },
+      gemini: { ...DEFAULT_PROVIDER_SETTINGS.gemini },
+      cursor: { ...DEFAULT_PROVIDER_SETTINGS.cursor },
+    },
+    warning,
+    filePathDisplay: formatDisplayPath(filePath),
+  }
+}
+
+function formatDisplayPath(filePath: string) {
+  const homePath = homedir()
+  if (filePath === homePath) return "~"
+  if (filePath.startsWith(`${homePath}${path.sep}`)) {
+    return `~${filePath.slice(homePath.length)}`
+  }
+  return filePath
+}