cerebras-cli 1.0.5 → 1.0.138

package/src/storage/storage.ts

@@ -0,0 +1,226 @@
+import { Log } from "../util/log"
+import path from "path"
+import fs from "fs/promises"
+import { Global } from "../global"
+import { lazy } from "../util/lazy"
+import { Lock } from "../util/lock"
+import { $ } from "bun"
+import { NamedError } from "@opencode-ai/util/error"
+import z from "zod"
+
+export namespace Storage {
+  const log = Log.create({ service: "storage" })
+
+  type Migration = (dir: string) => Promise<void>
+
+  export const NotFoundError = NamedError.create(
+    "NotFoundError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  const MIGRATIONS: Migration[] = [
+    async (dir) => {
+      const project = path.resolve(dir, "../project")
+      if (!fs.exists(project)) return
+      for await (const projectDir of new Bun.Glob("*").scan({
+        cwd: project,
+        onlyFiles: false,
+      })) {
+        log.info(`migrating project ${projectDir}`)
+        let projectID = projectDir
+        const fullProjectDir = path.join(project, projectDir)
+        let worktree = "/"
+
+        if (projectID !== "global") {
+          for await (const msgFile of new Bun.Glob("storage/session/message/*/*.json").scan({
+            cwd: path.join(project, projectDir),
+            absolute: true,
+          })) {
+            const json = await Bun.file(msgFile).json()
+            worktree = json.path?.root
+            if (worktree) break
+          }
+          if (!worktree) continue
+          if (!(await fs.exists(worktree))) continue
+          const [id] = await $`git rev-list --max-parents=0 --all`
+            .quiet()
+            .nothrow()
+            .cwd(worktree)
+            .text()
+            .then((x) =>
+              x
+                .split("\n")
+                .filter(Boolean)
+                .map((x) => x.trim())
+                .toSorted(),
+            )
+          if (!id) continue
+          projectID = id
+
+          await Bun.write(
+            path.join(dir, "project", projectID + ".json"),
+            JSON.stringify({
+              id,
+              vcs: "git",
+              worktree,
+              time: {
+                created: Date.now(),
+                initialized: Date.now(),
+              },
+            }),
+          )
+
+          log.info(`migrating sessions for project ${projectID}`)
+          for await (const sessionFile of new Bun.Glob("storage/session/info/*.json").scan({
+            cwd: fullProjectDir,
+            absolute: true,
+          })) {
+            const dest = path.join(dir, "session", projectID, path.basename(sessionFile))
+            log.info("copying", {
+              sessionFile,
+              dest,
+            })
+            const session = await Bun.file(sessionFile).json()
+            await Bun.write(dest, JSON.stringify(session))
+            log.info(`migrating messages for session ${session.id}`)
+            for await (const msgFile of new Bun.Glob(`storage/session/message/${session.id}/*.json`).scan({
+              cwd: fullProjectDir,
+              absolute: true,
+            })) {
+              const dest = path.join(dir, "message", session.id, path.basename(msgFile))
+              log.info("copying", {
+                msgFile,
+                dest,
+              })
+              const message = await Bun.file(msgFile).json()
+              await Bun.write(dest, JSON.stringify(message))
+
+              log.info(`migrating parts for message ${message.id}`)
+              for await (const partFile of new Bun.Glob(`storage/session/part/${session.id}/${message.id}/*.json`).scan(
+                {
+                  cwd: fullProjectDir,
+                  absolute: true,
+                },
+              )) {
+                const dest = path.join(dir, "part", message.id, path.basename(partFile))
+                const part = await Bun.file(partFile).json()
+                log.info("copying", {
+                  partFile,
+                  dest,
+                })
+                await Bun.write(dest, JSON.stringify(part))
+              }
+            }
+          }
+        }
+      }
+    },
+    async (dir) => {
+      for await (const item of new Bun.Glob("session/*/*.json").scan({
+        cwd: dir,
+        absolute: true,
+      })) {
+        const session = await Bun.file(item).json()
+        if (!session.projectID) continue
+        if (!session.summary?.diffs) continue
+        const { diffs } = session.summary
+        await Bun.file(path.join(dir, "session_diff", session.id + ".json")).write(JSON.stringify(diffs))
+        await Bun.file(path.join(dir, "session", session.projectID, session.id + ".json")).write(
+          JSON.stringify({
+            ...session,
+            summary: {
+              additions: diffs.reduce((sum: any, x: any) => sum + x.additions, 0),
+              deletions: diffs.reduce((sum: any, x: any) => sum + x.deletions, 0),
+            },
+          }),
+        )
+      }
+    },
+  ]
+
+  const state = lazy(async () => {
+    const dir = path.join(Global.Path.data, "storage")
+    const migration = await Bun.file(path.join(dir, "migration"))
+      .json()
+      .then((x) => parseInt(x))
+      .catch(() => 0)
+    for (let index = migration; index < MIGRATIONS.length; index++) {
+      log.info("running migration", { index })
+      const migration = MIGRATIONS[index]
+      await migration(dir).catch(() => log.error("failed to run migration", { index }))
+      await Bun.write(path.join(dir, "migration"), (index + 1).toString())
+    }
+    return {
+      dir,
+    }
+  })
+
+  export async function remove(key: string[]) {
+    const dir = await state().then((x) => x.dir)
+    const target = path.join(dir, ...key) + ".json"
+    return withErrorHandling(async () => {
+      await fs.unlink(target).catch(() => {})
+    })
+  }
+
+  export async function read<T>(key: string[]) {
+    const dir = await state().then((x) => x.dir)
+    const target = path.join(dir, ...key) + ".json"
+    return withErrorHandling(async () => {
+      using _ = await Lock.read(target)
+      const result = await Bun.file(target).json()
+      return result as T
+    })
+  }
+
+  export async function update<T>(key: string[], fn: (draft: T) => void) {
+    const dir = await state().then((x) => x.dir)
+    const target = path.join(dir, ...key) + ".json"
+    return withErrorHandling(async () => {
+      using _ = await Lock.write(target)
+      const content = await Bun.file(target).json()
+      fn(content)
+      await Bun.write(target, JSON.stringify(content, null, 2))
+      return content as T
+    })
+  }
+
+  export async function write<T>(key: string[], content: T) {
+    const dir = await state().then((x) => x.dir)
+    const target = path.join(dir, ...key) + ".json"
+    return withErrorHandling(async () => {
+      using _ = await Lock.write(target)
+      await Bun.write(target, JSON.stringify(content, null, 2))
+    })
+  }
+
+  async function withErrorHandling<T>(body: () => Promise<T>) {
+    return body().catch((e) => {
+      if (!(e instanceof Error)) throw e
+      const errnoException = e as NodeJS.ErrnoException
+      if (errnoException.code === "ENOENT") {
+        throw new NotFoundError({ message: `Resource not found: ${errnoException.path}` })
+      }
+      throw e
+    })
+  }
+
+  const glob = new Bun.Glob("**/*")
+  export async function list(prefix: string[]) {
+    const dir = await state().then((x) => x.dir)
+    try {
+      const result = await Array.fromAsync(
+        glob.scan({
+          cwd: path.join(dir, ...prefix),
+          onlyFiles: true,
+        }),
+      ).then((results) => results.map((x) => [...prefix, ...x.slice(0, -5).split(path.sep)]))
+      result.sort()
+      return result
+    } catch {
+      return []
+    }
+  }
+}

