@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/tool/tool.ts

@@ -1,166 +0,0 @@
-import z from "zod"
-import { Effect } from "effect"
-import type { MessageV2 } from "../session/message-v2"
-import type { Permission } from "../permission"
-import type { SessionID, MessageID } from "../session/schema"
-import * as Truncate from "./truncate"
-import { RecoverableError } from "./recoverable"
-import { Agent } from "@/agent/agent"
-
-export interface Metadata {
-  [key: string]: any
-}
-
-// TODO: remove this hack
-export type DynamicDescription = (agent: Agent.Info) => Effect.Effect<string>
-
-export type Context<M extends Metadata = Metadata> = {
-  sessionID: SessionID
-  messageID: MessageID
-  agent: string
-  actorID?: string
-  taskId?: string
-  abort: AbortSignal
-  callID?: string
-  extra?: { [key: string]: unknown }
-  messages: MessageV2.WithParts[]
-  metadata(input: { title?: string; metadata?: M }): Effect.Effect<void>
-  ask(input: Omit<Permission.Request, "id" | "sessionID" | "tool">): Effect.Effect<void>
-}
-
-export interface ExecuteResult<M extends Metadata = Metadata> {
-  title: string
-  metadata: M
-  output: string
-  attachments?: Omit<MessageV2.FilePart, "id" | "sessionID" | "messageID">[]
-}
-
-export interface Def<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
-  id: string
-  description: string
-  parameters: Parameters
-  execute(args: z.infer<Parameters>, ctx: Context): Effect.Effect<ExecuteResult<M>>
-  formatValidationError?(error: z.ZodError): string
-  shell?: {
-    description: string
-    parse(script: string): Effect.Effect<z.infer<Parameters>[], unknown>
-    // Optional recovery for shell-mode calls that arrive shaped like the tool's
-    // JSON args (no usable `script`). Returns the tool's parsed JSON shape to be
-    // routed to execute, or undefined if rawArgs can't be lifted. Lets shell mode
-    // transparently accept a JSON-shape call instead of erroring.
-    recover?(rawArgs: unknown): z.infer<Parameters> | undefined
-  }
-}
-export type DefWithoutID<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> = Omit<
-  Def<Parameters, M>,
-  "id"
->
-
-export interface Info<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
-  id: string
-  init: () => Effect.Effect<DefWithoutID<Parameters, M>>
-}
-
-type Init<Parameters extends z.ZodType, M extends Metadata> =
-  | DefWithoutID<Parameters, M>
-  | (() => Effect.Effect<DefWithoutID<Parameters, M>>)
-
-export type InferParameters<T> =
-  T extends Info<infer P, any> ? z.infer<P> : T extends Effect.Effect<Info<infer P, any>, any, any> ? z.infer<P> : never
-export type InferMetadata<T> =
-  T extends Info<any, infer M> ? M : T extends Effect.Effect<Info<any, infer M>, any, any> ? M : never
-
-export type InferDef<T> =
-  T extends Info<infer P, infer M>
-    ? Def<P, M>
-    : T extends Effect.Effect<Info<infer P, infer M>, any, any>
-      ? Def<P, M>
-      : never
-
-// Builds the agent-facing message for an argument-validation failure. zod v4's
-// prettifyError gives a precise, path-annotated breakdown (which field, what was
-// expected vs received) — far more actionable than dumping the raw issue JSON —
-// so we surface that directly for ZodErrors and keep a generic fallback for
-// anything else.
-export function validationErrorMessage(id: string, error: unknown): string {
-  if (error instanceof z.ZodError) {
-    return `Invalid arguments for the ${id} tool:\n${z.prettifyError(error)}`
-  }
-  return `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`
-}
-
-function wrap<Parameters extends z.ZodType, Result extends Metadata>(
-  id: string,
-  init: Init<Parameters, Result>,
-  truncate: Truncate.Interface,
-  agents: Agent.Interface,
-) {
-  return () =>
-    Effect.gen(function* () {
-      const toolInfo = typeof init === "function" ? { ...(yield* init()) } : { ...init }
-      const execute = toolInfo.execute
-      toolInfo.execute = (args, ctx) => {
-        const attrs = {
-          "tool.name": id,
-          "session.id": ctx.sessionID,
-          "message.id": ctx.messageID,
-          ...(ctx.callID ? { "tool.call_id": ctx.callID } : {}),
-        }
-        return Effect.gen(function* () {
-          yield* Effect.try({
-            try: () => toolInfo.parameters.parse(args),
-            catch: (error) => {
-              // Bad arguments are always agent-recoverable: the model sees the
-              // message and rewrites the call next turn. Mark it so the TUI
-              // renders it muted instead of alarming the user with a red block.
-              if (error instanceof z.ZodError && toolInfo.formatValidationError) {
-                return new RecoverableError(toolInfo.formatValidationError(error), { cause: error })
-              }
-              return new RecoverableError(validationErrorMessage(id, error), { cause: error })
-            },
-          })
-          const result = yield* execute(args, ctx)
-          if (result.metadata.truncated !== undefined) {
-            return result
-          }
-          const agent = yield* agents.get(ctx.agent)
-          const truncated = yield* truncate.output(result.output, {}, agent)
-          return {
-            ...result,
-            output: truncated.content,
-            metadata: {
-              ...result.metadata,
-              truncated: truncated.truncated,
-              ...(truncated.truncated && { outputPath: truncated.outputPath }),
-            },
-          }
-        }).pipe(Effect.orDie, Effect.withSpan("Tool.execute", { attributes: attrs }))
-      }
-      return toolInfo
-    })
-}
-
-export function define<Parameters extends z.ZodType, Result extends Metadata, R, ID extends string = string>(
-  id: ID,
-  init: Effect.Effect<Init<Parameters, Result>, never, R>,
-): Effect.Effect<Info<Parameters, Result>, never, R | Truncate.Service | Agent.Service> & { id: ID } {
-  return Object.assign(
-    Effect.gen(function* () {
-      const resolved = yield* init
-      const truncate = yield* Truncate.Service
-      const agents = yield* Agent.Service
-      return { id, init: wrap(id, resolved, truncate, agents) }
-    }),
-    { id },
-  )
-}
-
-export function init<P extends z.ZodType, M extends Metadata>(info: Info<P, M>): Effect.Effect<Def<P, M>> {
-  return Effect.gen(function* () {
-    const init = yield* info.init()
-    return {
-      ...init,
-      id: info.id,
-    }
-  })
-}

