wip: sync

Co-authored-by: adamdotdevin <2363879+adamdottv@users.noreply.github.com>
Co-authored-by: Jay V <air@live.ca>
Co-authored-by: Aiden Cline <63023139+rekram1-node@users.noreply.github.com>
Co-authored-by: Andrew Joslin <andrew@ajoslin.com>
Co-authored-by: GitHub Action <action@github.com>
Co-authored-by: Tobias Walle <9933601+tobias-walle@users.noreply.github.com>

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+end_of_line = lf
+indent_style = space
+indent_size = 2
+max_line_length = 80

.github/workflows/deploy.yml

@@ -0,0 +1,26 @@
+name: deploy
+
+on:
+  push:
+    branches:
+      - dev
+      - production
+  workflow_dispatch:
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: oven-sh/setup-bun@v1
+        with:
+          bun-version: 1.2.17
+
+      - run: bun install
+
+      - run: bun sst deploy --stage=${{ github.ref_name }}
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/notify-discord.yml

@@ -0,0 +1,14 @@
+name: discord
+
+on:
+  release:
+    types: [published]   # fires only when a release is published
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send nicely-formatted embed to Discord
+        uses: SethCohen/github-releases-to-discord@v1
+        with:
+          webhook_url: ${{ secrets.DISCORD_WEBHOOK }}

.github/workflows/opencode.yml

@@ -0,0 +1,24 @@
+name: opencode
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  opencode:
+    if: startsWith(github.event.comment.body, 'hey opencode')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run opencode
+        uses: sst/opencode/sdks/github@github-v1
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+        with:
+          model: anthropic/claude-sonnet-4-20250514

.github/workflows/publish-github-action.yml

@@ -0,0 +1,30 @@
+name: publish-github-action
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "github-v*.*.*"
+      - "!github-v1"
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - run: git fetch --force --tags
+
+      - name: Publish
+        run: |
+          git config --global user.email "opencode@sst.dev"
+          git config --global user.name "opencode"
+          ./script/publish
+        working-directory: ./sdks/github

.github/workflows/publish-vscode.yml

@@ -0,0 +1,36 @@
+name: publish-vscode
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - "vscode-v*.*.*"
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.2.17
+
+      - run: git fetch --force --tags
+      - run: bun install -g @vscode/vsce
+
+      - name: Publish
+        run: |
+          bun install
+          ./script/publish
+        working-directory: ./sdks/vscode
+        env:
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          OPENVSX_TOKEN: ${{ secrets.OPENVSX_TOKEN }}

.github/workflows/publish.yml

@@ -0,0 +1,65 @@
+name: publish
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - dev
+    tags:
+      - "*"
+      - "!vscode-v*"
+      - "!github-v*"
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+permissions:
+  contents: write
+  packages: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - run: git fetch --force --tags
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ">=1.24.0"
+          cache: true
+          cache-dependency-path: go.sum
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.2.17
+
+      - name: Install makepkg
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y pacman-package-manager
+
+      - name: Setup SSH for AUR
+        run: |
+          mkdir -p ~/.ssh
+          echo "${{ secrets.AUR_KEY }}" > ~/.ssh/id_rsa
+          chmod 600 ~/.ssh/id_rsa
+          ssh-keyscan -H aur.archlinux.org >> ~/.ssh/known_hosts
+          git config --global user.email "opencode@sst.dev"
+          git config --global user.name "opencode"
+
+      - name: Publish
+        run: |
+          bun install
+          if [ "${{ startsWith(github.ref, 'refs/tags/') }}" = "true" ]; then
+            ./script/publish.ts
+          else
+            ./script/publish.ts --snapshot
+          fi
+        working-directory: ./packages/opencode
+        env:
+          GITHUB_TOKEN: ${{ secrets.SST_GITHUB_TOKEN }}
+          AUR_KEY: ${{ secrets.AUR_KEY }}
+          NPM_CONFIG_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/stats.yml

@@ -0,0 +1,32 @@
+name: stats
+
+on:
+  schedule:
+    - cron: "0 12 * * *" # Run daily at 12:00 UTC
+  workflow_dispatch: # Allow manual trigger
+
+jobs:
+  stats:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Run stats script
+        run: bun scripts/stats.ts
+
+      - name: Commit stats
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add STATS.md
+          git diff --staged --quiet || git commit -m "ignore: update download stats $(date -I)"
+          git push

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+node_modules
+.sst
+.env
+.idea
+.vscode
+openapi.json
+scratch

.opencode/agent/example-driven-docs-writer.md

@@ -0,0 +1,44 @@
+---
+description: >-
+  Use this agent when you need to create or improve documentation that requires
+  concrete examples to illustrate every concept. Examples include:
+  <example>Context: User has written a new API endpoint and needs documentation.
+  user: 'I just created a POST /users endpoint that accepts name and email
+  fields. Can you document this?' assistant: 'I'll use the
+  example-driven-docs-writer agent to create documentation with practical
+  examples for your API endpoint.' <commentary>Since the user needs
+  documentation with examples, use the example-driven-docs-writer agent to
+  create comprehensive docs with code samples.</commentary></example>
+  <example>Context: User has a complex configuration file that needs
+  documentation. user: 'This config file has multiple sections and I need docs
+  that show how each option works' assistant: 'Let me use the
+  example-driven-docs-writer agent to create documentation that breaks down each
+  configuration option with practical examples.' <commentary>The user needs
+  documentation that demonstrates configuration options, perfect for the
+  example-driven-docs-writer agent.</commentary></example>
+---
+You are an expert technical documentation writer who specializes in creating clear, example-rich documentation that never leaves readers guessing. Your core principle is that every concept must be immediately illustrated with concrete examples, code samples, or practical demonstrations.
+
+Your documentation approach:
+- Never write more than one sentence in any section without providing an example, code snippet, diagram, or practical illustration
+- Break up longer explanations with multiple examples showing different scenarios or use cases
+- Use concrete, realistic examples rather than abstract or placeholder content
+- Include both basic and advanced examples when covering complex topics
+- Show expected inputs, outputs, and results for all examples
+- Use code blocks, bullet points, tables, or other formatting to visually separate examples from explanatory text
+
+Structural requirements:
+- Start each section with a brief one-sentence explanation followed immediately by an example
+- For multi-step processes, provide an example after each step
+- Include error examples and edge cases alongside success scenarios
+- Use consistent formatting and naming conventions throughout examples
+- Ensure examples are copy-pasteable and functional when applicable
+
+Quality standards:
+- Verify that no paragraph exceeds one sentence without an accompanying example
+- Test that examples are accurate and would work in real scenarios
+- Ensure examples progress logically from simple to complex
+- Include context for when and why to use different approaches shown in examples
+- Provide troubleshooting examples for common issues
+
+When you receive a documentation request, immediately identify what needs examples and plan to illustrate every single concept, feature, or instruction with concrete demonstrations. Ask for clarification if you need more context to create realistic, useful examples.

AGENTS.md

@@ -0,0 +1,13 @@
+## Style
+
+- prefer single word variable/function names
+- avoid try catch where possible - prefer to let exceptions bubble up
+- avoid else statements where possible
+- do not make useless helper functions - inline functionality unless the
+  function is reusable or composable
+- prefer Bun apis
+
+## Workflow
+
+- you can regenerate the golang sdk by calling ./scripts/stainless.ts
+- we use bun for everything

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 opencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,110 @@
+<p align="center">
+  <a href="https://opencode.ai">
+    <picture>
+      <source srcset="packages/web/src/assets/logo-ornate-dark.svg" media="(prefers-color-scheme: dark)">
+      <source srcset="packages/web/src/assets/logo-ornate-light.svg" media="(prefers-color-scheme: light)">
+      <img src="packages/web/src/assets/logo-ornate-light.svg" alt="opencode logo">
+    </picture>
+  </a>
+</p>
+<p align="center">AI coding agent, built for the terminal.</p>
+<p align="center">
+  <a href="https://opencode.ai/discord"><img alt="Discord" src="https://img.shields.io/discord/1391832426048651334?style=flat-square&label=discord" /></a>
+  <a href="https://www.npmjs.com/package/opencode-ai"><img alt="npm" src="https://img.shields.io/npm/v/opencode-ai?style=flat-square" /></a>
+  <a href="https://github.com/sst/opencode/actions/workflows/publish.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/sst/opencode/publish.yml?style=flat-square&branch=dev" /></a>
+</p>
+
+[![opencode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)
+
+---
+
+### Installation
+
+```bash
+# YOLO
+curl -fsSL https://opencode.ai/install | bash
+
+# Package managers
+npm i -g opencode-ai@latest        # or bun/pnpm/yarn
+brew install sst/tap/opencode      # macOS
+paru -S opencode-bin               # Arch Linux
+```
+
+> [!TIP]
+> Remove versions older than 0.1.x before installing.
+
+#### Installation Directory
+
+The install script respects the following priority order for the installation path:
+
+1. `$OPENCODE_INSTALL_DIR` - Custom installation directory
+2. `$XDG_BIN_DIR` - XDG Base Directory Specification compliant path
+3. `$HOME/bin` - Standard user binary directory (if exists or can be created)
+4. `$HOME/.opencode/bin` - Default fallback
+
+```bash
+# Examples
+OPENCODE_INSTALL_DIR=/usr/local/bin curl -fsSL https://opencode.ai/install | bash
+XDG_BIN_DIR=$HOME/.local/bin curl -fsSL https://opencode.ai/install | bash
+```
+
+### Documentation
+
+For more info on how to configure opencode [**head over to our docs**](https://opencode.ai/docs).
+
+### Contributing
+
+opencode is an opinionated tool so any fundamental feature needs to go through a
+design process with the core team.
+
+> [!IMPORTANT]
+> We do not accept PRs for core features.
+
+However we still merge a ton of PRs - you can contribute:
+
+- Bug fixes
+- Improvements to LLM performance
+- Support for new providers
+- Fixes for env specific quirks
+- Missing standard behavior
+- Documentation
+
+Take a look at the git history to see what kind of PRs we end up merging.
+
+> [!NOTE]
+> If you do not follow the above guidelines we might close your PR.
+
+To run opencode locally you need.
+
+- Bun
+- Golang 1.24.x
+
+And run.
+
+```bash
+$ bun install
+$ bun run packages/opencode/src/index.ts
+```
+
+#### Development Notes
+
+**API Client**: After making changes to the TypeScript API endpoints in `packages/opencode/src/server/server.ts`, you will need the opencode team to generate a new stainless sdk for the clients.
+
+### FAQ
+
+#### How is this different than Claude Code?
+
+It's very similar to Claude Code in terms of capability. Here are the key differences:
+
+- 100% open source
+- Not coupled to any provider. Although Anthropic is recommended, opencode can be used with OpenAI, Google or even local models. As models evolve the gaps between them will close and pricing will drop so being provider agnostic is important.
+- A focus on TUI. opencode is built by neovim users and the creators of [terminal.shop](https://terminal.shop); we are going to push the limits of what's possible in the terminal.
+- A client/server architecture. This for example can allow opencode to run on your computer, while you can drive it remotely from a mobile app. Meaning that the TUI frontend is just one of the possible clients.
+
+#### What's the other repo?
+
+The other confusingly named repo has no relation to this one. You can [read the story behind it here](https://x.com/thdxr/status/1933561254481666466).
+
+---
+
+**Join our community** [Discord](https://discord.gg/opencode) | [YouTube](https://www.youtube.com/c/sst-dev) | [X.com](https://x.com/SST_dev)

STATS.md

@@ -0,0 +1,29 @@
+# Download Stats
+
+| Date       | GitHub Downloads | npm Downloads    | Total             |
+| ---------- | ---------------- | ---------------- | ----------------- |
+| 2025-06-29 | 18,789 (+0)      | 39,420 (+0)      | 58,209 (+0)       |
+| 2025-06-30 | 20,127 (+1,338)  | 41,059 (+1,639)  | 61,186 (+2,977)   |
+| 2025-07-01 | 22,108 (+1,981)  | 43,745 (+2,686)  | 65,853 (+4,667)   |
+| 2025-07-02 | 24,814 (+2,706)  | 46,168 (+2,423)  | 70,982 (+5,129)   |
+| 2025-07-03 | 27,834 (+3,020)  | 49,955 (+3,787)  | 77,789 (+6,807)   |
+| 2025-07-04 | 30,608 (+2,774)  | 54,758 (+4,803)  | 85,366 (+7,577)   |
+| 2025-07-05 | 32,524 (+1,916)  | 58,371 (+3,613)  | 90,895 (+5,529)   |
+| 2025-07-06 | 33,766 (+1,242)  | 59,694 (+1,323)  | 93,460 (+2,565)   |
+| 2025-07-08 | 38,052 (+4,286)  | 64,468 (+4,774)  | 102,520 (+9,060)  |
+| 2025-07-10 | 43,796 (+5,744)  | 71,402 (+6,934)  | 115,198 (+12,678) |
+| 2025-07-11 | 46,982 (+3,186)  | 77,462 (+6,060)  | 124,444 (+9,246)  |
+| 2025-07-12 | 49,302 (+2,320)  | 82,177 (+4,715)  | 131,479 (+7,035)  |
+| 2025-07-13 | 50,803 (+1,501)  | 86,394 (+4,217)  | 137,197 (+5,718)  |
+| 2025-07-14 | 53,283 (+2,480)  | 87,860 (+1,466)  | 141,143 (+3,946)  |
+| 2025-07-15 | 57,590 (+4,307)  | 91,036 (+3,176)  | 148,626 (+7,483)  |
+| 2025-07-16 | 62,313 (+4,723)  | 95,258 (+4,222)  | 157,571 (+8,945)  |
+| 2025-07-17 | 66,684 (+4,371)  | 100,048 (+4,790) | 166,732 (+9,161)  |
+| 2025-07-18 | 70,379 (+3,695)  | 102,587 (+2,539) | 172,966 (+6,234)  |
+| 2025-07-19 | 73,497 (+3,117)  | 105,904 (+3,317) | 179,401 (+6,434)  |
+| 2025-07-20 | 76,453 (+2,956)  | 109,044 (+3,140) | 185,497 (+6,096)  |
+| 2025-07-21 | 80,197 (+3,744)  | 113,537 (+4,493) | 193,734 (+8,237)  |
+| 2025-07-22 | 84,251 (+4,054)  | 118,073 (+4,536) | 202,324 (+8,590)  |
+| 2025-07-23 | 88,589 (+4,338)  | 121,436 (+3,363) | 210,025 (+7,701)  |
+| 2025-07-24 | 92,469 (+3,880)  | 124,091 (+2,655) | 216,560 (+6,535)  |
+| 2025-07-25 | 96,417 (+3,948)  | 126,985 (+2,894) | 223,402 (+6,842)  |

bunfig.toml

@@ -0,0 +1,2 @@
+[install]
+exact = true

infra/app.ts

@@ -0,0 +1,48 @@
+export const domain = (() => {
+  if ($app.stage === "production") return "opencode.ai"
+  if ($app.stage === "dev") return "dev.opencode.ai"
+  return `${$app.stage}.dev.opencode.ai`
+})()
+
+const GITHUB_APP_ID = new sst.Secret("GITHUB_APP_ID")
+const GITHUB_APP_PRIVATE_KEY = new sst.Secret("GITHUB_APP_PRIVATE_KEY")
+const bucket = new sst.cloudflare.Bucket("Bucket")
+
+export const api = new sst.cloudflare.Worker("Api", {
+  domain: `api.${domain}`,
+  handler: "packages/function/src/api.ts",
+  environment: {
+    WEB_DOMAIN: domain,
+  },
+  url: true,
+  link: [bucket, GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY],
+  transform: {
+    worker: (args) => {
+      args.logpush = true
+      args.bindings = $resolve(args.bindings).apply((bindings) => [
+        ...bindings,
+        {
+          name: "SYNC_SERVER",
+          type: "durable_object_namespace",
+          className: "SyncServer",
+        },
+      ])
+      args.migrations = {
+        // Note: when releasing the next tag, make sure all stages use tag v2
+        oldTag: $app.stage === "production" ? "" : "v1",
+        newTag: $app.stage === "production" ? "" : "v1",
+        //newSqliteClasses: ["SyncServer"],
+      }
+    },
+  },
+})
+
+new sst.cloudflare.x.Astro("Web", {
+  domain,
+  path: "packages/web",
+  environment: {
+    // For astro config
+    SST_STAGE: $app.stage,
+    VITE_API_URL: api.url,
+  },
+})

install

@@ -0,0 +1,188 @@
+#!/usr/bin/env bash
+set -euo pipefail
+APP=opencode
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+ORANGE='\033[38;2;255;140;0m'
+NC='\033[0m' # No Color
+
+requested_version=${VERSION:-}
+
+os=$(uname -s | tr '[:upper:]' '[:lower:]')
+if [[ "$os" == "darwin" ]]; then
+    os="darwin"
+fi
+arch=$(uname -m)
+
+if [[ "$arch" == "aarch64" ]]; then
+  arch="arm64"
+elif [[ "$arch" == "x86_64" ]]; then
+  arch="x64"
+fi
+
+filename="$APP-$os-$arch.zip"
+
+
+case "$filename" in
+    *"-linux-"*)
+        [[ "$arch" == "x64" || "$arch" == "arm64" ]] || exit 1
+    ;;
+    *"-darwin-"*)
+        [[ "$arch" == "x64" || "$arch" == "arm64" ]] || exit 1
+    ;;
+    *"-windows-"*)
+        [[ "$arch" == "x64" ]] || exit 1
+    ;;
+    *)
+        echo "${RED}Unsupported OS/Arch: $os/$arch${NC}"
+        exit 1
+    ;;
+esac
+
+INSTALL_DIR=$HOME/.opencode/bin
+mkdir -p "$INSTALL_DIR"
+
+if [ -z "$requested_version" ]; then
+    url="https://github.com/sst/opencode/releases/latest/download/$filename"
+    specific_version=$(curl -s https://api.github.com/repos/sst/opencode/releases/latest | awk -F'"' '/"tag_name": "/ {gsub(/^v/, "", $4); print $4}')
+
+    if [[ $? -ne 0 || -z "$specific_version" ]]; then
+        echo "${RED}Failed to fetch version information${NC}"
+        exit 1
+    fi
+else
+    url="https://github.com/sst/opencode/releases/download/v${requested_version}/$filename"
+    specific_version=$requested_version
+fi
+
+print_message() {
+    local level=$1
+    local message=$2
+    local color=""
+
+    case $level in
+        info) color="${GREEN}" ;;
+        warning) color="${YELLOW}" ;;
+        error) color="${RED}" ;;
+    esac
+
+    echo -e "${color}${message}${NC}"
+}
+
+check_version() {
+    if command -v opencode >/dev/null 2>&1; then
+        opencode_path=$(which opencode)
+
+
+        ## TODO: check if version is installed
+        # installed_version=$(opencode version)
+        installed_version="0.0.1"
+        installed_version=$(echo $installed_version | awk '{print $2}')
+
+        if [[ "$installed_version" != "$specific_version" ]]; then
+            print_message info "Installed version: ${YELLOW}$installed_version."
+        else
+            print_message info "Version ${YELLOW}$specific_version${GREEN} already installed"
+            exit 0
+        fi
+    fi
+}
+
+download_and_install() {
+    print_message info "Downloading ${ORANGE}opencode ${GREEN}version: ${YELLOW}$specific_version ${GREEN}..."
+    mkdir -p opencodetmp && cd opencodetmp
+    curl -# -L -o "$filename" "$url"
+    unzip -q "$filename"
+    mv opencode "$INSTALL_DIR"
+    cd .. && rm -rf opencodetmp 
+}
+
+check_version
+download_and_install
+
+
+add_to_path() {
+    local config_file=$1
+    local command=$2
+
+    if grep -Fxq "$command" "$config_file"; then
+        print_message info "Command already exists in $config_file, skipping write."
+    elif [[ -w $config_file ]]; then
+        echo -e "\n# opencode" >> "$config_file"
+        echo "$command" >> "$config_file"
+        print_message info "Successfully added ${ORANGE}opencode ${GREEN}to \$PATH in $config_file"
+    else
+        print_message warning "Manually add the directory to $config_file (or similar):"
+        print_message info "  $command"
+    fi
+}
+
+XDG_CONFIG_HOME=${XDG_CONFIG_HOME:-$HOME/.config}
+
+current_shell=$(basename "$SHELL")
+case $current_shell in
+    fish)
+        config_files="$HOME/.config/fish/config.fish"
+    ;;
+    zsh)
+        config_files="$HOME/.zshrc $HOME/.zshenv $XDG_CONFIG_HOME/zsh/.zshrc $XDG_CONFIG_HOME/zsh/.zshenv"
+    ;;
+    bash)
+        config_files="$HOME/.bashrc $HOME/.bash_profile $HOME/.profile $XDG_CONFIG_HOME/bash/.bashrc $XDG_CONFIG_HOME/bash/.bash_profile"
+    ;;
+    ash)
+        config_files="$HOME/.ashrc $HOME/.profile /etc/profile"
+    ;;
+    sh)
+        config_files="$HOME/.ashrc $HOME/.profile /etc/profile"
+    ;;
+    *)
+        # Default case if none of the above matches
+        config_files="$HOME/.bashrc $HOME/.bash_profile $XDG_CONFIG_HOME/bash/.bashrc $XDG_CONFIG_HOME/bash/.bash_profile"
+    ;;
+esac
+
+config_file=""
+for file in $config_files; do
+    if [[ -f $file ]]; then
+        config_file=$file
+        break
+    fi
+done
+
+if [[ -z $config_file ]]; then
+    print_message error "No config file found for $current_shell. Checked files: ${config_files[@]}"
+    exit 1
+fi
+
+if [[ ":$PATH:" != *":$INSTALL_DIR:"* ]]; then
+    case $current_shell in
+        fish)
+            add_to_path "$config_file" "fish_add_path $INSTALL_DIR"
+        ;;
+        zsh)
+            add_to_path "$config_file" "export PATH=$INSTALL_DIR:\$PATH"
+        ;;
+        bash)
+            add_to_path "$config_file" "export PATH=$INSTALL_DIR:\$PATH"
+        ;;
+        ash)
+            add_to_path "$config_file" "export PATH=$INSTALL_DIR:\$PATH"
+        ;;
+        sh)
+            add_to_path "$config_file" "export PATH=$INSTALL_DIR:\$PATH"
+        ;;
+        *)
+            export PATH=$INSTALL_DIR:$PATH
+            print_message warning "Manually add the directory to $config_file (or similar):"
+            print_message info "  export PATH=$INSTALL_DIR:\$PATH"
+        ;;
+    esac
+fi
+
+if [ -n "${GITHUB_ACTIONS-}" ] && [ "${GITHUB_ACTIONS}" == "true" ]; then
+    echo "$INSTALL_DIR" >> $GITHUB_PATH
+    print_message info "Added $INSTALL_DIR to \$GITHUB_PATH"
+fi

opencode.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openrouter": {
+      "models": {
+        "moonshotai/kimi-k2": {
+          "options": {
+            "provider": {
+              "order": ["baseten"],
+              "allow_fallbacks": false
+            }
+          }
+        }
+      }
+    },
+    "huggingface": {
+      "models": {
+        "Qwen/Qwen3-235B-A22B-Instruct-2507:fireworks-ai": {}
+      }
+    }
+  },
+  "mcp": {
+    "weather": {
+      "type": "local",
+      "command": ["opencode", "x", "@h1deya/mcp-server-weather"]
+    }
+  }
+}

package.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "opencode",
+  "private": true,
+  "type": "module",
+  "packageManager": "bun@1.2.14",
+  "scripts": {
+    "dev": "bun run packages/opencode/src/index.ts",
+    "typecheck": "bun run --filter='*' typecheck",
+    "stainless": "./scripts/stainless",
+    "postinstall": "./scripts/hooks"
+  },
+  "workspaces": {
+    "packages": [
+      "packages/*"
+    ],
+    "catalog": {
+      "typescript": "5.8.2",
+      "@types/node": "22.13.9",
+      "zod": "3.25.49",
+      "ai": "5.0.0-beta.21"
+    }
+  },
+  "devDependencies": {
+    "prettier": "3.5.3",
+    "sst": "3.17.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sst/opencode"
+  },
+  "license": "MIT",
+  "prettier": {
+    "semi": false,
+    "printWidth": 120
+  },
+  "trustedDependencies": [
+    "esbuild",
+    "protobufjs",
+    "sharp"
+  ],
+  "patchedDependencies": {}
+}

packages/function/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@opencode/function",
+  "version": "0.0.1",
+  "$schema": "https://json.schemastore.org/package.json",
+  "private": true,
+  "type": "module",
+  "devDependencies": {
+    "@cloudflare/workers-types": "4.20250522.0",
+    "typescript": "catalog:",
+    "@types/node": "catalog:"
+  },
+  "dependencies": {
+    "@octokit/auth-app": "8.0.1",
+    "@octokit/rest": "22.0.0",
+    "jose": "6.0.11"
+  }
+}

packages/function/src/api.ts