package/src/telemetry/index.ts

@@ -0,0 +1,247 @@
+import { Log } from "@/util/log"
+import { Instance } from "@/project/instance"
+import z from "zod"
+
+/**
+ * Telemetry module for logging API request metrics to Cloudflare worker
+ *
+ * Tracks cache hit rates, token usage, conversation turns, and other metrics
+ * for monitoring and optimization purposes.
+ */
+export namespace Telemetry {
+  const log = Log.create({ service: "telemetry" })
+
+  // Telemetry endpoint
+  const TELEMETRY_ENDPOINT =
+    process.env.OPENCODE_TELEMETRY_URL || "https://opencode-telemetry.kevin-taylor-d8d.workers.dev"
+
+  // Batch settings
+  const BATCH_SIZE = 10
+  const BATCH_INTERVAL_MS = 30_000 // 30 seconds
+
+  // Schema for telemetry entry
+  export const Entry = z.object({
+    // Identifiers
+    sessionID: z.string().optional(),
+    providerID: z.string().optional(),
+    modelID: z.string().optional(),
+    apiKeyHash: z.string().optional(), // Hash of API key for identification
+
+    // Per-step token metrics
+    inputTokens: z.number().default(0),
+    outputTokens: z.number().default(0),
+    reasoningTokens: z.number().default(0),
+    cachedTokens: z.number().default(0),
+
+    // Per-step computed metrics
+    cacheHitRate: z.number().default(0),
+
+    // Session-level cumulative totals (like sidebar displays)
+    sessionTotalCachedTokens: z.number().default(0),
+    sessionTotalPromptTokens: z.number().default(0),
+    sessionTotalOutputTokens: z.number().default(0),
+    sessionOverallHitRate: z.number().default(0),
+
+    // Session context
+    conversationTurns: z.number().default(0),
+
+    // Metadata
+    finishReason: z.string().optional(),
+  })
+  export type Entry = z.infer<typeof Entry>
+
+  /**
+   * Hash an API key for telemetry (privacy-preserving identifier)
+   * Uses last 8 chars + hash to create a unique but non-reversible ID
+   */
+  export async function hashApiKey(apiKey: string | undefined): Promise<string | undefined> {
+    if (!apiKey || apiKey.length < 8) return undefined
+    // Take last 4 chars (visible part) + hash of full key
+    const suffix = apiKey.slice(-4)
+    const hash = Bun.hash(apiKey).toString(16).slice(0, 8)
+    return `${hash}_${suffix}`
+  }
+
+  // Internal state for batching
+  const state = Instance.state(
+    () => {
+      const queue: Entry[] = []
+      let timer: ReturnType<typeof setTimeout> | undefined
+
+      return {
+        queue,
+        timer,
+        enabled: true,
+      }
+    },
+    async (entry) => {
+      // Flush remaining entries on shutdown
+      if (entry.timer) {
+        clearTimeout(entry.timer)
+      }
+      if (entry.queue.length > 0) {
+        await flush(entry.queue)
+        entry.queue.length = 0
+      }
+    },
+  )
+
+  /**
+   * Check if telemetry is enabled
+   */
+  export function isEnabled(): boolean {
+    return state().enabled
+  }
+
+  /**
+   * Enable or disable telemetry
+   */
+  export function setEnabled(enabled: boolean): void {
+    state().enabled = enabled
+    if (!enabled) {
+      // Clear any pending entries
+      state().queue.length = 0
+      if (state().timer) {
+        clearTimeout(state().timer)
+        state().timer = undefined
+      }
+    }
+  }
+
+  /**
+   * Log a telemetry entry
+   *
+   * Entries are batched and sent periodically to reduce network overhead.
+   */
+  export function track(entry: Entry): void {
+    const s = state()
+    if (!s.enabled) return
+
+    log.info("tracking telemetry", {
+      providerID: entry.providerID,
+      modelID: entry.modelID,
+      cacheHitRate: entry.cacheHitRate,
+      cachedTokens: entry.cachedTokens,
+      inputTokens: entry.inputTokens,
+    })
+
+    s.queue.push(entry)
+
+    // Send immediately if batch is full
+    if (s.queue.length >= BATCH_SIZE) {
+      const entries = s.queue.splice(0, BATCH_SIZE)
+      flush(entries).catch((e) => log.error("flush error", { error: e }))
+    }
+
+    // Start batch timer if not already running
+    if (!s.timer) {
+      s.timer = setTimeout(() => {
+        s.timer = undefined
+        if (s.queue.length > 0) {
+          const entries = s.queue.splice(0)
+          flush(entries).catch((e) => log.error("flush error", { error: e }))
+        }
+      }, BATCH_INTERVAL_MS)
+    }
+  }
+
+  /**
+   * Convenience method to track from session processor data
+   */
+  export function trackFromUsage(input: {
+    sessionID: string
+    providerID: string
+    modelID: string
+    apiKeyHash?: string // Pre-hashed API key identifier
+    // Per-step tokens
+    tokens: {
+      input: number
+      output: number
+      reasoning: number
+      cache: {
+        read: number
+      }
+    }
+    conversationTurns: number
+    finishReason?: string
+    // Session-level cumulative totals
+    sessionTotals?: {
+      cachedTokens: number
+      promptTokens: number
+      outputTokens: number
+    }
+  }): void {
+    // Calculate per-step cache hit rate
+    const totalPromptTokens = input.tokens.input + input.tokens.cache.read
+    const cacheHitRate = totalPromptTokens > 0 ? (input.tokens.cache.read / totalPromptTokens) * 100 : 0
+
+    // Calculate session-level overall hit rate
+    const sessionOverallHitRate =
+      input.sessionTotals && input.sessionTotals.promptTokens > 0
+        ? (input.sessionTotals.cachedTokens / input.sessionTotals.promptTokens) * 100
+        : 0
+
+    track({
+      sessionID: input.sessionID,
+      providerID: input.providerID,
+      modelID: input.modelID,
+      apiKeyHash: input.apiKeyHash,
+      // Per-step metrics
+      inputTokens: input.tokens.input,
+      outputTokens: input.tokens.output,
+      reasoningTokens: input.tokens.reasoning,
+      cachedTokens: input.tokens.cache.read,
+      cacheHitRate,
+      // Session-level cumulative totals
+      sessionTotalCachedTokens: input.sessionTotals?.cachedTokens ?? 0,
+      sessionTotalPromptTokens: input.sessionTotals?.promptTokens ?? 0,
+      sessionTotalOutputTokens: input.sessionTotals?.outputTokens ?? 0,
+      sessionOverallHitRate,
+      // Context
+      conversationTurns: input.conversationTurns,
+      finishReason: input.finishReason,
+    })
+  }
+
+  /**
+   * Flush entries to the telemetry endpoint
+   */
+  async function flush(entries: Entry[]): Promise<void> {
+    if (entries.length === 0) return
+
+    log.info("flushing telemetry", { count: entries.length })
+
+    try {
+      const enrichedEntries = entries
+
+      const res = await fetch(`${TELEMETRY_ENDPOINT}/batch`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ entries: enrichedEntries }),
+      })
+
+      if (!res.ok) {
+        log.error("telemetry flush failed", { status: res.status })
+      }
+    } catch (e) {
+      // Silently fail - telemetry should not disrupt normal operation
+      log.error("telemetry error", { error: e })
+    }
+  }
+
+  /**
+   * Force flush any pending entries immediately
+   */
+  export async function forceFlush(): Promise<void> {
+    const s = state()
+    if (s.timer) {
+      clearTimeout(s.timer)
+      s.timer = undefined
+    }
+    if (s.queue.length > 0) {
+      const entries = s.queue.splice(0)
+      await flush(entries)
+    }
+  }
+}
+