kaizenai 0.1.0

package/src/server/attachments.ts

@@ -0,0 +1,133 @@
+import path from "node:path"
+import { mkdir, writeFile } from "node:fs/promises"
+import {
+  MAX_CHAT_ATTACHMENTS,
+  MAX_CHAT_IMAGE_BYTES,
+  SUPPORTED_CHAT_IMAGE_MIME_TYPES,
+  type ChatAttachment,
+  type ChatAttachmentUpload,
+  type ChatImageAttachment,
+  type UserPromptEntry,
+} from "../shared/types"
+
+export const ATTACHMENTS_ROUTE_PREFIX = "/attachments"
+export const MAX_CHAT_IMAGE_DATA_URL_CHARS = 14_000_000
+export const SUPPORTED_CHAT_IMAGE_MIME_TYPES_SET = new Set(SUPPORTED_CHAT_IMAGE_MIME_TYPES)
+
+const EXTENSIONS_BY_MIME_TYPE: Record<string, string> = {
+  "image/gif": ".gif",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+}
+
+export function normalizeAttachmentRelativePath(rawRelativePath: string): string | null {
+  const normalized = path.normalize(rawRelativePath).replace(/^[/\\]+/, "")
+  if (!normalized || normalized.startsWith("..") || normalized.includes("\0")) {
+    return null
+  }
+  return normalized.replace(/\\/g, "/")
+}
+
+export function resolveAttachmentPath(attachmentsDir: string, relativePath: string): string | null {
+  const normalizedRelativePath = normalizeAttachmentRelativePath(relativePath)
+  if (!normalizedRelativePath) return null
+
+  const attachmentsRoot = path.resolve(attachmentsDir)
+  const filePath = path.resolve(path.join(attachmentsRoot, normalizedRelativePath))
+  if (!filePath.startsWith(`${attachmentsRoot}${path.sep}`)) {
+    return null
+  }
+
+  return filePath
+}
+
+export function buildAttachmentPreviewUrl(relativePath: string): string {
+  return `${ATTACHMENTS_ROUTE_PREFIX}/${relativePath.split("/").map(encodeURIComponent).join("/")}`
+}
+
+function parseBase64DataUrl(dataUrl: string): { mimeType: string; bytes: Buffer } | null {
+  const match = /^data:([^,;]+)(?:;charset=[^,;]+)?;base64,([a-z0-9+/=\r\n ]+)$/i.exec(dataUrl.trim())
+  if (!match) return null
+
+  const mimeType = match[1].toLowerCase()
+  const base64 = match[2].replace(/\s+/g, "")
+  try {
+    return {
+      mimeType,
+      bytes: Buffer.from(base64, "base64"),
+    }
+  } catch {
+    return null
+  }
+}
+
+function extensionForMimeType(mimeType: string): string | null {
+  return EXTENSIONS_BY_MIME_TYPE[mimeType] ?? null
+}
+
+export async function persistChatAttachments(input: {
+  attachmentsDir: string
+  chatId: string
+  messageEntry: UserPromptEntry
+  uploads: ChatAttachmentUpload[] | undefined
+}): Promise<ChatAttachment[] | undefined> {
+  const uploads = input.uploads ?? []
+  if (uploads.length === 0) return undefined
+  if (uploads.length > MAX_CHAT_ATTACHMENTS) {
+    throw new Error(`Too many image attachments. Maximum is ${MAX_CHAT_ATTACHMENTS}.`)
+  }
+
+  const persisted: ChatImageAttachment[] = []
+
+  for (const [index, attachment] of uploads.entries()) {
+    if (attachment.type !== "image") {
+      throw new Error("Unsupported attachment type.")
+    }
+    if (!attachment.name.trim()) {
+      throw new Error("Attachment name is required.")
+    }
+    if (!attachment.mimeType.trim() || !SUPPORTED_CHAT_IMAGE_MIME_TYPES_SET.has(attachment.mimeType.toLowerCase() as typeof SUPPORTED_CHAT_IMAGE_MIME_TYPES[number])) {
+      throw new Error(`Unsupported image type: ${attachment.mimeType}`)
+    }
+    if (attachment.sizeBytes <= 0 || attachment.sizeBytes > MAX_CHAT_IMAGE_BYTES) {
+      throw new Error(`Image attachment '${attachment.name}' is empty or too large.`)
+    }
+    if (!attachment.dataUrl.trim() || attachment.dataUrl.length > MAX_CHAT_IMAGE_DATA_URL_CHARS) {
+      throw new Error(`Image attachment '${attachment.name}' payload is invalid or too large.`)
+    }
+
+    const parsed = parseBase64DataUrl(attachment.dataUrl)
+    if (!parsed || parsed.mimeType !== attachment.mimeType.toLowerCase()) {
+      throw new Error(`Invalid image attachment payload for '${attachment.name}'.`)
+    }
+    if (parsed.bytes.byteLength !== attachment.sizeBytes) {
+      throw new Error(`Image attachment '${attachment.name}' size did not match payload.`)
+    }
+
+    const extension = extensionForMimeType(parsed.mimeType)
+    if (!extension) {
+      throw new Error(`Unsupported image type: ${attachment.mimeType}`)
+    }
+
+    const relativePath = `${input.chatId}/${input.messageEntry._id}/${index}${extension}`
+    const filePath = resolveAttachmentPath(input.attachmentsDir, relativePath)
+    if (!filePath) {
+      throw new Error(`Failed to resolve persisted path for '${attachment.name}'.`)
+    }
+
+    await mkdir(path.dirname(filePath), { recursive: true })
+    await writeFile(filePath, parsed.bytes)
+
+    persisted.push({
+      type: "image",
+      id: `${input.messageEntry._id}:${index}`,
+      name: attachment.name.trim(),
+      mimeType: parsed.mimeType,
+      sizeBytes: parsed.bytes.byteLength,
+      relativePath,
+    })
+  }
+
+  return persisted
+}