@@ -0,0 +1,375 @@
+import { DurableObject } from "cloudflare:workers"
+import { randomUUID } from "node:crypto"
+import { jwtVerify, createRemoteJWKSet } from "jose"
+import { createAppAuth } from "@octokit/auth-app"
+import { Octokit } from "@octokit/rest"
+import { Resource } from "sst"
+
+type Env = {
+  SYNC_SERVER: DurableObjectNamespace<SyncServer>
+  Bucket: R2Bucket
+  WEB_DOMAIN: string
+}
+
+export class SyncServer extends DurableObject<Env> {
+  constructor(ctx: DurableObjectState, env: Env) {
+    super(ctx, env)
+  }
+  async fetch() {
+    console.log("SyncServer subscribe")
+
+    const webSocketPair = new WebSocketPair()
+    const [client, server] = Object.values(webSocketPair)
+
+    this.ctx.acceptWebSocket(server)
+
+    const data = await this.ctx.storage.list()
+    Array.from(data.entries())
+      .filter(([key, _]) => key.startsWith("session/"))
+      .map(([key, content]) => server.send(JSON.stringify({ key, content })))
+
+    return new Response(null, {
+      status: 101,
+      webSocket: client,
+    })
+  }
+
+  async webSocketMessage(ws, message) {}
+
+  async webSocketClose(ws, code, reason, wasClean) {
+    ws.close(code, "Durable Object is closing WebSocket")
+  }
+
+  async publish(key: string, content: any) {
+    const sessionID = await this.getSessionID()
+    if (
+      !key.startsWith(`session/info/${sessionID}`) &&
+      !key.startsWith(`session/message/${sessionID}/`) &&
+      !key.startsWith(`session/part/${sessionID}/`)
+    )
+      return new Response("Error: Invalid key", { status: 400 })
+
+    // store message
+    await this.env.Bucket.put(`share/${key}.json`, JSON.stringify(content), {
+      httpMetadata: {
+        contentType: "application/json",
+      },
+    })
+    await this.ctx.storage.put(key, content)
+    const clients = this.ctx.getWebSockets()
+    console.log("SyncServer publish", key, "to", clients.length, "subscribers")
+    for (const client of clients) {
+      client.send(JSON.stringify({ key, content }))
+    }
+  }
+
+  public async share(sessionID: string) {
+    let secret = await this.getSecret()
+    if (secret) return secret
+    secret = randomUUID()
+
+    await this.ctx.storage.put("secret", secret)
+    await this.ctx.storage.put("sessionID", sessionID)
+
+    return secret
+  }
+
+  public async getData() {
+    const data = (await this.ctx.storage.list()) as Map<string, any>
+    return Array.from(data.entries())
+      .filter(([key, _]) => key.startsWith("session/"))
+      .map(([key, content]) => ({ key, content }))
+  }
+
+  public async assertSecret(secret: string) {
+    if (secret !== (await this.getSecret())) throw new Error("Invalid secret")
+  }
+
+  private async getSecret() {
+    return this.ctx.storage.get<string>("secret")
+  }
+
+  private async getSessionID() {
+    return this.ctx.storage.get<string>("sessionID")
+  }
+
+  async clear() {
+    const sessionID = await this.getSessionID()
+    const list = await this.env.Bucket.list({
+      prefix: `session/message/${sessionID}/`,
+      limit: 1000,
+    })
+    for (const item of list.objects) {
+      await this.env.Bucket.delete(item.key)
+    }
+    await this.env.Bucket.delete(`session/info/${sessionID}`)
+    await this.ctx.storage.deleteAll()
+  }
+
+  static shortName(id: string) {
+    return id.substring(id.length - 8)
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    const url = new URL(request.url)
+    const splits = url.pathname.split("/")
+    const method = splits[1]
+
+    if (request.method === "GET" && method === "") {
+      return new Response("Hello, world!", {
+        headers: { "Content-Type": "text/plain" },
+      })
+    }
+
+    if (request.method === "POST" && method === "share_create") {
+      const body = await request.json<any>()
+      const sessionID = body.sessionID
+      const short = SyncServer.shortName(sessionID)
+      const id = env.SYNC_SERVER.idFromName(short)
+      const stub = env.SYNC_SERVER.get(id)
+      const secret = await stub.share(sessionID)
+      return new Response(
+        JSON.stringify({
+          secret,
+          url: `https://${env.WEB_DOMAIN}/s/${short}`,
+        }),
+        {
+          headers: { "Content-Type": "application/json" },
+        },
+      )
+    }
+
+    if (request.method === "POST" && method === "share_delete") {
+      const body = await request.json<any>()
+      const sessionID = body.sessionID
+      const secret = body.secret
+      const id = env.SYNC_SERVER.idFromName(SyncServer.shortName(sessionID))
+      const stub = env.SYNC_SERVER.get(id)
+      await stub.assertSecret(secret)
+      await stub.clear()
+      return new Response(JSON.stringify({}), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    if (request.method === "POST" && method === "share_delete_admin") {
+      const id = env.SYNC_SERVER.idFromName("oVF8Rsiv")
+      const stub = env.SYNC_SERVER.get(id)
+      await stub.clear()
+      return new Response(JSON.stringify({}), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    if (request.method === "POST" && method === "share_sync") {
+      const body = await request.json<{
+        sessionID: string
+        secret: string
+        key: string
+        content: any
+      }>()
+      const name = SyncServer.shortName(body.sessionID)
+      const id = env.SYNC_SERVER.idFromName(name)
+      const stub = env.SYNC_SERVER.get(id)
+      await stub.assertSecret(body.secret)
+      await stub.publish(body.key, body.content)
+      return new Response(JSON.stringify({}), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    if (request.method === "GET" && method === "share_poll") {
+      const upgradeHeader = request.headers.get("Upgrade")
+      if (!upgradeHeader || upgradeHeader !== "websocket") {
+        return new Response("Error: Upgrade header is required", {
+          status: 426,
+        })
+      }
+      const id = url.searchParams.get("id")
+      console.log("share_poll", id)
+      if (!id) return new Response("Error: Share ID is required", { status: 400 })
+      const stub = env.SYNC_SERVER.get(env.SYNC_SERVER.idFromName(id))
+      return stub.fetch(request)
+    }
+
+    if (request.method === "GET" && method === "share_data") {
+      const id = url.searchParams.get("id")
+      console.log("share_data", id)
+      if (!id) return new Response("Error: Share ID is required", { status: 400 })
+      const stub = env.SYNC_SERVER.get(env.SYNC_SERVER.idFromName(id))
+      const data = await stub.getData()
+
+      let info
+      const messages: Record<string, any> = {}
+      data.forEach((d) => {
+        const [root, type, ...splits] = d.key.split("/")
+        if (root !== "session") return
+        if (type === "info") {
+          info = d.content
+          return
+        }
+        if (type === "message") {
+          messages[d.content.id] = {
+            parts: [],
+            ...d.content,
+          }
+        }
+        if (type === "part") {
+          messages[d.content.messageID].parts.push(d.content)
+        }
+      })
+
+      return new Response(
+        JSON.stringify({
+          info,
+          messages,
+        }),
+        {
+          headers: { "Content-Type": "application/json" },
+        },
+      )
+    }
+
+    /**
+     * Used by the GitHub action to get GitHub installation access token given the OIDC token
+     */
+    if (request.method === "POST" && method === "exchange_github_app_token") {
+      const EXPECTED_AUDIENCE = "opencode-github-action"
+      const GITHUB_ISSUER = "https://token.actions.githubusercontent.com"
+      const JWKS_URL = `${GITHUB_ISSUER}/.well-known/jwks`
+
+      // get Authorization header
+      const authHeader = request.headers.get("Authorization")
+      const token = authHeader?.replace(/^Bearer /, "")
+      if (!token)
+        return new Response(JSON.stringify({ error: "Authorization header is required" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" },
+        })
+
+      // verify token
+      const JWKS = createRemoteJWKSet(new URL(JWKS_URL))
+      let owner, repo
+      try {
+        const { payload } = await jwtVerify(token, JWKS, {
+          issuer: GITHUB_ISSUER,
+          audience: EXPECTED_AUDIENCE,
+        })
+        const sub = payload.sub // e.g. 'repo:my-org/my-repo:ref:refs/heads/main'
+        const parts = sub.split(":")[1].split("/")
+        owner = parts[0]
+        repo = parts[1]
+      } catch (err) {
+        console.error("Token verification failed:", err)
+        return new Response(JSON.stringify({ error: "Invalid or expired token" }), {
+          status: 403,
+          headers: { "Content-Type": "application/json" },
+        })
+      }
+
+      // Create app JWT token
+      const auth = createAppAuth({
+        appId: Resource.GITHUB_APP_ID.value,
+        privateKey: Resource.GITHUB_APP_PRIVATE_KEY.value,
+      })
+      const appAuth = await auth({ type: "app" })
+
+      // Lookup installation
+      const octokit = new Octokit({ auth: appAuth.token })
+      const { data: installation } = await octokit.apps.getRepoInstallation({ owner, repo })
+
+      // Get installation token
+      const installationAuth = await auth({ type: "installation", installationId: installation.id })
+
+      return new Response(JSON.stringify({ token: installationAuth.token }), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    /**
+     * Used by the GitHub action to get GitHub installation access token given user PAT token (used when testing `opencode github run` locally)
+     */
+    if (request.method === "POST" && method === "exchange_github_app_token_with_pat") {
+      const body = await request.json<any>()
+      const owner = body.owner
+      const repo = body.repo
+
+      try {
+        // get Authorization header
+        const authHeader = request.headers.get("Authorization")
+        const token = authHeader?.replace(/^Bearer /, "")
+        if (!token) throw new Error("Authorization header is required")
+
+        // Verify permissions
+        const userClient = new Octokit({ auth: token })
+        const { data: repoData } = await userClient.repos.get({ owner, repo })
+        if (!repoData.permissions.admin && !repoData.permissions.push && !repoData.permissions.maintain)
+          throw new Error("User does not have write permissions")
+
+        // Get installation token
+        const auth = createAppAuth({
+          appId: Resource.GITHUB_APP_ID.value,
+          privateKey: Resource.GITHUB_APP_PRIVATE_KEY.value,
+        })
+        const appAuth = await auth({ type: "app" })
+
+        // Lookup installation
+        const appClient = new Octokit({ auth: appAuth.token })
+        const { data: installation } = await appClient.apps.getRepoInstallation({ owner, repo })
+
+        // Get installation token
+        const installationAuth = await auth({ type: "installation", installationId: installation.id })
+
+        return new Response(JSON.stringify({ token: installationAuth.token }), {
+          headers: { "Content-Type": "application/json" },
+        })
+      } catch (e: any) {
+        let error = e
+        if (e instanceof Error) {
+          error = e.message
+        }
+
+        return new Response(JSON.stringify({ error }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" },
+        })
+      }
+    }
+
+    /**
+     * Used by the opencode CLI to check if the GitHub app is installed
+     */
+    if (request.method === "GET" && method === "get_github_app_installation") {
+      const owner = url.searchParams.get("owner")
+      const repo = url.searchParams.get("repo")
+
+      const auth = createAppAuth({
+        appId: Resource.GITHUB_APP_ID.value,
+        privateKey: Resource.GITHUB_APP_PRIVATE_KEY.value,
+      })
+      const appAuth = await auth({ type: "app" })
+
+      // Lookup installation
+      const octokit = new Octokit({ auth: appAuth.token })
+      let installation
+      try {
+        const ret = await octokit.apps.getRepoInstallation({ owner, repo })
+        installation = ret.data
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("Not Found")) {
+          // not installed
+        } else {
+          throw err
+        }
+      }
+
+      return new Response(JSON.stringify({ installation }), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    return new Response("Not Found", { status: 404 })
+  },
+}

packages/function/sst-env.d.ts

@@ -0,0 +1,33 @@
+/* This file is auto-generated by SST. Do not edit. */
+/* tslint:disable */
+/* eslint-disable */
+/* deno-fmt-ignore-file */
+
+import "sst"
+declare module "sst" {
+  export interface Resource {
+    "GITHUB_APP_ID": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
+    "GITHUB_APP_PRIVATE_KEY": {
+      "type": "sst.sst.Secret"
+      "value": string
+    }
+    "Web": {
+      "type": "sst.cloudflare.Astro"
+      "url": string
+    }
+  }
+}
+// cloudflare 
+import * as cloudflare from "@cloudflare/workers-types";
+declare module "sst" {
+  export interface Resource {
+    "Api": cloudflare.Service
+    "Bucket": cloudflare.R2Bucket
+  }
+}
+
+import "sst"
+export {}

packages/function/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@tsconfig/node22/tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["@cloudflare/workers-types", "node"]
+  }
+}

packages/opencode/.gitignore

@@ -0,0 +1,4 @@
+research
+dist
+gen
+app.log

packages/opencode/AGENTS.md

@@ -0,0 +1,40 @@
+# opencode agent guidelines
+
+## Build/Test Commands
+
+- **Install**: `bun install`
+- **Run**: `bun run index.ts`
+- **Typecheck**: `bun run typecheck` (npm run typecheck)
+- **Test**: `bun test` (runs all tests)
+- **Single test**: `bun test test/tool/tool.test.ts` (specific test file)
+
+## Code Style
+
+- **Runtime**: Bun with TypeScript ESM modules
+- **Imports**: Use relative imports for local modules, named imports preferred
+- **Types**: Zod schemas for validation, TypeScript interfaces for structure
+- **Naming**: camelCase for variables/functions, PascalCase for classes/namespaces
+- **Error handling**: Use Result patterns, avoid throwing exceptions in tools
+- **File structure**: Namespace-based organization (e.g., `Tool.define()`, `Session.create()`)
+
+## IMPORTANT
+
+- Try to keep things in one function unless composable or reusable
+- DO NOT do unnecessary destructuring of variables
+- DO NOT use `else` statements unless necessary
+- DO NOT use `try`/`catch` if it can be avoided
+- AVOID `try`/`catch` where possible
+- AVOID `else` statements
+- AVOID using `any` type
+- AVOID `let` statements
+- PREFER single word variable names where possible
+- Use as many bun apis as possible like Bun.file()
+
+## Architecture
+
+- **Tools**: Implement `Tool.Info` interface with `execute()` method
+- **Context**: Pass `sessionID` in tool context, use `App.provide()` for DI
+- **Validation**: All inputs validated with Zod schemas
+- **Logging**: Use `Log.create({ service: "name" })` pattern
+- **Storage**: Use `Storage` namespace for persistence
+- **API Client**: Go TUI communicates with TypeScript server via stainless SDK. When adding/modifying server endpoints in `packages/opencode/src/server/server.ts`, ask the user to generate a new client SDK to proceed with client-side changes.

packages/opencode/README.md

@@ -0,0 +1,15 @@
+# js
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.12. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

packages/opencode/bin/opencode

@@ -0,0 +1,61 @@
+#!/bin/sh
+set -e
+
+if [ -n "$OPENCODE_BIN_PATH" ]; then
+    resolved="$OPENCODE_BIN_PATH"
+else
+    # Get the real path of this script, resolving any symlinks
+    script_path="$0"
+    while [ -L "$script_path" ]; do
+        link_target="$(readlink "$script_path")"
+        case "$link_target" in
+            /*) script_path="$link_target" ;;
+            *) script_path="$(dirname "$script_path")/$link_target" ;;
+        esac
+    done
+    script_dir="$(dirname "$script_path")"
+    script_dir="$(cd "$script_dir" && pwd)"
+    
+    # Map platform names
+    case "$(uname -s)" in
+        Darwin) platform="darwin" ;;
+        Linux) platform="linux" ;;
+        MINGW*|CYGWIN*|MSYS*) platform="win32" ;;
+        *) platform="$(uname -s | tr '[:upper:]' '[:lower:]')" ;;
+    esac
+    
+    # Map architecture names  
+    case "$(uname -m)" in
+        x86_64|amd64) arch="x64" ;;
+        aarch64) arch="arm64" ;;
+        armv7l) arch="arm" ;;
+        *) arch="$(uname -m)" ;;
+    esac
+    
+    name="opencode-${platform}-${arch}"
+    binary="opencode"
+    [ "$platform" = "win32" ] && binary="opencode.exe"
+    
+    # Search for the binary starting from real script location
+    resolved=""
+    current_dir="$script_dir"
+    while [ "$current_dir" != "/" ]; do
+        candidate="$current_dir/node_modules/$name/bin/$binary"
+        if [ -f "$candidate" ]; then
+            resolved="$candidate"
+            break
+        fi
+        current_dir="$(dirname "$current_dir")"
+    done
+    
+    if [ -z "$resolved" ]; then
+        printf "It seems that your package manager failed to install the right version of the opencode CLI for your platform. You can try manually installing the \"%s\" package\n" "$name" >&2
+        exit 1
+    fi
+fi
+
+# Handle SIGINT gracefully
+trap '' INT
+
+# Execute the binary with all arguments
+exec "$resolved" "$@"

packages/opencode/bin/opencode.cmd

@@ -0,0 +1,56 @@
+@echo off
+setlocal enabledelayedexpansion
+
+if defined OPENCODE_BIN_PATH (
+    set "resolved=%OPENCODE_BIN_PATH%"
+    goto :execute
+)
+
+rem Get the directory of this script
+set "script_dir=%~dp0"
+set "script_dir=%script_dir:~0,-1%"
+
+rem Detect platform and architecture
+set "platform=win32"
+
+rem Detect architecture
+if "%PROCESSOR_ARCHITECTURE%"=="AMD64" (
+    set "arch=x64"
+) else if "%PROCESSOR_ARCHITECTURE%"=="ARM64" (
+    set "arch=arm64"
+) else if "%PROCESSOR_ARCHITECTURE%"=="x86" (
+    set "arch=x86"
+) else (
+    set "arch=x64"
+)
+
+set "name=opencode-!platform!-!arch!"
+set "binary=opencode.exe"
+
+rem Search for the binary starting from script location
+set "resolved="
+set "current_dir=%script_dir%"
+
+:search_loop
+set "candidate=%current_dir%\node_modules\%name%\bin\%binary%"
+if exist "%candidate%" (
+    set "resolved=%candidate%"
+    goto :execute
+)
+
+rem Move up one directory
+for %%i in ("%current_dir%") do set "parent_dir=%%~dpi"
+set "parent_dir=%parent_dir:~0,-1%"
+
+rem Check if we've reached the root
+if "%current_dir%"=="%parent_dir%" goto :not_found
+set "current_dir=%parent_dir%"
+goto :search_loop
+
+:not_found
+echo It seems that your package manager failed to install the right version of the opencode CLI for your platform. You can try manually installing the "%name%" package >&2
+exit /b 1
+
+:execute
+rem Execute the binary with all arguments
+"%resolved%" %*

packages/opencode/package.json

@@ -0,0 +1,52 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "version": "0.0.5",
+  "name": "opencode",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "dev": "bun run ./src/index.ts"
+  },
+  "bin": {
+    "opencode": "./bin/opencode"
+  },
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "devDependencies": {
+    "@ai-sdk/amazon-bedrock": "2.2.10",
+    "@ai-sdk/anthropic": "1.2.12",
+    "@standard-schema/spec": "1.0.0",
+    "@tsconfig/bun": "1.0.7",
+    "@types/bun": "latest",
+    "@types/turndown": "5.0.5",
+    "@types/yargs": "17.0.33",
+    "typescript": "catalog:",
+    "vscode-languageserver-types": "3.17.5",
+    "zod-to-json-schema": "3.24.5"
+  },
+  "dependencies": {
+    "@clack/prompts": "0.11.0",
+    "@hono/zod-validator": "0.4.2",
+    "@modelcontextprotocol/sdk": "1.15.1",
+    "@openauthjs/openauth": "0.4.3",
+    "@standard-schema/spec": "1.0.0",
+    "@zip.js/zip.js": "2.7.62",
+    "ai": "catalog:",
+    "decimal.js": "10.5.0",
+    "diff": "8.0.2",
+    "gray-matter": "4.0.3",
+    "hono": "4.7.10",
+    "hono-openapi": "0.4.8",
+    "isomorphic-git": "1.32.1",
+    "open": "10.1.2",
+    "remeda": "2.22.3",
+    "turndown": "7.2.0",
+    "vscode-jsonrpc": "8.2.1",
+    "xdg-basedir": "5.1.0",
+    "yargs": "18.0.0",
+    "zod": "catalog:",
+    "zod-openapi": "4.1.0"
+  }
+}

packages/opencode/script/postinstall.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+function detectPlatformAndArch() {
+  // Map platform names
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "win32"
+      break
+    default:
+      platform = os.platform()
+      break
+  }
+
+  // Map architecture names
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    case "arm":
+      arch = "arm"
+      break
+    default:
+      arch = os.arch()
+      break
+  }
+
+  return { platform, arch }
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `opencode-${platform}-${arch}`
+  const binary = platform === "win32" ? "opencode.exe" : "opencode"
+
+  try {
+    // Use require.resolve to find the package
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binary)
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
+    }
+
+    return binaryPath
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
+}
+
+function main() {
+  try {
+    const binaryPath = findBinary()
+    const binScript = path.join(__dirname, "bin", "opencode")
+
+    // Remove existing bin script if it exists
+    if (fs.existsSync(binScript)) {
+      fs.unlinkSync(binScript)
+    }
+
+    // Create symlink to the actual binary
+    fs.symlinkSync(binaryPath, binScript)
+    console.log(`opencode binary symlinked: ${binScript} -> ${binaryPath}`)
+  } catch (error) {
+    console.error("Failed to create opencode binary symlink:", error.message)
+    process.exit(1)
+  }
+}
+
+main()

packages/opencode/script/publish.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+
+import pkg from "../package.json"
+
+const dry = process.argv.includes("--dry")
+const snapshot = process.argv.includes("--snapshot")
+
+const version = snapshot
+  ? `0.0.0-${new Date().toISOString().slice(0, 16).replace(/[-:T]/g, "")}`
+  : await $`git describe --tags --abbrev=0`
+      .text()
+      .then((x) => x.substring(1).trim())
+      .catch(() => {
+        console.error("tag not found")
+        process.exit(1)
+      })
+
+console.log(`publishing ${version}`)
+
+const GOARCH: Record<string, string> = {
+  arm64: "arm64",
+  x64: "amd64",
+  "x64-baseline": "amd64",
+}
+
+const targets = [
+  ["linux", "arm64"],
+  ["linux", "x64"],
+  ["linux", "x64-baseline"],
+  ["darwin", "x64"],
+  ["darwin", "arm64"],
+  ["windows", "x64"],
+]
+
+await $`rm -rf dist`
+
+const optionalDependencies: Record<string, string> = {}
+const npmTag = snapshot ? "snapshot" : "latest"
+for (const [os, arch] of targets) {
+  console.log(`building ${os}-${arch}`)
+  const name = `${pkg.name}-${os}-${arch}`
+  await $`mkdir -p dist/${name}/bin`
+  await $`CGO_ENABLED=0 GOOS=${os} GOARCH=${GOARCH[arch]} go build -ldflags="-s -w -X main.Version=${version}" -o ../opencode/dist/${name}/bin/tui ../tui/cmd/opencode/main.go`.cwd(
+    "../tui",
+  )
+  await $`bun build --define OPENCODE_VERSION="'${version}'" --compile --minify --target=bun-${os}-${arch} --outfile=dist/${name}/bin/opencode ./src/index.ts ./dist/${name}/bin/tui`
+  await $`rm -rf ./dist/${name}/bin/tui`
+  await Bun.file(`dist/${name}/package.json`).write(
+    JSON.stringify(
+      {
+        name,
+        version,
+        os: [os === "windows" ? "win32" : os],
+        cpu: [arch],
+      },
+      null,
+      2,
+    ),
+  )
+  if (!dry) await $`cd dist/${name} && bun publish --access public --tag ${npmTag}`
+  optionalDependencies[name] = version
+}
+
+await $`mkdir -p ./dist/${pkg.name}`
+await $`cp -r ./bin ./dist/${pkg.name}/bin`
+await $`cp ./script/postinstall.mjs ./dist/${pkg.name}/postinstall.mjs`
+await Bun.file(`./dist/${pkg.name}/package.json`).write(
+  JSON.stringify(
+    {
+      name: pkg.name + "-ai",
+      bin: {
+        [pkg.name]: `./bin/${pkg.name}`,
+      },
+      scripts: {
+        postinstall: "node ./postinstall.mjs",
+      },
+      version,
+      optionalDependencies,
+    },
+    null,
+    2,
+  ),
+)
+if (!dry) await $`cd ./dist/${pkg.name} && bun publish --access public --tag ${npmTag}`
+
+if (!snapshot) {
+  // Github Release
+  for (const key of Object.keys(optionalDependencies)) {
+    await $`cd dist/${key}/bin && zip -r ../../${key}.zip *`
+  }
+
+  const previous = await fetch("https://api.github.com/repos/sst/opencode/releases/latest")
+    .then((res) => {
+      if (!res.ok) throw new Error(res.statusText)
+      return res.json()
+    })
+    .then((data) => data.tag_name)
+
+  console.log("finding commits between", previous, "and", "HEAD")
+  const commits = await fetch(`https://api.github.com/repos/sst/opencode/compare/${previous}...HEAD`)
+    .then((res) => res.json())
+    .then((data) => data.commits || [])
+
+  const raw = commits.map((commit: any) => `- ${commit.commit.message.split("\n").join(" ")}`)
+  console.log(raw)
+
+  const notes =
+    raw
+      .filter((x: string) => {
+        const lower = x.toLowerCase()
+        return (
+          !lower.includes("ignore:") &&
+          !lower.includes("chore:") &&
+          !lower.includes("ci:") &&
+          !lower.includes("wip:") &&
+          !lower.includes("docs:") &&
+          !lower.includes("doc:")
+        )
+      })
+      .join("\n") || "No notable changes"
+
+  if (!dry) await $`gh release create v${version} --title "v${version}" --notes ${notes} ./dist/*.zip`
+
+  // Calculate SHA values
+  const arm64Sha = await $`sha256sum ./dist/opencode-linux-arm64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+  const x64Sha = await $`sha256sum ./dist/opencode-linux-x64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+  const macX64Sha = await $`sha256sum ./dist/opencode-darwin-x64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+  const macArm64Sha = await $`sha256sum ./dist/opencode-darwin-arm64.zip | cut -d' ' -f1`.text().then((x) => x.trim())
+
+  // AUR package
+  const pkgbuild = [
+    "# Maintainer: dax",
+    "# Maintainer: adam",
+    "",
+    "pkgname='${pkg}'",
+    `pkgver=${version.split("-")[0]}`,
+    "options=('!debug' '!strip')",
+    "pkgrel=1",
+    "pkgdesc='The AI coding agent built for the terminal.'",
+    "url='https://github.com/sst/opencode'",
+    "arch=('aarch64' 'x86_64')",
+    "license=('MIT')",
+    "provides=('opencode')",
+    "conflicts=('opencode')",
+    "depends=('fzf' 'ripgrep')",
+    "",
+    `source_aarch64=("\${pkgname}_\${pkgver}_aarch64.zip::https://github.com/sst/opencode/releases/download/v${version}/opencode-linux-arm64.zip")`,
+    `sha256sums_aarch64=('${arm64Sha}')`,
+    "",
+    `source_x86_64=("\${pkgname}_\${pkgver}_x86_64.zip::https://github.com/sst/opencode/releases/download/v${version}/opencode-linux-x64.zip")`,
+    `sha256sums_x86_64=('${x64Sha}')`,
+    "",
+    "package() {",
+    '  install -Dm755 ./opencode "${pkgdir}/usr/bin/opencode"',
+    "}",
+    "",
+  ].join("\n")
+
+  for (const pkg of ["opencode", "opencode-bin"]) {
+    await $`rm -rf ./dist/aur-${pkg}`
+    await $`git clone ssh://aur@aur.archlinux.org/${pkg}.git ./dist/aur-${pkg}`
+    await $`cd ./dist/aur-${pkg} && git checkout master`
+    await Bun.file(`./dist/aur-${pkg}/PKGBUILD`).write(pkgbuild.replace("${pkg}", pkg))
+    await $`cd ./dist/aur-${pkg} && makepkg --printsrcinfo > .SRCINFO`
+    await $`cd ./dist/aur-${pkg} && git add PKGBUILD .SRCINFO`
+    await $`cd ./dist/aur-${pkg} && git commit -m "Update to v${version}"`
+    if (!dry) await $`cd ./dist/aur-${pkg} && git push`
+  }
+
+  // Homebrew formula
+  const homebrewFormula = [
+    "# typed: false",
+    "# frozen_string_literal: true",
+    "",
+    "# This file was generated by GoReleaser. DO NOT EDIT.",
+    "class Opencode < Formula",
+    `  desc "The AI coding agent built for the terminal."`,
+    `  homepage "https://github.com/sst/opencode"`,
+    `  version "${version.split("-")[0]}"`,
+    "",
+    "  on_macos do",
+    "    if Hardware::CPU.intel?",
+    `      url "https://github.com/sst/opencode/releases/download/v${version}/opencode-darwin-x64.zip"`,
+    `      sha256 "${macX64Sha}"`,
+    "",
+    "      def install",
+    '        bin.install "opencode"',
+    "      end",
+    "    end",
+    "    if Hardware::CPU.arm?",
+    `      url "https://github.com/sst/opencode/releases/download/v${version}/opencode-darwin-arm64.zip"`,
+    `      sha256 "${macArm64Sha}"`,
+    "",
+    "      def install",
+    '        bin.install "opencode"',
+    "      end",
+    "    end",
+    "  end",
+    "",
+    "  on_linux do",
+    "    if Hardware::CPU.intel? and Hardware::CPU.is_64_bit?",
+    `      url "https://github.com/sst/opencode/releases/download/v${version}/opencode-linux-x64.zip"`,
+    `      sha256 "${x64Sha}"`,
+    "      def install",
+    '        bin.install "opencode"',
+    "      end",
+    "    end",
+    "    if Hardware::CPU.arm? and Hardware::CPU.is_64_bit?",
+    `      url "https://github.com/sst/opencode/releases/download/v${version}/opencode-linux-arm64.zip"`,
+    `      sha256 "${arm64Sha}"`,
+    "      def install",
+    '        bin.install "opencode"',
+    "      end",
+    "    end",
+    "  end",
+    "end",
+    "",
+    "",
+  ].join("\n")
+
+  await $`rm -rf ./dist/homebrew-tap`
+  await $`git clone https://${process.env["GITHUB_TOKEN"]}@github.com/sst/homebrew-tap.git ./dist/homebrew-tap`
+  await Bun.file("./dist/homebrew-tap/opencode.rb").write(homebrewFormula)
+  await $`cd ./dist/homebrew-tap && git add opencode.rb`
+  await $`cd ./dist/homebrew-tap && git commit -m "Update to v${version}"`
+  if (!dry) await $`cd ./dist/homebrew-tap && git push`
+}

packages/opencode/script/schema.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+
+import "zod-openapi/extend"
+import { Config } from "../src/config/config"
+import { zodToJsonSchema } from "zod-to-json-schema"
+
+const file = process.argv[2]
+
+const result = zodToJsonSchema(Config.Info, {
+  /**
+   * We'll use the `default` values of the field as the only value in `examples`.
+   * This will ensure no docs are needed to be read, as the configuration is
+   * self-documenting.
+   *
+   * See https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.9.5
+   */
+  postProcess(jsonSchema) {
+    const schema = jsonSchema as typeof jsonSchema & {
+      examples?: unknown[]
+    }
+    if (schema && typeof schema === "object" && "type" in schema && schema.type === "string" && schema?.default) {
+      if (!schema.examples) {
+        schema.examples = [schema.default]
+      }
+
+      schema.description = [schema.description || "", `default: \`${schema.default}\``]
+        .filter(Boolean)
+        .join("\n\n")
+        .trim()
+    }
+
+    return jsonSchema
+  },
+})
+await Bun.write(file, JSON.stringify(result, null, 2))

packages/opencode/src/agent/agent.ts

@@ -0,0 +1,102 @@
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import z from "zod"
+import { Provider } from "../provider/provider"
+import { generateObject, type ModelMessage } from "ai"
+import PROMPT_GENERATE from "./generate.txt"
+import { SystemPrompt } from "../session/system"
+
+export namespace Agent {
+  export const Info = z
+    .object({
+      name: z.string(),
+      model: z
+        .object({
+          modelID: z.string(),
+          providerID: z.string(),
+        })
+        .optional(),
+      description: z.string(),
+      prompt: z.string().optional(),
+      tools: z.record(z.boolean()),
+    })
+    .openapi({
+      ref: "Agent",
+    })
+  export type Info = z.infer<typeof Info>
+  const state = App.state("agent", async () => {
+    const cfg = await Config.get()
+    const result: Record<string, Info> = {
+      general: {
+        name: "general",
+        description:
+          "General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you.",
+        tools: {
+          todoread: false,
+          todowrite: false,
+        },
+      },
+    }
+    for (const [key, value] of Object.entries(cfg.agent ?? {})) {
+      if (value.disable) continue
+      let item = result[key]
+      if (!item)
+        item = result[key] = {
+          name: key,
+          description: "",
+          tools: {
+            todowrite: false,
+            todoread: false,
+          },
+        }
+      const model = value.model ?? cfg.model
+      if (model) item.model = Provider.parseModel(model)
+      if (value.prompt) item.prompt = value.prompt
+      if (value.tools)
+        item.tools = {
+          ...item.tools,
+          ...value.tools,
+        }
+      if (value.description) item.description = value.description
+    }
+    return result
+  })
+
+  export async function get(agent: string) {
+    return state().then((x) => x[agent])
+  }
+
+  export async function list() {
+    return state().then((x) => Object.values(x))
+  }
+
+  export async function generate(input: { description: string }) {
+    const defaultModel = await Provider.defaultModel()
+    const model = await Provider.getModel(defaultModel.providerID, defaultModel.modelID)
+    const system = SystemPrompt.header(defaultModel.providerID)
+    system.push(PROMPT_GENERATE)
+    const existing = await list()
+    const result = await generateObject({
+      temperature: 0.3,
+      prompt: [
+        ...system.map(
+          (item): ModelMessage => ({
+            role: "system",
+            content: item,
+          }),
+        ),
+        {
+          role: "user",
+          content: `Create an agent configuration based on this request: \"${input.description}\".\n\nIMPORTANT: The following identifiers already exist and must NOT be used: ${existing.map((i) => i.name).join(", ")}\n  Return ONLY the JSON object, no other text, do not wrap in backticks`,
+        },
+      ],
+      model: model.language,
+      schema: z.object({
+        identifier: z.string(),
+        whenToUse: z.string(),
+        systemPrompt: z.string(),
+      }),
+    })
+    return result.object
+  }
+}

packages/opencode/src/agent/generate.txt

@@ -0,0 +1,75 @@
+You are an elite AI agent architect specializing in crafting high-performance agent configurations. Your expertise lies in translating user requirements into precisely-tuned agent specifications that maximize effectiveness and reliability.
+
+**Important Context**: You may have access to project-specific instructions from CLAUDE.md files and other context that may include coding standards, project structure, and custom requirements. Consider this context when creating agents to ensure they align with the project's established patterns and practices.
+
+When a user describes what they want an agent to do, you will:
+
+1. **Extract Core Intent**: Identify the fundamental purpose, key responsibilities, and success criteria for the agent. Look for both explicit requirements and implicit needs. Consider any project-specific context from CLAUDE.md files. For agents that are meant to review code, you should assume that the user is asking to review recently written code and not the whole codebase, unless the user has explicitly instructed you otherwise.
+
+2. **Design Expert Persona**: Create a compelling expert identity that embodies deep domain knowledge relevant to the task. The persona should inspire confidence and guide the agent's decision-making approach.
+
+3. **Architect Comprehensive Instructions**: Develop a system prompt that:
+
+   - Establishes clear behavioral boundaries and operational parameters
+   - Provides specific methodologies and best practices for task execution
+   - Anticipates edge cases and provides guidance for handling them
+   - Incorporates any specific requirements or preferences mentioned by the user
+   - Defines output format expectations when relevant
+   - Aligns with project-specific coding standards and patterns from CLAUDE.md
+
+4. **Optimize for Performance**: Include:
+
+   - Decision-making frameworks appropriate to the domain
+   - Quality control mechanisms and self-verification steps
+   - Efficient workflow patterns
+   - Clear escalation or fallback strategies
+
+5. **Create Identifier**: Design a concise, descriptive identifier that:
+   - Uses lowercase letters, numbers, and hyphens only
+   - Is typically 2-4 words joined by hyphens
+   - Clearly indicates the agent's primary function
+   - Is memorable and easy to type
+   - Avoids generic terms like "helper" or "assistant"
+
+6 **Example agent descriptions**:
+
+- in the 'whenToUse' field of the JSON object, you should include examples of when this agent should be used.
+- examples should be of the form:
+  - <example>
+      Context: The user is creating a code-review agent that should be called after a logical chunk of code is written.
+      user: "Please write a function that checks if a number is prime"
+      assistant: "Here is the relevant function: "
+      <function call omitted for brevity only for this example>
+      <commentary>
+      Since the user is greeting, use the Task tool to launch the greeting-responder agent to respond with a friendly joke. 
+      </commentary>
+      assistant: "Now let me use the code-reviewer agent to review the code"
+    </example>
+  - <example>
+      Context: User is creating an agent to respond to the word "hello" with a friendly jok.
+      user: "Hello"
+      assistant: "I'm going to use the Task tool to launch the greeting-responder agent to respond with a friendly joke"
+      <commentary>
+      Since the user is greeting, use the greeting-responder agent to respond with a friendly joke. 
+      </commentary>
+    </example>
+- If the user mentioned or implied that the agent should be used proactively, you should include examples of this.
+- NOTE: Ensure that in the examples, you are making the assistant use the Agent tool and not simply respond directly to the task.
+
+Your output must be a valid JSON object with exactly these fields:
+{
+"identifier": "A unique, descriptive identifier using lowercase letters, numbers, and hyphens (e.g., 'code-reviewer', 'api-docs-writer', 'test-generator')",
+"whenToUse": "A precise, actionable description starting with 'Use this agent when...' that clearly defines the triggering conditions and use cases. Ensure you include examples as described above.",
+"systemPrompt": "The complete system prompt that will govern the agent's behavior, written in second person ('You are...', 'You will...') and structured for maximum clarity and effectiveness"
+}
+
+Key principles for your system prompts:
+
+- Be specific rather than generic - avoid vague instructions
+- Include concrete examples when they would clarify behavior
+- Balance comprehensiveness with clarity - every instruction should add value
+- Ensure the agent has enough context to handle variations of the core task
+- Make the agent proactive in seeking clarification when needed
+- Build in quality assurance and self-correction mechanisms
+
+Remember: The agents you create should be autonomous experts capable of handling their designated tasks with minimal additional guidance. Your system prompts are their complete operational manual.

packages/opencode/src/app/app.ts

@@ -0,0 +1,145 @@
+import "zod-openapi/extend"
+import { Log } from "../util/log"
+import { Context } from "../util/context"
+import { Filesystem } from "../util/filesystem"
+import { Global } from "../global"
+import path from "path"
+import os from "os"
+import { z } from "zod"
+
+export namespace App {
+  const log = Log.create({ service: "app" })
+
+  export const Info = z
+    .object({
+      hostname: z.string(),
+      git: z.boolean(),
+      path: z.object({
+        config: z.string(),
+        data: z.string(),
+        root: z.string(),
+        cwd: z.string(),
+        state: z.string(),
+      }),
+      time: z.object({
+        initialized: z.number().optional(),
+      }),
+    })
+    .openapi({
+      ref: "App",
+    })
+  export type Info = z.infer<typeof Info>
+
+  const ctx = Context.create<{
+    info: Info
+    services: Map<any, { state: any; shutdown?: (input: any) => Promise<void> }>
+  }>("app")
+
+  export const use = ctx.use
+
+  const APP_JSON = "app.json"
+
+  export type Input = {
+    cwd: string
+  }
+
+  export const provideExisting = ctx.provide
+  export async function provide<T>(input: Input, cb: (app: App.Info) => Promise<T>) {
+    log.info("creating", {
+      cwd: input.cwd,
+    })
+    const git = await Filesystem.findUp(".git", input.cwd).then(([x]) => (x ? path.dirname(x) : undefined))
+    log.info("git", { git })
+
+    const data = path.join(Global.Path.data, "project", git ? directory(git) : "global")
+    const stateFile = Bun.file(path.join(data, APP_JSON))
+    const state = (await stateFile.json().catch(() => ({}))) as {
+      initialized: number
+    }
+    await stateFile.write(JSON.stringify(state))
+
+    const services = new Map<
+      any,
+      {
+        state: any
+        shutdown?: (input: any) => Promise<void>
+      }
+    >()
+
+    const root = git ?? input.cwd
+
+    const info: Info = {
+      hostname: os.hostname(),
+      time: {
+        initialized: state.initialized,
+      },
+      git: git !== undefined,
+      path: {
+        config: Global.Path.config,
+        state: Global.Path.state,
+        data,
+        root,
+        cwd: input.cwd,
+      },
+    }
+    const app = {
+      services,
+      info,
+    }
+
+    return ctx.provide(app, async () => {
+      try {
+        const result = await cb(app.info)
+        return result
+      } finally {
+        for (const [key, entry] of app.services.entries()) {
+          if (!entry.shutdown) continue
+          log.info("shutdown", { name: key })
+          await entry.shutdown?.(await entry.state)
+        }
+      }
+    })
+  }
+
+  export function state<State>(
+    key: any,
+    init: (app: Info) => State,
+    shutdown?: (state: Awaited<State>) => Promise<void>,
+  ) {
+    return () => {
+      const app = ctx.use()
+      const services = app.services
+      if (!services.has(key)) {
+        log.info("registering service", { name: key })
+        services.set(key, {
+          state: init(app.info),
+          shutdown,
+        })
+      }
+      return services.get(key)?.state as State
+    }
+  }
+
+  export function info() {
+    return ctx.use().info
+  }
+
+  export async function initialize() {
+    const { info } = ctx.use()
+    info.time.initialized = Date.now()
+    await Bun.write(
+      path.join(info.path.data, APP_JSON),
+      JSON.stringify({
+        initialized: Date.now(),
+      }),
+    )
+  }
+
+  function directory(input: string): string {
+    return input
+      .split(path.sep)
+      .filter(Boolean)
+      .join("-")
+      .replace(/[^A-Za-z0-9_]/g, "-")
+  }
+}

packages/opencode/src/auth/anthropic.ts

@@ -0,0 +1,84 @@
+import { generatePKCE } from "@openauthjs/openauth/pkce"
+import { Auth } from "./index"
+
+export namespace AuthAnthropic {
+  const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+
+  export async function authorize(mode: "max" | "console") {
+    const pkce = await generatePKCE()
+
+    const url = new URL(
+      `https://${mode === "console" ? "console.anthropic.com" : "claude.ai"}/oauth/authorize`,
+      import.meta.url,
+    )
+    url.searchParams.set("code", "true")
+    url.searchParams.set("client_id", CLIENT_ID)
+    url.searchParams.set("response_type", "code")
+    url.searchParams.set("redirect_uri", "https://console.anthropic.com/oauth/code/callback")
+    url.searchParams.set("scope", "org:create_api_key user:profile user:inference")
+    url.searchParams.set("code_challenge", pkce.challenge)
+    url.searchParams.set("code_challenge_method", "S256")
+    url.searchParams.set("state", pkce.verifier)
+    return {
+      url: url.toString(),
+      verifier: pkce.verifier,
+    }
+  }
+
+  export async function exchange(code: string, verifier: string) {
+    const splits = code.split("#")
+    const result = await fetch("https://console.anthropic.com/v1/oauth/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        code: splits[0],
+        state: splits[1],
+        grant_type: "authorization_code",
+        client_id: CLIENT_ID,
+        redirect_uri: "https://console.anthropic.com/oauth/code/callback",
+        code_verifier: verifier,
+      }),
+    })
+    if (!result.ok) throw new ExchangeFailed()
+    const json = await result.json()
+    return {
+      refresh: json.refresh_token as string,
+      access: json.access_token as string,
+      expires: Date.now() + json.expires_in * 1000,
+    }
+  }
+
+  export async function access() {
+    const info = await Auth.get("anthropic")
+    if (!info || info.type !== "oauth") return
+    if (info.access && info.expires > Date.now()) return info.access
+    const response = await fetch("https://console.anthropic.com/v1/oauth/token", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: info.refresh,
+        client_id: CLIENT_ID,
+      }),
+    })
+    if (!response.ok) return
+    const json = await response.json()
+    await Auth.set("anthropic", {
+      type: "oauth",
+      refresh: json.refresh_token as string,
+      access: json.access_token as string,
+      expires: Date.now() + json.expires_in * 1000,
+    })
+    return json.access_token as string
+  }
+
+  export class ExchangeFailed extends Error {
+    constructor() {
+      super("Exchange failed")
+    }
+  }
+}