package/src/tool/truncate.ts

@@ -1,201 +0,0 @@
-import { NodePath } from "@effect/platform-node"
-import { Cause, Duration, Effect, Layer, Schedule, Context } from "effect"
-import path from "path"
-import type { Agent } from "../agent/agent"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { evaluate } from "@/permission/evaluate"
-import { Identifier } from "../id/id"
-import { Log } from "../util"
-import { ToolID } from "./schema"
-import { TRUNCATION_DIR } from "./truncation-dir"
-
-const log = Log.create({ service: "truncation" })
-const RETENTION = Duration.days(7)
-
-export const MAX_LINES = 2000
-export const MAX_BYTES = 50 * 1024
-export const DIR = TRUNCATION_DIR
-export const GLOB = path.join(TRUNCATION_DIR, "*")
-
-const ERROR_PATTERN = /error|exception|failed|fatal|traceback|panic|exit code/i
-const TAIL_SCAN_CHARS = 2048
-
-export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
-
-export interface Options {
-  maxLines?: number
-  maxBytes?: number
-  direction?: "head" | "tail" | "head+tail"
-  pressureCaps?: boolean
-}
-
-function hasActorTool(agent?: Agent.Info) {
-  if (!agent?.permission) return false
-  return evaluate("actor", "*", agent.permission).action !== "deny"
-}
-
-export interface Interface {
-  readonly cleanup: () => Effect.Effect<void>
-  readonly write: (text: string) => Effect.Effect<string>
-  /**
-   * Returns output unchanged when it fits within the limits, otherwise writes the full text
-   * to the truncation directory and returns a preview plus a hint to inspect the saved file.
-   */
-  readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Truncate") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-
-    const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-      const cutoff = Identifier.timestamp(
-        Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
-      )
-      const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
-        Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
-        Effect.catch(() => Effect.succeed([])),
-      )
-      for (const entry of entries) {
-        if (Identifier.timestamp(entry) >= cutoff) continue
-        yield* fs.remove(path.join(TRUNCATION_DIR, entry)).pipe(Effect.catch(() => Effect.void))
-      }
-    })
-
-    const write = Effect.fn("Truncate.write")(function* (text: string) {
-      const file = path.join(TRUNCATION_DIR, ToolID.ascending())
-      yield* fs.ensureDir(TRUNCATION_DIR).pipe(Effect.orDie)
-      yield* fs.writeFileString(file, text).pipe(Effect.orDie)
-      return file
-    })
-
-    const output = Effect.fn("Truncate.output")(function* (text: string, options: Options = {}, agent?: Agent.Info) {
-      let maxLines = options.maxLines ?? MAX_LINES
-      let maxBytes = options.maxBytes ?? MAX_BYTES
-      const direction = options.direction ?? "head+tail"
-      const pressureCaps = options.pressureCaps ?? false
-
-      if (pressureCaps) {
-        maxLines = Math.floor(maxLines / 2)
-        maxBytes = Math.floor(maxBytes / 2)
-      }
-
-      const lines = text.split("\n")
-      const totalBytes = Buffer.byteLength(text, "utf-8")
-
-      if (lines.length <= maxLines && totalBytes <= maxBytes) {
-        return { content: text, truncated: false } as const
-      }
-
-      if (direction === "head+tail") {
-        // Check if the last TAIL_SCAN_CHARS contain an error pattern
-        const tailScan = text.length > TAIL_SCAN_CHARS ? text.slice(-TAIL_SCAN_CHARS) : text
-        const hasErrors = ERROR_PATTERN.test(tailScan)
-
-        if (hasErrors) {
-          // Allocate 70% of budget to head, 30% to tail
-          const headMaxLines = Math.floor(maxLines * 0.7)
-          const headMaxBytes = Math.floor(maxBytes * 0.7)
-          const tailMaxLines = maxLines - headMaxLines
-          const tailMaxBytes = maxBytes - headMaxBytes
-
-          // Collect head lines
-          const headOut: string[] = []
-          let headBytes = 0
-          for (let i = 0; i < lines.length && headOut.length < headMaxLines; i++) {
-            const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-            if (headBytes + size > headMaxBytes) break
-            headOut.push(lines[i])
-            headBytes += size
-          }
-
-          // Collect tail lines
-          const tailOut: string[] = []
-          let tailBytes = 0
-          for (let i = lines.length - 1; i >= 0 && tailOut.length < tailMaxLines; i--) {
-            const size = Buffer.byteLength(lines[i], "utf-8") + (tailOut.length > 0 ? 1 : 0)
-            if (tailBytes + size > tailMaxBytes) break
-            tailOut.unshift(lines[i])
-            tailBytes += size
-          }
-
-          const omitted = lines.length - headOut.length - tailOut.length
-          const file = yield* write(text)
-
-          const hintText = hasActorTool(agent)
-            ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the actor tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-            : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-          return {
-            content: `${headOut.join("\n")}\n\n... ${omitted} lines omitted — showing head and tail ...\n\n${tailOut.join("\n")}\n\n${hintText}`,
-            truncated: true,
-            outputPath: file,
-          } as const
-        }
-        // No errors in tail: degrade to head behavior
-      }
-
-      const out: string[] = []
-      let i = 0
-      let bytes = 0
-      let hitBytes = false
-
-      if (direction === "head" || direction === "head+tail") {
-        for (i = 0; i < lines.length && i < maxLines; i++) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (i > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.push(lines[i])
-          bytes += size
-        }
-      } else {
-        for (i = lines.length - 1; i >= 0 && out.length < maxLines; i--) {
-          const size = Buffer.byteLength(lines[i], "utf-8") + (out.length > 0 ? 1 : 0)
-          if (bytes + size > maxBytes) {
-            hitBytes = true
-            break
-          }
-          out.unshift(lines[i])
-          bytes += size
-        }
-      }
-
-      const removed = hitBytes ? totalBytes - bytes : lines.length - out.length
-      const unit = hitBytes ? "bytes" : "lines"
-      const preview = out.join("\n")
-      const file = yield* write(text)
-
-      const hintText = hasActorTool(agent)
-        ? `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse the actor tool to have explore agent process this file with Grep and Read (with offset/limit). Do NOT read the full file yourself - delegate to save context.`
-        : `The tool call succeeded but the output was truncated. Full output saved to: ${file}\nUse Grep to search the full content or Read with offset/limit to view specific sections.`
-
-      return {
-        content:
-          direction === "head" || direction === "head+tail"
-            ? `${preview}\n\n...${removed} ${unit} truncated...\n\n${hintText}`
-            : `...${removed} ${unit} truncated...\n\n${hintText}\n\n${preview}`,
-        truncated: true,
-        outputPath: file,
-      } as const
-    })
-
-    yield* cleanup().pipe(
-      Effect.catchCause((cause) => {
-        log.error("truncation cleanup failed", { cause: Cause.pretty(cause) })
-        return Effect.void
-      }),
-      Effect.repeat(Schedule.spaced(Duration.hours(1))),
-      Effect.delay(Duration.minutes(1)),
-      Effect.forkScoped,
-    )
-
-    return Service.of({ cleanup, write, output })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(NodePath.layer))

