Vendor opencode source for docker build

opencode/packages/plugin/.gitignore

@@ -0,0 +1 @@
+dist

opencode/packages/plugin/package.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@opencode-ai/plugin",
+  "version": "1.1.53",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "build": "tsc"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./tool": "./src/tool.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@opencode-ai/sdk": "workspace:*",
+    "zod": "catalog:"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "catalog:",
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "@typescript/native-preview": "catalog:"
+  }
+}

opencode/packages/plugin/script/publish.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+import { Script } from "@opencode-ai/script"
+import { $ } from "bun"
+
+const dir = new URL("..", import.meta.url).pathname
+process.chdir(dir)
+
+await $`bun tsc`
+const pkg = await import("../package.json").then((m) => m.default)
+const original = JSON.parse(JSON.stringify(pkg))
+for (const [key, value] of Object.entries(pkg.exports)) {
+  const file = value.replace("./src/", "./dist/").replace(".ts", "")
+  // @ts-ignore
+  pkg.exports[key] = {
+    import: file + ".js",
+    types: file + ".d.ts",
+  }
+}
+await Bun.write("package.json", JSON.stringify(pkg, null, 2))
+await $`bun pm pack && npm publish *.tgz --tag ${Script.channel} --access public`
+await Bun.write("package.json", JSON.stringify(original, null, 2))

opencode/packages/plugin/src/example.ts

@@ -0,0 +1,18 @@
+import { Plugin } from "./index"
+import { tool } from "./tool"
+
+export const ExamplePlugin: Plugin = async (ctx) => {
+  return {
+    tool: {
+      mytool: tool({
+        description: "This is a custom tool",
+        args: {
+          foo: tool.schema.string().describe("foo"),
+        },
+        async execute(args) {
+          return `Hello ${args.foo}!`
+        },
+      }),
+    },
+  }
+}

opencode/packages/plugin/src/index.ts