packages/opencode/src/auth/copilot.ts

@@ -0,0 +1,19 @@
+import { Global } from "../global"
+import { lazy } from "../util/lazy"
+import path from "path"
+
+export const AuthCopilot = lazy(async () => {
+  const file = Bun.file(path.join(Global.Path.state, "plugin", "copilot.ts"))
+  const exists = await file.exists()
+  const response = fetch("https://raw.githubusercontent.com/sst/opencode-github-copilot/refs/heads/main/auth.ts")
+    .then((x) => Bun.write(file, x))
+    .catch(() => {})
+
+  if (!exists) {
+    const worked = await response
+    if (!worked) return
+  }
+  const result = await import(file.name!).catch(() => {})
+  if (!result) return
+  return result.AuthCopilot
+})

packages/opencode/src/auth/github-copilot.ts

@@ -0,0 +1,147 @@
+import { z } from "zod"
+import { Auth } from "./index"
+import { NamedError } from "../util/error"
+
+export namespace AuthGithubCopilot {
+  const CLIENT_ID = "Iv1.b507a08c87ecfe98"
+  const DEVICE_CODE_URL = "https://github.com/login/device/code"
+  const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token"
+  const COPILOT_API_KEY_URL = "https://api.github.com/copilot_internal/v2/token"
+
+  interface DeviceCodeResponse {
+    device_code: string
+    user_code: string
+    verification_uri: string
+    expires_in: number
+    interval: number
+  }
+
+  interface AccessTokenResponse {
+    access_token?: string
+    error?: string
+    error_description?: string
+  }
+
+  interface CopilotTokenResponse {
+    token: string
+    expires_at: number
+    refresh_in: number
+    endpoints: {
+      api: string
+    }
+  }
+
+  export async function authorize() {
+    const deviceResponse = await fetch(DEVICE_CODE_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+      },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        scope: "read:user",
+      }),
+    })
+    const deviceData: DeviceCodeResponse = await deviceResponse.json()
+    return {
+      device: deviceData.device_code,
+      user: deviceData.user_code,
+      verification: deviceData.verification_uri,
+      interval: deviceData.interval || 5,
+      expiry: deviceData.expires_in,
+    }
+  }
+
+  export async function poll(device_code: string) {
+    const response = await fetch(ACCESS_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+      },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      }),
+    })
+
+    if (!response.ok) return "failed"
+
+    const data: AccessTokenResponse = await response.json()
+
+    if (data.access_token) {
+      // Store the GitHub OAuth token
+      await Auth.set("github-copilot", {
+        type: "oauth",
+        refresh: data.access_token,
+        access: "",
+        expires: 0,
+      })
+      return "complete"
+    }
+
+    if (data.error === "authorization_pending") return "pending"
+
+    if (data.error) return "failed"
+
+    return "pending"
+  }
+
+  export async function access() {
+    const info = await Auth.get("github-copilot")
+    if (!info || info.type !== "oauth") return
+    if (info.access && info.expires > Date.now()) return info.access
+
+    // Get new Copilot API token
+    const response = await fetch(COPILOT_API_KEY_URL, {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${info.refresh}`,
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+        "Editor-Version": "vscode/1.99.3",
+        "Editor-Plugin-Version": "copilot-chat/0.26.7",
+      },
+    })
+
+    if (!response.ok) return
+
+    const tokenData: CopilotTokenResponse = await response.json()
+
+    // Store the Copilot API token
+    await Auth.set("github-copilot", {
+      type: "oauth",
+      refresh: info.refresh,
+      access: tokenData.token,
+      expires: tokenData.expires_at * 1000,
+    })
+
+    return tokenData.token
+  }
+
+  export const DeviceCodeError = NamedError.create("DeviceCodeError", z.object({}))
+
+  export const TokenExchangeError = NamedError.create(
+    "TokenExchangeError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const AuthenticationError = NamedError.create(
+    "AuthenticationError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const CopilotTokenError = NamedError.create(
+    "CopilotTokenError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+}

packages/opencode/src/auth/index.ts

@@ -0,0 +1,51 @@
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import { z } from "zod"
+
+export namespace Auth {
+  export const Oauth = z.object({
+    type: z.literal("oauth"),
+    refresh: z.string(),
+    access: z.string(),
+    expires: z.number(),
+  })
+
+  export const Api = z.object({
+    type: z.literal("api"),
+    key: z.string(),
+  })
+
+  export const Info = z.discriminatedUnion("type", [Oauth, Api])
+  export type Info = z.infer<typeof Info>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(providerID: string) {
+    const file = Bun.file(filepath)
+    return file
+      .json()
+      .catch(() => ({}))
+      .then((x) => x[providerID] as Info | undefined)
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    const file = Bun.file(filepath)
+    return file.json().catch(() => ({}))
+  }
+
+  export async function set(key: string, info: Info) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    await Bun.write(file, JSON.stringify({ ...data, [key]: info }, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function remove(key: string) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    delete data[key]
+    await Bun.write(file, JSON.stringify(data, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+}

packages/opencode/src/bun/index.ts

@@ -0,0 +1,92 @@
+import { z } from "zod"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import { NamedError } from "../util/error"
+import { readableStreamToText } from "bun"
+
+export namespace BunProc {
+  const log = Log.create({ service: "bun" })
+
+  export async function run(cmd: string[], options?: Bun.SpawnOptions.OptionsObject<any, any, any>) {
+    log.info("running", {
+      cmd: [which(), ...cmd],
+      ...options,
+    })
+    const result = Bun.spawn([which(), ...cmd], {
+      ...options,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...options?.env,
+        BUN_BE_BUN: "1",
+      },
+    })
+    const code = await result.exited
+    const stdout = result.stdout
+      ? typeof result.stdout === "number"
+        ? result.stdout
+        : await readableStreamToText(result.stdout)
+      : undefined
+    const stderr = result.stderr
+      ? typeof result.stderr === "number"
+        ? result.stderr
+        : await readableStreamToText(result.stderr)
+      : undefined
+    log.info("done", {
+      code,
+      stdout,
+      stderr,
+    })
+    if (code !== 0) {
+      throw new Error(`Command failed with exit code ${result.exitCode}`)
+    }
+    return result
+  }
+
+  export function which() {
+    return process.execPath
+  }
+
+  export const InstallFailedError = NamedError.create(
+    "BunInstallFailedError",
+    z.object({
+      pkg: z.string(),
+      version: z.string(),
+    }),
+  )
+
+  export async function install(pkg: string, version = "latest") {
+    const mod = path.join(Global.Path.cache, "node_modules", pkg)
+    const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
+    const parsed = await pkgjson.json().catch(async () => {
+      const result = { dependencies: {} }
+      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
+      return result
+    })
+    if (parsed.dependencies[pkg] === version) return mod
+
+    // Build command arguments
+    const args = ["add", "--force", "--exact", "--cwd", Global.Path.cache, pkg + "@" + version]
+
+    // Let Bun handle registry resolution:
+    // - If .npmrc files exist, Bun will use them automatically
+    // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
+    log.info("installing package using Bun's default registry resolution", { pkg, version })
+
+    await BunProc.run(args, {
+      cwd: Global.Path.cache,
+    }).catch((e) => {
+      throw new InstallFailedError(
+        { pkg, version },
+        {
+          cause: e,
+        },
+      )
+    })
+    parsed.dependencies[pkg] = version
+    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
+    return mod
+  }
+}

packages/opencode/src/bus/index.ts

@@ -0,0 +1,109 @@
+import { z, type ZodType } from "zod"
+import { App } from "../app/app"
+import { Log } from "../util/log"
+
+export namespace Bus {
+  const log = Log.create({ service: "bus" })
+  type Subscription = (event: any) => void
+
+  const state = App.state("bus", () => {
+    const subscriptions = new Map<any, Subscription[]>()
+
+    return {
+      subscriptions,
+    }
+  })
+
+  export type EventDefinition = ReturnType<typeof event>
+
+  const registry = new Map<string, EventDefinition>()
+
+  export function event<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z.discriminatedUnion(
+      "type",
+      registry
+        .entries()
+        .map(([type, def]) =>
+          z
+            .object({
+              type: z.literal(type),
+              properties: def.properties,
+            })
+            .openapi({
+              ref: "Event" + "." + def.type,
+            }),
+        )
+        .toArray() as any,
+    )
+  }
+
+  export async function publish<Definition extends EventDefinition>(
+    def: Definition,
+    properties: z.output<Definition["properties"]>,
+  ) {
+    const payload = {
+      type: def.type,
+      properties,
+    }
+    log.info("publishing", {
+      type: def.type,
+    })
+    const pending = []
+    for (const key of [def.type, "*"]) {
+      const match = state().subscriptions.get(key)
+      for (const sub of match ?? []) {
+        pending.push(sub(payload))
+      }
+    }
+    return Promise.all(pending)
+  }
+
+  export function subscribe<Definition extends EventDefinition>(
+    def: Definition,
+    callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
+  ) {
+    return raw(def.type, callback)
+  }
+
+  export function once<Definition extends EventDefinition>(
+    def: Definition,
+    callback: (event: {
+      type: Definition["type"]
+      properties: z.infer<Definition["properties"]>
+    }) => "done" | undefined,
+  ) {
+    const unsub = subscribe(def, (event) => {
+      if (callback(event)) unsub()
+    })
+  }
+
+  export function subscribeAll(callback: (event: any) => void) {
+    return raw("*", callback)
+  }
+
+  function raw(type: string, callback: (event: any) => void) {
+    log.info("subscribing", { type })
+    const subscriptions = state().subscriptions
+    let match = subscriptions.get(type) ?? []
+    match.push(callback)
+    subscriptions.set(type, match)
+
+    return () => {
+      log.info("unsubscribing", { type })
+      const match = subscriptions.get(type)
+      if (!match) return
+      const index = match.indexOf(callback)
+      if (index === -1) return
+      match.splice(index, 1)
+    }
+  }
+}

packages/opencode/src/cli/bootstrap.ts

@@ -0,0 +1,18 @@
+import { App } from "../app/app"
+import { ConfigHooks } from "../config/hooks"
+import { Format } from "../format"
+import { LSP } from "../lsp"
+import { Share } from "../share/share"
+import { Snapshot } from "../snapshot"
+
+export async function bootstrap<T>(input: App.Input, cb: (app: App.Info) => Promise<T>) {
+  return App.provide(input, async (app) => {
+    Share.init()
+    Format.init()
+    ConfigHooks.init()
+    LSP.init()
+    Snapshot.init()
+
+    return cb(app)
+  })
+}

packages/opencode/src/cli/cmd/agent.ts

@@ -0,0 +1,110 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "../../global"
+import { Agent } from "../../agent/agent"
+import path from "path"
+import matter from "gray-matter"
+import { App } from "../../app/app"
+
+const AgentCreateCommand = cmd({
+  command: "create",
+  describe: "create a new agent",
+  async handler() {
+    await App.provide({ cwd: process.cwd() }, async (app) => {
+      UI.empty()
+      prompts.intro("Create agent")
+
+      let scope: "global" | "project" = "global"
+      if (app.git) {
+        const scopeResult = await prompts.select({
+          message: "Location",
+          options: [
+            {
+              label: "Current project",
+              value: "project" as const,
+              hint: app.path.root,
+            },
+            {
+              label: "Global",
+              value: "global" as const,
+              hint: Global.Path.config,
+            },
+          ],
+        })
+        if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
+        scope = scopeResult
+      }
+
+      const query = await prompts.text({
+        message: "Description",
+        placeholder: "What should this agent do?",
+        validate: (x) => (x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(query)) throw new UI.CancelledError()
+
+      const spinner = prompts.spinner()
+
+      spinner.start("Generating agent configuration...")
+      const generated = await Agent.generate({ description: query })
+      spinner.stop(`Agent ${generated.identifier} generated`)
+
+      const availableTools = [
+        "bash",
+        "read",
+        "write",
+        "edit",
+        "list",
+        "glob",
+        "grep",
+        "webfetch",
+        "task",
+        "todowrite",
+        "todoread",
+      ]
+
+      const selectedTools = await prompts.multiselect({
+        message: "Select tools to enable",
+        options: availableTools.map((tool) => ({
+          label: tool,
+          value: tool,
+        })),
+        initialValues: availableTools,
+      })
+      if (prompts.isCancel(selectedTools)) throw new UI.CancelledError()
+
+      const tools: Record<string, boolean> = {}
+      for (const tool of availableTools) {
+        if (!selectedTools.includes(tool)) {
+          tools[tool] = false
+        }
+      }
+
+      const frontmatter: any = {
+        description: generated.whenToUse,
+      }
+      if (Object.keys(tools).length > 0) {
+        frontmatter.tools = tools
+      }
+
+      const content = matter.stringify(generated.systemPrompt, frontmatter)
+      const filePath = path.join(
+        scope === "global" ? Global.Path.config : path.join(app.path.root, ".opencode"),
+        `agent`,
+        `${generated.identifier}.md`,
+      )
+
+      await Bun.write(filePath, content)
+
+      prompts.log.success(`Agent created: ${filePath}`)
+      prompts.outro("Done")
+    })
+  },
+})
+
+export const AgentCommand = cmd({
+  command: "agent",
+  describe: "manage agents",
+  builder: (yargs) => yargs.command(AgentCreateCommand).demandCommand(),
+  async handler() {},
+})

packages/opencode/src/cli/cmd/auth.ts

@@ -0,0 +1,311 @@
+import { AuthAnthropic } from "../../auth/anthropic"
+import { AuthCopilot } from "../../auth/copilot"
+import { Auth } from "../../auth"
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import open from "open"
+import { UI } from "../ui"
+import { ModelsDev } from "../../provider/models"
+import { map, pipe, sortBy, values } from "remeda"
+import path from "path"
+import os from "os"
+import { Global } from "../../global"
+
+export const AuthCommand = cmd({
+  command: "auth",
+  describe: "manage credentials",
+  builder: (yargs) =>
+    yargs.command(AuthLoginCommand).command(AuthLogoutCommand).command(AuthListCommand).demandCommand(),
+  async handler() {},
+})
+
+export const AuthListCommand = cmd({
+  command: "list",
+  aliases: ["ls"],
+  describe: "list providers",
+  async handler() {
+    UI.empty()
+    const authPath = path.join(Global.Path.data, "auth.json")
+    const homedir = os.homedir()
+    const displayPath = authPath.startsWith(homedir) ? authPath.replace(homedir, "~") : authPath
+    prompts.intro(`Credentials ${UI.Style.TEXT_DIM}${displayPath}`)
+    const results = await Auth.all().then((x) => Object.entries(x))
+    const database = await ModelsDev.get()
+
+    for (const [providerID, result] of results) {
+      const name = database[providerID]?.name || providerID
+      prompts.log.info(`${name} ${UI.Style.TEXT_DIM}${result.type}`)
+    }
+
+    prompts.outro(`${results.length} credentials`)
+
+    // Environment variables section
+    const activeEnvVars: Array<{ provider: string; envVar: string }> = []
+
+    for (const [providerID, provider] of Object.entries(database)) {
+      for (const envVar of provider.env) {
+        if (process.env[envVar]) {
+          activeEnvVars.push({
+            provider: provider.name || providerID,
+            envVar,
+          })
+        }
+      }
+    }
+
+    if (activeEnvVars.length > 0) {
+      UI.empty()
+      prompts.intro("Environment")
+
+      for (const { provider, envVar } of activeEnvVars) {
+        prompts.log.info(`${provider} ${UI.Style.TEXT_DIM}${envVar}`)
+      }
+
+      prompts.outro(`${activeEnvVars.length} environment variables`)
+    }
+  },
+})
+
+export const AuthLoginCommand = cmd({
+  command: "login",
+  describe: "log in to a provider",
+  async handler() {
+    UI.empty()
+    prompts.intro("Add credential")
+    const providers = await ModelsDev.get()
+    const priority: Record<string, number> = {
+      anthropic: 0,
+      "github-copilot": 1,
+      openai: 2,
+      google: 3,
+      openrouter: 4,
+      vercel: 5,
+    }
+    let provider = await prompts.select({
+      message: "Select provider",
+      maxItems: 8,
+      options: [
+        ...pipe(
+          providers,
+          values(),
+          sortBy(
+            (x) => priority[x.id] ?? 99,
+            (x) => x.name ?? x.id,
+          ),
+          map((x) => ({
+            label: x.name,
+            value: x.id,
+            hint: priority[x.id] === 0 ? "recommended" : undefined,
+          })),
+        ),
+        {
+          value: "other",
+          label: "Other",
+        },
+      ],
+    })
+
+    if (prompts.isCancel(provider)) throw new UI.CancelledError()
+
+    if (provider === "other") {
+      provider = await prompts.text({
+        message: "Enter provider id",
+        validate: (x) => (x.match(/^[0-9a-z-]+$/) ? undefined : "a-z, 0-9 and hyphens only"),
+      })
+      if (prompts.isCancel(provider)) throw new UI.CancelledError()
+      provider = provider.replace(/^@ai-sdk\//, "")
+      if (prompts.isCancel(provider)) throw new UI.CancelledError()
+      prompts.log.warn(
+        `This only stores a credential for ${provider} - you will need configure it in opencode.json, check the docs for examples.`,
+      )
+    }
+
+    if (provider === "amazon-bedrock") {
+      prompts.log.info(
+        "Amazon bedrock can be configured with standard AWS environment variables like AWS_BEARER_TOKEN_BEDROCK, AWS_PROFILE or AWS_ACCESS_KEY_ID",
+      )
+      prompts.outro("Done")
+      return
+    }
+
+    if (provider === "anthropic") {
+      const method = await prompts.select({
+        message: "Login method",
+        options: [
+          {
+            label: "Claude Pro/Max",
+            value: "max",
+          },
+          {
+            label: "Create API Key",
+            value: "console",
+          },
+          {
+            label: "Manually enter API Key",
+            value: "api",
+          },
+        ],
+      })
+      if (prompts.isCancel(method)) throw new UI.CancelledError()
+
+      if (method === "max") {
+        // some weird bug where program exits without this
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        const { url, verifier } = await AuthAnthropic.authorize("max")
+        prompts.note("Trying to open browser...")
+        try {
+          await open(url)
+        } catch (e) {
+          prompts.log.error(
+            "Failed to open browser perhaps you are running without a display or X server, please open the following URL in your browser:",
+          )
+        }
+        prompts.log.info(url)
+
+        const code = await prompts.text({
+          message: "Paste the authorization code here: ",
+          validate: (x) => (x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(code)) throw new UI.CancelledError()
+
+        try {
+          const credentials = await AuthAnthropic.exchange(code, verifier)
+          await Auth.set("anthropic", {
+            type: "oauth",
+            refresh: credentials.refresh,
+            access: credentials.access,
+            expires: credentials.expires,
+          })
+          prompts.log.success("Login successful")
+        } catch {
+          prompts.log.error("Invalid code")
+        }
+        prompts.outro("Done")
+        return
+      }
+
+      if (method === "console") {
+        // some weird bug where program exits without this
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        const { url, verifier } = await AuthAnthropic.authorize("console")
+        prompts.note("Trying to open browser...")
+        try {
+          await open(url)
+        } catch (e) {
+          prompts.log.error(
+            "Failed to open browser perhaps you are running without a display or X server, please open the following URL in your browser:",
+          )
+        }
+        prompts.log.info(url)
+
+        const code = await prompts.text({
+          message: "Paste the authorization code here: ",
+          validate: (x) => (x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(code)) throw new UI.CancelledError()
+
+        try {
+          const credentials = await AuthAnthropic.exchange(code, verifier)
+          const accessToken = credentials.access
+          const response = await fetch("https://api.anthropic.com/api/oauth/claude_cli/create_api_key", {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${accessToken}`,
+              "Content-Type": "application/x-www-form-urlencoded",
+              Accept: "application/json, text/plain, */*",
+            },
+          })
+          if (!response.ok) {
+            throw new Error("Failed to create API key")
+          }
+          const json = await response.json()
+          await Auth.set("anthropic", {
+            type: "api",
+            key: json.raw_key,
+          })
+
+          prompts.log.success("Login successful - API key created and saved")
+        } catch (error) {
+          prompts.log.error("Invalid code or failed to create API key")
+        }
+        prompts.outro("Done")
+        return
+      }
+    }
+
+    const copilot = await AuthCopilot()
+    if (provider === "github-copilot" && copilot) {
+      await new Promise((resolve) => setTimeout(resolve, 10))
+      const deviceInfo = await copilot.authorize()
+
+      prompts.note(`Please visit: ${deviceInfo.verification}\nEnter code: ${deviceInfo.user}`)
+
+      const spinner = prompts.spinner()
+      spinner.start("Waiting for authorization...")
+
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, deviceInfo.interval * 1000))
+        const response = await copilot.poll(deviceInfo.device)
+        if (response.status === "pending") continue
+        if (response.status === "success") {
+          await Auth.set("github-copilot", {
+            type: "oauth",
+            refresh: response.refresh,
+            access: response.access,
+            expires: response.expires,
+          })
+          spinner.stop("Login successful")
+          break
+        }
+        if (response.status === "failed") {
+          spinner.stop("Failed to authorize", 1)
+          break
+        }
+      }
+
+      prompts.outro("Done")
+      return
+    }
+
+    if (provider === "vercel") {
+      prompts.log.info("You can create an api key in the dashboard")
+    }
+
+    const key = await prompts.password({
+      message: "Enter your API key",
+      validate: (x) => (x.length > 0 ? undefined : "Required"),
+    })
+    if (prompts.isCancel(key)) throw new UI.CancelledError()
+    await Auth.set(provider, {
+      type: "api",
+      key,
+    })
+
+    prompts.outro("Done")
+  },
+})
+
+export const AuthLogoutCommand = cmd({
+  command: "logout",
+  describe: "log out from a configured provider",
+  async handler() {
+    UI.empty()
+    const credentials = await Auth.all().then((x) => Object.entries(x))
+    prompts.intro("Remove credential")
+    if (credentials.length === 0) {
+      prompts.log.error("No credentials found")
+      return
+    }
+    const database = await ModelsDev.get()
+    const providerID = await prompts.select({
+      message: "Select provider",
+      options: credentials.map(([key, value]) => ({
+        label: (database[key]?.name || key) + UI.Style.TEXT_DIM + " (" + value.type + ")",
+        value: key,
+      })),
+    })
+    if (prompts.isCancel(providerID)) throw new UI.CancelledError()
+    await Auth.remove(providerID)
+    prompts.outro("Logout successful")
+  },
+})

packages/opencode/src/cli/cmd/cmd.ts

@@ -0,0 +1,5 @@
+import type { CommandModule } from "yargs"
+
+export function cmd<T, U>(input: CommandModule<T, U>) {
+  return input
+}

packages/opencode/src/cli/cmd/debug/file.ts

@@ -0,0 +1,36 @@
+import { File } from "../../../file"
+import { bootstrap } from "../../bootstrap"
+import { cmd } from "../cmd"
+
+const FileReadCommand = cmd({
+  command: "read <path>",
+  builder: (yargs) =>
+    yargs.positional("path", {
+      type: "string",
+      demandOption: true,
+      description: "File path to read",
+    }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const content = await File.read(args.path)
+      console.log(content)
+    })
+  },
+})
+
+const FileStatusCommand = cmd({
+  command: "status",
+  builder: (yargs) => yargs,
+  async handler() {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const status = await File.status()
+      console.log(JSON.stringify(status, null, 2))
+    })
+  },
+})
+
+export const FileCommand = cmd({
+  command: "file",
+  builder: (yargs) => yargs.command(FileReadCommand).command(FileStatusCommand).demandCommand(),
+  async handler() {},
+})

packages/opencode/src/cli/cmd/debug/index.ts

@@ -0,0 +1,39 @@
+import { Global } from "../../../global"
+import { bootstrap } from "../../bootstrap"
+import { cmd } from "../cmd"
+import { FileCommand } from "./file"
+import { LSPCommand } from "./lsp"
+import { RipgrepCommand } from "./ripgrep"
+import { ScrapCommand } from "./scrap"
+import { SnapshotCommand } from "./snapshot"
+
+export const DebugCommand = cmd({
+  command: "debug",
+  builder: (yargs) =>
+    yargs
+      .command(LSPCommand)
+      .command(RipgrepCommand)
+      .command(FileCommand)
+      .command(ScrapCommand)
+      .command(SnapshotCommand)
+      .command(PathsCommand)
+      .command({
+        command: "wait",
+        async handler() {
+          await bootstrap({ cwd: process.cwd() }, async () => {
+            await new Promise((resolve) => setTimeout(resolve, 1_000 * 60 * 60 * 24))
+          })
+        },
+      })
+      .demandCommand(),
+  async handler() {},
+})
+
+const PathsCommand = cmd({
+  command: "paths",
+  handler() {
+    for (const [key, value] of Object.entries(Global.Path)) {
+      console.log(key.padEnd(10), value)
+    }
+  },
+})

packages/opencode/src/cli/cmd/debug/lsp.ts

@@ -0,0 +1,46 @@
+import { LSP } from "../../../lsp"
+import { bootstrap } from "../../bootstrap"
+import { cmd } from "../cmd"
+import { Log } from "../../../util/log"
+
+export const LSPCommand = cmd({
+  command: "lsp",
+  builder: (yargs) =>
+    yargs.command(DiagnosticsCommand).command(SymbolsCommand).command(DocumentSymbolsCommand).demandCommand(),
+  async handler() {},
+})
+
+const DiagnosticsCommand = cmd({
+  command: "diagnostics <file>",
+  builder: (yargs) => yargs.positional("file", { type: "string", demandOption: true }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      await LSP.touchFile(args.file, true)
+      console.log(await LSP.diagnostics())
+    })
+  },
+})
+
+export const SymbolsCommand = cmd({
+  command: "symbols <query>",
+  builder: (yargs) => yargs.positional("query", { type: "string", demandOption: true }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      using _ = Log.Default.time("symbols")
+      const results = await LSP.workspaceSymbol(args.query)
+      console.log(JSON.stringify(results, null, 2))
+    })
+  },
+})
+
+export const DocumentSymbolsCommand = cmd({
+  command: "document-symbols <uri>",
+  builder: (yargs) => yargs.positional("uri", { type: "string", demandOption: true }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      using _ = Log.Default.time("document-symbols")
+      const results = await LSP.documentSymbol(args.uri)
+      console.log(JSON.stringify(results, null, 2))
+    })
+  },
+})

packages/opencode/src/cli/cmd/debug/ripgrep.ts

@@ -0,0 +1,82 @@
+import { App } from "../../../app/app"
+import { Ripgrep } from "../../../file/ripgrep"
+import { bootstrap } from "../../bootstrap"
+import { cmd } from "../cmd"
+
+export const RipgrepCommand = cmd({
+  command: "rg",
+  builder: (yargs) => yargs.command(TreeCommand).command(FilesCommand).command(SearchCommand).demandCommand(),
+  async handler() {},
+})
+
+const TreeCommand = cmd({
+  command: "tree",
+  builder: (yargs) =>
+    yargs.option("limit", {
+      type: "number",
+    }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const app = App.info()
+      console.log(await Ripgrep.tree({ cwd: app.path.cwd, limit: args.limit }))
+    })
+  },
+})
+
+const FilesCommand = cmd({
+  command: "files",
+  builder: (yargs) =>
+    yargs
+      .option("query", {
+        type: "string",
+        description: "Filter files by query",
+      })
+      .option("glob", {
+        type: "string",
+        description: "Glob pattern to match files",
+      })
+      .option("limit", {
+        type: "number",
+        description: "Limit number of results",
+      }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const app = App.info()
+      const files = await Ripgrep.files({
+        cwd: app.path.cwd,
+        query: args.query,
+        glob: args.glob ? [args.glob] : undefined,
+        limit: args.limit,
+      })
+      console.log(files.join("\n"))
+    })
+  },
+})
+
+const SearchCommand = cmd({
+  command: "search <pattern>",
+  builder: (yargs) =>
+    yargs
+      .positional("pattern", {
+        type: "string",
+        demandOption: true,
+        description: "Search pattern",
+      })
+      .option("glob", {
+        type: "array",
+        description: "File glob patterns",
+      })
+      .option("limit", {
+        type: "number",
+        description: "Limit number of results",
+      }),
+  async handler(args) {
+    const results = await Ripgrep.search({
+      cwd: process.cwd(),
+      pattern: args.pattern,
+      glob: args.glob as string[] | undefined,
+      limit: args.limit,
+    })
+    console.log(JSON.stringify(results, null, 2))
+  },
+})

packages/opencode/src/cli/cmd/debug/scrap.ts

@@ -0,0 +1,7 @@
+import { cmd } from "../cmd"
+
+export const ScrapCommand = cmd({
+  command: "scrap",
+  builder: (yargs) => yargs,
+  async handler() {},
+})

packages/opencode/src/cli/cmd/debug/snapshot.ts

@@ -0,0 +1,33 @@
+import { Snapshot } from "../../../snapshot"
+import { bootstrap } from "../../bootstrap"
+import { cmd } from "../cmd"
+
+export const SnapshotCommand = cmd({
+  command: "snapshot",
+  builder: (yargs) => yargs.command(TrackCommand).command(PatchCommand).demandCommand(),
+  async handler() {},
+})
+
+const TrackCommand = cmd({
+  command: "track",
+  async handler() {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      console.log(await Snapshot.track())
+    })
+  },
+})
+
+const PatchCommand = cmd({
+  command: "patch <hash>",
+  builder: (yargs) =>
+    yargs.positional("hash", {
+      type: "string",
+      description: "hash",
+      demandOption: true,
+    }),
+  async handler(args) {
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      console.log(await Snapshot.patch(args.hash))
+    })
+  },
+})

packages/opencode/src/cli/cmd/generate.ts

@@ -0,0 +1,14 @@
+import { Server } from "../../server/server"
+import fs from "fs/promises"
+import type { CommandModule } from "yargs"
+
+export const GenerateCommand = {
+  command: "generate",
+  handler: async () => {
+    const specs = await Server.openapi()
+    const dir = "gen"
+    await fs.rmdir(dir, { recursive: true }).catch(() => {})
+    await fs.mkdir(dir, { recursive: true })
+    process.stdout.write(JSON.stringify(specs, null, 2))
+  },
+} satisfies CommandModule

packages/opencode/src/cli/cmd/install-github.ts