package/src/server/backgrounds.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+import os from "node:os"
+
+const BACKGROUND_DIRS = [
+  path.join(os.homedir(), ".local/share/backgrounds"),
+  "/usr/share/backgrounds",
+  "/Library/Desktop Pictures",
+  path.join(os.homedir(), "Pictures"),
+  process.platform === "win32" ? "C:\\Windows\\Web\\Wallpaper" : "",
+].filter(Boolean)
+
+export interface SystemBackground {
+  id: string
+  name: string
+  url: string
+}
+
+export async function getSystemBackgrounds(): Promise<SystemBackground[]> {
+  const backgrounds: SystemBackground[] = []
+  const seen = new Set<string>()
+
+  async function scanDir(dir: string, depth = 0) {
+    if (depth > 3) return // Prevent excessive recursion depth
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true })
+      
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          await scanDir(path.join(dir, entry.name), depth + 1)
+        } else if (entry.isFile()) {
+          const ext = path.extname(entry.name).toLowerCase()
+          if (ext === ".jpg" || ext === ".jpeg" || ext === ".png" || ext === ".webp") {
+            const fullPath = path.join(dir, entry.name)
+            if (seen.has(fullPath)) continue
+            seen.add(fullPath)
+            
+            const id = Buffer.from(fullPath).toString('base64url')
+            backgrounds.push({
+              id,
+              name: entry.name,
+              url: `/api/backgrounds/${id}`
+            })
+          }
+        }
+      }
+    } catch (err) {
+      // Ignore if directory doesn't exist or is inaccessible
+    }
+  }
+
+  for (const dir of BACKGROUND_DIRS) {
+    if (!dir) continue
+    await scanDir(dir)
+  }
+  
+  return backgrounds
+}
+
+export async function resolveBackgroundPath(id: string): Promise<string | null> {
+  try {
+    const fullPath = Buffer.from(id, 'base64url').toString('utf-8')
+    const isAllowed = BACKGROUND_DIRS.some(dir => dir && fullPath.startsWith(dir))
+    if (!isAllowed) return null
+    
+    const stats = await fs.stat(fullPath)
+    if (!stats.isFile()) return null
+    
+    return fullPath
+  } catch {
+    return null
+  }
+}

