cerebras-cli 1.0.0

package/src/telemetry/index.ts

@@ -0,0 +1,232 @@
+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(),
+
+    // 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>
+
+  // 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
+    // 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,
+      // 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)
+    }
+  }
+}
+

package/src/tool/bash.ts

@@ -0,0 +1,365 @@
+import z from "zod"
+import { spawn } from "child_process"
+import { Tool } from "./tool"
+import DESCRIPTION from "./bash.txt"
+import { Log } from "../util/log"
+import { Instance } from "../project/instance"
+import { lazy } from "@/util/lazy"
+import { Language } from "web-tree-sitter"
+import { Agent } from "@/agent/agent"
+import { $ } from "bun"
+import { Filesystem } from "@/util/filesystem"
+import { Wildcard } from "@/util/wildcard"
+import { Permission } from "@/permission"
+import { fileURLToPath } from "url"
+import { Flag } from "@/flag/flag.ts"
+import path from "path"
+import { iife } from "@/util/iife"
+
+const DEFAULT_MAX_OUTPUT_LENGTH = 30_000
+const MAX_OUTPUT_LENGTH = (() => {
+  const parsed = Number(Flag.OPENCODE_EXPERIMENTAL_BASH_MAX_OUTPUT_LENGTH)
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_OUTPUT_LENGTH
+})()
+const DEFAULT_TIMEOUT = 2 * 60 * 1000
+const SIGKILL_TIMEOUT_MS = 200
+
+export const log = Log.create({ service: "bash-tool" })
+
+const resolveWasm = (asset: string) => {
+  if (asset.startsWith("file://")) return fileURLToPath(asset)
+  if (asset.startsWith("/") || /^[a-z]:/i.test(asset)) return asset
+  const url = new URL(asset, import.meta.url)
+  return fileURLToPath(url)
+}
+
+const parser = lazy(async () => {
+  const { Parser } = await import("web-tree-sitter")
+  const { default: treeWasm } = await import("web-tree-sitter/tree-sitter.wasm" as string, {
+    with: { type: "wasm" },
+  })
+  const treePath = resolveWasm(treeWasm)
+  await Parser.init({
+    locateFile() {
+      return treePath
+    },
+  })
+  const { default: bashWasm } = await import("tree-sitter-bash/tree-sitter-bash.wasm" as string, {
+    with: { type: "wasm" },
+  })
+  const bashPath = resolveWasm(bashWasm)
+  const bashLanguage = await Language.load(bashPath)
+  const p = new Parser()
+  p.setLanguage(bashLanguage)
+  return p
+})
+
+// TODO: we may wanna rename this tool so it works better on other shells
+
+export const BashTool = Tool.define("bash", async () => {
+  const shell = iife(() => {
+    const s = process.env.SHELL
+    if (s) {
+      const basename = path.basename(s)
+      if (!new Set(["fish", "nu"]).has(basename)) {
+        return s
+      }
+    }
+
+    if (process.platform === "darwin") {
+      return "/bin/zsh"
+    }
+
+    if (process.platform === "win32") {
+      // Let Bun / Node pick COMSPEC (usually cmd.exe)
+      // or explicitly:
+      return process.env.COMSPEC || true
+    }
+
+    const bash = Bun.which("bash")
+    if (bash) {
+      return bash
+    }
+
+    return true
+  })
+  log.info("bash tool using shell", { shell })
+
+  return {
+    description: DESCRIPTION,
+    parameters: z.object({
+      command: z.string().describe("The command to execute"),
+      timeout: z.number().describe("Optional timeout in milliseconds").optional(),
+      workdir: z
+        .string()
+        .describe(
+          `The working directory to run the command in. Defaults to ${Instance.directory}. Use this instead of 'cd' commands.`,
+        )
+        .optional(),
+      description: z
+        .string()
+        .describe(
+          "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'",
+        ),
+    }),
+    async execute(params, ctx) {
+      const cwd = params.workdir || Instance.directory
+      if (params.timeout !== undefined && params.timeout < 0) {
+        throw new Error(`Invalid timeout value: ${params.timeout}. Timeout must be a positive number.`)
+      }
+      const timeout = params.timeout ?? DEFAULT_TIMEOUT
+      const tree = await parser().then((p) => p.parse(params.command))
+      if (!tree) {
+        throw new Error("Failed to parse command")
+      }
+      const agent = await Agent.get(ctx.agent)
+
+      const checkExternalDirectory = async (dir: string) => {
+        if (Filesystem.contains(Instance.directory, dir)) return
+        const title = `This command references paths outside of ${Instance.directory}`
+        if (agent.permission.external_directory === "ask") {
+          await Permission.ask({
+            type: "external_directory",
+            pattern: [dir, path.join(dir, "*")],
+            sessionID: ctx.sessionID,
+            messageID: ctx.messageID,
+            callID: ctx.callID,
+            title,
+            metadata: {
+              command: params.command,
+            },
+          })
+        } else if (agent.permission.external_directory === "deny") {
+          throw new Permission.RejectedError(
+            ctx.sessionID,
+            "external_directory",
+            ctx.callID,
+            {
+              command: params.command,
+            },
+            `${title} so this command is not allowed to be executed.`,
+          )
+        }
+      }
+
+      await checkExternalDirectory(cwd)
+
+      const permissions = agent.permission.bash
+
+      const askPatterns = new Set<string>()
+      for (const node of tree.rootNode.descendantsOfType("command")) {
+        if (!node) continue
+        const command = []
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i)
+          if (!child) continue
+          if (
+            child.type !== "command_name" &&
+            child.type !== "word" &&
+            child.type !== "string" &&
+            child.type !== "raw_string" &&
+            child.type !== "concatenation"
+          ) {
+            continue
+          }
+          command.push(child.text)
+        }
+
+        // not an exhaustive list, but covers most common cases
+        if (["cd", "rm", "cp", "mv", "mkdir", "touch", "chmod", "chown"].includes(command[0])) {
+          for (const arg of command.slice(1)) {
+            if (arg.startsWith("-") || (command[0] === "chmod" && arg.startsWith("+"))) continue
+            const resolved = await $`realpath ${arg}`
+              .quiet()
+              .nothrow()
+              .text()
+              .then((x) => x.trim())
+            log.info("resolved path", { arg, resolved })
+            if (resolved) {
+              // Git Bash on Windows returns Unix-style paths like /c/Users/...
+              const normalized =
+                process.platform === "win32" && resolved.match(/^\/[a-z]\//)
+                  ? resolved.replace(/^\/([a-z])\//, (_, drive) => `${drive.toUpperCase()}:\\`).replace(/\//g, "\\")
+                  : resolved
+
+              await checkExternalDirectory(normalized)
+            }
+          }
+        }
+
+        // always allow cd if it passes above check
+        if (command[0] !== "cd") {
+          const action = Wildcard.allStructured({ head: command[0], tail: command.slice(1) }, permissions)
+          if (action === "deny") {
+            throw new Error(
+              `The user has specifically restricted access to this command, you are not allowed to execute it. Here is the configuration: ${JSON.stringify(permissions)}`,
+            )
+          }
+          if (action === "ask") {
+            const pattern = (() => {
+              if (command.length === 0) return
+              const head = command[0]
+              // Find first non-flag argument as subcommand
+              const sub = command.slice(1).find((arg) => !arg.startsWith("-"))
+              return sub ? `${head} ${sub} *` : `${head} *`
+            })()
+            if (pattern) {
+              askPatterns.add(pattern)
+            }
+          }
+        }
+      }
+
+      if (askPatterns.size > 0) {
+        const patterns = Array.from(askPatterns)
+        await Permission.ask({
+          type: "bash",
+          pattern: patterns,
+          sessionID: ctx.sessionID,
+          messageID: ctx.messageID,
+          callID: ctx.callID,
+          title: params.command,
+          metadata: {
+            command: params.command,
+            patterns,
+          },
+        })
+      }
+
+      const proc = spawn(params.command, {
+        shell,
+        cwd,
+        env: {
+          ...process.env,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: process.platform !== "win32",
+      })
+
+      let output = ""
+
+      // Initialize metadata with empty output
+      ctx.metadata({
+        metadata: {
+          output: "",
+          description: params.description,
+        },
+      })
+
+      const append = (chunk: Buffer) => {
+        if (output.length <= MAX_OUTPUT_LENGTH) {
+          output += chunk.toString()
+          ctx.metadata({
+            metadata: {
+              output,
+              description: params.description,
+            },
+          })
+        }
+      }
+
+      proc.stdout?.on("data", append)
+      proc.stderr?.on("data", append)
+
+      let timedOut = false
+      let aborted = false
+      let exited = false
+
+      const killTree = async () => {
+        const pid = proc.pid
+        if (!pid || exited) {
+          return
+        }
+
+        if (process.platform === "win32") {
+          await new Promise<void>((resolve) => {
+            const killer = spawn("taskkill", ["/pid", String(pid), "/f", "/t"], { stdio: "ignore" })
+            killer.once("exit", resolve)
+            killer.once("error", resolve)
+          })
+          return
+        }
+
+        try {
+          process.kill(-pid, "SIGTERM")
+          await Bun.sleep(SIGKILL_TIMEOUT_MS)
+          if (!exited) {
+            process.kill(-pid, "SIGKILL")
+          }
+        } catch (_e) {
+          proc.kill("SIGTERM")
+          await Bun.sleep(SIGKILL_TIMEOUT_MS)
+          if (!exited) {
+            proc.kill("SIGKILL")
+          }
+        }
+      }
+
+      if (ctx.abort.aborted) {
+        aborted = true
+        await killTree()
+      }
+
+      const abortHandler = () => {
+        aborted = true
+        void killTree()
+      }
+
+      ctx.abort.addEventListener("abort", abortHandler, { once: true })
+
+      const timeoutTimer = setTimeout(() => {
+        timedOut = true
+        void killTree()
+      }, timeout + 100)
+
+      await new Promise<void>((resolve, reject) => {
+        const cleanup = () => {
+          clearTimeout(timeoutTimer)
+          ctx.abort.removeEventListener("abort", abortHandler)
+        }
+
+        proc.once("exit", () => {
+          exited = true
+          cleanup()
+          resolve()
+        })
+
+        proc.once("error", (error) => {
+          exited = true
+          cleanup()
+          reject(error)
+        })
+      })
+
+      let resultMetadata: String[] = ["<bash_metadata>"]
+
+      if (output.length > MAX_OUTPUT_LENGTH) {
+        output = output.slice(0, MAX_OUTPUT_LENGTH)
+        resultMetadata.push(`bash tool truncated output as it exceeded ${MAX_OUTPUT_LENGTH} char limit`)
+      }
+
+      if (timedOut) {
+        resultMetadata.push(`bash tool terminated commmand after exceeding timeout ${timeout} ms`)
+      }
+
+      if (aborted) {
+        resultMetadata.push("User aborted the command")
+      }
+
+      if (resultMetadata.length > 1) {
+        resultMetadata.push("</bash_metadata>")
+        output += "\n\n" + resultMetadata.join("\n")
+      }
+
+      return {
+        title: params.description,
+        metadata: {
+          output,
+          exit: proc.exitCode,
+          description: params.description,
+        },
+        output,
+      }
+    },
+  }
+})