@@ -0,0 +1,221 @@
+import { $ } from "bun"
+import path from "path"
+import { exec } from "child_process"
+import * as prompts from "@clack/prompts"
+import { map, pipe, sortBy, values } from "remeda"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { ModelsDev } from "../../provider/models"
+import { App } from "../../app/app"
+
+const WORKFLOW_FILE = ".github/workflows/opencode.yml"
+
+export const InstallGithubCommand = cmd({
+  command: "install-github",
+  describe: "install the GitHub agent",
+  async handler() {
+    await App.provide({ cwd: process.cwd() }, async () => {
+      UI.empty()
+      prompts.intro("Install GitHub agent")
+      const app = await getAppInfo()
+      await installGitHubApp()
+
+      const providers = await ModelsDev.get()
+      const provider = await promptProvider()
+      const model = await promptModel()
+      //const key = await promptKey()
+
+      await addWorkflowFiles()
+      printNextSteps()
+
+      function printNextSteps() {
+        let step2
+        if (provider === "amazon-bedrock") {
+          step2 =
+            "Configure OIDC in AWS - https://docs.github.com/en/actions/how-tos/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services"
+        } else {
+          const url = `https://github.com/organizations/${app.owner}/settings/secrets/actions`
+          const env = providers[provider].env
+          const envStr =
+            env.length === 1
+              ? `\`${env[0]}\` secret`
+              : `\`${[env.slice(0, -1).join("\`, \`"), ...env.slice(-1)].join("\` and \`")}\` secrets`
+          step2 = `Add ${envStr} for ${providers[provider].name} - ${url}`
+        }
+
+        prompts.outro(
+          [
+            "Next steps:",
+            `    1. Commit "${WORKFLOW_FILE}" file and push`,
+            `    2. ${step2}`,
+            "    3. Learn how to use the GitHub agent - https://docs.opencode.ai/docs/github/getting-started",
+          ].join("\n"),
+        )
+      }
+
+      async function getAppInfo() {
+        const app = App.info()
+        if (!app.git) {
+          prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)
+          throw new UI.CancelledError()
+        }
+
+        // Get repo info
+        const info = await $`git remote get-url origin`.quiet().nothrow().text()
+        // match https or git pattern
+        // ie. https://github.com/sst/opencode.git
+        // ie. git@github.com:sst/opencode.git
+        const parsed = info.match(/git@github\.com:(.*)\.git/) ?? info.match(/github\.com\/(.*)\.git/)
+        if (!parsed) {
+          prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)
+          throw new UI.CancelledError()
+        }
+        const [owner, repo] = parsed[1].split("/")
+        return { owner, repo, root: app.path.root }
+      }
+
+      async function promptProvider() {
+        const priority: Record<string, number> = {
+          anthropic: 0,
+          "github-copilot": 1,
+          openai: 2,
+          google: 3,
+        }
+        let provider = await prompts.select({
+          message: "Select provider",
+          maxItems: 8,
+          options: pipe(
+            providers,
+            values(),
+            sortBy(
+              (x) => priority[x.id] ?? 99,
+              (x) => x.name ?? x.id,
+            ),
+            map((x) => ({
+              label: x.name,
+              value: x.id,
+              hint: priority[x.id] === 0 ? "recommended" : undefined,
+            })),
+          ),
+        })
+
+        if (prompts.isCancel(provider)) throw new UI.CancelledError()
+
+        return provider
+      }
+
+      async function promptModel() {
+        const providerData = providers[provider]!
+
+        const model = await prompts.select({
+          message: "Select model",
+          maxItems: 8,
+          options: pipe(
+            providerData.models,
+            values(),
+            sortBy((x) => x.name ?? x.id),
+            map((x) => ({
+              label: x.name ?? x.id,
+              value: x.id,
+            })),
+          ),
+        })
+
+        if (prompts.isCancel(model)) throw new UI.CancelledError()
+        return model
+      }
+
+      async function installGitHubApp() {
+        const s = prompts.spinner()
+        s.start("Installing GitHub app")
+
+        // Get installation
+        const installation = await getInstallation()
+        if (installation) return s.stop("GitHub app already installed")
+
+        // Open browser
+        const url = "https://github.com/apps/opencode-agent"
+        const command =
+          process.platform === "darwin"
+            ? `open "${url}"`
+            : process.platform === "win32"
+              ? `start "${url}"`
+              : `xdg-open "${url}"`
+
+        exec(command, (error) => {
+          if (error) {
+            prompts.log.warn(`Could not open browser. Please visit: ${url}`)
+          }
+        })
+
+        // Wait for installation
+        s.message("Waiting for GitHub app to be installed")
+        const MAX_RETRIES = 60
+        let retries = 0
+        do {
+          const installation = await getInstallation()
+          if (installation) break
+
+          if (retries > MAX_RETRIES) {
+            s.stop(
+              `Failed to detect GitHub app installation. Make sure to install the app for the \`${app.owner}/${app.repo}\` repository.`,
+            )
+            throw new UI.CancelledError()
+          }
+
+          retries++
+          await new Promise((resolve) => setTimeout(resolve, 1000))
+        } while (true)
+
+        s.stop("Installed GitHub app")
+
+        async function getInstallation() {
+          return await fetch(`https://api.opencode.ai/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`)
+            .then((res) => res.json())
+            .then((data) => data.installation)
+        }
+      }
+
+      async function addWorkflowFiles() {
+        const envStr =
+          provider === "amazon-bedrock"
+            ? ""
+            : `\n        env:${providers[provider].env.map((e) => `\n          ${e}: \${{ secrets.${e} }}`).join("")}`
+
+        await Bun.write(
+          path.join(app.root, WORKFLOW_FILE),
+          `
+name: opencode
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  opencode:
+    if: |
+      startsWith(github.event.comment.body, 'opencode') ||
+      startsWith(github.event.comment.body, 'hi opencode') ||
+      startsWith(github.event.comment.body, 'hey opencode') ||
+      contains(github.event.comment.body, '@opencode-agent')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Run opencode
+        uses: sst/opencode/sdks/github@github-v1${envStr}
+        with:
+          model: ${provider}/${model}
+`.trim(),
+        )
+
+        prompts.log.success(`Added workflow file: "${WORKFLOW_FILE}"`)
+      }
+    })
+  },
+})

packages/opencode/src/cli/cmd/mcp.ts

@@ -0,0 +1,79 @@
+import { cmd } from "./cmd"
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+
+export const McpCommand = cmd({
+  command: "mcp",
+  builder: (yargs) => yargs.command(McpAddCommand).demandCommand(),
+  async handler() {},
+})
+
+export const McpAddCommand = cmd({
+  command: "add",
+  describe: "add an MCP server",
+  async handler() {
+    UI.empty()
+    prompts.intro("Add MCP server")
+
+    const name = await prompts.text({
+      message: "Enter MCP server name",
+      validate: (x) => (x.length > 0 ? undefined : "Required"),
+    })
+    if (prompts.isCancel(name)) throw new UI.CancelledError()
+
+    const type = await prompts.select({
+      message: "Select MCP server type",
+      options: [
+        {
+          label: "Local",
+          value: "local",
+          hint: "Run a local command",
+        },
+        {
+          label: "Remote",
+          value: "remote",
+          hint: "Connect to a remote URL",
+        },
+      ],
+    })
+    if (prompts.isCancel(type)) throw new UI.CancelledError()
+
+    if (type === "local") {
+      const command = await prompts.text({
+        message: "Enter command to run",
+        placeholder: "e.g., opencode x @modelcontextprotocol/server-filesystem",
+        validate: (x) => (x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(command)) throw new UI.CancelledError()
+
+      prompts.log.info(`Local MCP server "${name}" configured with command: ${command}`)
+      prompts.outro("MCP server added successfully")
+      return
+    }
+
+    if (type === "remote") {
+      const url = await prompts.text({
+        message: "Enter MCP server URL",
+        placeholder: "e.g., https://example.com/mcp",
+        validate: (x) => {
+          if (x.length === 0) return "Required"
+          const isValid = URL.canParse(x)
+          return isValid ? undefined : "Invalid URL"
+        },
+      })
+      if (prompts.isCancel(url)) throw new UI.CancelledError()
+
+      const client = new Client({
+        name: "opencode",
+        version: "1.0.0",
+      })
+      const transport = new StreamableHTTPClientTransport(new URL(url))
+      await client.connect(transport)
+      prompts.log.info(`Remote MCP server "${name}" configured with URL: ${url}`)
+    }
+
+    prompts.outro("MCP server added successfully")
+  },
+})

packages/opencode/src/cli/cmd/models.ts

@@ -0,0 +1,19 @@
+import { App } from "../../app/app"
+import { Provider } from "../../provider/provider"
+import { cmd } from "./cmd"
+
+export const ModelsCommand = cmd({
+  command: "models",
+  describe: "list all available models",
+  handler: async () => {
+    await App.provide({ cwd: process.cwd() }, async () => {
+      const providers = await Provider.list()
+
+      for (const [providerID, provider] of Object.entries(providers)) {
+        for (const modelID of Object.keys(provider.info.models)) {
+          console.log(`${providerID}/${modelID}`)
+        }
+      }
+    })
+  },
+})

packages/opencode/src/cli/cmd/run.ts

@@ -0,0 +1,190 @@
+import type { Argv } from "yargs"
+import { Bus } from "../../bus"
+import { Provider } from "../../provider/provider"
+import { Session } from "../../session"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { Flag } from "../../flag/flag"
+import { Config } from "../../config/config"
+import { bootstrap } from "../bootstrap"
+import { MessageV2 } from "../../session/message-v2"
+import { Mode } from "../../session/mode"
+import { Identifier } from "../../id/id"
+
+const TOOL: Record<string, [string, string]> = {
+  todowrite: ["Todo", UI.Style.TEXT_WARNING_BOLD],
+  todoread: ["Todo", UI.Style.TEXT_WARNING_BOLD],
+  bash: ["Bash", UI.Style.TEXT_DANGER_BOLD],
+  edit: ["Edit", UI.Style.TEXT_SUCCESS_BOLD],
+  glob: ["Glob", UI.Style.TEXT_INFO_BOLD],
+  grep: ["Grep", UI.Style.TEXT_INFO_BOLD],
+  list: ["List", UI.Style.TEXT_INFO_BOLD],
+  read: ["Read", UI.Style.TEXT_HIGHLIGHT_BOLD],
+  write: ["Write", UI.Style.TEXT_SUCCESS_BOLD],
+  websearch: ["Search", UI.Style.TEXT_DIM_BOLD],
+}
+
+export const RunCommand = cmd({
+  command: "run [message..]",
+  describe: "run opencode with a message",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("message", {
+        describe: "message to send",
+        type: "string",
+        array: true,
+        default: [],
+      })
+      .option("continue", {
+        alias: ["c"],
+        describe: "continue the last session",
+        type: "boolean",
+      })
+      .option("session", {
+        alias: ["s"],
+        describe: "session id to continue",
+        type: "string",
+      })
+      .option("share", {
+        type: "boolean",
+        describe: "share the session",
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      })
+      .option("mode", {
+        type: "string",
+        describe: "mode to use",
+      })
+  },
+  handler: async (args) => {
+    let message = args.message.join(" ")
+
+    if (!process.stdin.isTTY) message += "\n" + (await Bun.stdin.text())
+
+    await bootstrap({ cwd: process.cwd() }, async () => {
+      const session = await (async () => {
+        if (args.continue) {
+          const list = Session.list()
+          const first = await list.next()
+          await list.return()
+          if (first.done) return
+          return first.value
+        }
+
+        if (args.session) return Session.get(args.session)
+
+        return Session.create()
+      })()
+
+      if (!session) {
+        UI.error("Session not found")
+        return
+      }
+
+      UI.empty()
+      UI.println(UI.logo())
+      UI.empty()
+
+      const cfg = await Config.get()
+      if (cfg.share === "auto" || Flag.OPENCODE_AUTO_SHARE || args.share) {
+        try {
+          await Session.share(session.id)
+          UI.println(UI.Style.TEXT_INFO_BOLD + "~  https://opencode.ai/s/" + session.id.slice(-8))
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("disabled")) {
+            UI.println(UI.Style.TEXT_DANGER_BOLD + "!  " + error.message)
+          } else {
+            throw error
+          }
+        }
+      }
+      UI.empty()
+
+      const { providerID, modelID } = args.model ? Provider.parseModel(args.model) : await Provider.defaultModel()
+      UI.println(UI.Style.TEXT_NORMAL_BOLD + "@ ", UI.Style.TEXT_NORMAL + `${providerID}/${modelID}`)
+      UI.empty()
+
+      function printEvent(color: string, type: string, title: string) {
+        UI.println(
+          color + `|`,
+          UI.Style.TEXT_NORMAL + UI.Style.TEXT_DIM + ` ${type.padEnd(7, " ")}`,
+          "",
+          UI.Style.TEXT_NORMAL + title,
+        )
+      }
+
+      let text = ""
+      Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+        if (evt.properties.part.sessionID !== session.id) return
+        if (evt.properties.part.messageID === messageID) return
+        const part = evt.properties.part
+
+        if (part.type === "tool" && part.state.status === "completed") {
+          const [tool, color] = TOOL[part.tool] ?? [part.tool, UI.Style.TEXT_INFO_BOLD]
+          const title =
+            part.state.title || Object.keys(part.state.input).length > 0 ? JSON.stringify(part.state.input) : "Unknown"
+          printEvent(color, tool, title)
+        }
+
+        if (part.type === "text") {
+          text = part.text
+
+          if (part.time?.end) {
+            UI.empty()
+            UI.println(UI.markdown(text))
+            UI.empty()
+            text = ""
+            return
+          }
+        }
+      })
+
+      let errorMsg: string | undefined
+      Bus.subscribe(Session.Event.Error, async (evt) => {
+        const { sessionID, error } = evt.properties
+        if (sessionID !== session.id || !error) return
+        let err = String(error.name)
+
+        if ("data" in error && error.data && "message" in error.data) {
+          err = error.data.message
+        }
+        errorMsg = errorMsg ? errorMsg + "\n" + err : err
+
+        UI.error(err)
+      })
+
+      const mode = args.mode ? await Mode.get(args.mode) : await Mode.list().then((x) => x[0])
+
+      const messageID = Identifier.ascending("message")
+      const result = await Session.chat({
+        sessionID: session.id,
+        messageID,
+        ...(mode.model
+          ? mode.model
+          : {
+              providerID,
+              modelID,
+            }),
+        mode: mode.name,
+        parts: [
+          {
+            id: Identifier.ascending("part"),
+            type: "text",
+            text: message,
+          },
+        ],
+      })
+
+      const isPiped = !process.stdout.isTTY
+      if (isPiped) {
+        const match = result.parts.findLast((x) => x.type === "text")
+        if (match) process.stdout.write(UI.markdown(match.text))
+        if (errorMsg) process.stdout.write(errorMsg)
+      }
+      UI.empty()
+    })
+  },
+})

packages/opencode/src/cli/cmd/serve.ts

@@ -0,0 +1,46 @@
+import { Provider } from "../../provider/provider"
+import { Server } from "../../server/server"
+import { bootstrap } from "../bootstrap"
+import { cmd } from "./cmd"
+
+export const ServeCommand = cmd({
+  command: "serve",
+  builder: (yargs) =>
+    yargs
+      .option("port", {
+        alias: ["p"],
+        type: "number",
+        describe: "port to listen on",
+        default: 4096,
+      })
+      .option("hostname", {
+        alias: ["h"],
+        type: "string",
+        describe: "hostname to listen on",
+        default: "127.0.0.1",
+      }),
+  describe: "starts a headless opencode server",
+  handler: async (args) => {
+    const cwd = process.cwd()
+    await bootstrap({ cwd }, async () => {
+      const providers = await Provider.list()
+      if (Object.keys(providers).length === 0) {
+        return "needs_provider"
+      }
+
+      const hostname = args.hostname
+      const port = args.port
+
+      const server = Server.listen({
+        port,
+        hostname,
+      })
+
+      console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
+
+      await new Promise(() => {})
+
+      server.stop()
+    })
+  },
+})

packages/opencode/src/cli/cmd/stats.ts

@@ -0,0 +1,98 @@
+import { cmd } from "./cmd"
+
+interface SessionStats {
+  totalSessions: number
+  totalMessages: number
+  totalCost: number
+  totalTokens: {
+    input: number
+    output: number
+    reasoning: number
+    cache: {
+      read: number
+      write: number
+    }
+  }
+  toolUsage: Record<string, number>
+  dateRange: {
+    earliest: number
+    latest: number
+  }
+  days: number
+  costPerDay: number
+}
+
+export const StatsCommand = cmd({
+  command: "stats",
+  handler: async () => {},
+})
+
+export function displayStats(stats: SessionStats) {
+  const width = 56
+
+  function renderRow(label: string, value: string): string {
+    const availableWidth = width - 1
+    const paddingNeeded = availableWidth - label.length - value.length
+    const padding = Math.max(0, paddingNeeded)
+    return `│${label}${" ".repeat(padding)}${value} │`
+  }
+
+  // Overview section
+  console.log("┌────────────────────────────────────────────────────────┐")
+  console.log("│                       OVERVIEW                         │")
+  console.log("├────────────────────────────────────────────────────────┤")
+  console.log(renderRow("Sessions", stats.totalSessions.toLocaleString()))
+  console.log(renderRow("Messages", stats.totalMessages.toLocaleString()))
+  console.log(renderRow("Days", stats.days.toString()))
+  console.log("└────────────────────────────────────────────────────────┘")
+  console.log()
+
+  // Cost & Tokens section
+  console.log("┌────────────────────────────────────────────────────────┐")
+  console.log("│                    COST & TOKENS                       │")
+  console.log("├────────────────────────────────────────────────────────┤")
+  const cost = isNaN(stats.totalCost) ? 0 : stats.totalCost
+  const costPerDay = isNaN(stats.costPerDay) ? 0 : stats.costPerDay
+  console.log(renderRow("Total Cost", `$${cost.toFixed(2)}`))
+  console.log(renderRow("Cost/Day", `$${costPerDay.toFixed(2)}`))
+  console.log(renderRow("Input", formatNumber(stats.totalTokens.input)))
+  console.log(renderRow("Output", formatNumber(stats.totalTokens.output)))
+  console.log(renderRow("Cache Read", formatNumber(stats.totalTokens.cache.read)))
+  console.log(renderRow("Cache Write", formatNumber(stats.totalTokens.cache.write)))
+  console.log("└────────────────────────────────────────────────────────┘")
+  console.log()
+
+  // Tool Usage section
+  if (Object.keys(stats.toolUsage).length > 0) {
+    const sortedTools = Object.entries(stats.toolUsage)
+      .sort(([, a], [, b]) => b - a)
+      .slice(0, 10)
+
+    console.log("┌────────────────────────────────────────────────────────┐")
+    console.log("│                      TOOL USAGE                        │")
+    console.log("├────────────────────────────────────────────────────────┤")
+
+    const maxCount = Math.max(...sortedTools.map(([, count]) => count))
+    const totalToolUsage = Object.values(stats.toolUsage).reduce((a, b) => a + b, 0)
+
+    for (const [tool, count] of sortedTools) {
+      const barLength = Math.max(1, Math.floor((count / maxCount) * 20))
+      const bar = "█".repeat(barLength)
+      const percentage = ((count / totalToolUsage) * 100).toFixed(1)
+
+      const content = ` ${tool.padEnd(10)} ${bar.padEnd(20)} ${count.toString().padStart(3)} (${percentage.padStart(4)}%)`
+      const padding = Math.max(0, width - content.length)
+      console.log(`│${content}${" ".repeat(padding)} │`)
+    }
+    console.log("└────────────────────────────────────────────────────────┘")
+  }
+  console.log()
+}
+function formatNumber(num: number): string {
+  if (num >= 1000000) {
+    return (num / 1000000).toFixed(1) + "M"
+  } else if (num >= 1000) {
+    return (num / 1000).toFixed(1) + "K"
+  }
+  return num.toString()
+}

packages/opencode/src/cli/cmd/tui.ts

@@ -0,0 +1,185 @@
+import { Global } from "../../global"
+import { Provider } from "../../provider/provider"
+import { Server } from "../../server/server"
+import { bootstrap } from "../bootstrap"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import path from "path"
+import fs from "fs/promises"
+import { Installation } from "../../installation"
+import { Config } from "../../config/config"
+import { Bus } from "../../bus"
+import { Log } from "../../util/log"
+import { FileWatcher } from "../../file/watch"
+import { Mode } from "../../session/mode"
+import { Ide } from "../../ide"
+
+export const TuiCommand = cmd({
+  command: "$0 [project]",
+  describe: "start opencode tui",
+  builder: (yargs) =>
+    yargs
+      .positional("project", {
+        type: "string",
+        describe: "path to start opencode in",
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      })
+      .option("prompt", {
+        alias: ["p"],
+        type: "string",
+        describe: "prompt to use",
+      })
+      .option("mode", {
+        type: "string",
+        describe: "mode to use",
+      })
+      .option("port", {
+        type: "number",
+        describe: "port to listen on",
+        default: 0,
+      })
+      .option("hostname", {
+        alias: ["h"],
+        type: "string",
+        describe: "hostname to listen on",
+        default: "127.0.0.1",
+      }),
+  handler: async (args) => {
+    while (true) {
+      const cwd = args.project ? path.resolve(args.project) : process.cwd()
+      try {
+        process.chdir(cwd)
+      } catch (e) {
+        UI.error("Failed to change directory to " + cwd)
+        return
+      }
+      const result = await bootstrap({ cwd }, async (app) => {
+        FileWatcher.init()
+        const providers = await Provider.list()
+        if (Object.keys(providers).length === 0) {
+          return "needs_provider"
+        }
+
+        const server = Server.listen({
+          port: args.port,
+          hostname: args.hostname,
+        })
+
+        let cmd = ["go", "run", "./main.go"]
+        let cwd = Bun.fileURLToPath(new URL("../../../../tui/cmd/opencode", import.meta.url))
+        if (Bun.embeddedFiles.length > 0) {
+          const blob = Bun.embeddedFiles[0] as File
+          let binaryName = blob.name
+          if (process.platform === "win32" && !binaryName.endsWith(".exe")) {
+            binaryName += ".exe"
+          }
+          const binary = path.join(Global.Path.cache, "tui", binaryName)
+          const file = Bun.file(binary)
+          if (!(await file.exists())) {
+            await Bun.write(file, blob, { mode: 0o755 })
+            await fs.chmod(binary, 0o755)
+          }
+          cwd = process.cwd()
+          cmd = [binary]
+        }
+        Log.Default.info("tui", {
+          cmd,
+        })
+        const proc = Bun.spawn({
+          cmd: [
+            ...cmd,
+            ...(args.model ? ["--model", args.model] : []),
+            ...(args.prompt ? ["--prompt", args.prompt] : []),
+            ...(args.mode ? ["--mode", args.mode] : []),
+          ],
+          cwd,
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "inherit",
+          env: {
+            ...process.env,
+            CGO_ENABLED: "0",
+            OPENCODE_SERVER: server.url.toString(),
+            OPENCODE_APP_INFO: JSON.stringify(app),
+            OPENCODE_MODES: JSON.stringify(await Mode.list()),
+          },
+          onExit: () => {
+            server.stop()
+          },
+        })
+
+        ;(async () => {
+          if (Installation.VERSION === "dev") return
+          if (Installation.isSnapshot()) return
+          const config = await Config.global()
+          if (config.autoupdate === false) return
+          const latest = await Installation.latest().catch(() => {})
+          if (!latest) return
+          if (Installation.VERSION === latest) return
+          const method = await Installation.method()
+          if (method === "unknown") return
+          await Installation.upgrade(method, latest)
+            .then(() => {
+              Bus.publish(Installation.Event.Updated, { version: latest })
+            })
+            .catch(() => {})
+        })()
+        ;(async () => {
+          if (Ide.alreadyInstalled()) return
+          const ide = await Ide.ide()
+          if (ide === "unknown") return
+          await Ide.install(ide)
+            .then(() => {
+              Bus.publish(Ide.Event.Installed, { ide })
+            })
+            .catch(() => {})
+        })()
+
+        await proc.exited
+        server.stop()
+
+        return "done"
+      })
+      if (result === "done") break
+      if (result === "needs_provider") {
+        UI.empty()
+        UI.println(UI.logo("   "))
+        const result = await Bun.spawn({
+          cmd: [...getOpencodeCommand(), "auth", "login"],
+          cwd: process.cwd(),
+          stdout: "inherit",
+          stderr: "inherit",
+          stdin: "inherit",
+        }).exited
+        if (result !== 0) return
+        UI.empty()
+      }
+    }
+  },
+})
+
+/**
+ * Get the correct command to run opencode CLI
+ * In development: ["bun", "run", "packages/opencode/src/index.ts"]
+ * In production: ["/path/to/opencode"]
+ */
+function getOpencodeCommand(): string[] {
+  // Check if OPENCODE_BIN_PATH is set (used by shell wrapper scripts)
+  if (process.env["OPENCODE_BIN_PATH"]) {
+    return [process.env["OPENCODE_BIN_PATH"]]
+  }
+
+  const execPath = process.execPath.toLowerCase()
+
+  if (Installation.isDev()) {
+    // In development, use bun to run the TypeScript entry point
+    return [execPath, "run", process.argv[1]]
+  }
+
+  // In production, use the current executable path
+  return [process.execPath]
+}

packages/opencode/src/cli/cmd/upgrade.ts

@@ -0,0 +1,57 @@
+import type { Argv } from "yargs"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../../installation"
+
+export const UpgradeCommand = {
+  command: "upgrade [target]",
+  describe: "upgrade opencode to the latest or a specific version",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("target", {
+        describe: "version to upgrade to, for ex '0.1.48' or 'v0.1.48'",
+        type: "string",
+      })
+      .option("method", {
+        alias: "m",
+        describe: "installation method to use",
+        type: "string",
+        choices: ["curl", "npm", "pnpm", "bun", "brew"],
+      })
+  },
+  handler: async (args: { target?: string; method?: string }) => {
+    UI.empty()
+    UI.println(UI.logo("  "))
+    UI.empty()
+    prompts.intro("Upgrade")
+    const detectedMethod = await Installation.method()
+    const method = (args.method as Installation.Method) ?? detectedMethod
+    if (method === "unknown") {
+      prompts.log.error(`opencode is installed to ${process.execPath} and seems to be managed by a package manager`)
+      prompts.outro("Done")
+      return
+    }
+    prompts.log.info("Using method: " + method)
+    const target = args.target ?? (await Installation.latest())
+
+    if (Installation.VERSION === target) {
+      prompts.log.warn(`opencode upgrade skipped: ${target} is already installed`)
+      prompts.outro("Done")
+      return
+    }
+
+    prompts.log.info(`From ${Installation.VERSION} → ${target}`)
+    const spinner = prompts.spinner()
+    spinner.start("Upgrading...")
+    const err = await Installation.upgrade(method, target).catch((err) => err)
+    if (err) {
+      spinner.stop("Upgrade failed")
+      if (err instanceof Installation.UpgradeFailedError) prompts.log.error(err.data.stderr)
+      else if (err instanceof Error) prompts.log.error(err.message)
+      prompts.outro("Done")
+      return
+    }
+    spinner.stop("Upgrade complete")
+    prompts.outro("Done")
+  },
+}

packages/opencode/src/cli/error.ts

@@ -0,0 +1,16 @@
+import { Config } from "../config/config"
+import { MCP } from "../mcp"
+import { UI } from "./ui"
+
+export function FormatError(input: unknown) {
+  if (MCP.Failed.isInstance(input))
+    return `MCP server "${input.data.name}" failed. Note, opencode does not support MCP authentication yet.`
+  if (Config.JsonError.isInstance(input)) return `Config file at ${input.data.path} is not valid JSON`
+  if (Config.InvalidError.isInstance(input))
+    return [
+      `Config file at ${input.data.path} is invalid`,
+      ...(input.data.issues?.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")) ?? []),
+    ].join("\n")
+
+  if (UI.CancelledError.isInstance(input)) return ""
+}

packages/opencode/src/cli/ui.ts

@@ -0,0 +1,83 @@
+import { z } from "zod"
+import { EOL } from "os"
+import { NamedError } from "../util/error"
+
+export namespace UI {
+  const LOGO = [
+    [`█▀▀█ █▀▀█ █▀▀ █▀▀▄ `, `█▀▀ █▀▀█ █▀▀▄ █▀▀`],
+    [`█░░█ █░░█ █▀▀ █░░█ `, `█░░ █░░█ █░░█ █▀▀`],
+    [`▀▀▀▀ █▀▀▀ ▀▀▀ ▀  ▀ `, `▀▀▀ ▀▀▀▀ ▀▀▀  ▀▀▀`],
+  ]
+
+  export const CancelledError = NamedError.create("UICancelledError", z.void())
+
+  export const Style = {
+    TEXT_HIGHLIGHT: "\x1b[96m",
+    TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
+    TEXT_DIM: "\x1b[90m",
+    TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
+    TEXT_NORMAL: "\x1b[0m",
+    TEXT_NORMAL_BOLD: "\x1b[1m",
+    TEXT_WARNING: "\x1b[93m",
+    TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
+    TEXT_DANGER: "\x1b[91m",
+    TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
+    TEXT_SUCCESS: "\x1b[92m",
+    TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
+    TEXT_INFO: "\x1b[94m",
+    TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
+  }
+
+  export function println(...message: string[]) {
+    print(...message)
+    Bun.stderr.write(EOL)
+  }
+
+  export function print(...message: string[]) {
+    blank = false
+    Bun.stderr.write(message.join(" "))
+  }
+
+  let blank = false
+  export function empty() {
+    if (blank) return
+    println("" + Style.TEXT_NORMAL)
+    blank = true
+  }
+
+  export function logo(pad?: string) {
+    const result = []
+    for (const row of LOGO) {
+      if (pad) result.push(pad)
+      result.push(Bun.color("gray", "ansi"))
+      result.push(row[0])
+      result.push("\x1b[0m")
+      result.push(row[1])
+      result.push(EOL)
+    }
+    return result.join("").trimEnd()
+  }
+
+  export async function input(prompt: string): Promise<string> {
+    const readline = require("readline")
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    })
+
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        rl.close()
+        resolve(answer.trim())
+      })
+    })
+  }
+
+  export function error(message: string) {
+    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
+  }
+
+  export function markdown(text: string): string {
+    return text
+  }
+}

packages/opencode/src/config/config.ts