package/src/server/cli-runtime.ts

@@ -0,0 +1,333 @@
+import process from "node:process"
+import { spawnSync } from "node:child_process"
+import { hasCommand, spawnDetached } from "./process-utils"
+import {
+  APP_NAME,
+  CLI_COMMAND,
+  DISABLE_SELF_UPDATE_ENV_VAR,
+  getDataDirDisplay,
+  LOG_PREFIX,
+  PACKAGE_NAME,
+} from "../shared/branding"
+import type { UpdateInstallErrorCode } from "../shared/types"
+import { PROD_SERVER_PORT } from "../shared/ports"
+import { CLI_SUPPRESS_OPEN_ONCE_ENV_VAR } from "./restart"
+
+export interface CliOptions {
+  port: number
+  host: string
+  openBrowser: boolean
+  strictPort: boolean
+}
+
+export interface CliUpdateOptions {
+  version: string
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  argv: string[]
+  command: string
+}
+
+export interface StartedCli {
+  kind: "started"
+  stop: () => Promise<void>
+}
+
+export interface RestartingCli {
+  kind: "restarting"
+  reason: "startup_update" | "ui_update"
+}
+
+export interface ExitedCli {
+  kind: "exited"
+  code: number
+}
+
+export type CliRunResult = StartedCli | RestartingCli | ExitedCli
+
+export interface CliRuntimeDeps {
+  version: string
+  bunVersion: string
+  allowSelfUpdate?: boolean
+  startServer: (options: CliOptions & {
+    update: CliUpdateOptions
+    onMigrationProgress?: (message: string) => void
+  }) => Promise<{ port: number; stop: () => Promise<void> }>
+  fetchLatestVersion: (packageName: string) => Promise<string>
+  installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  openUrl: (url: string) => void
+  log: (message: string) => void
+  warn: (message: string) => void
+}
+
+export interface UpdateInstallAttemptResult {
+  ok: boolean
+  errorCode: UpdateInstallErrorCode | null
+  userTitle: string | null
+  userMessage: string | null
+}
+
+type ParsedArgs =
+  | { kind: "run"; options: CliOptions }
+  | { kind: "help" }
+  | { kind: "version" }
+
+const MINIMUM_BUN_VERSION = "1.3.5"
+
+function printHelp() {
+  console.log(`${APP_NAME} — local-only project chat UI
+
+Usage:
+  ${CLI_COMMAND} [options]
+
+Options:
+  --port <number>      Port to listen on (default: ${PROD_SERVER_PORT})
+  --host <host>        Bind to a specific host or IP
+  --remote             Shortcut for --host 0.0.0.0
+  --strict-port        Fail instead of trying another port
+  --no-open            Don't open browser automatically
+  --version            Print version and exit
+  --help               Show this help message`)
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  let port = PROD_SERVER_PORT
+  let host = "127.0.0.1"
+  let openBrowser = true
+  let strictPort = false
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index]
+    if (arg === "--version" || arg === "-v") {
+      return { kind: "version" }
+    }
+    if (arg === "--help" || arg === "-h") {
+      return { kind: "help" }
+    }
+    if (arg === "--port") {
+      const next = argv[index + 1]
+      if (!next) throw new Error("Missing value for --port")
+      port = Number(next)
+      index += 1
+      continue
+    }
+    if (arg === "--host") {
+      const next = argv[index + 1]
+      if (!next || next.startsWith("-")) throw new Error("Missing value for --host")
+      host = next
+      index += 1
+      continue
+    }
+    if (arg === "--remote") {
+      host = "0.0.0.0"
+      continue
+    }
+    if (arg === "--no-open") {
+      openBrowser = false
+      continue
+    }
+    if (arg === "--strict-port") {
+      strictPort = true
+      continue
+    }
+    if (!arg.startsWith("-")) throw new Error(`Unexpected positional argument: ${arg}`)
+  }
+
+  return {
+    kind: "run",
+    options: {
+      port,
+      host,
+      openBrowser,
+      strictPort,
+    },
+  }
+}
+
+export function compareVersions(currentVersion: string, latestVersion: string) {
+  const currentParts = normalizeVersion(currentVersion)
+  const latestParts = normalizeVersion(latestVersion)
+  const length = Math.max(currentParts.length, latestParts.length)
+
+  for (let index = 0; index < length; index += 1) {
+    const current = currentParts[index] ?? 0
+    const latest = latestParts[index] ?? 0
+    if (current === latest) continue
+    return current < latest ? -1 : 1
+  }
+
+  return 0
+}
+
+function normalizeVersion(version: string) {
+  return version
+    .trim()
+    .replace(/^v/i, "")
+    .split("-")[0]
+    .split(".")
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part))
+}
+
+async function maybeSelfUpdate(_argv: string[], deps: CliRuntimeDeps) {
+  if (process.env[DISABLE_SELF_UPDATE_ENV_VAR] === "1") {
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} checking for updates`)
+
+  let latestVersion: string
+  try {
+    latestVersion = await deps.fetchLatestVersion(PACKAGE_NAME)
+  }
+  catch (error) {
+    deps.warn(`${LOG_PREFIX} update check failed, continuing current version`)
+    if (error instanceof Error && error.message) {
+      deps.warn(`${LOG_PREFIX} ${error.message}`)
+    }
+    return null
+  }
+
+  if (!latestVersion || compareVersions(deps.version, latestVersion) >= 0) {
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} installing ${PACKAGE_NAME}@${latestVersion}`)
+  const installResult = deps.installVersion(PACKAGE_NAME, latestVersion)
+  if (!installResult.ok) {
+    deps.warn(`${LOG_PREFIX} update failed, continuing current version`)
+    if (installResult.userMessage) {
+      deps.warn(`${LOG_PREFIX} ${installResult.userMessage}`)
+    }
+    return null
+  }
+
+  deps.log(`${LOG_PREFIX} restarting into updated version`)
+  return "startup_update"
+}
+
+export async function runCli(argv: string[], deps: CliRuntimeDeps): Promise<CliRunResult> {
+  const parsedArgs = parseArgs(argv)
+  if (parsedArgs.kind === "version") {
+    deps.log(deps.version)
+    return { kind: "exited", code: 0 }
+  }
+  if (parsedArgs.kind === "help") {
+    printHelp()
+    return { kind: "exited", code: 0 }
+  }
+  if (compareVersions(deps.bunVersion, MINIMUM_BUN_VERSION) < 0) {
+    deps.warn(`${LOG_PREFIX} Bun ${MINIMUM_BUN_VERSION}+ is required for the embedded terminal. Current Bun: ${deps.bunVersion}`)
+    return { kind: "exited", code: 1 }
+  }
+
+  if (deps.allowSelfUpdate !== false) {
+    const shouldRestart = await maybeSelfUpdate(argv, deps)
+    if (shouldRestart !== null) {
+      return { kind: "restarting", reason: shouldRestart }
+    }
+  }
+
+  const { port, stop } = await deps.startServer({
+    ...parsedArgs.options,
+    onMigrationProgress: deps.log,
+    update: {
+      version: deps.version,
+      fetchLatestVersion: deps.fetchLatestVersion,
+      installVersion: deps.installVersion,
+      argv,
+      command: CLI_COMMAND,
+    },
+  })
+  const bindHost = parsedArgs.options.host
+  const displayHost = bindHost === "127.0.0.1" || bindHost === "0.0.0.0" ? "localhost" : bindHost
+  const launchUrl = `http://${displayHost}:${port}`
+
+  deps.log(`${LOG_PREFIX} listening on http://${bindHost}:${port}`)
+  deps.log(`${LOG_PREFIX} data dir: ${getDataDirDisplay()}`)
+
+  const suppressOpenBrowser = process.env[CLI_SUPPRESS_OPEN_ONCE_ENV_VAR] === "1"
+  if (parsedArgs.options.openBrowser && !suppressOpenBrowser) {
+    deps.openUrl(launchUrl)
+  }
+
+  return {
+    kind: "started",
+    stop,
+  }
+}
+
+export function openUrl(url: string) {
+  const platform = process.platform
+  if (platform === "darwin") {
+    spawnDetached("open", [url])
+  } else if (platform === "win32") {
+    spawnDetached("cmd", ["/c", "start", "", url])
+  } else {
+    spawnDetached("xdg-open", [url])
+  }
+  console.log(`${LOG_PREFIX} opened in default browser`)
+}
+
+export async function fetchLatestPackageVersion(packageName: string) {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`)
+  if (!response.ok) {
+    throw new Error(`registry returned ${response.status}`)
+  }
+
+  const payload = await response.json() as { version?: unknown }
+  if (typeof payload.version !== "string" || !payload.version.trim()) {
+    throw new Error("registry response did not include a version")
+  }
+
+  return payload.version
+}
+
+export function classifyInstallVersionFailure(output: string): UpdateInstallAttemptResult {
+  const normalizedOutput = output.trim()
+  if (/No version matching .* found|failed to resolve/i.test(normalizedOutput)) {
+    return {
+      ok: false,
+      errorCode: "version_not_live_yet",
+      userTitle: "Update not live yet",
+      userMessage: "This update is still propagating. Try again in a few minutes.",
+    }
+  }
+
+  return {
+    ok: false,
+    errorCode: "install_failed",
+    userTitle: "Update failed",
+    userMessage: "Kaizen could not install the update. Try again later.",
+  }
+}
+
+export function installPackageVersion(packageName: string, version: string) {
+  if (!hasCommand("bun")) {
+    return {
+      ok: false,
+      errorCode: "command_missing",
+      userTitle: "Bun not found",
+      userMessage: "Kaizen could not find Bun to install the update.",
+    } satisfies UpdateInstallAttemptResult
+  }
+
+  const result = spawnSync("bun", ["install", "-g", `${packageName}@${version}`], {
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+  })
+  const stdout = result.stdout ?? ""
+  const stderr = result.stderr ?? ""
+  if (stdout) process.stdout.write(stdout)
+  if (stderr) process.stderr.write(stderr)
+  if (result.status === 0) {
+    return {
+      ok: true,
+      errorCode: null,
+      userTitle: null,
+      userMessage: null,
+    } satisfies UpdateInstallAttemptResult
+  }
+
+  return classifyInstallVersionFailure(`${stdout}\n${stderr}`)
+}

package/src/server/cli-supervisor.ts

@@ -0,0 +1,81 @@
+import process from "node:process"
+import { spawn } from "node:child_process"
+import { CLI_COMMAND, LOG_PREFIX } from "../shared/branding"
+import {
+  CLI_CHILD_ARGS_ENV_VAR,
+  CLI_CHILD_COMMAND_ENV_VAR,
+  CLI_CHILD_MODE,
+  CLI_CHILD_MODE_ENV_VAR,
+  CLI_SUPPRESS_OPEN_ONCE_ENV_VAR,
+  isUiUpdateRestart,
+  parseChildArgsEnv,
+  shouldRestartCliProcess,
+} from "./restart"
+
+interface ChildExit {
+  code: number | null
+  signal: NodeJS.Signals | null
+}
+
+function getChildProcessSpec() {
+  const command = process.env[CLI_CHILD_COMMAND_ENV_VAR] || CLI_COMMAND
+  const args = parseChildArgsEnv(process.env[CLI_CHILD_ARGS_ENV_VAR])
+  return { command, args }
+}
+
+function spawnChild(argv: string[]) {
+  const childProcess = getChildProcessSpec()
+  const suppressOpenThisChild = suppressOpenOnNextChild
+  suppressOpenOnNextChild = false
+  return new Promise<ChildExit>((resolve, reject) => {
+    const child = spawn(childProcess.command, [...childProcess.args, ...argv], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        [CLI_CHILD_MODE_ENV_VAR]: CLI_CHILD_MODE,
+        ...(suppressOpenThisChild ? { [CLI_SUPPRESS_OPEN_ONCE_ENV_VAR]: "1" } : {}),
+      },
+    })
+
+    const forwardSignal = (signal: NodeJS.Signals) => {
+      if (child.exitCode !== null) return
+      child.kill(signal)
+    }
+
+    const onSigint = () => {
+      forwardSignal("SIGINT")
+    }
+    const onSigterm = () => {
+      forwardSignal("SIGTERM")
+    }
+
+    process.on("SIGINT", onSigint)
+    process.on("SIGTERM", onSigterm)
+
+    child.once("error", (error) => {
+      process.off("SIGINT", onSigint)
+      process.off("SIGTERM", onSigterm)
+      reject(error)
+    })
+
+    child.once("exit", (code, signal) => {
+      process.off("SIGINT", onSigint)
+      process.off("SIGTERM", onSigterm)
+      resolve({ code, signal })
+    })
+  })
+}
+
+const argv = process.argv.slice(2)
+let suppressOpenOnNextChild = false
+
+while (true) {
+  const result = await spawnChild(argv)
+  if (shouldRestartCliProcess(result.code, result.signal)) {
+    suppressOpenOnNextChild = isUiUpdateRestart(result.code, result.signal)
+    console.log(`${LOG_PREFIX} supervisor restarting ${CLI_COMMAND} in the same terminal session`)
+    continue
+  }
+
+  process.exit(result.code ?? (result.signal ? 1 : 0))
+}

package/src/server/cli.ts

@@ -0,0 +1,68 @@
+import { existsSync } from "node:fs"
+import process from "node:process"
+import { LOG_PREFIX } from "../shared/branding"
+import {
+  fetchLatestPackageVersion,
+  installPackageVersion,
+  openUrl,
+  runCli,
+} from "./cli-runtime"
+import { CLI_STARTUP_UPDATE_RESTART_EXIT_CODE, CLI_UI_UPDATE_RESTART_EXIT_CODE } from "./restart"
+import { startKaizenServer } from "./server"
+
+// Read version from package.json at the package root
+const packageRootUrl = new URL("../../", import.meta.url)
+const pkg = await Bun.file(new URL("package.json", packageRootUrl)).json()
+const VERSION: string = pkg.version ?? "0.0.0"
+const ALLOW_SELF_UPDATE = !existsSync(new URL(".git", packageRootUrl))
+
+const argv = process.argv.slice(2)
+let resolveExitAction: ((action: "ui_restart" | "exit") => void) | null = null
+
+const result = await runCli(argv, {
+  version: VERSION,
+  bunVersion: Bun.version,
+  allowSelfUpdate: ALLOW_SELF_UPDATE,
+  startServer: async (options) => {
+    const started = await startKaizenServer(options)
+    if (started.updateManager && options.update) {
+      started.updateManager.onChange((snapshot) => {
+        if (snapshot.status !== "restart_pending") return
+        console.log(`${LOG_PREFIX} update installed, shutting down current process for restart`)
+        resolveExitAction?.("ui_restart")
+      })
+    }
+
+    return started
+  },
+  fetchLatestVersion: fetchLatestPackageVersion,
+  installVersion: installPackageVersion,
+  openUrl,
+  log: console.log,
+  warn: console.warn,
+})
+
+if (result.kind === "exited") {
+  process.exit(result.code)
+}
+
+if (result.kind === "restarting") {
+  process.exit(result.reason === "startup_update" ? CLI_STARTUP_UPDATE_RESTART_EXIT_CODE : CLI_UI_UPDATE_RESTART_EXIT_CODE)
+}
+
+const exitAction = await new Promise<"ui_restart" | "exit">((resolve) => {
+  resolveExitAction = resolve
+
+  const shutdown = () => {
+    resolve("exit")
+  }
+
+  process.once("SIGINT", shutdown)
+  process.once("SIGTERM", shutdown)
+})
+
+await result.stop()
+if (exitAction === "ui_restart") {
+  console.log(`${LOG_PREFIX} current process stopped, handing restart back to supervisor`)
+}
+process.exit(exitAction === "ui_restart" ? CLI_UI_UPDATE_RESTART_EXIT_CODE : 0)