@@ -0,0 +1,227 @@
+import type {
+  Event,
+  createOpencodeClient,
+  Project,
+  Model,
+  Provider,
+  Permission,
+  UserMessage,
+  Message,
+  Part,
+  Auth,
+  Config,
+} from "@opencode-ai/sdk"
+
+import type { BunShell } from "./shell"
+import { type ToolDefinition } from "./tool"
+
+export * from "./tool"
+
+export type ProviderContext = {
+  source: "env" | "config" | "custom" | "api"
+  info: Provider
+  options: Record<string, any>
+}
+
+export type PluginInput = {
+  client: ReturnType<typeof createOpencodeClient>
+  project: Project
+  directory: string
+  worktree: string
+  serverUrl: URL
+  $: BunShell
+}
+
+export type Plugin = (input: PluginInput) => Promise<Hooks>
+
+export type AuthHook = {
+  provider: string
+  loader?: (auth: () => Promise<Auth>, provider: Provider) => Promise<Record<string, any>>
+  methods: (
+    | {
+        type: "oauth"
+        label: string
+        prompts?: Array<
+          | {
+              type: "text"
+              key: string
+              message: string
+              placeholder?: string
+              validate?: (value: string) => string | undefined
+              condition?: (inputs: Record<string, string>) => boolean
+            }
+          | {
+              type: "select"
+              key: string
+              message: string
+              options: Array<{
+                label: string
+                value: string
+                hint?: string
+              }>
+              condition?: (inputs: Record<string, string>) => boolean
+            }
+        >
+        authorize(inputs?: Record<string, string>): Promise<AuthOuathResult>
+      }
+    | {
+        type: "api"
+        label: string
+        prompts?: Array<
+          | {
+              type: "text"
+              key: string
+              message: string
+              placeholder?: string
+              validate?: (value: string) => string | undefined
+              condition?: (inputs: Record<string, string>) => boolean
+            }
+          | {
+              type: "select"
+              key: string
+              message: string
+              options: Array<{
+                label: string
+                value: string
+                hint?: string
+              }>
+              condition?: (inputs: Record<string, string>) => boolean
+            }
+        >
+        authorize?(inputs?: Record<string, string>): Promise<
+          | {
+              type: "success"
+              key: string
+              provider?: string
+            }
+          | {
+              type: "failed"
+            }
+        >
+      }
+  )[]
+}
+
+export type AuthOuathResult = { url: string; instructions: string } & (
+  | {
+      method: "auto"
+      callback(): Promise<
+        | ({
+            type: "success"
+            provider?: string
+          } & (
+            | {
+                refresh: string
+                access: string
+                expires: number
+                accountId?: string
+              }
+            | { key: string }
+          ))
+        | {
+            type: "failed"
+          }
+      >
+    }
+  | {
+      method: "code"
+      callback(code: string): Promise<
+        | ({
+            type: "success"
+            provider?: string
+          } & (
+            | {
+                refresh: string
+                access: string
+                expires: number
+                accountId?: string
+              }
+            | { key: string }
+          ))
+        | {
+            type: "failed"
+          }
+      >
+    }
+)
+
+export interface Hooks {
+  event?: (input: { event: Event }) => Promise<void>
+  config?: (input: Config) => Promise<void>
+  tool?: {
+    [key: string]: ToolDefinition
+  }
+  auth?: AuthHook
+  /**
+   * Called when a new message is received
+   */
+  "chat.message"?: (
+    input: {
+      sessionID: string
+      agent?: string
+      model?: { providerID: string; modelID: string }
+      messageID?: string
+      variant?: string
+    },
+    output: { message: UserMessage; parts: Part[] },
+  ) => Promise<void>
+  /**
+   * Modify parameters sent to LLM
+   */
+  "chat.params"?: (
+    input: { sessionID: string; agent: string; model: Model; provider: ProviderContext; message: UserMessage },
+    output: { temperature: number; topP: number; topK: number; options: Record<string, any> },
+  ) => Promise<void>
+  "chat.headers"?: (
+    input: { sessionID: string; agent: string; model: Model; provider: ProviderContext; message: UserMessage },
+    output: { headers: Record<string, string> },
+  ) => Promise<void>
+  "permission.ask"?: (input: Permission, output: { status: "ask" | "deny" | "allow" }) => Promise<void>
+  "command.execute.before"?: (
+    input: { command: string; sessionID: string; arguments: string },
+    output: { parts: Part[] },
+  ) => Promise<void>
+  "tool.execute.before"?: (
+    input: { tool: string; sessionID: string; callID: string },
+    output: { args: any },
+  ) => Promise<void>
+  "shell.env"?: (input: { cwd: string }, output: { env: Record<string, string> }) => Promise<void>
+  "tool.execute.after"?: (
+    input: { tool: string; sessionID: string; callID: string },
+    output: {
+      title: string
+      output: string
+      metadata: any
+    },
+  ) => Promise<void>
+  "experimental.chat.messages.transform"?: (
+    input: {},
+    output: {
+      messages: {
+        info: Message
+        parts: Part[]
+      }[]
+    },
+  ) => Promise<void>
+  "experimental.chat.system.transform"?: (
+    input: { sessionID?: string; model: Model },
+    output: {
+      system: string[]
+    },
+  ) => Promise<void>
+  /**
+   * Called before session compaction starts. Allows plugins to customize
+   * the compaction prompt.
+   *
+   * - `context`: Additional context strings appended to the default prompt
+   * - `prompt`: If set, replaces the default compaction prompt entirely
+   */
+  "experimental.session.compacting"?: (
+    input: { sessionID: string },
+    output: { context: string[]; prompt?: string },
+  ) => Promise<void>
+  "experimental.text.complete"?: (
+    input: { sessionID: string; messageID: string; partID: string },
+    output: { text: string },
+  ) => Promise<void>
+}

opencode/packages/plugin/src/shell.ts