@@ -0,0 +1,354 @@
+import { Log } from "../util/log"
+import path from "path"
+import { z } from "zod"
+import { App } from "../app/app"
+import { Filesystem } from "../util/filesystem"
+import { ModelsDev } from "../provider/models"
+import { mergeDeep, pipe } from "remeda"
+import { Global } from "../global"
+import fs from "fs/promises"
+import { lazy } from "../util/lazy"
+import { NamedError } from "../util/error"
+import matter from "gray-matter"
+
+export namespace Config {
+  const log = Log.create({ service: "config" })
+
+  export const state = App.state("config", async (app) => {
+    let result = await global()
+    for (const file of ["opencode.jsonc", "opencode.json"]) {
+      const found = await Filesystem.findUp(file, app.path.cwd, app.path.root)
+      for (const resolved of found.toReversed()) {
+        result = mergeDeep(result, await load(resolved))
+      }
+    }
+
+    result.agent = result.agent || {}
+    const markdownAgents = [
+      ...(await Filesystem.globUp("agent/*.md", Global.Path.config, Global.Path.config)),
+      ...(await Filesystem.globUp(".opencode/agent/*.md", app.path.cwd, app.path.root)),
+    ]
+    for (const item of markdownAgents) {
+      const content = await Bun.file(item).text()
+      const md = matter(content)
+      if (!md.data) continue
+
+      const config = {
+        name: path.basename(item, ".md"),
+        ...md.data,
+        prompt: md.content.trim(),
+      }
+      const parsed = Agent.safeParse(config)
+      if (parsed.success) {
+        result.agent = mergeDeep(result.agent, {
+          [config.name]: parsed.data,
+        })
+        continue
+      }
+      throw new InvalidError({ path: item }, { cause: parsed.error })
+    }
+
+    // Handle migration from autoshare to share field
+    if (result.autoshare === true && !result.share) {
+      result.share = "auto"
+    }
+    if (result.keybinds?.messages_revert && !result.keybinds.messages_undo) {
+      result.keybinds.messages_undo = result.keybinds.messages_revert
+    }
+
+    if (!result.username) {
+      const os = await import("os")
+      result.username = os.userInfo().username
+    }
+
+    log.info("loaded", result)
+
+    return result
+  })
+
+  export const McpLocal = z
+    .object({
+      type: z.literal("local").describe("Type of MCP server connection"),
+      command: z.string().array().describe("Command and arguments to run the MCP server"),
+      environment: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("Environment variables to set when running the MCP server"),
+      enabled: z.boolean().optional().describe("Enable or disable the MCP server on startup"),
+    })
+    .strict()
+    .openapi({
+      ref: "McpLocalConfig",
+    })
+
+  export const McpRemote = z
+    .object({
+      type: z.literal("remote").describe("Type of MCP server connection"),
+      url: z.string().describe("URL of the remote MCP server"),
+      enabled: z.boolean().optional().describe("Enable or disable the MCP server on startup"),
+      headers: z.record(z.string(), z.string()).optional().describe("Headers to send with the request"),
+    })
+    .strict()
+    .openapi({
+      ref: "McpRemoteConfig",
+    })
+
+  export const Mcp = z.discriminatedUnion("type", [McpLocal, McpRemote])
+  export type Mcp = z.infer<typeof Mcp>
+
+  export const Mode = z
+    .object({
+      model: z.string().optional(),
+      temperature: z.number().optional(),
+      prompt: z.string().optional(),
+      tools: z.record(z.string(), z.boolean()).optional(),
+      disable: z.boolean().optional(),
+    })
+    .openapi({
+      ref: "ModeConfig",
+    })
+  export type Mode = z.infer<typeof Mode>
+
+  export const Agent = Mode.extend({
+    description: z.string(),
+  }).openapi({
+    ref: "AgentConfig",
+  })
+
+  export const Keybinds = z
+    .object({
+      leader: z.string().optional().default("ctrl+x").describe("Leader key for keybind combinations"),
+      app_help: z.string().optional().default("<leader>h").describe("Show help dialog"),
+      switch_mode: z.string().optional().default("tab").describe("Next mode"),
+      switch_mode_reverse: z.string().optional().default("shift+tab").describe("Previous Mode"),
+      editor_open: z.string().optional().default("<leader>e").describe("Open external editor"),
+      session_export: z.string().optional().default("<leader>x").describe("Export session to editor"),
+      session_new: z.string().optional().default("<leader>n").describe("Create a new session"),
+      session_list: z.string().optional().default("<leader>l").describe("List all sessions"),
+      session_share: z.string().optional().default("<leader>s").describe("Share current session"),
+      session_unshare: z.string().optional().default("none").describe("Unshare current session"),
+      session_interrupt: z.string().optional().default("esc").describe("Interrupt current session"),
+      session_compact: z.string().optional().default("<leader>c").describe("Compact the session"),
+      tool_details: z.string().optional().default("<leader>d").describe("Toggle tool details"),
+      model_list: z.string().optional().default("<leader>m").describe("List available models"),
+      theme_list: z.string().optional().default("<leader>t").describe("List available themes"),
+      file_list: z.string().optional().default("<leader>f").describe("List files"),
+      file_close: z.string().optional().default("esc").describe("Close file"),
+      file_search: z.string().optional().default("<leader>/").describe("Search file"),
+      file_diff_toggle: z.string().optional().default("<leader>v").describe("Split/unified diff"),
+      project_init: z.string().optional().default("<leader>i").describe("Create/update AGENTS.md"),
+      input_clear: z.string().optional().default("ctrl+c").describe("Clear input field"),
+      input_paste: z.string().optional().default("ctrl+v").describe("Paste from clipboard"),
+      input_submit: z.string().optional().default("enter").describe("Submit input"),
+      input_newline: z.string().optional().default("shift+enter,ctrl+j").describe("Insert newline in input"),
+      messages_page_up: z.string().optional().default("pgup").describe("Scroll messages up by one page"),
+      messages_page_down: z.string().optional().default("pgdown").describe("Scroll messages down by one page"),
+      messages_half_page_up: z.string().optional().default("ctrl+alt+u").describe("Scroll messages up by half page"),
+      messages_half_page_down: z
+        .string()
+        .optional()
+        .default("ctrl+alt+d")
+        .describe("Scroll messages down by half page"),
+      messages_previous: z.string().optional().default("ctrl+up").describe("Navigate to previous message"),
+      messages_next: z.string().optional().default("ctrl+down").describe("Navigate to next message"),
+      messages_first: z.string().optional().default("ctrl+g").describe("Navigate to first message"),
+      messages_last: z.string().optional().default("ctrl+alt+g").describe("Navigate to last message"),
+      messages_layout_toggle: z.string().optional().default("<leader>p").describe("Toggle layout"),
+      messages_copy: z.string().optional().default("<leader>y").describe("Copy message"),
+      messages_revert: z.string().optional().default("none").describe("@deprecated use messages_undo. Revert message"),
+      messages_undo: z.string().optional().default("<leader>u").describe("Undo message"),
+      messages_redo: z.string().optional().default("<leader>r").describe("Redo message"),
+      app_exit: z.string().optional().default("ctrl+c,<leader>q").describe("Exit the application"),
+    })
+    .strict()
+    .openapi({
+      ref: "KeybindsConfig",
+    })
+
+  export const Layout = z.enum(["auto", "stretch"]).openapi({
+    ref: "LayoutConfig",
+  })
+  export type Layout = z.infer<typeof Layout>
+
+  export const Info = z
+    .object({
+      $schema: z.string().optional().describe("JSON schema reference for configuration validation"),
+      theme: z.string().optional().describe("Theme name to use for the interface"),
+      keybinds: Keybinds.optional().describe("Custom keybind configurations"),
+      share: z
+        .enum(["manual", "auto", "disabled"])
+        .optional()
+        .describe(
+          "Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing",
+        ),
+      autoshare: z
+        .boolean()
+        .optional()
+        .describe("@deprecated Use 'share' field instead. Share newly created sessions automatically"),
+      autoupdate: z.boolean().optional().describe("Automatically update to the latest version"),
+      disabled_providers: z.array(z.string()).optional().describe("Disable providers that are loaded automatically"),
+      model: z.string().describe("Model to use in the format of provider/model, eg anthropic/claude-2").optional(),
+      small_model: z
+        .string()
+        .describe(
+          "Small model to use for tasks like summarization and title generation in the format of provider/model",
+        )
+        .optional(),
+      username: z
+        .string()
+        .optional()
+        .describe("Custom username to display in conversations instead of system username"),
+      mode: z
+        .object({
+          build: Mode.optional(),
+          plan: Mode.optional(),
+        })
+        .catchall(Mode)
+        .optional()
+        .describe("Modes configuration, see https://opencode.ai/docs/modes"),
+      agent: z
+        .object({
+          general: Agent.optional(),
+        })
+        .catchall(Agent)
+        .optional()
+        .describe("Modes configuration, see https://opencode.ai/docs/modes"),
+      provider: z
+        .record(
+          ModelsDev.Provider.partial()
+            .extend({
+              models: z.record(ModelsDev.Model.partial()),
+              options: z
+                .object({
+                  apiKey: z.string().optional(),
+                  baseURL: z.string().optional(),
+                })
+                .catchall(z.any())
+                .optional(),
+            })
+            .strict(),
+        )
+        .optional()
+        .describe("Custom provider configurations and model overrides"),
+      mcp: z.record(z.string(), Mcp).optional().describe("MCP (Model Context Protocol) server configurations"),
+      instructions: z.array(z.string()).optional().describe("Additional instruction files or patterns to include"),
+      layout: Layout.optional().describe("@deprecated Always uses stretch layout."),
+      experimental: z
+        .object({
+          hook: z
+            .object({
+              file_edited: z
+                .record(
+                  z.string(),
+                  z
+                    .object({
+                      command: z.string().array(),
+                      environment: z.record(z.string(), z.string()).optional(),
+                    })
+                    .array(),
+                )
+                .optional(),
+              session_completed: z
+                .object({
+                  command: z.string().array(),
+                  environment: z.record(z.string(), z.string()).optional(),
+                })
+                .array()
+                .optional(),
+            })
+            .optional(),
+        })
+        .optional(),
+    })
+    .strict()
+    .openapi({
+      ref: "Config",
+    })
+
+  export type Info = z.output<typeof Info>
+
+  export const global = lazy(async () => {
+    let result = pipe(
+      {},
+      mergeDeep(await load(path.join(Global.Path.config, "config.json"))),
+      mergeDeep(await load(path.join(Global.Path.config, "opencode.json"))),
+    )
+
+    await import(path.join(Global.Path.config, "config"), {
+      with: {
+        type: "toml",
+      },
+    })
+      .then(async (mod) => {
+        const { provider, model, ...rest } = mod.default
+        if (provider && model) result.model = `${provider}/${model}`
+        result["$schema"] = "https://opencode.ai/config.json"
+        result = mergeDeep(result, rest)
+        await Bun.write(path.join(Global.Path.config, "config.json"), JSON.stringify(result, null, 2))
+        await fs.unlink(path.join(Global.Path.config, "config"))
+      })
+      .catch(() => {})
+
+    return result
+  })
+
+  async function load(configPath: string) {
+    let text = await Bun.file(configPath)
+      .text()
+      .catch((err) => {
+        if (err.code === "ENOENT") return
+        throw new JsonError({ path: configPath }, { cause: err })
+      })
+    if (!text) return {}
+
+    text = text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
+      return process.env[varName] || ""
+    })
+
+    const fileMatches = text.match(/"?\{file:([^}]+)\}"?/g)
+    if (fileMatches) {
+      const configDir = path.dirname(configPath)
+      for (const match of fileMatches) {
+        const filePath = match.replace(/^"?\{file:/, "").replace(/\}"?$/, "")
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
+        const fileContent = await Bun.file(resolvedPath).text()
+        text = text.replace(match, JSON.stringify(fileContent))
+      }
+    }
+
+    let data: any
+    try {
+      data = JSON.parse(text)
+    } catch (err) {
+      throw new JsonError({ path: configPath }, { cause: err as Error })
+    }
+
+    const parsed = Info.safeParse(data)
+    if (parsed.success) {
+      if (!parsed.data.$schema) {
+        parsed.data.$schema = "https://opencode.ai/config.json"
+        await Bun.write(configPath, JSON.stringify(parsed.data, null, 2))
+      }
+      return parsed.data
+    }
+    throw new InvalidError({ path: configPath, issues: parsed.error.issues })
+  }
+  export const JsonError = NamedError.create(
+    "ConfigJsonError",
+    z.object({
+      path: z.string(),
+    }),
+  )
+
+  export const InvalidError = NamedError.create(
+    "ConfigInvalidError",
+    z.object({
+      path: z.string(),
+      issues: z.custom<z.ZodIssue[]>().optional(),
+    }),
+  )
+
+  export function get() {
+    return state()
+  }
+}

packages/opencode/src/config/hooks.ts

@@ -0,0 +1,56 @@
+import { App } from "../app/app"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Session } from "../session"
+import { Log } from "../util/log"
+import { Config } from "./config"
+import path from "path"
+
+export namespace ConfigHooks {
+  const log = Log.create({ service: "config.hooks" })
+
+  export function init() {
+    log.info("init")
+    const app = App.info()
+
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const cfg = await Config.get()
+      const ext = path.extname(payload.properties.file)
+      for (const item of cfg.experimental?.hook?.file_edited?.[ext] ?? []) {
+        log.info("file_edited", {
+          file: payload.properties.file,
+          command: item.command,
+        })
+        Bun.spawn({
+          cmd: item.command.map((x) => x.replace("$FILE", payload.properties.file)),
+          env: item.environment,
+          cwd: app.path.cwd,
+          stdout: "ignore",
+          stderr: "ignore",
+        })
+      }
+    })
+
+    Bus.subscribe(Session.Event.Idle, async (payload) => {
+      const cfg = await Config.get()
+      if (cfg.experimental?.hook?.session_completed) {
+        const session = await Session.get(payload.properties.sessionID)
+        // Only fire hook for top-level sessions (not subagent sessions)
+        if (session.parentID) return
+
+        for (const item of cfg.experimental.hook.session_completed) {
+          log.info("session_completed", {
+            command: item.command,
+          })
+          Bun.spawn({
+            cmd: item.command,
+            cwd: App.info().path.cwd,
+            env: item.environment,
+            stdout: "ignore",
+            stderr: "ignore",
+          })
+        }
+      }
+    })
+  }
+}

packages/opencode/src/file/fzf.ts

@@ -0,0 +1,130 @@
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import { z } from "zod"
+import { NamedError } from "../util/error"
+import { lazy } from "../util/lazy"
+import { Log } from "../util/log"
+import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"
+
+export namespace Fzf {
+  const log = Log.create({ service: "fzf" })
+
+  const VERSION = "0.62.0"
+  const PLATFORM = {
+    darwin: { extension: "tar.gz" },
+    linux: { extension: "tar.gz" },
+    win32: { extension: "zip" },
+  } as const
+
+  export const ExtractionFailedError = NamedError.create(
+    "FzfExtractionFailedError",
+    z.object({
+      filepath: z.string(),
+      stderr: z.string(),
+    }),
+  )
+
+  export const UnsupportedPlatformError = NamedError.create(
+    "FzfUnsupportedPlatformError",
+    z.object({
+      platform: z.string(),
+    }),
+  )
+
+  export const DownloadFailedError = NamedError.create(
+    "FzfDownloadFailedError",
+    z.object({
+      url: z.string(),
+      status: z.number(),
+    }),
+  )
+
+  const state = lazy(async () => {
+    let filepath = Bun.which("fzf")
+    if (filepath) {
+      log.info("found", { filepath })
+      return { filepath }
+    }
+    filepath = path.join(
+      Global.Path.bin,
+      "fzf" + (process.platform === "win32" ? ".exe" : ""),
+    )
+
+    const file = Bun.file(filepath)
+    if (!(await file.exists())) {
+      const archMap = { x64: "amd64", arm64: "arm64" } as const
+      const arch = archMap[process.arch as keyof typeof archMap] ?? "amd64"
+
+      const config = PLATFORM[process.platform as keyof typeof PLATFORM]
+      if (!config)
+        throw new UnsupportedPlatformError({ platform: process.platform })
+
+      const version = VERSION
+      const platformName =
+        process.platform === "win32" ? "windows" : process.platform
+      const filename = `fzf-${version}-${platformName}_${arch}.${config.extension}`
+      const url = `https://github.com/junegunn/fzf/releases/download/v${version}/${filename}`
+
+      const response = await fetch(url)
+      if (!response.ok)
+        throw new DownloadFailedError({ url, status: response.status })
+
+      const buffer = await response.arrayBuffer()
+      const archivePath = path.join(Global.Path.bin, filename)
+      await Bun.write(archivePath, buffer)
+      if (config.extension === "tar.gz") {
+        const proc = Bun.spawn(["tar", "-xzf", archivePath, "fzf"], {
+          cwd: Global.Path.bin,
+          stderr: "pipe",
+          stdout: "pipe",
+        })
+        await proc.exited
+        if (proc.exitCode !== 0)
+          throw new ExtractionFailedError({
+            filepath,
+            stderr: await Bun.readableStreamToText(proc.stderr),
+          })
+      }
+      if (config.extension === "zip") {
+        const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])));
+        const entries = await zipFileReader.getEntries();
+        let fzfEntry: any;
+        for (const entry of entries) {
+          if (entry.filename === "fzf.exe") {
+            fzfEntry = entry;
+            break;
+          }
+        }
+
+        if (!fzfEntry) {
+          throw new ExtractionFailedError({
+            filepath: archivePath,
+            stderr: "fzf.exe not found in zip archive",
+          });
+        }
+
+        const fzfBlob = await fzfEntry.getData(new BlobWriter());
+        if (!fzfBlob) {
+          throw new ExtractionFailedError({
+            filepath: archivePath,
+            stderr: "Failed to extract fzf.exe from zip archive",
+          });
+        }
+        await Bun.write(filepath, await fzfBlob.arrayBuffer());
+        await zipFileReader.close();
+      }
+      await fs.unlink(archivePath)
+      if (process.platform !== "win32") await fs.chmod(filepath, 0o755)
+    }
+
+    return {
+      filepath,
+    }
+  })
+
+  export async function filepath() {
+    const { filepath } = await state()
+    return filepath
+  }
+}

packages/opencode/src/file/index.ts

@@ -0,0 +1,123 @@
+import { z } from "zod"
+import { Bus } from "../bus"
+import { $ } from "bun"
+import { createPatch } from "diff"
+import path from "path"
+import * as git from "isomorphic-git"
+import { App } from "../app/app"
+import fs from "fs"
+import { Log } from "../util/log"
+
+export namespace File {
+  const log = Log.create({ service: "file" })
+
+  export const Info = z
+    .object({
+      path: z.string(),
+      added: z.number().int(),
+      removed: z.number().int(),
+      status: z.enum(["added", "deleted", "modified"]),
+    })
+    .openapi({
+      ref: "File",
+    })
+
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Edited: Bus.event(
+      "file.edited",
+      z.object({
+        file: z.string(),
+      }),
+    ),
+  }
+
+  export async function status() {
+    const app = App.info()
+    if (!app.git) return []
+
+    const diffOutput = await $`git diff --numstat HEAD`.cwd(app.path.cwd).quiet().nothrow().text()
+
+    const changedFiles: Info[] = []
+
+    if (diffOutput.trim()) {
+      const lines = diffOutput.trim().split("\n")
+      for (const line of lines) {
+        const [added, removed, filepath] = line.split("\t")
+        changedFiles.push({
+          path: filepath,
+          added: added === "-" ? 0 : parseInt(added, 10),
+          removed: removed === "-" ? 0 : parseInt(removed, 10),
+          status: "modified",
+        })
+      }
+    }
+
+    const untrackedOutput = await $`git ls-files --others --exclude-standard`.cwd(app.path.cwd).quiet().nothrow().text()
+
+    if (untrackedOutput.trim()) {
+      const untrackedFiles = untrackedOutput.trim().split("\n")
+      for (const filepath of untrackedFiles) {
+        try {
+          const content = await Bun.file(path.join(app.path.root, filepath)).text()
+          const lines = content.split("\n").length
+          changedFiles.push({
+            path: filepath,
+            added: lines,
+            removed: 0,
+            status: "added",
+          })
+        } catch {
+          continue
+        }
+      }
+    }
+
+    // Get deleted files
+    const deletedOutput = await $`git diff --name-only --diff-filter=D HEAD`.cwd(app.path.cwd).quiet().nothrow().text()
+
+    if (deletedOutput.trim()) {
+      const deletedFiles = deletedOutput.trim().split("\n")
+      for (const filepath of deletedFiles) {
+        changedFiles.push({
+          path: filepath,
+          added: 0,
+          removed: 0, // Could get original line count but would require another git command
+          status: "deleted",
+        })
+      }
+    }
+
+    return changedFiles.map((x) => ({
+      ...x,
+      path: path.relative(app.path.cwd, path.join(app.path.root, x.path)),
+    }))
+  }
+
+  export async function read(file: string) {
+    using _ = log.time("read", { file })
+    const app = App.info()
+    const full = path.join(app.path.cwd, file)
+    const content = await Bun.file(full)
+      .text()
+      .catch(() => "")
+      .then((x) => x.trim())
+    if (app.git) {
+      const rel = path.relative(app.path.root, full)
+      const diff = await git.status({
+        fs,
+        dir: app.path.root,
+        filepath: rel,
+      })
+      if (diff !== "unmodified") {
+        const original = await $`git show HEAD:${rel}`.cwd(app.path.root).quiet().nothrow().text()
+        const patch = createPatch(file, original, content, "old", "new", {
+          context: Infinity,
+        })
+        return { type: "patch", content: patch }
+      }
+    }
+    return { type: "raw", content }
+  }
+}

packages/opencode/src/file/ripgrep.ts

@@ -0,0 +1,353 @@
+// Ripgrep utility functions
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import { z } from "zod"
+import { NamedError } from "../util/error"
+import { lazy } from "../util/lazy"
+import { $ } from "bun"
+import { Fzf } from "./fzf"
+import { ZipReader, BlobReader, BlobWriter } from "@zip.js/zip.js"
+
+export namespace Ripgrep {
+  const Stats = z.object({
+    elapsed: z.object({
+      secs: z.number(),
+      nanos: z.number(),
+      human: z.string(),
+    }),
+    searches: z.number(),
+    searches_with_match: z.number(),
+    bytes_searched: z.number(),
+    bytes_printed: z.number(),
+    matched_lines: z.number(),
+    matches: z.number(),
+  })
+
+  const Begin = z.object({
+    type: z.literal("begin"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+    }),
+  })
+
+  export const Match = z.object({
+    type: z.literal("match"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+      lines: z.object({
+        text: z.string(),
+      }),
+      line_number: z.number(),
+      absolute_offset: z.number(),
+      submatches: z.array(
+        z.object({
+          match: z.object({
+            text: z.string(),
+          }),
+          start: z.number(),
+          end: z.number(),
+        }),
+      ),
+    }),
+  })
+
+  const End = z.object({
+    type: z.literal("end"),
+    data: z.object({
+      path: z.object({
+        text: z.string(),
+      }),
+      binary_offset: z.number().nullable(),
+      stats: Stats,
+    }),
+  })
+
+  const Summary = z.object({
+    type: z.literal("summary"),
+    data: z.object({
+      elapsed_total: z.object({
+        human: z.string(),
+        nanos: z.number(),
+        secs: z.number(),
+      }),
+      stats: Stats,
+    }),
+  })
+
+  const Result = z.union([Begin, Match, End, Summary])
+
+  export type Result = z.infer<typeof Result>
+  export type Match = z.infer<typeof Match>
+  export type Begin = z.infer<typeof Begin>
+  export type End = z.infer<typeof End>
+  export type Summary = z.infer<typeof Summary>
+  const PLATFORM = {
+    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+    "arm64-linux": {
+      platform: "aarch64-unknown-linux-gnu",
+      extension: "tar.gz",
+    },
+    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
+  } as const
+
+  export const ExtractionFailedError = NamedError.create(
+    "RipgrepExtractionFailedError",
+    z.object({
+      filepath: z.string(),
+      stderr: z.string(),
+    }),
+  )
+
+  export const UnsupportedPlatformError = NamedError.create(
+    "RipgrepUnsupportedPlatformError",
+    z.object({
+      platform: z.string(),
+    }),
+  )
+
+  export const DownloadFailedError = NamedError.create(
+    "RipgrepDownloadFailedError",
+    z.object({
+      url: z.string(),
+      status: z.number(),
+    }),
+  )
+
+  const state = lazy(async () => {
+    let filepath = Bun.which("rg")
+    if (filepath) return { filepath }
+    filepath = path.join(Global.Path.bin, "rg" + (process.platform === "win32" ? ".exe" : ""))
+
+    const file = Bun.file(filepath)
+    if (!(await file.exists())) {
+      const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
+      const config = PLATFORM[platformKey]
+      if (!config) throw new UnsupportedPlatformError({ platform: platformKey })
+
+      const version = "14.1.1"
+      const filename = `ripgrep-${version}-${config.platform}.${config.extension}`
+      const url = `https://github.com/BurntSushi/ripgrep/releases/download/${version}/${filename}`
+
+      const response = await fetch(url)
+      if (!response.ok) throw new DownloadFailedError({ url, status: response.status })
+
+      const buffer = await response.arrayBuffer()
+      const archivePath = path.join(Global.Path.bin, filename)
+      await Bun.write(archivePath, buffer)
+      if (config.extension === "tar.gz") {
+        const args = ["tar", "-xzf", archivePath, "--strip-components=1"]
+
+        if (platformKey.endsWith("-darwin")) args.push("--include=*/rg")
+        if (platformKey.endsWith("-linux")) args.push("--wildcards", "*/rg")
+
+        const proc = Bun.spawn(args, {
+          cwd: Global.Path.bin,
+          stderr: "pipe",
+          stdout: "pipe",
+        })
+        await proc.exited
+        if (proc.exitCode !== 0)
+          throw new ExtractionFailedError({
+            filepath,
+            stderr: await Bun.readableStreamToText(proc.stderr),
+          })
+      }
+      if (config.extension === "zip") {
+        if (config.extension === "zip") {
+          const zipFileReader = new ZipReader(new BlobReader(new Blob([await Bun.file(archivePath).arrayBuffer()])))
+          const entries = await zipFileReader.getEntries()
+          let rgEntry: any
+          for (const entry of entries) {
+            if (entry.filename.endsWith("rg.exe")) {
+              rgEntry = entry
+              break
+            }
+          }
+
+          if (!rgEntry) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "rg.exe not found in zip archive",
+            })
+          }
+
+          const rgBlob = await rgEntry.getData(new BlobWriter())
+          if (!rgBlob) {
+            throw new ExtractionFailedError({
+              filepath: archivePath,
+              stderr: "Failed to extract rg.exe from zip archive",
+            })
+          }
+          await Bun.write(filepath, await rgBlob.arrayBuffer())
+          await zipFileReader.close()
+        }
+      }
+      await fs.unlink(archivePath)
+      if (!platformKey.endsWith("-win32")) await fs.chmod(filepath, 0o755)
+    }
+
+    return {
+      filepath,
+    }
+  })
+
+  export async function filepath() {
+    const { filepath } = await state()
+    return filepath
+  }
+
+  export async function files(input: { cwd: string; query?: string; glob?: string[]; limit?: number }) {
+    const commands = [`${$.escape(await filepath())} --files --follow --hidden --glob='!.git/*'`]
+
+    if (input.glob) {
+      for (const g of input.glob) {
+        commands[0] += ` --glob='${g}'`
+      }
+    }
+
+    if (input.query) commands.push(`${await Fzf.filepath()} --filter=${input.query}`)
+    if (input.limit) commands.push(`head -n ${input.limit}`)
+    const joined = commands.join(" | ")
+    const result = await $`${{ raw: joined }}`.cwd(input.cwd).nothrow().text()
+    return result.split("\n").filter(Boolean)
+  }
+
+  export async function tree(input: { cwd: string; limit?: number }) {
+    const files = await Ripgrep.files({ cwd: input.cwd })
+    interface Node {
+      path: string[]
+      children: Node[]
+    }
+
+    function getPath(node: Node, parts: string[], create: boolean) {
+      if (parts.length === 0) return node
+      let current = node
+      for (const part of parts) {
+        let existing = current.children.find((x) => x.path.at(-1) === part)
+        if (!existing) {
+          if (!create) return
+          existing = {
+            path: current.path.concat(part),
+            children: [],
+          }
+          current.children.push(existing)
+        }
+        current = existing
+      }
+      return current
+    }
+
+    const root: Node = {
+      path: [],
+      children: [],
+    }
+    for (const file of files) {
+      if (file.includes(".opencode")) continue
+      const parts = file.split(path.sep)
+      getPath(root, parts, true)
+    }
+
+    function sort(node: Node) {
+      node.children.sort((a, b) => {
+        if (!a.children.length && b.children.length) return 1
+        if (!b.children.length && a.children.length) return -1
+        return a.path.at(-1)!.localeCompare(b.path.at(-1)!)
+      })
+      for (const child of node.children) {
+        sort(child)
+      }
+    }
+    sort(root)
+
+    let current = [root]
+    const result: Node = {
+      path: [],
+      children: [],
+    }
+
+    let processed = 0
+    const limit = input.limit ?? 50
+    while (current.length > 0) {
+      const next = []
+      for (const node of current) {
+        if (node.children.length) next.push(...node.children)
+      }
+      const max = Math.max(...current.map((x) => x.children.length))
+      for (let i = 0; i < max && processed < limit; i++) {
+        for (const node of current) {
+          const child = node.children[i]
+          if (!child) continue
+          getPath(result, child.path, true)
+          processed++
+          if (processed >= limit) break
+        }
+      }
+      if (processed >= limit) {
+        for (const node of [...current, ...next]) {
+          const compare = getPath(result, node.path, false)
+          if (!compare) continue
+          if (compare?.children.length !== node.children.length) {
+            const diff = node.children.length - compare.children.length
+            compare.children.push({
+              path: compare.path.concat(`[${diff} truncated]`),
+              children: [],
+            })
+          }
+        }
+        break
+      }
+      current = next
+    }
+
+    const lines: string[] = []
+
+    function render(node: Node, depth: number) {
+      const indent = "\t".repeat(depth)
+      lines.push(indent + node.path.at(-1) + (node.children.length ? "/" : ""))
+      for (const child of node.children) {
+        render(child, depth + 1)
+      }
+    }
+    result.children.map((x) => render(x, 0))
+
+    return lines.join("\n")
+  }
+
+  export async function search(input: { cwd: string; pattern: string; glob?: string[]; limit?: number }) {
+    const args = [`${await filepath()}`, "--json", "--hidden", "--glob='!.git/*'"]
+
+    if (input.glob) {
+      for (const g of input.glob) {
+        args.push(`--glob=${g}`)
+      }
+    }
+
+    if (input.limit) {
+      args.push(`--max-count=${input.limit}`)
+    }
+
+    args.push(input.pattern)
+
+    const command = args.join(" ")
+    const result = await $`${{ raw: command }}`.cwd(input.cwd).quiet().nothrow()
+    if (result.exitCode !== 0) {
+      return []
+    }
+
+    const lines = result.text().trim().split("\n").filter(Boolean)
+    // Parse JSON lines from ripgrep output
+
+    return lines
+      .map((line) => JSON.parse(line))
+      .map((parsed) => Result.parse(parsed))
+      .filter((r) => r.type === "match")
+      .map((r) => r.data)
+  }
+}

packages/opencode/src/file/time.ts

@@ -0,0 +1,38 @@
+import { App } from "../app/app"
+import { Log } from "../util/log"
+
+export namespace FileTime {
+  const log = Log.create({ service: "file.time" })
+  export const state = App.state("tool.filetimes", () => {
+    const read: {
+      [sessionID: string]: {
+        [path: string]: Date | undefined
+      }
+    } = {}
+    return {
+      read,
+    }
+  })
+
+  export function read(sessionID: string, file: string) {
+    log.info("read", { sessionID, file })
+    const { read } = state()
+    read[sessionID] = read[sessionID] || {}
+    read[sessionID][file] = new Date()
+  }
+
+  export function get(sessionID: string, file: string) {
+    return state().read[sessionID]?.[file]
+  }
+
+  export async function assert(sessionID: string, filepath: string) {
+    const time = get(sessionID, filepath)
+    if (!time) throw new Error(`You must read the file ${filepath} before overwriting it. Use the Read tool first`)
+    const stats = await Bun.file(filepath).stat()
+    if (stats.mtime.getTime() > time.getTime()) {
+      throw new Error(
+        `File ${filepath} has been modified since it was last read.\nLast modification: ${stats.mtime.toISOString()}\nLast read: ${time.toISOString()}\n\nPlease read the file again before modifying it.`,
+      )
+    }
+  }
+}

packages/opencode/src/file/watch.ts

@@ -0,0 +1,52 @@
+import { z } from "zod"
+import { Bus } from "../bus"
+import fs from "fs"
+import { App } from "../app/app"
+import { Log } from "../util/log"
+import { Flag } from "../flag/flag"
+
+export namespace FileWatcher {
+  const log = Log.create({ service: "file.watcher" })
+
+  export const Event = {
+    Updated: Bus.event(
+      "file.watcher.updated",
+      z.object({
+        file: z.string(),
+        event: z.union([z.literal("rename"), z.literal("change")]),
+      }),
+    ),
+  }
+  const state = App.state(
+    "file.watcher",
+    () => {
+      const app = App.use()
+      if (!app.info.git) return {}
+      try {
+        const watcher = fs.watch(app.info.path.cwd, { recursive: true }, (event, file) => {
+          log.info("change", { file, event })
+          if (!file) return
+          // for some reason async local storage is lost here
+          // https://github.com/oven-sh/bun/issues/20754
+          App.provideExisting(app, async () => {
+            Bus.publish(Event.Updated, {
+              file,
+              event,
+            })
+          })
+        })
+        return { watcher }
+      } catch {
+        return {}
+      }
+    },
+    async (state) => {
+      state.watcher?.close()
+    },
+  )
+
+  export function init() {
+    if (Flag.OPENCODE_DISABLE_WATCHER || true) return
+    state()
+  }
+}

packages/opencode/src/flag/flag.ts

@@ -0,0 +1,9 @@
+export namespace Flag {
+  export const OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE")
+  export const OPENCODE_DISABLE_WATCHER = truthy("OPENCODE_DISABLE_WATCHER")
+
+  function truthy(key: string) {
+    const value = process.env[key]?.toLowerCase()
+    return value === "true" || value === "1"
+  }
+}

packages/opencode/src/format/formatter.ts

@@ -0,0 +1,159 @@
+import { App } from "../app/app"
+import { BunProc } from "../bun"
+import { Filesystem } from "../util/filesystem"
+import path from "path"
+
+export interface Info {
+  name: string
+  command: string[]
+  environment?: Record<string, string>
+  extensions: string[]
+  enabled(): Promise<boolean>
+}
+
+export const gofmt: Info = {
+  name: "gofmt",
+  command: ["gofmt", "-w", "$FILE"],
+  extensions: [".go"],
+  async enabled() {
+    return Bun.which("gofmt") !== null
+  },
+}
+
+export const mix: Info = {
+  name: "mix",
+  command: ["mix", "format", "$FILE"],
+  extensions: [".ex", ".exs", ".eex", ".heex", ".leex", ".neex", ".sface"],
+  async enabled() {
+    return Bun.which("mix") !== null
+  },
+}
+
+export const prettier: Info = {
+  name: "prettier",
+  command: [BunProc.which(), "x", "prettier", "--write", "$FILE"],
+  environment: {
+    BUN_BE_BUN: "1",
+  },
+  extensions: [
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".html",
+    ".htm",
+    ".css",
+    ".scss",
+    ".sass",
+    ".less",
+    ".vue",
+    ".svelte",
+    ".json",
+    ".jsonc",
+    ".yaml",
+    ".yml",
+    ".toml",
+    ".xml",
+    ".md",
+    ".mdx",
+    ".graphql",
+    ".gql",
+  ],
+  async enabled() {
+    const app = App.info()
+    const nms = await Filesystem.findUp("node_modules", app.path.cwd, app.path.root)
+    for (const item of nms) {
+      if (await Bun.file(path.join(item, ".bin", "prettier")).exists()) return true
+    }
+    return false
+  },
+}
+
+export const zig: Info = {
+  name: "zig",
+  command: ["zig", "fmt", "$FILE"],
+  extensions: [".zig", ".zon"],
+  async enabled() {
+    return Bun.which("zig") !== null
+  },
+}
+
+export const clang: Info = {
+  name: "clang-format",
+  command: ["clang-format", "-i", "$FILE"],
+  extensions: [".c", ".cc", ".cpp", ".cxx", ".c++", ".h", ".hh", ".hpp", ".hxx", ".h++", ".ino", ".C", ".H"],
+  async enabled() {
+    return Bun.which("clang-format") !== null
+  },
+}
+
+export const ktlint: Info = {
+  name: "ktlint",
+  command: ["ktlint", "-F", "$FILE"],
+  extensions: [".kt", ".kts"],
+  async enabled() {
+    return Bun.which("ktlint") !== null
+  },
+}
+
+export const ruff: Info = {
+  name: "ruff",
+  command: ["ruff", "format", "$FILE"],
+  extensions: [".py", ".pyi"],
+  async enabled() {
+    if (!Bun.which("ruff")) return false
+    const app = App.info()
+    const configs = ["pyproject.toml", "ruff.toml", ".ruff.toml"]
+    for (const config of configs) {
+      const found = await Filesystem.findUp(config, app.path.cwd, app.path.root)
+      if (found.length > 0) {
+        if (config === "pyproject.toml") {
+          const content = await Bun.file(found[0]).text()
+          if (content.includes("[tool.ruff]")) return true
+        } else {
+          return true
+        }
+      }
+    }
+    const deps = ["requirements.txt", "pyproject.toml", "Pipfile"]
+    for (const dep of deps) {
+      const found = await Filesystem.findUp(dep, app.path.cwd, app.path.root)
+      if (found.length > 0) {
+        const content = await Bun.file(found[0]).text()
+        if (content.includes("ruff")) return true
+      }
+    }
+    return false
+  },
+}
+
+export const rubocop: Info = {
+  name: "rubocop",
+  command: ["rubocop", "--autocorrect", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("rubocop") !== null
+  },
+}
+
+export const standardrb: Info = {
+  name: "standardrb",
+  command: ["standardrb", "--fix", "$FILE"],
+  extensions: [".rb", ".rake", ".gemspec", ".ru"],
+  async enabled() {
+    return Bun.which("standardrb") !== null
+  },
+}
+
+export const htmlbeautifier: Info = {
+  name: "htmlbeautifier",
+  command: ["htmlbeautifier", "$FILE"],
+  extensions: [".erb", ".html.erb"],
+  async enabled() {
+    return Bun.which("htmlbeautifier") !== null
+  },
+}