package/src/tool/truncation-dir.ts

@@ -1,4 +0,0 @@
-import path from "path"
-import { Global } from "../global"
-
-export const TRUNCATION_DIR = path.join(Global.Path.data, "tool-output")

package/src/tool/webfetch.ts

@@ -1,208 +0,0 @@
-import z from "zod"
-import { Effect } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-import * as Tool from "./tool"
-import TurndownService from "turndown"
-import DESCRIPTION from "./webfetch.txt"
-import { isImageAttachment } from "@/util/media"
-import { assertSafeUrl } from "@/util/ssrf"
-
-const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
-const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
-const MAX_TIMEOUT = 120 * 1000 // 2 minutes
-
-const parameters = z.object({
-  url: z.string().describe("The URL to fetch content from"),
-  format: z
-    .enum(["text", "markdown", "html"])
-    .default("markdown")
-    .describe("The format to return the content in (text, markdown, or html). Defaults to markdown."),
-  timeout: z.number().describe("Optional timeout in seconds (max 120)").optional(),
-})
-
-export const WebFetchTool = Tool.define(
-  "webfetch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const httpOk = HttpClient.filterStatusOk(http)
-
-    return {
-      description: DESCRIPTION,
-      parameters,
-      execute: (params: z.infer<typeof parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
-            throw new Error("URL must start with http:// or https://")
-          }
-
-          yield* Effect.promise(() => assertSafeUrl(params.url))
-
-          yield* ctx.ask({
-            permission: "webfetch",
-            patterns: [params.url],
-            always: ["*"],
-            metadata: {
-              url: params.url,
-              format: params.format,
-              timeout: params.timeout,
-            },
-          })
-
-          const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000, MAX_TIMEOUT)
-
-          // Build Accept header based on requested format with q parameters for fallbacks
-          let acceptHeader = "*/*"
-          switch (params.format) {
-            case "markdown":
-              acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1"
-              break
-            case "text":
-              acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1"
-              break
-            case "html":
-              acceptHeader =
-                "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
-              break
-            default:
-              acceptHeader =
-                "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8"
-          }
-          const headers = {
-            "User-Agent":
-              "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
-            Accept: acceptHeader,
-            "Accept-Language": "en-US,en;q=0.9",
-          }
-
-          const request = HttpClientRequest.get(params.url).pipe(HttpClientRequest.setHeaders(headers))
-
-          // Retry with honest UA if blocked by Cloudflare bot detection (TLS fingerprint mismatch)
-          const response = yield* httpOk.execute(request).pipe(
-            Effect.catchIf(
-              (err) =>
-                err.reason._tag === "StatusCodeError" &&
-                err.reason.response.status === 403 &&
-                err.reason.response.headers["cf-mitigated"] === "challenge",
-              () =>
-                httpOk.execute(
-                  HttpClientRequest.get(params.url).pipe(
-                    HttpClientRequest.setHeaders({ ...headers, "User-Agent": "sleepycode" }),
-                  ),
-                ),
-            ),
-            Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error("Request timed out")) }),
-          )
-
-          // Block SSRF via redirect: if the response was redirected, validate final URL
-          const source = (response as any).source as Response | undefined
-          if (source?.url && source.url !== params.url) {
-            yield* Effect.promise(() => assertSafeUrl(source.url))
-          }
-
-          // Check content length
-          const contentLength = response.headers["content-length"]
-          if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const arrayBuffer = yield* response.arrayBuffer
-          if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const contentType = response.headers["content-type"] || ""
-          const mime = contentType.split(";")[0]?.trim().toLowerCase() || ""
-          const title = `${params.url} (${contentType})`
-
-          if (isImageAttachment(mime)) {
-            const base64Content = Buffer.from(arrayBuffer).toString("base64")
-            return {
-              title,
-              output: "Image fetched successfully",
-              metadata: {},
-              attachments: [
-                {
-                  type: "file" as const,
-                  mime,
-                  url: `data:${mime};base64,${base64Content}`,
-                },
-              ],
-            }
-          }
-
-          const content = new TextDecoder().decode(arrayBuffer)
-
-          // Handle content based on requested format and actual content type
-          switch (params.format) {
-            case "markdown":
-              if (contentType.includes("text/html")) {
-                const markdown = convertHTMLToMarkdown(content)
-                return {
-                  output: markdown,
-                  title,
-                  metadata: {},
-                }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "text":
-              if (contentType.includes("text/html")) {
-                const text = yield* Effect.promise(() => extractTextFromHTML(content))
-                return { output: text, title, metadata: {} }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "html":
-              return { output: content, title, metadata: {} }
-
-            default:
-              return { output: content, title, metadata: {} }
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
-
-async function extractTextFromHTML(html: string) {
-  let text = ""
-  let skipContent = false
-
-  const rewriter = new HTMLRewriter()
-    .on("script, style, noscript, iframe, object, embed", {
-      element() {
-        skipContent = true
-      },
-      text() {
-        // Skip text content inside these elements
-      },
-    })
-    .on("*", {
-      element(element) {
-        // Reset skip flag when entering other elements
-        if (!["script", "style", "noscript", "iframe", "object", "embed"].includes(element.tagName)) {
-          skipContent = false
-        }
-      },
-      text(input) {
-        if (!skipContent) {
-          text += input.text
-        }
-      },
-    })
-    .transform(new Response(html))
-
-  await rewriter.text()
-  return text.trim()
-}
-
-function convertHTMLToMarkdown(html: string): string {
-  const turndownService = new TurndownService({
-    headingStyle: "atx",
-    hr: "---",
-    bulletListMarker: "-",
-    codeBlockStyle: "fenced",
-    emDelimiter: "*",
-  })
-  turndownService.remove(["script", "style", "meta", "link"])
-  return turndownService.turndown(html)
-}

package/src/tool/webfetch.txt

@@ -1,13 +0,0 @@
-- Fetches content from a specified URL
-- Takes a URL and optional format as input
-- Fetches the URL content, converts to requested format (markdown by default)
-- Returns the content in the specified format
-- Use this tool when you need to retrieve and analyze web content
-
-Usage notes:
-  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
-  - The URL must be a fully-formed valid URL
-  - HTTP URLs will be automatically upgraded to HTTPS
-  - Format options: "markdown" (default), "text", or "html"
-  - This tool is read-only and does not modify any files
-  - Results may be summarized if the content is very large