@@ -0,0 +1,136 @@
+export type ShellFunction = (input: Uint8Array) => Uint8Array
+
+export type ShellExpression =
+  | { toString(): string }
+  | Array<ShellExpression>
+  | string
+  | { raw: string }
+  | ReadableStream
+
+export interface BunShell {
+  (strings: TemplateStringsArray, ...expressions: ShellExpression[]): BunShellPromise
+
+  /**
+   * Perform bash-like brace expansion on the given pattern.
+   * @param pattern - Brace pattern to expand
+   */
+  braces(pattern: string): string[]
+
+  /**
+   * Escape strings for input into shell commands.
+   */
+  escape(input: string): string
+
+  /**
+   * Change the default environment variables for shells created by this instance.
+   */
+  env(newEnv?: Record<string, string | undefined>): BunShell
+
+  /**
+   * Default working directory to use for shells created by this instance.
+   */
+  cwd(newCwd?: string): BunShell
+
+  /**
+   * Configure the shell to not throw an exception on non-zero exit codes.
+   */
+  nothrow(): BunShell
+
+  /**
+   * Configure whether or not the shell should throw an exception on non-zero exit codes.
+   */
+  throws(shouldThrow: boolean): BunShell
+}
+
+export interface BunShellPromise extends Promise<BunShellOutput> {
+  readonly stdin: WritableStream
+
+  /**
+   * Change the current working directory of the shell.
+   */
+  cwd(newCwd: string): this
+
+  /**
+   * Set environment variables for the shell.
+   */
+  env(newEnv: Record<string, string> | undefined): this
+
+  /**
+   * By default, the shell will write to the current process's stdout and stderr, as well as buffering that output.
+   * This configures the shell to only buffer the output.
+   */
+  quiet(): this
+
+  /**
+   * Read from stdout as a string, line by line
+   * Automatically calls quiet() to disable echoing to stdout.
+   */
+  lines(): AsyncIterable<string>
+
+  /**
+   * Read from stdout as a string.
+   * Automatically calls quiet() to disable echoing to stdout.
+   */
+  text(encoding?: BufferEncoding): Promise<string>
+
+  /**
+   * Read from stdout as a JSON object
+   * Automatically calls quiet()
+   */
+  json(): Promise<any>
+
+  /**
+   * Read from stdout as an ArrayBuffer
+   * Automatically calls quiet()
+   */
+  arrayBuffer(): Promise<ArrayBuffer>
+
+  /**
+   * Read from stdout as a Blob
+   * Automatically calls quiet()
+   */
+  blob(): Promise<Blob>
+
+  /**
+   * Configure the shell to not throw an exception on non-zero exit codes.
+   */
+  nothrow(): this
+
+  /**
+   * Configure whether or not the shell should throw an exception on non-zero exit codes.
+   */
+  throws(shouldThrow: boolean): this
+}
+
+export interface BunShellOutput {
+  readonly stdout: Buffer
+  readonly stderr: Buffer
+  readonly exitCode: number
+
+  /**
+   * Read from stdout as a string
+   */
+  text(encoding?: BufferEncoding): string
+
+  /**
+   * Read from stdout as a JSON object
+   */
+  json(): any
+
+  /**
+   * Read from stdout as an ArrayBuffer
+   */
+  arrayBuffer(): ArrayBuffer
+
+  /**
+   * Read from stdout as an Uint8Array
+   */
+  bytes(): Uint8Array
+
+  /**
+   * Read from stdout as a Blob
+   */
+  blob(): Blob
+}
+
+export type BunShellError = Error & BunShellOutput

opencode/packages/plugin/src/tool.ts

@@ -0,0 +1,38 @@
+import { z } from "zod"
+
+export type ToolContext = {
+  sessionID: string
+  messageID: string
+  agent: string
+  /**
+   * Current project directory for this session.
+   * Prefer this over process.cwd() when resolving relative paths.
+   */
+  directory: string
+  /**
+   * Project worktree root for this session.
+   * Useful for generating stable relative paths (e.g. path.relative(worktree, absPath)).
+   */
+  worktree: string
+  abort: AbortSignal
+  metadata(input: { title?: string; metadata?: { [key: string]: any } }): void
+  ask(input: AskInput): Promise<void>
+}
+
+type AskInput = {
+  permission: string
+  patterns: string[]
+  always: string[]
+  metadata: { [key: string]: any }
+}
+
+export function tool<Args extends z.ZodRawShape>(input: {
+  description: string
+  args: Args
+  execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>
+}) {
+  return input
+}
+tool.schema = z
+
+export type ToolDefinition = ReturnType<typeof tool>

opencode/packages/plugin/sst-env.d.ts

@@ -0,0 +1,9 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+/// <reference path="../../sst-env.d.ts" />
+
+import "sst"
+export {}

opencode/packages/plugin/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "@tsconfig/node22/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "module": "preserve",
+    "declaration": true,
+    "moduleResolution": "bundler",
+    "lib": ["es2022", "dom", "dom.iterable"]
+  },
+  "include": ["src"]
+}