packages/opencode/src/format/index.ts

@@ -0,0 +1,65 @@
+import { App } from "../app/app"
+import { Bus } from "../bus"
+import { File } from "../file"
+import { Log } from "../util/log"
+import path from "path"
+
+import * as Formatter from "./formatter"
+
+export namespace Format {
+  const log = Log.create({ service: "format" })
+
+  const state = App.state("format", () => {
+    const enabled: Record<string, boolean> = {}
+
+    return {
+      enabled,
+    }
+  })
+
+  async function isEnabled(item: Formatter.Info) {
+    const s = state()
+    let status = s.enabled[item.name]
+    if (status === undefined) {
+      status = await item.enabled()
+      s.enabled[item.name] = status
+    }
+    return status
+  }
+
+  async function getFormatter(ext: string) {
+    const result = []
+    for (const item of Object.values(Formatter)) {
+      if (!item.extensions.includes(ext)) continue
+      if (!(await isEnabled(item))) continue
+      result.push(item)
+    }
+    return result
+  }
+
+  export function init() {
+    log.info("init")
+    Bus.subscribe(File.Event.Edited, async (payload) => {
+      const file = payload.properties.file
+      log.info("formatting", { file })
+      const ext = path.extname(file)
+
+      for (const item of await getFormatter(ext)) {
+        log.info("running", { command: item.command })
+        const proc = Bun.spawn({
+          cmd: item.command.map((x) => x.replace("$FILE", file)),
+          cwd: App.info().path.cwd,
+          env: item.environment,
+          stdout: "ignore",
+          stderr: "ignore",
+        })
+        const exit = await proc.exited
+        if (exit !== 0)
+          log.error("failed", {
+            command: item.command,
+            ...item.environment,
+          })
+      }
+    })
+  }
+}

packages/opencode/src/global/index.ts

@@ -0,0 +1,37 @@
+import fs from "fs/promises"
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
+import path from "path"
+
+const app = "opencode"
+
+const data = path.join(xdgData!, app)
+const cache = path.join(xdgCache!, app)
+const config = path.join(xdgConfig!, app)
+const state = path.join(xdgState!, app)
+
+export namespace Global {
+  export const Path = {
+    data,
+    bin: path.join(data, "bin"),
+    cache,
+    config,
+    state,
+  } as const
+}
+
+await Promise.all([
+  fs.mkdir(Global.Path.data, { recursive: true }),
+  fs.mkdir(Global.Path.config, { recursive: true }),
+  fs.mkdir(Global.Path.state, { recursive: true }),
+])
+
+const CACHE_VERSION = "3"
+
+const version = await Bun.file(path.join(Global.Path.cache, "version"))
+  .text()
+  .catch(() => "0")
+
+if (version !== CACHE_VERSION) {
+  await fs.rm(Global.Path.cache, { recursive: true, force: true })
+  await Bun.file(path.join(Global.Path.cache, "version")).write(CACHE_VERSION)
+}

packages/opencode/src/id/id.ts

@@ -0,0 +1,71 @@
+import { z } from "zod"
+import { randomBytes } from "crypto"
+
+export namespace Identifier {
+  const prefixes = {
+    session: "ses",
+    message: "msg",
+    user: "usr",
+    part: "prt",
+  } as const
+
+  export function schema(prefix: keyof typeof prefixes) {
+    return z.string().startsWith(prefixes[prefix])
+  }
+
+  const LENGTH = 26
+
+  // State for monotonic ID generation
+  let lastTimestamp = 0
+  let counter = 0
+
+  export function ascending(prefix: keyof typeof prefixes, given?: string) {
+    return generateID(prefix, false, given)
+  }
+
+  export function descending(prefix: keyof typeof prefixes, given?: string) {
+    return generateID(prefix, true, given)
+  }
+
+  function generateID(prefix: keyof typeof prefixes, descending: boolean, given?: string): string {
+    if (!given) {
+      return generateNewID(prefix, descending)
+    }
+
+    if (!given.startsWith(prefixes[prefix])) {
+      throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
+    }
+    return given
+  }
+
+  function randomBase62(length: number): string {
+    const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    let result = ""
+    const bytes = randomBytes(length)
+    for (let i = 0; i < length; i++) {
+      result += chars[bytes[i] % 62]
+    }
+    return result
+  }
+
+  function generateNewID(prefix: keyof typeof prefixes, descending: boolean): string {
+    const currentTimestamp = Date.now()
+
+    if (currentTimestamp !== lastTimestamp) {
+      lastTimestamp = currentTimestamp
+      counter = 0
+    }
+    counter++
+
+    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
+
+    now = descending ? ~now : now
+
+    const timeBytes = Buffer.alloc(6)
+    for (let i = 0; i < 6; i++) {
+      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
+    }
+
+    return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
+  }
+}

packages/opencode/src/ide/index.ts

@@ -0,0 +1,74 @@
+import { $ } from "bun"
+import { z } from "zod"
+import { NamedError } from "../util/error"
+import { Log } from "../util/log"
+import { Bus } from "../bus"
+
+const SUPPORTED_IDES = ["Windsurf", "Visual Studio Code", "Cursor", "VSCodium"] as const
+
+export namespace Ide {
+  const log = Log.create({ service: "ide" })
+
+  export const Event = {
+    Installed: Bus.event(
+      "ide.installed",
+      z.object({
+        ide: z.string(),
+      }),
+    ),
+  }
+
+  export type Ide = Awaited<ReturnType<typeof ide>>
+
+  export const AlreadyInstalledError = NamedError.create("AlreadyInstalledError", z.object({}))
+
+  export const InstallFailedError = NamedError.create(
+    "InstallFailedError",
+    z.object({
+      stderr: z.string(),
+    }),
+  )
+
+  export async function ide() {
+    if (process.env["TERM_PROGRAM"] === "vscode") {
+      const v = process.env["GIT_ASKPASS"]
+      for (const ide of SUPPORTED_IDES) {
+        if (v?.includes(ide)) return ide
+      }
+    }
+    return "unknown"
+  }
+
+  export function alreadyInstalled() {
+    return process.env["OPENCODE_CALLER"] === "vscode"
+  }
+
+  export async function install(ide: Ide) {
+    const cmd = (() => {
+      switch (ide) {
+        case "Windsurf":
+          return $`windsurf --install-extension sst-dev.opencode`
+        case "Visual Studio Code":
+          return $`code --install-extension sst-dev.opencode`
+        case "Cursor":
+          return $`cursor --install-extension sst-dev.opencode`
+        case "VSCodium":
+          return $`codium --install-extension sst-dev.opencode`
+        default:
+          throw new Error(`Unknown IDE: ${ide}`)
+      }
+    })()
+    // TODO: check OPENCODE_CALLER
+    const result = await cmd.quiet().throws(false)
+    log.info("installed", {
+      ide,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    })
+    if (result.exitCode !== 0)
+      throw new InstallFailedError({
+        stderr: result.stderr.toString("utf8"),
+      })
+    if (result.stdout.toString().includes("already installed")) throw new AlreadyInstalledError({})
+  }
+}

packages/opencode/src/index.ts

@@ -0,0 +1,126 @@
+import "zod-openapi/extend"
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import { RunCommand } from "./cli/cmd/run"
+import { GenerateCommand } from "./cli/cmd/generate"
+import { Log } from "./util/log"
+import { AuthCommand } from "./cli/cmd/auth"
+import { AgentCommand } from "./cli/cmd/agent"
+import { UpgradeCommand } from "./cli/cmd/upgrade"
+import { ModelsCommand } from "./cli/cmd/models"
+import { UI } from "./cli/ui"
+import { Installation } from "./installation"
+import { NamedError } from "./util/error"
+import { FormatError } from "./cli/error"
+import { ServeCommand } from "./cli/cmd/serve"
+import { TuiCommand } from "./cli/cmd/tui"
+import { DebugCommand } from "./cli/cmd/debug"
+import { StatsCommand } from "./cli/cmd/stats"
+import { McpCommand } from "./cli/cmd/mcp"
+import { InstallGithubCommand } from "./cli/cmd/install-github"
+import { Trace } from "./trace"
+
+Trace.init()
+
+const cancel = new AbortController()
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+const cli = yargs(hideBin(process.argv))
+  .scriptName("opencode")
+  .help("help", "show help")
+  .version("version", "show version number", Installation.VERSION)
+  .alias("version", "v")
+  .option("print-logs", {
+    describe: "print logs to stderr",
+    type: "boolean",
+  })
+  .option("log-level", {
+    describe: "log level",
+    type: "string",
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
+  })
+  .middleware(async (opts) => {
+    await Log.init({
+      print: process.argv.includes("--print-logs"),
+      dev: Installation.isDev(),
+      level: (() => {
+        if (opts.logLevel) return opts.logLevel as Log.Level
+        if (Installation.isDev()) return "DEBUG"
+        return "INFO"
+      })(),
+    })
+
+    Log.Default.info("opencode", {
+      version: Installation.VERSION,
+      args: process.argv.slice(2),
+    })
+  })
+  .usage("\n" + UI.logo())
+  .command(McpCommand)
+  .command(TuiCommand)
+  .command(RunCommand)
+  .command(GenerateCommand)
+  .command(DebugCommand)
+  .command(AuthCommand)
+  .command(AgentCommand)
+  .command(UpgradeCommand)
+  .command(ServeCommand)
+  .command(ModelsCommand)
+  .command(StatsCommand)
+  .command(InstallGithubCommand)
+  .fail((msg) => {
+    if (msg.startsWith("Unknown argument") || msg.startsWith("Not enough non-option arguments")) {
+      cli.showHelp("log")
+    }
+  })
+  .strict()
+
+try {
+  await cli.parse()
+} catch (e) {
+  let data: Record<string, any> = {}
+  if (e instanceof NamedError) {
+    const obj = e.toObject()
+    Object.assign(data, {
+      ...obj.data,
+    })
+  }
+
+  if (e instanceof Error) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      cause: e.cause?.toString(),
+    })
+  }
+
+  if (e instanceof ResolveMessage) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      code: e.code,
+      specifier: e.specifier,
+      referrer: e.referrer,
+      position: e.position,
+      importKind: e.importKind,
+    })
+  }
+  Log.Default.error("fatal", data)
+  const formatted = FormatError(e)
+  if (formatted) UI.error(formatted)
+  if (formatted === undefined) UI.error("Unexpected error, check log file at " + Log.file() + " for more details")
+  process.exitCode = 1
+}
+
+cancel.abort()

packages/opencode/src/installation/index.ts

@@ -0,0 +1,151 @@
+import path from "path"
+import { $ } from "bun"
+import { z } from "zod"
+import { NamedError } from "../util/error"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+
+declare global {
+  const OPENCODE_VERSION: string
+}
+
+export namespace Installation {
+  const log = Log.create({ service: "installation" })
+
+  export type Method = Awaited<ReturnType<typeof method>>
+
+  export const Event = {
+    Updated: Bus.event(
+      "installation.updated",
+      z.object({
+        version: z.string(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      version: z.string(),
+      latest: z.string(),
+    })
+    .openapi({
+      ref: "InstallationInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export async function info() {
+    return {
+      version: VERSION,
+      latest: await latest(),
+    }
+  }
+
+  export function isSnapshot() {
+    return VERSION.startsWith("0.0.0")
+  }
+
+  export function isDev() {
+    return VERSION === "dev"
+  }
+
+  export async function method() {
+    if (process.execPath.includes(path.join(".opencode", "bin"))) return "curl"
+    const exec = process.execPath.toLowerCase()
+
+    const checks = [
+      {
+        name: "npm" as const,
+        command: () => $`npm list -g --depth=0`.throws(false).text(),
+      },
+      {
+        name: "yarn" as const,
+        command: () => $`yarn global list`.throws(false).text(),
+      },
+      {
+        name: "pnpm" as const,
+        command: () => $`pnpm list -g --depth=0`.throws(false).text(),
+      },
+      {
+        name: "bun" as const,
+        command: () => $`bun pm ls -g`.throws(false).text(),
+      },
+      {
+        name: "brew" as const,
+        command: () => $`brew list --formula opencode-ai`.throws(false).text(),
+      },
+    ]
+
+    checks.sort((a, b) => {
+      const aMatches = exec.includes(a.name)
+      const bMatches = exec.includes(b.name)
+      if (aMatches && !bMatches) return -1
+      if (!aMatches && bMatches) return 1
+      return 0
+    })
+
+    for (const check of checks) {
+      const output = await check.command()
+      if (output.includes("opencode-ai")) {
+        return check.name
+      }
+    }
+
+    return "unknown"
+  }
+
+  export const UpgradeFailedError = NamedError.create(
+    "UpgradeFailedError",
+    z.object({
+      stderr: z.string(),
+    }),
+  )
+
+  export async function upgrade(method: Method, target: string) {
+    const cmd = (() => {
+      switch (method) {
+        case "curl":
+          return $`curl -fsSL https://opencode.ai/install | bash`.env({
+            ...process.env,
+            VERSION: target,
+          })
+        case "npm":
+          return $`npm install -g opencode-ai@${target}`
+        case "pnpm":
+          return $`pnpm install -g opencode-ai@${target}`
+        case "bun":
+          return $`bun install -g opencode-ai@${target}`
+        case "brew":
+          return $`brew install sst/tap/opencode`.env({
+            HOMEBREW_NO_AUTO_UPDATE: "1",
+          })
+        default:
+          throw new Error(`Unknown method: ${method}`)
+      }
+    })()
+    const result = await cmd.quiet().throws(false)
+    log.info("upgraded", {
+      method,
+      target,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    })
+    if (result.exitCode !== 0)
+      throw new UpgradeFailedError({
+        stderr: result.stderr.toString("utf8"),
+      })
+  }
+
+  export const VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "dev"
+
+  export async function latest() {
+    return fetch("https://api.github.com/repos/sst/opencode/releases/latest")
+      .then((res) => res.json())
+      .then((data) => {
+        if (typeof data.tag_name !== "string") {
+          log.error("GitHub API error", data)
+          throw new Error("failed to fetch latest version")
+        }
+        return data.tag_name.slice(1) as string
+      })
+  }
+}

packages/opencode/src/lsp/client.ts

@@ -0,0 +1,191 @@
+import path from "path"
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node"
+import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types"
+import { App } from "../app/app"
+import { Log } from "../util/log"
+import { LANGUAGE_EXTENSIONS } from "./language"
+import { Bus } from "../bus"
+import z from "zod"
+import type { LSPServer } from "./server"
+import { NamedError } from "../util/error"
+import { withTimeout } from "../util/timeout"
+
+export namespace LSPClient {
+  const log = Log.create({ service: "lsp.client" })
+
+  export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+
+  export type Diagnostic = VSCodeDiagnostic
+
+  export const InitializeError = NamedError.create(
+    "LSPInitializeError",
+    z.object({
+      serverID: z.string(),
+    }),
+  )
+
+  export const Event = {
+    Diagnostics: Bus.event(
+      "lsp.client.diagnostics",
+      z.object({
+        serverID: z.string(),
+        path: z.string(),
+      }),
+    ),
+  }
+
+  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+    const app = App.info()
+    const l = log.clone().tag("serverID", input.serverID)
+    l.info("starting client")
+
+    const connection = createMessageConnection(
+      new StreamMessageReader(input.server.process.stdout),
+      new StreamMessageWriter(input.server.process.stdin),
+    )
+
+    const diagnostics = new Map<string, Diagnostic[]>()
+    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      const path = new URL(params.uri).pathname
+      l.info("textDocument/publishDiagnostics", {
+        path,
+      })
+      const exists = diagnostics.has(path)
+      diagnostics.set(path, params.diagnostics)
+      if (!exists && input.serverID === "typescript") return
+      Bus.publish(Event.Diagnostics, { path, serverID: input.serverID })
+    })
+    connection.onRequest("window/workDoneProgress/create", (params) => {
+      l.info("window/workDoneProgress/create", params)
+      return null
+    })
+    connection.onRequest("workspace/configuration", async () => {
+      return [{}]
+    })
+    connection.listen()
+
+    l.info("sending initialize")
+    await withTimeout(
+      connection.sendRequest("initialize", {
+        rootUri: "file://" + input.root,
+        processId: input.server.process.pid,
+        workspaceFolders: [
+          {
+            name: "workspace",
+            uri: "file://" + input.root,
+          },
+        ],
+        initializationOptions: {
+          ...input.server.initialization,
+        },
+        capabilities: {
+          window: {
+            workDoneProgress: true,
+          },
+          workspace: {
+            configuration: true,
+          },
+          textDocument: {
+            synchronization: {
+              didOpen: true,
+              didChange: true,
+            },
+            publishDiagnostics: {
+              versionSupport: true,
+            },
+          },
+        },
+      }),
+      5_000,
+    ).catch((err) => {
+      l.error("initialize error", { error: err })
+      throw new InitializeError(
+        { serverID: input.serverID },
+        {
+          cause: err,
+        },
+      )
+    })
+
+    await connection.sendNotification("initialized", {})
+
+    const files: {
+      [path: string]: number
+    } = {}
+
+    const result = {
+      root: input.root,
+      get serverID() {
+        return input.serverID
+      },
+      get connection() {
+        return connection
+      },
+      notify: {
+        async open(input: { path: string }) {
+          input.path = path.isAbsolute(input.path) ? input.path : path.resolve(app.path.cwd, input.path)
+          const file = Bun.file(input.path)
+          const text = await file.text()
+          const version = files[input.path]
+          if (version !== undefined) {
+            diagnostics.delete(input.path)
+            await connection.sendNotification("textDocument/didClose", {
+              textDocument: {
+                uri: `file://` + input.path,
+              },
+            })
+          }
+          log.info("textDocument/didOpen", input)
+          diagnostics.delete(input.path)
+          const extension = path.extname(input.path)
+          const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
+          await connection.sendNotification("textDocument/didOpen", {
+            textDocument: {
+              uri: `file://` + input.path,
+              languageId,
+              version: 0,
+              text,
+            },
+          })
+          files[input.path] = 0
+          return
+        },
+      },
+      get diagnostics() {
+        return diagnostics
+      },
+      async waitForDiagnostics(input: { path: string }) {
+        input.path = path.isAbsolute(input.path) ? input.path : path.resolve(app.path.cwd, input.path)
+        log.info("waiting for diagnostics", input)
+        let unsub: () => void
+        return await withTimeout(
+          new Promise<void>((resolve) => {
+            unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+              if (event.properties.path === input.path && event.properties.serverID === result.serverID) {
+                log.info("got diagnostics", input)
+                unsub?.()
+                resolve()
+              }
+            })
+          }),
+          3000,
+        )
+          .catch(() => {})
+          .finally(() => {
+            unsub?.()
+          })
+      },
+      async shutdown() {
+        l.info("shutting down")
+        connection.end()
+        connection.dispose()
+        input.server.process.kill()
+        l.info("shutdown")
+      },
+    }
+
+    l.info("initialized")
+
+    return result
+  }
+}

packages/opencode/src/lsp/index.ts

@@ -0,0 +1,231 @@
+import { App } from "../app/app"
+import { Log } from "../util/log"
+import { LSPClient } from "./client"
+import path from "path"
+import { LSPServer } from "./server"
+import { z } from "zod"
+
+export namespace LSP {
+  const log = Log.create({ service: "lsp" })
+
+  export const Range = z
+    .object({
+      start: z.object({
+        line: z.number(),
+        character: z.number(),
+      }),
+      end: z.object({
+        line: z.number(),
+        character: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "Range",
+    })
+  export type Range = z.infer<typeof Range>
+
+  export const Symbol = z
+    .object({
+      name: z.string(),
+      kind: z.number(),
+      location: z.object({
+        uri: z.string(),
+        range: Range,
+      }),
+    })
+    .openapi({
+      ref: "Symbol",
+    })
+  export type Symbol = z.infer<typeof Symbol>
+
+  export const DocumentSymbol = z
+    .object({
+      name: z.string(),
+      detail: z.string().optional(),
+      kind: z.number(),
+      range: Range,
+      selectionRange: Range,
+    })
+    .openapi({
+      ref: "DocumentSymbol",
+    })
+  export type DocumentSymbol = z.infer<typeof DocumentSymbol>
+
+  const state = App.state(
+    "lsp",
+    async () => {
+      const clients: LSPClient.Info[] = []
+      return {
+        broken: new Set<string>(),
+        clients,
+      }
+    },
+    async (state) => {
+      for (const client of state.clients) {
+        await client.shutdown()
+      }
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  async function getClients(file: string) {
+    const s = await state()
+    const extension = path.parse(file).ext
+    const result: LSPClient.Info[] = []
+    for (const server of Object.values(LSPServer)) {
+      if (!server.extensions.includes(extension)) continue
+      const root = await server.root(file, App.info())
+      if (!root) continue
+      if (s.broken.has(root + server.id)) continue
+
+      const match = s.clients.find((x) => x.root === root && x.serverID === server.id)
+      if (match) {
+        result.push(match)
+        continue
+      }
+      const handle = await server.spawn(App.info(), root)
+      if (!handle) continue
+      const client = await LSPClient.create({
+        serverID: server.id,
+        server: handle,
+        root,
+      }).catch((err) => {
+        s.broken.add(root + server.id)
+        handle.process.kill()
+        log.error("", { error: err })
+      })
+      if (!client) continue
+      s.clients.push(client)
+      result.push(client)
+    }
+    return result
+  }
+
+  export async function touchFile(input: string, waitForDiagnostics?: boolean) {
+    const clients = await getClients(input)
+    await run(async (client) => {
+      if (!clients.includes(client)) return
+      const wait = waitForDiagnostics ? client.waitForDiagnostics({ path: input }) : Promise.resolve()
+      await client.notify.open({ path: input })
+      return wait
+    })
+  }
+
+  export async function diagnostics() {
+    const results: Record<string, LSPClient.Diagnostic[]> = {}
+    for (const result of await run(async (client) => client.diagnostics)) {
+      for (const [path, diagnostics] of result.entries()) {
+        const arr = results[path] || []
+        arr.push(...diagnostics)
+        results[path] = arr
+      }
+    }
+    return results
+  }
+
+  export async function hover(input: { file: string; line: number; character: number }) {
+    return run((client) => {
+      return client.connection.sendRequest("textDocument/hover", {
+        textDocument: {
+          uri: `file://${input.file}`,
+        },
+        position: {
+          line: input.line,
+          character: input.character,
+        },
+      })
+    })
+  }
+
+  enum SymbolKind {
+    File = 1,
+    Module = 2,
+    Namespace = 3,
+    Package = 4,
+    Class = 5,
+    Method = 6,
+    Property = 7,
+    Field = 8,
+    Constructor = 9,
+    Enum = 10,
+    Interface = 11,
+    Function = 12,
+    Variable = 13,
+    Constant = 14,
+    String = 15,
+    Number = 16,
+    Boolean = 17,
+    Array = 18,
+    Object = 19,
+    Key = 20,
+    Null = 21,
+    EnumMember = 22,
+    Struct = 23,
+    Event = 24,
+    Operator = 25,
+    TypeParameter = 26,
+  }
+
+  const kinds = [
+    SymbolKind.Class,
+    SymbolKind.Function,
+    SymbolKind.Method,
+    SymbolKind.Interface,
+    SymbolKind.Variable,
+    SymbolKind.Constant,
+    SymbolKind.Struct,
+    SymbolKind.Enum,
+  ]
+
+  export async function workspaceSymbol(query: string) {
+    return run((client) =>
+      client.connection
+        .sendRequest("workspace/symbol", {
+          query,
+        })
+        .then((result: any) => result.filter((x: LSP.Symbol) => kinds.includes(x.kind)))
+        .then((result: any) => result.slice(0, 10))
+        .catch(() => []),
+    ).then((result) => result.flat() as LSP.Symbol[])
+  }
+
+  export async function documentSymbol(uri: string) {
+    return run((client) =>
+      client.connection
+        .sendRequest("textDocument/documentSymbol", {
+          textDocument: {
+            uri,
+          },
+        })
+        .catch(() => []),
+    )
+      .then((result) => result.flat() as (LSP.DocumentSymbol | LSP.Symbol)[])
+      .then((result) => result.filter(Boolean))
+  }
+
+  async function run<T>(input: (client: LSPClient.Info) => Promise<T>): Promise<T[]> {
+    const clients = await state().then((x) => x.clients)
+    const tasks = clients.map((x) => input(x))
+    return Promise.all(tasks)
+  }
+
+  export namespace Diagnostic {
+    export function pretty(diagnostic: LSPClient.Diagnostic) {
+      const severityMap = {
+        1: "ERROR",
+        2: "WARN",
+        3: "INFO",
+        4: "HINT",
+      }
+
+      const severity = severityMap[diagnostic.severity || 1]
+      const line = diagnostic.range.start.line + 1
+      const col = diagnostic.range.start.character + 1
+
+      return `${severity} [${line}:${col}] ${diagnostic.message}`
+    }
+  }
+}

packages/opencode/src/lsp/language.ts

@@ -0,0 +1,99 @@
+export const LANGUAGE_EXTENSIONS: Record<string, string> = {
+  ".abap": "abap",
+  ".bat": "bat",
+  ".bib": "bibtex",
+  ".bibtex": "bibtex",
+  ".clj": "clojure",
+  ".coffee": "coffeescript",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".cc": "cpp",
+  ".c++": "cpp",
+  ".cs": "csharp",
+  ".css": "css",
+  ".d": "d",
+  ".pas": "pascal",
+  ".pascal": "pascal",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".dart": "dart",
+  ".dockerfile": "dockerfile",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  ".fsscript": "fsharp",
+  ".gitcommit": "git-commit",
+  ".gitrebase": "git-rebase",
+  ".go": "go",
+  ".groovy": "groovy",
+  ".hbs": "handlebars",
+  ".handlebars": "handlebars",
+  ".hs": "haskell",
+  ".html": "html",
+  ".htm": "html",
+  ".ini": "ini",
+  ".java": "java",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".json": "json",
+  ".tex": "latex",
+  ".latex": "latex",
+  ".less": "less",
+  ".lua": "lua",
+  ".makefile": "makefile",
+  makefile: "makefile",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".m": "objective-c",
+  ".mm": "objective-cpp",
+  ".pl": "perl",
+  ".pm": "perl6",
+  ".php": "php",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".pug": "jade",
+  ".jade": "jade",
+  ".py": "python",
+  ".r": "r",
+  ".cshtml": "razor",
+  ".razor": "razor",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  ".erb": "erb",
+  ".html.erb": "erb",
+  ".js.erb": "erb",
+  ".css.erb": "erb",
+  ".json.erb": "erb",
+  ".rs": "rust",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".scala": "scala",
+  ".shader": "shaderlab",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".ksh": "shellscript",
+  ".sql": "sql",
+  ".swift": "swift",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".mtsx": "typescriptreact",
+  ".ctsx": "typescriptreact",
+  ".xml": "xml",
+  ".xsl": "xsl",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".zig": "zig",
+  ".zon": "zig",
+} as const

packages/opencode/src/lsp/server.ts

@@ -0,0 +1,364 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "child_process"
+import type { App } from "../app/app"
+import path from "path"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import { BunProc } from "../bun"
+import { $ } from "bun"
+import fs from "fs/promises"
+import { Filesystem } from "../util/filesystem"
+
+export namespace LSPServer {
+  const log = Log.create({ service: "lsp.server" })
+
+  export interface Handle {
+    process: ChildProcessWithoutNullStreams
+    initialization?: Record<string, any>
+  }
+
+  type RootFunction = (file: string, app: App.Info) => Promise<string | undefined>
+
+  const NearestRoot = (patterns: string[]): RootFunction => {
+    return async (file, app) => {
+      const files = Filesystem.up({
+        targets: patterns,
+        start: path.dirname(file),
+        stop: app.path.root,
+      })
+      const first = await files.next()
+      await files.return()
+      if (!first.value) return app.path.root
+      return path.dirname(first.value)
+    }
+  }
+
+  export interface Info {
+    id: string
+    extensions: string[]
+    global?: boolean
+    root: RootFunction
+    spawn(app: App.Info, root: string): Promise<Handle | undefined>
+  }
+
+  export const Typescript: Info = {
+    id: "typescript",
+    root: NearestRoot(["tsconfig.json", "package.json", "jsconfig.json"]),
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    async spawn(app, root) {
+      const tsserver = await Bun.resolve("typescript/lib/tsserver.js", app.path.cwd).catch(() => {})
+      if (!tsserver) return
+      const proc = spawn(BunProc.which(), ["x", "typescript-language-server", "--stdio"], {
+        cwd: root,
+        env: {
+          ...process.env,
+          BUN_BE_BUN: "1",
+        },
+      })
+      return {
+        process: proc,
+        initialization: {
+          tsserver: {
+            path: tsserver,
+          },
+        },
+      }
+    },
+  }
+
+  export const Gopls: Info = {
+    id: "golang",
+    root: async (file, app) => {
+      const work = await NearestRoot(["go.work"])(file, app)
+      if (work) return work
+      return NearestRoot(["go.mod", "go.sum"])(file, app)
+    },
+    extensions: [".go"],
+    async spawn(_, root) {
+      let bin = Bun.which("gopls", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+      if (!bin) {
+        if (!Bun.which("go")) return
+        log.info("installing gopls")
+        const proc = Bun.spawn({
+          cmd: ["go", "install", "golang.org/x/tools/gopls@latest"],
+          env: { ...process.env, GOBIN: Global.Path.bin },
+          stdout: "pipe",
+          stderr: "pipe",
+          stdin: "pipe",
+        })
+        const exit = await proc.exited
+        if (exit !== 0) {
+          log.error("Failed to install gopls")
+          return
+        }
+        bin = path.join(Global.Path.bin, "gopls" + (process.platform === "win32" ? ".exe" : ""))
+        log.info(`installed gopls`, {
+          bin,
+        })
+      }
+      return {
+        process: spawn(bin!, {
+          cwd: root,
+        }),
+      }
+    },
+  }
+
+  export const RubyLsp: Info = {
+    id: "ruby-lsp",
+    root: NearestRoot(["Gemfile"]),
+    extensions: [".rb", ".rake", ".gemspec", ".ru"],
+    async spawn(_, root) {
+      let bin = Bun.which("ruby-lsp", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+      if (!bin) {
+        const ruby = Bun.which("ruby")
+        const gem = Bun.which("gem")
+        if (!ruby || !gem) {
+          log.info("Ruby not found, please install Ruby first")
+          return
+        }
+        log.info("installing ruby-lsp")
+        const proc = Bun.spawn({
+          cmd: ["gem", "install", "ruby-lsp", "--bindir", Global.Path.bin],
+          stdout: "pipe",
+          stderr: "pipe",
+          stdin: "pipe",
+        })
+        const exit = await proc.exited
+        if (exit !== 0) {
+          log.error("Failed to install ruby-lsp")
+          return
+        }
+        bin = path.join(Global.Path.bin, "ruby-lsp" + (process.platform === "win32" ? ".exe" : ""))
+        log.info(`installed ruby-lsp`, {
+          bin,
+        })
+      }
+      return {
+        process: spawn(bin!, ["--stdio"], {
+          cwd: root,
+        }),
+      }
+    },
+  }
+
+  export const Pyright: Info = {
+    id: "pyright",
+    extensions: [".py", ".pyi"],
+    root: NearestRoot(["pyproject.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"]),
+    async spawn(_, root) {
+      const proc = spawn(BunProc.which(), ["x", "pyright-langserver", "--stdio"], {
+        cwd: root,
+        env: {
+          ...process.env,
+          BUN_BE_BUN: "1",
+        },
+      })
+      return {
+        process: proc,
+      }
+    },
+  }
+
+  export const ElixirLS: Info = {
+    id: "elixir-ls",
+    extensions: [".ex", ".exs"],
+    root: NearestRoot(["mix.exs", "mix.lock"]),
+    async spawn(_, root) {
+      let binary = Bun.which("elixir-ls")
+      if (!binary) {
+        const elixirLsPath = path.join(Global.Path.bin, "elixir-ls")
+        binary = path.join(
+          Global.Path.bin,
+          "elixir-ls-master",
+          "release",
+          process.platform === "win32" ? "language_server.bar" : "language_server.sh",
+        )
+
+        if (!(await Bun.file(binary).exists())) {
+          const elixir = Bun.which("elixir")
+          if (!elixir) {
+            log.error("elixir is required to run elixir-ls")
+            return
+          }
+
+          log.info("downloading elixir-ls from GitHub releases")
+
+          const response = await fetch("https://github.com/elixir-lsp/elixir-ls/archive/refs/heads/master.zip")
+          if (!response.ok) return
+          const zipPath = path.join(Global.Path.bin, "elixir-ls.zip")
+          await Bun.file(zipPath).write(response)
+
+          await $`unzip -o -q ${zipPath}`.cwd(Global.Path.bin).nothrow()
+
+          await fs.rm(zipPath, {
+            force: true,
+            recursive: true,
+          })
+
+          await $`mix deps.get && mix compile && mix elixir_ls.release2 -o release`
+            .quiet()
+            .cwd(path.join(Global.Path.bin, "elixir-ls-master"))
+            .env({ MIX_ENV: "prod", ...process.env })
+
+          log.info(`installed elixir-ls`, {
+            path: elixirLsPath,
+          })
+        }
+      }
+
+      return {
+        process: spawn(binary, {
+          cwd: root,
+        }),
+      }
+    },
+  }
+
+  export const Zls: Info = {
+    id: "zls",
+    extensions: [".zig", ".zon"],
+    root: NearestRoot(["build.zig"]),
+    async spawn(_, root) {
+      let bin = Bun.which("zls", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+
+      if (!bin) {
+        const zig = Bun.which("zig")
+        if (!zig) {
+          log.error("Zig is required to use zls. Please install Zig first.")
+          return
+        }
+
+        log.info("downloading zls from GitHub releases")
+
+        const releaseResponse = await fetch("https://api.github.com/repos/zigtools/zls/releases/latest")
+        if (!releaseResponse.ok) {
+          log.error("Failed to fetch zls release info")
+          return
+        }
+
+        const release = await releaseResponse.json()
+
+        const platform = process.platform
+        const arch = process.arch
+        let assetName = ""
+
+        let zlsArch: string = arch
+        if (arch === "arm64") zlsArch = "aarch64"
+        else if (arch === "x64") zlsArch = "x86_64"
+        else if (arch === "ia32") zlsArch = "x86"
+
+        let zlsPlatform: string = platform
+        if (platform === "darwin") zlsPlatform = "macos"
+        else if (platform === "win32") zlsPlatform = "windows"
+
+        const ext = platform === "win32" ? "zip" : "tar.xz"
+
+        assetName = `zls-${zlsArch}-${zlsPlatform}.${ext}`
+
+        const supportedCombos = [
+          "zls-x86_64-linux.tar.xz",
+          "zls-x86_64-macos.tar.xz",
+          "zls-x86_64-windows.zip",
+          "zls-aarch64-linux.tar.xz",
+          "zls-aarch64-macos.tar.xz",
+          "zls-aarch64-windows.zip",
+          "zls-x86-linux.tar.xz",
+          "zls-x86-windows.zip",
+        ]
+
+        if (!supportedCombos.includes(assetName)) {
+          log.error(`Platform ${platform} and architecture ${arch} is not supported by zls`)
+          return
+        }
+
+        const asset = release.assets.find((a: any) => a.name === assetName)
+        if (!asset) {
+          log.error(`Could not find asset ${assetName} in latest zls release`)
+          return
+        }
+
+        const downloadUrl = asset.browser_download_url
+        const downloadResponse = await fetch(downloadUrl)
+        if (!downloadResponse.ok) {
+          log.error("Failed to download zls")
+          return
+        }
+
+        const tempPath = path.join(Global.Path.bin, assetName)
+        await Bun.file(tempPath).write(downloadResponse)
+
+        if (ext === "zip") {
+          await $`unzip -o -q ${tempPath}`.cwd(Global.Path.bin).nothrow()
+        } else {
+          await $`tar -xf ${tempPath}`.cwd(Global.Path.bin).nothrow()
+        }
+
+        await fs.rm(tempPath, { force: true })
+
+        bin = path.join(Global.Path.bin, "zls" + (platform === "win32" ? ".exe" : ""))
+
+        if (!(await Bun.file(bin).exists())) {
+          log.error("Failed to extract zls binary")
+          return
+        }
+
+        if (platform !== "win32") {
+          await $`chmod +x ${bin}`.nothrow()
+        }
+
+        log.info(`installed zls`, { bin })
+      }
+
+      return {
+        process: spawn(bin, {
+          cwd: root,
+        }),
+      }
+    },
+  }
+
+  export const CSharp: Info = {
+    id: "csharp",
+    root: NearestRoot([".sln", ".csproj", "global.json"]),
+    extensions: [".cs"],
+    async spawn(_, root) {
+      let bin = Bun.which("csharp-ls", {
+        PATH: process.env["PATH"] + ":" + Global.Path.bin,
+      })
+      if (!bin) {
+        if (!Bun.which("dotnet")) {
+          log.error(".NET SDK is required to install csharp-ls")
+          return
+        }
+
+        log.info("installing csharp-ls via dotnet tool")
+        const proc = Bun.spawn({
+          cmd: ["dotnet", "tool", "install", "csharp-ls", "--tool-path", Global.Path.bin],
+          stdout: "pipe",
+          stderr: "pipe",
+          stdin: "pipe",
+        })
+        const exit = await proc.exited
+        if (exit !== 0) {
+          log.error("Failed to install csharp-ls")
+          return
+        }
+
+        bin = path.join(Global.Path.bin, "csharp-ls" + (process.platform === "win32" ? ".exe" : ""))
+        log.info(`installed csharp-ls`, { bin })
+      }
+
+      return {
+        process: spawn(bin, {
+          cwd: root,
+        }),
+      }
+    },
+  }
+}

packages/opencode/src/mcp/index.ts

@@ -0,0 +1,111 @@
+import { experimental_createMCPClient, type Tool } from "ai"
+import { Experimental_StdioMCPTransport } from "ai/mcp-stdio"
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import { Log } from "../util/log"
+import { NamedError } from "../util/error"
+import { z } from "zod"
+import { Session } from "../session"
+import { Bus } from "../bus"
+
+export namespace MCP {
+  const log = Log.create({ service: "mcp" })
+
+  export const Failed = NamedError.create(
+    "MCPFailed",
+    z.object({
+      name: z.string(),
+    }),
+  )
+
+  const state = App.state(
+    "mcp",
+    async () => {
+      const cfg = await Config.get()
+      const clients: {
+        [name: string]: Awaited<ReturnType<typeof experimental_createMCPClient>>
+      } = {}
+      for (const [key, mcp] of Object.entries(cfg.mcp ?? {})) {
+        if (mcp.enabled === false) {
+          log.info("mcp server disabled", { key })
+          continue
+        }
+        log.info("found", { key, type: mcp.type })
+        if (mcp.type === "remote") {
+          const client = await experimental_createMCPClient({
+            name: key,
+            transport: {
+              type: "sse",
+              url: mcp.url,
+              headers: mcp.headers,
+            },
+          }).catch(() => {})
+          if (!client) {
+            Bus.publish(Session.Event.Error, {
+              error: {
+                name: "UnknownError",
+                data: {
+                  message: `MCP server ${key} failed to start`,
+                },
+              },
+            })
+            continue
+          }
+          clients[key] = client
+        }
+
+        if (mcp.type === "local") {
+          const [cmd, ...args] = mcp.command
+          const client = await experimental_createMCPClient({
+            name: key,
+            transport: new Experimental_StdioMCPTransport({
+              stderr: "ignore",
+              command: cmd,
+              args,
+              env: {
+                ...process.env,
+                ...(cmd === "opencode" ? { BUN_BE_BUN: "1" } : {}),
+                ...mcp.environment,
+              },
+            }),
+          }).catch(() => {})
+          if (!client) {
+            Bus.publish(Session.Event.Error, {
+              error: {
+                name: "UnknownError",
+                data: {
+                  message: `MCP server ${key} failed to start`,
+                },
+              },
+            })
+            continue
+          }
+          clients[key] = client
+        }
+      }
+
+      return {
+        clients,
+      }
+    },
+    async (state) => {
+      for (const client of Object.values(state.clients)) {
+        client.close()
+      }
+    },
+  )
+
+  export async function clients() {
+    return state().then((state) => state.clients)
+  }
+
+  export async function tools() {
+    const result: Record<string, Tool> = {}
+    for (const [clientName, client] of Object.entries(await clients())) {
+      for (const [toolName, tool] of Object.entries(await client.tools())) {
+        result[clientName + "_" + toolName] = tool
+      }
+    }
+    return result
+  }
+}

packages/opencode/src/permission/index.ts

@@ -0,0 +1,136 @@
+import { App } from "../app/app"
+import { z } from "zod"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+
+export namespace Permission {
+  const log = Log.create({ service: "permission" })
+
+  export const Info = z
+    .object({
+      id: z.string(),
+      sessionID: z.string(),
+      title: z.string(),
+      metadata: z.record(z.any()),
+      time: z.object({
+        created: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "permission.info",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: Bus.event("permission.updated", Info),
+  }
+
+  const state = App.state(
+    "permission",
+    () => {
+      const pending: {
+        [sessionID: string]: {
+          [permissionID: string]: {
+            info: Info
+            resolve: () => void
+            reject: (e: any) => void
+          }
+        }
+      } = {}
+
+      const approved: {
+        [sessionID: string]: {
+          [permissionID: string]: Info
+        }
+      } = {}
+
+      return {
+        pending,
+        approved,
+      }
+    },
+    async (state) => {
+      for (const pending of Object.values(state.pending)) {
+        for (const item of Object.values(pending)) {
+          item.reject(new RejectedError(item.info.sessionID, item.info.id))
+        }
+      }
+    },
+  )
+
+  export function ask(input: {
+    id: Info["id"]
+    sessionID: Info["sessionID"]
+    title: Info["title"]
+    metadata: Info["metadata"]
+  }) {
+    return
+    const { pending, approved } = state()
+    log.info("asking", {
+      sessionID: input.sessionID,
+      permissionID: input.id,
+    })
+    if (approved[input.sessionID]?.[input.id]) {
+      log.info("previously approved", {
+        sessionID: input.sessionID,
+        permissionID: input.id,
+      })
+      return
+    }
+    const info: Info = {
+      id: input.id,
+      sessionID: input.sessionID,
+      title: input.title,
+      metadata: input.metadata,
+      time: {
+        created: Date.now(),
+      },
+    }
+    pending[input.sessionID] = pending[input.sessionID] || {}
+    return new Promise<void>((resolve, reject) => {
+      pending[input.sessionID][input.id] = {
+        info,
+        resolve,
+        reject,
+      }
+      setTimeout(() => {
+        respond({
+          sessionID: input.sessionID,
+          permissionID: input.id,
+          response: "always",
+        })
+      }, 1000)
+      Bus.publish(Event.Updated, info)
+    })
+  }
+
+  export function respond(input: {
+    sessionID: Info["sessionID"]
+    permissionID: Info["id"]
+    response: "once" | "always" | "reject"
+  }) {
+    log.info("response", input)
+    const { pending, approved } = state()
+    const match = pending[input.sessionID]?.[input.permissionID]
+    if (!match) return
+    delete pending[input.sessionID][input.permissionID]
+    if (input.response === "reject") {
+      match.reject(new RejectedError(input.sessionID, input.permissionID))
+      return
+    }
+    match.resolve()
+    if (input.response === "always") {
+      approved[input.sessionID] = approved[input.sessionID] || {}
+      approved[input.sessionID][input.permissionID] = match.info
+    }
+  }
+
+  export class RejectedError extends Error {
+    constructor(
+      public readonly sessionID: string,
+      public readonly permissionID: string,
+    ) {
+      super(`The user rejected permission to use this functionality`)
+    }
+  }
+}

packages/opencode/src/provider/models-macro.ts

@@ -0,0 +1,4 @@
+export async function data() {
+  const json = await fetch("https://models.dev/api.json").then((x) => x.text())
+  return json
+}

packages/opencode/src/provider/models.ts

@@ -0,0 +1,70 @@
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import { z } from "zod"
+import { data } from "./models-macro" with { type: "macro" }
+
+export namespace ModelsDev {
+  const log = Log.create({ service: "models.dev" })
+  const filepath = path.join(Global.Path.cache, "models.json")
+
+  export const Model = z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      release_date: z.string(),
+      attachment: z.boolean(),
+      reasoning: z.boolean(),
+      temperature: z.boolean(),
+      tool_call: z.boolean(),
+      cost: z.object({
+        input: z.number(),
+        output: z.number(),
+        cache_read: z.number().optional(),
+        cache_write: z.number().optional(),
+      }),
+      limit: z.object({
+        context: z.number(),
+        output: z.number(),
+      }),
+      options: z.record(z.any()),
+    })
+    .openapi({
+      ref: "Model",
+    })
+  export type Model = z.infer<typeof Model>
+
+  export const Provider = z
+    .object({
+      api: z.string().optional(),
+      name: z.string(),
+      env: z.array(z.string()),
+      id: z.string(),
+      npm: z.string().optional(),
+      models: z.record(Model),
+    })
+    .openapi({
+      ref: "Provider",
+    })
+
+  export type Provider = z.infer<typeof Provider>
+
+  export async function get() {
+    const file = Bun.file(filepath)
+    const result = await file.json().catch(() => {})
+    if (result) {
+      refresh()
+      return result as Record<string, Provider>
+    }
+    refresh()
+    const json = await data()
+    return JSON.parse(json) as Record<string, Provider>
+  }
+
+  async function refresh() {
+    const file = Bun.file(filepath)
+    log.info("refreshing")
+    const result = await fetch("https://models.dev/api.json").catch(() => {})
+    if (result && result.ok) await Bun.write(file, result)
+  }
+}

packages/opencode/src/provider/provider.ts

@@ -0,0 +1,474 @@
+import z from "zod"
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import { mergeDeep, sortBy } from "remeda"
+import { NoSuchModelError, type LanguageModel, type Provider as SDK } from "ai"
+import { Log } from "../util/log"
+import { BunProc } from "../bun"
+import { AuthAnthropic } from "../auth/anthropic"
+import { AuthCopilot } from "../auth/copilot"
+import { ModelsDev } from "./models"
+import { NamedError } from "../util/error"
+import { Auth } from "../auth"
+
+export namespace Provider {
+  const log = Log.create({ service: "provider" })
+
+  type CustomLoader = (
+    provider: ModelsDev.Provider,
+    api?: string,
+  ) => Promise<{
+    autoload: boolean
+    getModel?: (sdk: any, modelID: string) => Promise<any>
+    options?: Record<string, any>
+  }>
+
+  type Source = "env" | "config" | "custom" | "api"
+
+  const CUSTOM_LOADERS: Record<string, CustomLoader> = {
+    async anthropic(provider) {
+      const access = await AuthAnthropic.access()
+      if (!access) return { autoload: false }
+      for (const model of Object.values(provider.models)) {
+        model.cost = {
+          input: 0,
+          output: 0,
+        }
+      }
+      return {
+        autoload: true,
+        options: {
+          apiKey: "",
+          async fetch(input: any, init: any) {
+            const access = await AuthAnthropic.access()
+            const headers = {
+              ...init.headers,
+              authorization: `Bearer ${access}`,
+              "anthropic-beta": "oauth-2025-04-20",
+            }
+            delete headers["x-api-key"]
+            return fetch(input, {
+              ...init,
+              headers,
+            })
+          },
+        },
+      }
+    },
+    "github-copilot": async (provider) => {
+      const copilot = await AuthCopilot()
+      if (!copilot) return { autoload: false }
+      let info = await Auth.get("github-copilot")
+      if (!info || info.type !== "oauth") return { autoload: false }
+
+      if (provider && provider.models) {
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            output: 0,
+          }
+        }
+      }
+
+      return {
+        autoload: true,
+        options: {
+          apiKey: "",
+          async fetch(input: any, init: any) {
+            const info = await Auth.get("github-copilot")
+            if (!info || info.type !== "oauth") return
+            if (!info.access || info.expires < Date.now()) {
+              const tokens = await copilot.access(info.refresh)
+              if (!tokens) throw new Error("GitHub Copilot authentication expired")
+              await Auth.set("github-copilot", {
+                type: "oauth",
+                ...tokens,
+              })
+              info.access = tokens.access
+            }
+            let isAgentCall = false
+            let isVisionRequest = false
+            try {
+              const body = typeof init.body === "string" ? JSON.parse(init.body) : init.body
+              if (body?.messages) {
+                isAgentCall = body.messages.some((msg: any) => msg.role && ["tool", "assistant"].includes(msg.role))
+                isVisionRequest = body.messages.some(
+                  (msg: any) =>
+                    Array.isArray(msg.content) && msg.content.some((part: any) => part.type === "image_url"),
+                )
+              }
+            } catch {}
+            const headers: Record<string, string> = {
+              ...init.headers,
+              ...copilot.HEADERS,
+              Authorization: `Bearer ${info.access}`,
+              "Openai-Intent": "conversation-edits",
+              "X-Initiator": isAgentCall ? "agent" : "user",
+            }
+            if (isVisionRequest) {
+              headers["Copilot-Vision-Request"] = "true"
+            }
+            delete headers["x-api-key"]
+            return fetch(input, {
+              ...init,
+              headers,
+            })
+          },
+        },
+      }
+    },
+    openai: async () => {
+      return {
+        autoload: false,
+        async getModel(sdk: any, modelID: string) {
+          return sdk.responses(modelID)
+        },
+        options: {},
+      }
+    },
+    "amazon-bedrock": async () => {
+      if (!process.env["AWS_PROFILE"] && !process.env["AWS_ACCESS_KEY_ID"] && !process.env["AWS_BEARER_TOKEN_BEDROCK"])
+        return { autoload: false }
+
+      const region = process.env["AWS_REGION"] ?? "us-east-1"
+
+      const { fromNodeProviderChain } = await import(await BunProc.install("@aws-sdk/credential-providers"))
+      return {
+        autoload: true,
+        options: {
+          region,
+          credentialProvider: fromNodeProviderChain(),
+        },
+        async getModel(sdk: any, modelID: string) {
+          let regionPrefix = region.split("-")[0]
+
+          switch (regionPrefix) {
+            case "us": {
+              const modelRequiresPrefix = ["claude", "deepseek"].some((m) => modelID.includes(m))
+              if (modelRequiresPrefix) {
+                modelID = `${regionPrefix}.${modelID}`
+              }
+              break
+            }
+            case "eu": {
+              const regionRequiresPrefix = [
+                "eu-west-1",
+                "eu-west-3",
+                "eu-north-1",
+                "eu-central-1",
+                "eu-south-1",
+                "eu-south-2",
+              ].some((r) => region.includes(r))
+              const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((m) =>
+                modelID.includes(m),
+              )
+              if (regionRequiresPrefix && modelRequiresPrefix) {
+                modelID = `${regionPrefix}.${modelID}`
+              }
+              break
+            }
+            case "ap": {
+              const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) =>
+                modelID.includes(m),
+              )
+              if (modelRequiresPrefix) {
+                regionPrefix = "apac"
+                modelID = `${regionPrefix}.${modelID}`
+              }
+              break
+            }
+          }
+
+          return sdk.languageModel(modelID)
+        },
+      }
+    },
+    openrouter: async () => {
+      return {
+        autoload: false,
+        options: {
+          headers: {
+            "HTTP-Referer": "https://opencode.ai/",
+            "X-Title": "opencode",
+          },
+        },
+      }
+    },
+  }
+
+  const state = App.state("provider", async () => {
+    const config = await Config.get()
+    const database = await ModelsDev.get()
+
+    const providers: {
+      [providerID: string]: {
+        source: Source
+        info: ModelsDev.Provider
+        getModel?: (sdk: any, modelID: string) => Promise<any>
+        options: Record<string, any>
+      }
+    } = {}
+    const models = new Map<string, { info: ModelsDev.Model; language: LanguageModel }>()
+    const sdk = new Map<string, SDK>()
+
+    log.info("init")
+
+    function mergeProvider(
+      id: string,
+      options: Record<string, any>,
+      source: Source,
+      getModel?: (sdk: any, modelID: string) => Promise<any>,
+    ) {
+      const provider = providers[id]
+      if (!provider) {
+        const info = database[id]
+        if (!info) return
+        if (info.api && !options["baseURL"]) options["baseURL"] = info.api
+        providers[id] = {
+          source,
+          info,
+          options,
+          getModel,
+        }
+        return
+      }
+      provider.options = mergeDeep(provider.options, options)
+      provider.source = source
+      provider.getModel = getModel ?? provider.getModel
+    }
+
+    const configProviders = Object.entries(config.provider ?? {})
+
+    for (const [providerID, provider] of configProviders) {
+      const existing = database[providerID]
+      const parsed: ModelsDev.Provider = {
+        id: providerID,
+        npm: provider.npm ?? existing?.npm,
+        name: provider.name ?? existing?.name ?? providerID,
+        env: provider.env ?? existing?.env ?? [],
+        api: provider.api ?? existing?.api,
+        models: existing?.models ?? {},
+      }
+
+      for (const [modelID, model] of Object.entries(provider.models ?? {})) {
+        const existing = parsed.models[modelID]
+        const parsedModel: ModelsDev.Model = {
+          id: modelID,
+          name: model.name ?? existing?.name ?? modelID,
+          release_date: model.release_date ?? existing?.release_date,
+          attachment: model.attachment ?? existing?.attachment ?? false,
+          reasoning: model.reasoning ?? existing?.reasoning ?? false,
+          temperature: model.temperature ?? existing?.temperature ?? false,
+          tool_call: model.tool_call ?? existing?.tool_call ?? true,
+          cost:
+            !model.cost && !existing?.cost
+              ? {
+                  input: 0,
+                  output: 0,
+                  cache_read: 0,
+                  cache_write: 0,
+                }
+              : {
+                  cache_read: 0,
+                  cache_write: 0,
+                  ...existing?.cost,
+                  ...model.cost,
+                },
+          options: {
+            ...existing?.options,
+            ...model.options,
+          },
+          limit: model.limit ??
+            existing?.limit ?? {
+              context: 0,
+              output: 0,
+            },
+        }
+        parsed.models[modelID] = parsedModel
+      }
+      database[providerID] = parsed
+    }
+
+    const disabled = await Config.get().then((cfg) => new Set(cfg.disabled_providers ?? []))
+    // load env
+    for (const [providerID, provider] of Object.entries(database)) {
+      if (disabled.has(providerID)) continue
+      const apiKey = provider.env.map((item) => process.env[item]).at(0)
+      if (!apiKey) continue
+      mergeProvider(
+        providerID,
+        // only include apiKey if there's only one potential option
+        provider.env.length === 1 ? { apiKey } : {},
+        "env",
+      )
+    }
+
+    // load apikeys
+    for (const [providerID, provider] of Object.entries(await Auth.all())) {
+      if (disabled.has(providerID)) continue
+      if (provider.type === "api") {
+        mergeProvider(providerID, { apiKey: provider.key }, "api")
+      }
+    }
+
+    // load custom
+    for (const [providerID, fn] of Object.entries(CUSTOM_LOADERS)) {
+      if (disabled.has(providerID)) continue
+      const result = await fn(database[providerID])
+      if (result && (result.autoload || providers[providerID])) {
+        mergeProvider(providerID, result.options ?? {}, "custom", result.getModel)
+      }
+    }
+
+    // load config
+    for (const [providerID, provider] of configProviders) {
+      mergeProvider(providerID, provider.options ?? {}, "config")
+    }
+
+    for (const [providerID, provider] of Object.entries(providers)) {
+      if (Object.keys(provider.info.models).length === 0) {
+        delete providers[providerID]
+        continue
+      }
+      log.info("found", { providerID })
+    }
+
+    return {
+      models,
+      providers,
+      sdk,
+    }
+  })
+
+  export async function list() {
+    return state().then((state) => state.providers)
+  }
+
+  async function getSDK(provider: ModelsDev.Provider) {
+    return (async () => {
+      using _ = log.time("getSDK", {
+        providerID: provider.id,
+      })
+      const s = await state()
+      const existing = s.sdk.get(provider.id)
+      if (existing) return existing
+      const pkg = provider.npm ?? provider.id
+      const mod = await import(await BunProc.install(pkg, "beta"))
+      const fn = mod[Object.keys(mod).find((key) => key.startsWith("create"))!]
+      const loaded = fn({
+        name: provider.id,
+        ...s.providers[provider.id]?.options,
+      })
+      s.sdk.set(provider.id, loaded)
+      return loaded as SDK
+    })().catch((e) => {
+      throw new InitError({ providerID: provider.id }, { cause: e })
+    })
+  }
+
+  export async function getModel(providerID: string, modelID: string) {
+    const key = `${providerID}/${modelID}`
+    const s = await state()
+    if (s.models.has(key)) return s.models.get(key)!
+
+    log.info("getModel", {
+      providerID,
+      modelID,
+    })
+
+    const provider = s.providers[providerID]
+    if (!provider) throw new ModelNotFoundError({ providerID, modelID })
+    const info = provider.info.models[modelID]
+    if (!info) throw new ModelNotFoundError({ providerID, modelID })
+    const sdk = await getSDK(provider.info)
+
+    try {
+      const language = provider.getModel ? await provider.getModel(sdk, modelID) : sdk.languageModel(modelID)
+      log.info("found", { providerID, modelID })
+      s.models.set(key, {
+        info,
+        language,
+      })
+      return {
+        info,
+        language,
+      }
+    } catch (e) {
+      if (e instanceof NoSuchModelError)
+        throw new ModelNotFoundError(
+          {
+            modelID: modelID,
+            providerID,
+          },
+          { cause: e },
+        )
+      throw e
+    }
+  }
+
+  export async function getSmallModel(providerID: string) {
+    const cfg = await Config.get()
+
+    if (cfg.small_model) {
+      const parsed = parseModel(cfg.small_model)
+      return getModel(parsed.providerID, parsed.modelID)
+    }
+
+    const provider = await state().then((state) => state.providers[providerID])
+    if (!provider) return
+    const priority = ["3-5-haiku", "3.5-haiku", "gemini-2.5-flash"]
+    for (const item of priority) {
+      for (const model of Object.keys(provider.info.models)) {
+        if (model.includes(item)) return getModel(providerID, model)
+      }
+    }
+  }
+
+  const priority = ["gemini-2.5-pro-preview", "codex-mini", "claude-sonnet-4"]
+  export function sort(models: ModelsDev.Model[]) {
+    return sortBy(
+      models,
+      [(model) => priority.findIndex((filter) => model.id.includes(filter)), "desc"],
+      [(model) => (model.id.includes("latest") ? 0 : 1), "asc"],
+      [(model) => model.id, "desc"],
+    )
+  }
+
+  export async function defaultModel() {
+    const cfg = await Config.get()
+    if (cfg.model) return parseModel(cfg.model)
+    const provider = await list()
+      .then((val) => Object.values(val))
+      .then((x) => x.find((p) => !cfg.provider || Object.keys(cfg.provider).includes(p.info.id)))
+    if (!provider) throw new Error("no providers found")
+    const [model] = sort(Object.values(provider.info.models))
+    if (!model) throw new Error("no models found")
+    return {
+      providerID: provider.info.id,
+      modelID: model.id,
+    }
+  }
+
+  export function parseModel(model: string) {
+    const [providerID, ...rest] = model.split("/")
+    return {
+      providerID: providerID,
+      modelID: rest.join("/"),
+    }
+  }
+
+  export const ModelNotFoundError = NamedError.create(
+    "ProviderModelNotFoundError",
+    z.object({
+      providerID: z.string(),
+      modelID: z.string(),
+    }),
+  )
+
+  export const InitError = NamedError.create(
+    "ProviderInitError",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+}

packages/opencode/src/provider/transform.ts

@@ -0,0 +1,52 @@
+import type { ModelMessage } from "ai"
+import { unique } from "remeda"
+
+export namespace ProviderTransform {
+  export function message(msgs: ModelMessage[], providerID: string, modelID: string) {
+    if (providerID === "anthropic" || modelID.includes("anthropic") || modelID.includes("claude")) {
+      const system = msgs.filter((msg) => msg.role === "system").slice(0, 2)
+      const final = msgs.filter((msg) => msg.role !== "system").slice(-2)
+
+      const providerOptions = {
+        anthropic: {
+          cacheControl: { type: "ephemeral" },
+        },
+        openrouter: {
+          cache_control: { type: "ephemeral" },
+        },
+        bedrock: {
+          cachePoint: { type: "ephemeral" },
+        },
+        openaiCompatible: {
+          cache_control: { type: "ephemeral" },
+        },
+      }
+
+      for (const msg of unique([...system, ...final])) {
+        const shouldUseContentOptions = providerID !== "anthropic" && Array.isArray(msg.content) && msg.content.length > 0
+        
+        if (shouldUseContentOptions) {
+          const lastContent = msg.content[msg.content.length - 1]
+          if (lastContent && typeof lastContent === "object") {
+            lastContent.providerOptions = {
+              ...lastContent.providerOptions,
+              ...providerOptions,
+            }
+            continue
+          }
+        }
+        
+        msg.providerOptions = {
+          ...msg.providerOptions,
+          ...providerOptions,
+        }
+      }
+    }
+    return msgs
+  }
+
+  export function temperature(_providerID: string, modelID: string) {
+    if (modelID.includes("qwen")) return 0.55
+    return 0
+  }
+}

packages/opencode/src/server/server.ts

@@ -0,0 +1,838 @@
+import { Log } from "../util/log"
+import { Bus } from "../bus"
+import { describeRoute, generateSpecs, openAPISpecs } from "hono-openapi"
+import { Hono } from "hono"
+import { streamSSE } from "hono/streaming"
+import { Session } from "../session"
+import { resolver, validator as zValidator } from "hono-openapi/zod"
+import { z } from "zod"
+import { Provider } from "../provider/provider"
+import { App } from "../app/app"
+import { mapValues } from "remeda"
+import { NamedError } from "../util/error"
+import { ModelsDev } from "../provider/models"
+import { Ripgrep } from "../file/ripgrep"
+import { Config } from "../config/config"
+import { File } from "../file"
+import { LSP } from "../lsp"
+import { MessageV2 } from "../session/message-v2"
+import { Mode } from "../session/mode"
+import { callTui, TuiRoute } from "./tui"
+
+const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.record(z.string(), z.any()),
+            })
+            .openapi({
+              ref: "Error",
+            }),
+        ),
+      },
+    },
+  },
+} as const
+
+export namespace Server {
+  const log = Log.create({ service: "server" })
+
+  export type Routes = ReturnType<typeof app>
+
+  function app() {
+    const app = new Hono()
+
+    const result = app
+      .onError((err, c) => {
+        if (err instanceof NamedError) {
+          return c.json(err.toObject(), {
+            status: 400,
+          })
+        }
+        return c.json(new NamedError.Unknown({ message: err.toString() }).toObject(), {
+          status: 400,
+        })
+      })
+      .use(async (c, next) => {
+        const skipLogging = c.req.path === "/log"
+        if (!skipLogging) {
+          log.info("request", {
+            method: c.req.method,
+            path: c.req.path,
+          })
+        }
+        const start = Date.now()
+        await next()
+        if (!skipLogging) {
+          log.info("response", {
+            duration: Date.now() - start,
+          })
+        }
+      })
+      .get(
+        "/doc",
+        openAPISpecs(app, {
+          documentation: {
+            info: {
+              title: "opencode",
+              version: "0.0.3",
+              description: "opencode api",
+            },
+            openapi: "3.0.0",
+          },
+        }),
+      )
+      .get(
+        "/event",
+        describeRoute({
+          description: "Get events",
+          responses: {
+            200: {
+              description: "Event stream",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    Bus.payloads().openapi({
+                      ref: "Event",
+                    }),
+                  ),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          log.info("event connected")
+          return streamSSE(c, async (stream) => {
+            stream.writeSSE({
+              data: JSON.stringify({}),
+            })
+            const unsub = Bus.subscribeAll(async (event) => {
+              await stream.writeSSE({
+                data: JSON.stringify(event),
+              })
+            })
+            await new Promise<void>((resolve) => {
+              stream.onAbort(() => {
+                unsub()
+                resolve()
+                log.info("event disconnected")
+              })
+            })
+          })
+        },
+      )
+      .get(
+        "/app",
+        describeRoute({
+          description: "Get app info",
+          responses: {
+            200: {
+              description: "200",
+              content: {
+                "application/json": {
+                  schema: resolver(App.Info),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          return c.json(App.info())
+        },
+      )
+      .post(
+        "/app/init",
+        describeRoute({
+          description: "Initialize the app",
+          responses: {
+            200: {
+              description: "Initialize the app",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          await App.initialize()
+          return c.json(true)
+        },
+      )
+      .get(
+        "/config",
+        describeRoute({
+          description: "Get config info",
+          responses: {
+            200: {
+              description: "Get config info",
+              content: {
+                "application/json": {
+                  schema: resolver(Config.Info),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          return c.json(await Config.get())
+        },
+      )
+      .get(
+        "/session",
+        describeRoute({
+          description: "List all sessions",
+          responses: {
+            200: {
+              description: "List of sessions",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info.array()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const sessions = await Array.fromAsync(Session.list())
+          sessions.sort((a, b) => b.time.updated - a.time.updated)
+          return c.json(sessions)
+        },
+      )
+      .post(
+        "/session",
+        describeRoute({
+          description: "Create a new session",
+          responses: {
+            ...ERRORS,
+            200: {
+              description: "Successfully created session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const session = await Session.create()
+          return c.json(session)
+        },
+      )
+      .delete(
+        "/session/:id",
+        describeRoute({
+          description: "Delete a session and all its data",
+          responses: {
+            200: {
+              description: "Successfully deleted session",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          await Session.remove(c.req.valid("param").id)
+          return c.json(true)
+        },
+      )
+      .post(
+        "/session/:id/init",
+        describeRoute({
+          description: "Analyze the app and create an AGENTS.md file",
+          responses: {
+            200: {
+              description: "200",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        zValidator(
+          "json",
+          z.object({
+            messageID: z.string(),
+            providerID: z.string(),
+            modelID: z.string(),
+          }),
+        ),
+        async (c) => {
+          const sessionID = c.req.valid("param").id
+          const body = c.req.valid("json")
+          await Session.initialize({ ...body, sessionID })
+          return c.json(true)
+        },
+      )
+      .post(
+        "/session/:id/abort",
+        describeRoute({
+          description: "Abort a session",
+          responses: {
+            200: {
+              description: "Aborted session",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          return c.json(Session.abort(c.req.valid("param").id))
+        },
+      )
+      .post(
+        "/session/:id/share",
+        describeRoute({
+          description: "Share a session",
+          responses: {
+            200: {
+              description: "Successfully shared session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          await Session.share(id)
+          const session = await Session.get(id)
+          return c.json(session)
+        },
+      )
+      .delete(
+        "/session/:id/share",
+        describeRoute({
+          description: "Unshare the session",
+          responses: {
+            200: {
+              description: "Successfully unshared session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          await Session.unshare(id)
+          const session = await Session.get(id)
+          return c.json(session)
+        },
+      )
+      .post(
+        "/session/:id/summarize",
+        describeRoute({
+          description: "Summarize the session",
+          responses: {
+            200: {
+              description: "Summarized session",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        zValidator(
+          "json",
+          z.object({
+            providerID: z.string(),
+            modelID: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          const body = c.req.valid("json")
+          await Session.summarize({ ...body, sessionID: id })
+          return c.json(true)
+        },
+      )
+      .get(
+        "/session/:id/message",
+        describeRoute({
+          description: "List messages for a session",
+          responses: {
+            200: {
+              description: "List of messages",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    z
+                      .object({
+                        info: MessageV2.Info,
+                        parts: MessageV2.Part.array(),
+                      })
+                      .array(),
+                  ),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        async (c) => {
+          const messages = await Session.messages(c.req.valid("param").id)
+          return c.json(messages)
+        },
+      )
+      .post(
+        "/session/:id/message",
+        describeRoute({
+          description: "Create and send a new message to a session",
+          responses: {
+            200: {
+              description: "Created message",
+              content: {
+                "application/json": {
+                  schema: resolver(MessageV2.Assistant),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string().openapi({ description: "Session ID" }),
+          }),
+        ),
+        zValidator("json", Session.ChatInput.omit({ sessionID: true })),
+        async (c) => {
+          const sessionID = c.req.valid("param").id
+          const body = c.req.valid("json")
+          const msg = await Session.chat({ ...body, sessionID })
+          return c.json(msg)
+        },
+      )
+      .post(
+        "/session/:id/revert",
+        describeRoute({
+          description: "Revert a message",
+          responses: {
+            200: {
+              description: "Updated session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        zValidator("json", Session.RevertInput.omit({ sessionID: true })),
+        async (c) => {
+          const id = c.req.valid("param").id
+          log.info("revert", c.req.valid("json"))
+          const session = await Session.revert({ sessionID: id, ...c.req.valid("json") })
+          return c.json(session)
+        },
+      )
+      .post(
+        "/session/:id/unrevert",
+        describeRoute({
+          description: "Restore all reverted messages",
+          responses: {
+            200: {
+              description: "Updated session",
+              content: {
+                "application/json": {
+                  schema: resolver(Session.Info),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "param",
+          z.object({
+            id: z.string(),
+          }),
+        ),
+        async (c) => {
+          const id = c.req.valid("param").id
+          const session = await Session.unrevert({ sessionID: id })
+          return c.json(session)
+        },
+      )
+      .get(
+        "/config/providers",
+        describeRoute({
+          description: "List all providers",
+          responses: {
+            200: {
+              description: "List of providers",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    z.object({
+                      providers: ModelsDev.Provider.array(),
+                      default: z.record(z.string(), z.string()),
+                    }),
+                  ),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const providers = await Provider.list().then((x) => mapValues(x, (item) => item.info))
+          return c.json({
+            providers: Object.values(providers),
+            default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+          })
+        },
+      )
+      .get(
+        "/find",
+        describeRoute({
+          description: "Find text in files",
+          responses: {
+            200: {
+              description: "Matches",
+              content: {
+                "application/json": {
+                  schema: resolver(Ripgrep.Match.shape.data.array()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "query",
+          z.object({
+            pattern: z.string(),
+          }),
+        ),
+        async (c) => {
+          const app = App.info()
+          const pattern = c.req.valid("query").pattern
+          const result = await Ripgrep.search({
+            cwd: app.path.cwd,
+            pattern,
+            limit: 10,
+          })
+          return c.json(result)
+        },
+      )
+      .get(
+        "/find/file",
+        describeRoute({
+          description: "Find files",
+          responses: {
+            200: {
+              description: "File paths",
+              content: {
+                "application/json": {
+                  schema: resolver(z.string().array()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "query",
+          z.object({
+            query: z.string(),
+          }),
+        ),
+        async (c) => {
+          const query = c.req.valid("query").query
+          const app = App.info()
+          const result = await Ripgrep.files({
+            cwd: app.path.cwd,
+            query,
+            limit: 10,
+          })
+          return c.json(result)
+        },
+      )
+      .get(
+        "/find/symbol",
+        describeRoute({
+          description: "Find workspace symbols",
+          responses: {
+            200: {
+              description: "Symbols",
+              content: {
+                "application/json": {
+                  schema: resolver(LSP.Symbol.array()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "query",
+          z.object({
+            query: z.string(),
+          }),
+        ),
+        async (c) => {
+          const query = c.req.valid("query").query
+          const result = await LSP.workspaceSymbol(query)
+          return c.json(result)
+        },
+      )
+      .get(
+        "/file",
+        describeRoute({
+          description: "Read a file",
+          responses: {
+            200: {
+              description: "File content",
+              content: {
+                "application/json": {
+                  schema: resolver(
+                    z.object({
+                      type: z.enum(["raw", "patch"]),
+                      content: z.string(),
+                    }),
+                  ),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "query",
+          z.object({
+            path: z.string(),
+          }),
+        ),
+        async (c) => {
+          const path = c.req.valid("query").path
+          const content = await File.read(path)
+          log.info("read file", {
+            path,
+            content: content.content,
+          })
+          return c.json(content)
+        },
+      )
+      .get(
+        "/file/status",
+        describeRoute({
+          description: "Get file status",
+          responses: {
+            200: {
+              description: "File status",
+              content: {
+                "application/json": {
+                  schema: resolver(File.Info.array()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const content = await File.status()
+          return c.json(content)
+        },
+      )
+      .post(
+        "/log",
+        describeRoute({
+          description: "Write a log entry to the server logs",
+          responses: {
+            200: {
+              description: "Log entry written successfully",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "json",
+          z.object({
+            service: z.string().openapi({ description: "Service name for the log entry" }),
+            level: z.enum(["debug", "info", "error", "warn"]).openapi({ description: "Log level" }),
+            message: z.string().openapi({ description: "Log message" }),
+            extra: z
+              .record(z.string(), z.any())
+              .optional()
+              .openapi({ description: "Additional metadata for the log entry" }),
+          }),
+        ),
+        async (c) => {
+          const { service, level, message, extra } = c.req.valid("json")
+          const logger = Log.create({ service })
+
+          switch (level) {
+            case "debug":
+              logger.debug(message, extra)
+              break
+            case "info":
+              logger.info(message, extra)
+              break
+            case "error":
+              logger.error(message, extra)
+              break
+            case "warn":
+              logger.warn(message, extra)
+              break
+          }
+
+          return c.json(true)
+        },
+      )
+      .get(
+        "/mode",
+        describeRoute({
+          description: "List all modes",
+          responses: {
+            200: {
+              description: "List of modes",
+              content: {
+                "application/json": {
+                  schema: resolver(Mode.Info.array()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => {
+          const modes = await Mode.list()
+          return c.json(modes)
+        },
+      )
+      .post(
+        "/tui/append-prompt",
+        describeRoute({
+          description: "Append prompt to the TUI",
+          responses: {
+            200: {
+              description: "Prompt processed successfully",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        zValidator(
+          "json",
+          z.object({
+            text: z.string(),
+          }),
+        ),
+        async (c) => c.json(await callTui(c)),
+      )
+      .post(
+        "/tui/open-help",
+        describeRoute({
+          description: "Open the help dialog",
+          responses: {
+            200: {
+              description: "Help dialog opened successfully",
+              content: {
+                "application/json": {
+                  schema: resolver(z.boolean()),
+                },
+              },
+            },
+          },
+        }),
+        async (c) => c.json(await callTui(c)),
+      )
+      .route("/tui/control", TuiRoute)
+
+    return result
+  }
+
+  export async function openapi() {
+    const a = app()
+    const result = await generateSpecs(a, {
+      documentation: {
+        info: {
+          title: "opencode",
+          version: "1.0.0",
+          description: "opencode api",
+        },
+        openapi: "3.0.0",
+      },
+    })
+    return result
+  }
+
+  export function listen(opts: { port: number; hostname: string }) {
+    const server = Bun.serve({
+      port: opts.port,
+      hostname: opts.hostname,
+      idleTimeout: 0,
+      fetch: app().fetch,
+    })
+    return server
+  }
+}

packages/opencode/src/server/tui.ts

@@ -0,0 +1,30 @@
+import { Hono, type Context } from "hono"
+import { AsyncQueue } from "../util/queue"
+
+interface Request {
+  path: string
+  body: any
+}
+
+const request = new AsyncQueue<Request>()
+const response = new AsyncQueue<any>()
+
+export async function callTui(ctx: Context) {
+  const body = await ctx.req.json()
+  request.push({
+    path: ctx.req.path,
+    body,
+  })
+  return response.next()
+}
+
+export const TuiRoute = new Hono()
+  .get("/next", async (c) => {
+    const req = await request.next()
+    return c.json(req)
+  })
+  .post("/response", async (c) => {
+    const body = await c.req.json()
+    response.push(body)
+    return c.json(true)
+  })

packages/opencode/src/session/message-v2.ts

@@ -0,0 +1,514 @@
+import z from "zod"
+import { Bus } from "../bus"
+import { NamedError } from "../util/error"
+import { Message } from "./message"
+import { convertToModelMessages, type ModelMessage, type UIMessage } from "ai"
+import { Identifier } from "../id/id"
+import { LSP } from "../lsp"
+
+export namespace MessageV2 {
+  export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
+  export const AbortedError = NamedError.create("MessageAbortedError", z.object({}))
+  export const AuthError = NamedError.create(
+    "ProviderAuthError",
+    z.object({
+      providerID: z.string(),
+      message: z.string(),
+    }),
+  )
+
+  export const ToolStatePending = z
+    .object({
+      status: z.literal("pending"),
+    })
+    .openapi({
+      ref: "ToolStatePending",
+    })
+
+  export type ToolStatePending = z.infer<typeof ToolStatePending>
+
+  export const ToolStateRunning = z
+    .object({
+      status: z.literal("running"),
+      input: z.any(),
+      title: z.string().optional(),
+      metadata: z.record(z.any()).optional(),
+      time: z.object({
+        start: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "ToolStateRunning",
+    })
+  export type ToolStateRunning = z.infer<typeof ToolStateRunning>
+
+  export const ToolStateCompleted = z
+    .object({
+      status: z.literal("completed"),
+      input: z.record(z.any()),
+      output: z.string(),
+      title: z.string(),
+      metadata: z.record(z.any()),
+      time: z.object({
+        start: z.number(),
+        end: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "ToolStateCompleted",
+    })
+  export type ToolStateCompleted = z.infer<typeof ToolStateCompleted>
+
+  export const ToolStateError = z
+    .object({
+      status: z.literal("error"),
+      input: z.record(z.any()),
+      error: z.string(),
+      time: z.object({
+        start: z.number(),
+        end: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "ToolStateError",
+    })
+  export type ToolStateError = z.infer<typeof ToolStateError>
+
+  export const ToolState = z
+    .discriminatedUnion("status", [ToolStatePending, ToolStateRunning, ToolStateCompleted, ToolStateError])
+    .openapi({
+      ref: "ToolState",
+    })
+
+  const PartBase = z.object({
+    id: z.string(),
+    sessionID: z.string(),
+    messageID: z.string(),
+  })
+
+  export const SnapshotPart = PartBase.extend({
+    type: z.literal("snapshot"),
+    snapshot: z.string(),
+  }).openapi({
+    ref: "SnapshotPart",
+  })
+  export type SnapshotPart = z.infer<typeof SnapshotPart>
+
+  export const PatchPart = PartBase.extend({
+    type: z.literal("patch"),
+    hash: z.string(),
+    files: z.string().array(),
+  }).openapi({
+    ref: "PatchPart",
+  })
+  export type PatchPart = z.infer<typeof PatchPart>
+
+  export const TextPart = PartBase.extend({
+    type: z.literal("text"),
+    text: z.string(),
+    synthetic: z.boolean().optional(),
+    time: z
+      .object({
+        start: z.number(),
+        end: z.number().optional(),
+      })
+      .optional(),
+  }).openapi({
+    ref: "TextPart",
+  })
+  export type TextPart = z.infer<typeof TextPart>
+
+  export const ToolPart = PartBase.extend({
+    type: z.literal("tool"),
+    callID: z.string(),
+    tool: z.string(),
+    state: ToolState,
+  }).openapi({
+    ref: "ToolPart",
+  })
+  export type ToolPart = z.infer<typeof ToolPart>
+
+  const FilePartSourceBase = z.object({
+    text: z
+      .object({
+        value: z.string(),
+        start: z.number().int(),
+        end: z.number().int(),
+      })
+      .openapi({
+        ref: "FilePartSourceText",
+      }),
+  })
+
+  export const FileSource = FilePartSourceBase.extend({
+    type: z.literal("file"),
+    path: z.string(),
+  }).openapi({
+    ref: "FileSource",
+  })
+
+  export const SymbolSource = FilePartSourceBase.extend({
+    type: z.literal("symbol"),
+    path: z.string(),
+    range: LSP.Range,
+    name: z.string(),
+    kind: z.number().int(),
+  }).openapi({
+    ref: "SymbolSource",
+  })
+
+  export const FilePartSource = z.discriminatedUnion("type", [FileSource, SymbolSource]).openapi({
+    ref: "FilePartSource",
+  })
+
+  export const FilePart = PartBase.extend({
+    type: z.literal("file"),
+    mime: z.string(),
+    filename: z.string().optional(),
+    url: z.string(),
+    source: FilePartSource.optional(),
+  }).openapi({
+    ref: "FilePart",
+  })
+  export type FilePart = z.infer<typeof FilePart>
+
+  export const StepStartPart = PartBase.extend({
+    type: z.literal("step-start"),
+  }).openapi({
+    ref: "StepStartPart",
+  })
+  export type StepStartPart = z.infer<typeof StepStartPart>
+
+  export const StepFinishPart = PartBase.extend({
+    type: z.literal("step-finish"),
+    cost: z.number(),
+    tokens: z.object({
+      input: z.number(),
+      output: z.number(),
+      reasoning: z.number(),
+      cache: z.object({
+        read: z.number(),
+        write: z.number(),
+      }),
+    }),
+  }).openapi({
+    ref: "StepFinishPart",
+  })
+  export type StepFinishPart = z.infer<typeof StepFinishPart>
+
+  const Base = z.object({
+    id: z.string(),
+    sessionID: z.string(),
+  })
+
+  export const User = Base.extend({
+    role: z.literal("user"),
+    time: z.object({
+      created: z.number(),
+    }),
+  }).openapi({
+    ref: "UserMessage",
+  })
+  export type User = z.infer<typeof User>
+
+  export const Part = z
+    .discriminatedUnion("type", [TextPart, FilePart, ToolPart, StepStartPart, StepFinishPart, SnapshotPart, PatchPart])
+    .openapi({
+      ref: "Part",
+    })
+  export type Part = z.infer<typeof Part>
+
+  export const Assistant = Base.extend({
+    role: z.literal("assistant"),
+    time: z.object({
+      created: z.number(),
+      completed: z.number().optional(),
+    }),
+    error: z
+      .discriminatedUnion("name", [
+        AuthError.Schema,
+        NamedError.Unknown.Schema,
+        OutputLengthError.Schema,
+        AbortedError.Schema,
+      ])
+      .optional(),
+    system: z.string().array(),
+    modelID: z.string(),
+    providerID: z.string(),
+    mode: z.string(),
+    path: z.object({
+      cwd: z.string(),
+      root: z.string(),
+    }),
+    summary: z.boolean().optional(),
+    cost: z.number(),
+    tokens: z.object({
+      input: z.number(),
+      output: z.number(),
+      reasoning: z.number(),
+      cache: z.object({
+        read: z.number(),
+        write: z.number(),
+      }),
+    }),
+  }).openapi({
+    ref: "AssistantMessage",
+  })
+  export type Assistant = z.infer<typeof Assistant>
+
+  export const Info = z.discriminatedUnion("role", [User, Assistant]).openapi({
+    ref: "Message",
+  })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: Bus.event(
+      "message.updated",
+      z.object({
+        info: Info,
+      }),
+    ),
+    Removed: Bus.event(
+      "message.removed",
+      z.object({
+        sessionID: z.string(),
+        messageID: z.string(),
+      }),
+    ),
+    PartUpdated: Bus.event(
+      "message.part.updated",
+      z.object({
+        part: Part,
+      }),
+    ),
+    PartRemoved: Bus.event(
+      "message.part.removed",
+      z.object({
+        messageID: z.string(),
+        partID: z.string(),
+      }),
+    ),
+  }
+
+  export function fromV1(v1: Message.Info) {
+    if (v1.role === "assistant") {
+      const info: Assistant = {
+        id: v1.id,
+        sessionID: v1.metadata.sessionID,
+        role: "assistant",
+        time: {
+          created: v1.metadata.time.created,
+          completed: v1.metadata.time.completed,
+        },
+        cost: v1.metadata.assistant!.cost,
+        path: v1.metadata.assistant!.path,
+        summary: v1.metadata.assistant!.summary,
+        tokens: v1.metadata.assistant!.tokens,
+        modelID: v1.metadata.assistant!.modelID,
+        providerID: v1.metadata.assistant!.providerID,
+        system: v1.metadata.assistant!.system,
+        mode: "build",
+        error: v1.metadata.error,
+      }
+      const parts = v1.parts.flatMap((part): Part[] => {
+        const base = {
+          id: Identifier.ascending("part"),
+          messageID: v1.id,
+          sessionID: v1.metadata.sessionID,
+        }
+        if (part.type === "text") {
+          return [
+            {
+              ...base,
+              type: "text",
+              text: part.text,
+            },
+          ]
+        }
+        if (part.type === "step-start") {
+          return [
+            {
+              ...base,
+              type: "step-start",
+            },
+          ]
+        }
+        if (part.type === "tool-invocation") {
+          return [
+            {
+              ...base,
+              type: "tool",
+              callID: part.toolInvocation.toolCallId,
+              tool: part.toolInvocation.toolName,
+              state: (() => {
+                if (part.toolInvocation.state === "partial-call") {
+                  return {
+                    status: "pending",
+                  }
+                }
+
+                const { title, time, ...metadata } = v1.metadata.tool[part.toolInvocation.toolCallId] ?? {}
+                if (part.toolInvocation.state === "call") {
+                  return {
+                    status: "running",
+                    input: part.toolInvocation.args,
+                    time: {
+                      start: time?.start,
+                    },
+                  }
+                }
+
+                if (part.toolInvocation.state === "result") {
+                  return {
+                    status: "completed",
+                    input: part.toolInvocation.args,
+                    output: part.toolInvocation.result,
+                    title,
+                    time,
+                    metadata,
+                  }
+                }
+                throw new Error("unknown tool invocation state")
+              })(),
+            },
+          ]
+        }
+        return []
+      })
+      return {
+        info,
+        parts,
+      }
+    }
+
+    if (v1.role === "user") {
+      const info: User = {
+        id: v1.id,
+        sessionID: v1.metadata.sessionID,
+        role: "user",
+        time: {
+          created: v1.metadata.time.created,
+        },
+      }
+      const parts = v1.parts.flatMap((part): Part[] => {
+        const base = {
+          id: Identifier.ascending("part"),
+          messageID: v1.id,
+          sessionID: v1.metadata.sessionID,
+        }
+        if (part.type === "text") {
+          return [
+            {
+              ...base,
+              type: "text",
+              text: part.text,
+            },
+          ]
+        }
+        if (part.type === "file") {
+          return [
+            {
+              ...base,
+              type: "file",
+              mime: part.mediaType,
+              filename: part.filename,
+              url: part.url,
+            },
+          ]
+        }
+        return []
+      })
+      return { info, parts }
+    }
+
+    throw new Error("unknown message type")
+  }
+
+  export function toModelMessage(
+    input: {
+      info: Info
+      parts: Part[]
+    }[],
+  ): ModelMessage[] {
+    const result: UIMessage[] = []
+
+    for (const msg of input) {
+      if (msg.parts.length === 0) continue
+
+      if (msg.info.role === "user") {
+        result.push({
+          id: msg.info.id,
+          role: "user",
+          parts: msg.parts.flatMap((part): UIMessage["parts"] => {
+            if (part.type === "text")
+              return [
+                {
+                  type: "text",
+                  text: part.text,
+                },
+              ]
+            // text/plain files are converted into text parts, ignore them
+            if (part.type === "file" && part.mime !== "text/plain")
+              return [
+                {
+                  type: "file",
+                  url: part.url,
+                  mediaType: part.mime,
+                  filename: part.filename,
+                },
+              ]
+            return []
+          }),
+        })
+      }
+
+      if (msg.info.role === "assistant") {
+        result.push({
+          id: msg.info.id,
+          role: "assistant",
+          parts: msg.parts.flatMap((part): UIMessage["parts"] => {
+            if (part.type === "text")
+              return [
+                {
+                  type: "text",
+                  text: part.text,
+                },
+              ]
+            if (part.type === "step-start")
+              return [
+                {
+                  type: "step-start",
+                },
+              ]
+            if (part.type === "tool") {
+              if (part.state.status === "completed")
+                return [
+                  {
+                    type: ("tool-" + part.tool) as `tool-${string}`,
+                    state: "output-available",
+                    toolCallId: part.callID,
+                    input: part.state.input,
+                    output: part.state.output,
+                  },
+                ]
+              if (part.state.status === "error")
+                return [
+                  {
+                    type: ("tool-" + part.tool) as `tool-${string}`,
+                    state: "output-error",
+                    toolCallId: part.callID,
+                    input: part.state.input,
+                    errorText: part.state.error,
+                  },
+                ]
+            }
+
+            return []
+          }),
+        })
+      }
+    }
+
+    return convertToModelMessages(result)
+  }
+}

packages/opencode/src/session/message.ts

@@ -0,0 +1,189 @@
+import z from "zod"
+import { NamedError } from "../util/error"
+
+export namespace Message {
+  export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
+  export const AuthError = NamedError.create(
+    "ProviderAuthError",
+    z.object({
+      providerID: z.string(),
+      message: z.string(),
+    }),
+  )
+
+  export const ToolCall = z
+    .object({
+      state: z.literal("call"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+    })
+    .openapi({
+      ref: "ToolCall",
+    })
+  export type ToolCall = z.infer<typeof ToolCall>
+
+  export const ToolPartialCall = z
+    .object({
+      state: z.literal("partial-call"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+    })
+    .openapi({
+      ref: "ToolPartialCall",
+    })
+  export type ToolPartialCall = z.infer<typeof ToolPartialCall>
+
+  export const ToolResult = z
+    .object({
+      state: z.literal("result"),
+      step: z.number().optional(),
+      toolCallId: z.string(),
+      toolName: z.string(),
+      args: z.custom<Required<unknown>>(),
+      result: z.string(),
+    })
+    .openapi({
+      ref: "ToolResult",
+    })
+  export type ToolResult = z.infer<typeof ToolResult>
+
+  export const ToolInvocation = z.discriminatedUnion("state", [ToolCall, ToolPartialCall, ToolResult]).openapi({
+    ref: "ToolInvocation",
+  })
+  export type ToolInvocation = z.infer<typeof ToolInvocation>
+
+  export const TextPart = z
+    .object({
+      type: z.literal("text"),
+      text: z.string(),
+    })
+    .openapi({
+      ref: "TextPart",
+    })
+  export type TextPart = z.infer<typeof TextPart>
+
+  export const ReasoningPart = z
+    .object({
+      type: z.literal("reasoning"),
+      text: z.string(),
+      providerMetadata: z.record(z.any()).optional(),
+    })
+    .openapi({
+      ref: "ReasoningPart",
+    })
+  export type ReasoningPart = z.infer<typeof ReasoningPart>
+
+  export const ToolInvocationPart = z
+    .object({
+      type: z.literal("tool-invocation"),
+      toolInvocation: ToolInvocation,
+    })
+    .openapi({
+      ref: "ToolInvocationPart",
+    })
+  export type ToolInvocationPart = z.infer<typeof ToolInvocationPart>
+
+  export const SourceUrlPart = z
+    .object({
+      type: z.literal("source-url"),
+      sourceId: z.string(),
+      url: z.string(),
+      title: z.string().optional(),
+      providerMetadata: z.record(z.any()).optional(),
+    })
+    .openapi({
+      ref: "SourceUrlPart",
+    })
+  export type SourceUrlPart = z.infer<typeof SourceUrlPart>
+
+  export const FilePart = z
+    .object({
+      type: z.literal("file"),
+      mediaType: z.string(),
+      filename: z.string().optional(),
+      url: z.string(),
+    })
+    .openapi({
+      ref: "FilePart",
+    })
+  export type FilePart = z.infer<typeof FilePart>
+
+  export const StepStartPart = z
+    .object({
+      type: z.literal("step-start"),
+    })
+    .openapi({
+      ref: "StepStartPart",
+    })
+  export type StepStartPart = z.infer<typeof StepStartPart>
+
+  export const MessagePart = z
+    .discriminatedUnion("type", [TextPart, ReasoningPart, ToolInvocationPart, SourceUrlPart, FilePart, StepStartPart])
+    .openapi({
+      ref: "MessagePart",
+    })
+  export type MessagePart = z.infer<typeof MessagePart>
+
+  export const Info = z
+    .object({
+      id: z.string(),
+      role: z.enum(["user", "assistant"]),
+      parts: z.array(MessagePart),
+      metadata: z
+        .object({
+          time: z.object({
+            created: z.number(),
+            completed: z.number().optional(),
+          }),
+          error: z
+            .discriminatedUnion("name", [AuthError.Schema, NamedError.Unknown.Schema, OutputLengthError.Schema])
+            .optional(),
+          sessionID: z.string(),
+          tool: z.record(
+            z.string(),
+            z
+              .object({
+                title: z.string(),
+                snapshot: z.string().optional(),
+                time: z.object({
+                  start: z.number(),
+                  end: z.number(),
+                }),
+              })
+              .catchall(z.any()),
+          ),
+          assistant: z
+            .object({
+              system: z.string().array(),
+              modelID: z.string(),
+              providerID: z.string(),
+              path: z.object({
+                cwd: z.string(),
+                root: z.string(),
+              }),
+              cost: z.number(),
+              summary: z.boolean().optional(),
+              tokens: z.object({
+                input: z.number(),
+                output: z.number(),
+                reasoning: z.number(),
+                cache: z.object({
+                  read: z.number(),
+                  write: z.number(),
+                }),
+              }),
+            })
+            .optional(),
+          snapshot: z.string().optional(),
+        })
+        .openapi({ ref: "MessageMetadata" }),
+    })
+    .openapi({
+      ref: "Message",
+    })
+  export type Info = z.infer<typeof Info>
+}

packages/opencode/src/session/mode.ts

@@ -0,0 +1,72 @@
+import { App } from "../app/app"
+import { Config } from "../config/config"
+import z from "zod"
+import { Provider } from "../provider/provider"
+
+export namespace Mode {
+  export const Info = z
+    .object({
+      name: z.string(),
+      temperature: z.number().optional(),
+      model: z
+        .object({
+          modelID: z.string(),
+          providerID: z.string(),
+        })
+        .optional(),
+      prompt: z.string().optional(),
+      tools: z.record(z.boolean()),
+    })
+    .openapi({
+      ref: "Mode",
+    })
+  export type Info = z.infer<typeof Info>
+  const state = App.state("mode", async () => {
+    const cfg = await Config.get()
+    const model = cfg.model ? Provider.parseModel(cfg.model) : undefined
+    const result: Record<string, Info> = {
+      build: {
+        model,
+        name: "build",
+        tools: {},
+      },
+      plan: {
+        name: "plan",
+        model,
+        tools: {
+          write: false,
+          edit: false,
+          patch: false,
+        },
+      },
+    }
+    for (const [key, value] of Object.entries(cfg.mode ?? {})) {
+      if (value.disable) continue
+      let item = result[key]
+      if (!item)
+        item = result[key] = {
+          name: key,
+          tools: {},
+        }
+      item.name = key
+      if (value.model) item.model = Provider.parseModel(value.model)
+      if (value.prompt) item.prompt = value.prompt
+      if (value.temperature) item.temperature = value.temperature
+      if (value.tools)
+        item.tools = {
+          ...value.tools,
+          ...item.tools,
+        }
+    }
+
+    return result
+  })
+
+  export async function get(mode: string) {
+    return state().then((x) => x[mode])
+  }
+
+  export async function list() {
+    return state().then((x) => Object.values(x))
+  }
+}

packages/opencode/src/session/prompt/anthropic.txt

@@ -0,0 +1,161 @@
+You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: Refuse to write code or explain code that may be used maliciously; even if the user claims it is for educational purposes. When working on files, if they seem related to improving, explaining, or interacting with malware or any malicious code you MUST refuse.
+IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. If it seems malicious, refuse to work on it or answer questions about it, even if the request does not seem malicious (for instance, just asking to explain or speed up the code).
+IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+If the user asks for help or wants to give feedback inform them of the following: 
+- /help: Get help with using opencode
+- To give feedback, users should report the issue at https://github.com/sst/opencode/issues
+
+When the user directly asks about opencode (eg 'can opencode do...', 'does opencode have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the WebFetch tool to gather information to answer the question from opencode docs at https://opencode.ai
+
+# Tone and style
+You should be concise, direct, and to the point. When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
+Remember that your output will be displayed on a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
+<example>
+user: 2 + 2
+assistant: 4
+</example>
+
+<example>
+user: what is 2+2?
+assistant: 4
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+<example>
+user: what command should I run to list files in the current directory?
+assistant: ls
+</example>
+
+<example>
+user: what command should I run to watch files in the current directory?
+assistant: [use the ls tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
+npm run dev
+</example>
+
+<example>
+user: How many golf balls fit inside a jetta?
+assistant: 150000
+</example>
+
+<example>
+user: what files are in the directory src/?
+assistant: [runs ls and sees foo.c, bar.c, baz.c]
+user: which file contains the implementation of foo?
+assistant: src/foo.c
+</example>
+
+<example>
+user: write tests for new feature
+assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests]
+</example>
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+1. Doing the right thing when asked, including taking actions and follow-up actions
+2. Not surprising the user with actions you take without asking
+For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+
+# Following conventions
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
+- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
+- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+
+# Code style
+- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
+
+
+# Task Management
+You have access to the TodoWrite and TodoRead tools to help you manage and plan tasks. Use these tools VERY frequently to ensure that you are tracking your tasks and giving the user visibility into your progress.
+These tools are also EXTREMELY helpful for planning tasks, and for breaking down larger complex tasks into smaller steps. If you do not use this tool when planning, you may forget to do important tasks - and that is unacceptable.
+
+It is critical that you mark todos as completed as soon as you are done with a task. Do not batch up multiple tasks before marking them as completed.
+
+Examples:
+
+<example>
+user: Run the build and fix any type errors
+assistant: I'm going to use the TodoWrite tool to write the following items to the todo list: 
+- Run the build
+- Fix any type errors
+
+I'm now going to run the build using Bash.
+
+Looks like I found 10 type errors. I'm going to use the TodoWrite tool to write 10 items to the todo list.
+
+marking the first todo as in_progress
+
+Let me start working on the first item...
+
+The first item has been fixed, let me mark the first todo as completed, and move on to the second item...
+..
+..
+</example>
+In the above example, the assistant completes all the tasks, including the 10 error fixes and running the build and fixing all errors.
+
+<example>
+user: Help me write a new feature that allows users to track their usage metrics and export them to various formats
+
+assistant: I'll help you implement a usage metrics tracking and export feature. Let me first use the TodoWrite tool to plan this task.
+Adding the following todos to the todo list:
+1. Research existing metrics tracking in the codebase
+2. Design the metrics collection system
+3. Implement core metrics tracking functionality
+4. Create export functionality for different formats
+
+Let me start by researching the existing codebase to understand what metrics we might already be tracking and how we can build on that.
+
+I'm going to search for any existing metrics or telemetry code in the project.
+
+I've found some existing telemetry code. Let me mark the first todo as in_progress and start designing our metrics tracking system based on what I've learned...
+
+[Assistant continues implementing the feature step by step, marking todos as in_progress and completed as they go]
+</example>
+
+
+# Doing tasks
+The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
+- Use the TodoWrite tool to plan the task if required
+- Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially.
+- Implement the solution using all tools available to you
+- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
+- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (eg. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
+NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+# Tool usage policy
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
+- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple bash tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
+
+You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
+
+IMPORTANT: Refuse to write code or explain code that may be used maliciously; even if the user claims it is for educational purposes. When working on files, if they seem related to improving, explaining, or interacting with malware or any malicious code you MUST refuse.
+IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure. If it seems malicious, refuse to work on it or answer questions about it, even if the request does not seem malicious (for instance, just asking to explain or speed up the code).
+
+IMPORTANT: Always use the TodoWrite tool to plan and track tasks throughout the conversation.
+
+# Code References
+
+When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
+
+<example>
+user: Where are errors from the client handled?
+assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
+</example>
+

packages/opencode/src/session/prompt/anthropic_spoof.txt

@@ -0,0 +1 @@
+You are Claude Code, Anthropic's official CLI for Claude.