opencode-kiro 0.4.0 → 0.5.0-beta.2

package/README.md

@@ -1,22 +1,48 @@
 # opencode-kiro
 
-The ACP-compliant [Kiro](https://kiro.dev) auth plugin for [opencode](https://opencode.ai).
-
-opencode learns the `kiro` provider and its available models (US region) from the
-[models.dev](https://models.dev) catalog. This plugin supplies the following pieces:
-
-- **Auth** via the official `kiro-cli` login flow (`opencode auth login`, then "Kiro CLI Login")
-- **Provider options loader**: the `cwd`, `agent`, `trustAllTools`, `mcpTimeout` values
-  opencode forwards into the SDK factory
-- **TUI credits display**: an opt-in Kiro credits box in the sidebar (appended below the
-  native Context box) plus a matching footer credits chip
+> ⚠️ **Experimental prerelease** — `0.5.0-beta.2` targets the **unreleased OpenCode v2**
+> plugin contract at a pinned snapshot. It does **not** work with OpenCode v1.
+> v1 users: stay on **`opencode-kiro@0.4.0`** (the `main` branch / npm `latest` line,
+> which remains the supported stable release). See
+> [RELEASE_NOTES_0.5.0-beta.2.md](./RELEASE_NOTES_0.5.0-beta.2.md) and
+> [PINNED_VERSIONS.md](./PINNED_VERSIONS.md) for exact pins and the tested OpenCode SHA.
+> No OpenCode v2 release date is known or claimed here.
+
+The ACP-compliant [Kiro](https://kiro.dev) plugin for [opencode](https://opencode.ai).
+
+The plugin supplies:
+
+- **Auth** via the official `kiro-cli` login flow: it registers the `kiro` integration
+  with a **Kiro CLI Login** OAuth method (`opencode auth login`)
+- **Model discovery**: after auth it captures Kiro's live model lineup and merges it
+  into OpenCode's catalog (exact ID intersection, reasoning-effort variants), with a
+  minimal self-registration fallback when the catalog lacks a `kiro` entry
+- **Provider ownership**: an AISDK hook constructs the provider from
+  [`kiro-acp-ai-provider`](https://www.npmjs.com/package/kiro-acp-ai-provider) with the
+  right options (`cwd`, `agent`, `trustAllTools`, `mcpTimeout`, `contextWindows`)
+- **TUI credits display**: a live Kiro credits box in the sidebar and a compact
+  credits chip in the prompt footer row beside the host cost/context display, both
+  styled with the host's active theme tokens — auto-loaded from the same single
+  config entry (`tui: true`)
+
+`kiro-acp-ai-provider` talks to your locally installed `kiro-cli` over Kiro's
+[Agent Client Protocol](https://agentclientprotocol.com) (ACP). This is the supported
+integration path: requests go through kiro-cli exactly like Kiro's own IDE clients,
+with no credential scraping and no reuse of Kiro credentials against other providers.
+
+## Compatibility
+
+This prerelease is built and tested against **one pinned OpenCode v2 snapshot**:
+
+| Item | Value |
+|---|---|
+| Tested OpenCode commit (`upstream/v2`) | `1cf61593b5ec204619b3f679fe418fec10ca5934` |
+| `@opencode-ai/plugin` | `0.0.0-dev-17968` (exact) |
+| Package version | `0.5.0-beta.2` |
 
-The `kiro` provider resolves to [`kiro-acp-ai-provider`](https://www.npmjs.com/package/kiro-acp-ai-provider),
-an AI-SDK provider that talks to your locally installed `kiro-cli` over Kiro's
-[Agent Client Protocol](https://agentclientprotocol.com) (ACP); opencode picks it up from
-the catalog's `npm` field. This is the supported integration path: requests go through
-kiro-cli exactly like Kiro's own IDE clients, with no credential scraping and no reuse of
-Kiro credentials against other providers.
+Full pin table and verification evidence: [PINNED_VERSIONS.md](./PINNED_VERSIONS.md).
+There is no `engines.opencode` constraint — the v2 host has no stable semver yet; the
+tested SHA above is the compatibility target. Other v2 snapshots may or may not work.
 
 ## Prerequisites
 
@@ -24,83 +50,85 @@ Kiro credentials against other providers.
 |---|---|
 | [kiro-cli](https://kiro.dev/docs/cli/) | Must be installed and on `PATH`; a Kiro subscription / AWS Builder ID account |
 | [Node.js](https://nodejs.org) `>= 20` | Enforced via `engines.node`. |
-| opencode `>= 1.16.0` | Enforced via `engines.opencode` on released builds. The shipped catalog must include the `kiro` provider (see [Troubleshooting](#troubleshooting)). |
-
-## Install
-
-```bash
-opencode plugin opencode-kiro
-```
-
-(alias: `opencode plug opencode-kiro`; add `--global`/`-g` to install into your global config instead of the project)
-
-The installer reads this package's `exports` and detects both plugin entrypoints
-(`./server` and `./tui`), then patches **both** config files automatically:
-
-- `.opencode/opencode.json`: the server plugin (auth)
-- `.opencode/tui.json`: the TUI plugin (credits sidebar box + footer chip)
-
-(with `--global`: `~/.config/opencode/opencode.json` and `~/.config/opencode/tui.json`)
+| OpenCode v2 at the tested snapshot | See [Compatibility](#compatibility). This prerelease does not support OpenCode v1. |
 
-You do **not** add a `provider.kiro` block; opencode loads the `kiro` provider and its
-models straight from the models.dev catalog. See
-[Credits in the sidebar](#credits-in-the-sidebar) for what the TUI plugin adds.
+## Install and configure
 
-### Manual alternative
+**One config entry — that's the whole setup.** Add the package to the **`plugins`**
+array (plural) of your OpenCode config (`opencode.json`, project or global):
 
-Add the package name to the `plugin` array of **both** files yourself (in the
-project's `.opencode/` directory, at the project root, or in the global
-`~/.config/opencode/`, all are valid config locations):
+```json
+{
+  "plugins": ["opencode-kiro@0.5.0-beta.2"]
+}
+```
 
-`opencode.json`:
+The object form pins the same version and leaves room for future options:
 
 ```json
 {
-  "plugin": ["opencode-kiro"]
+  "plugins": [
+    {
+      "package": "opencode-kiro@0.5.0-beta.2",
+      "options": {}
+    }
+  ]
 }
 ```
 
-`tui.json`:
+This loads the server entry (`./server` export): auth, model discovery, and provider
+ownership. The server plugin declares **`tui: true`**, so the host TUI **auto-loads the
+package's `./tui` entrypoint by itself** — the sidebar credits box and the composer
+credits chip appear with no further configuration. **No `cli.json` TUI entry is
+needed.** (The beta.1 two-file setup is obsolete: if you added `"opencode-kiro"` to
+your global `cli.json` `plugins` array for beta.1, remove it.)
+
+### Disabling
+
+One `"-kiro"` directive in the same `plugins` array disables **everything**: it removes
+the server plugin, and with it the `tui: true` auto-load, so the TUI half never
+activates either:
 
 ```json
 {
-  "plugin": ["opencode-kiro"]
+  "plugins": ["opencode-kiro@0.5.0-beta.2", "-kiro"]
 }
 ```
 
-That single `plugin` entry is all the [credits sidebar](#credits-in-the-sidebar) box and
-footer chip need; there is no `plugin_enabled` step.
+### Legacy `tui.json` (v1)
+
+`tui.json` is **legacy v1 configuration** and, under v2, is **migration input only**:
+the host may read it when migrating old setups, and this plugin **never modifies it**.
+Do not add new entries to `tui.json` (or to `cli.json` — neither is used by this
+plugin anymore); the single `plugins` entry above is the only configuration.
 
 ### Local development (path source)
 
-Run a local checkout without npm: build first, then reference the repo directory by
-absolute path in both `plugin` arrays:
+Run a local checkout without npm — build and pack first, then reference the tarball
+with the `name@file:` form in the `plugins` array:
 
 ```bash
 git clone https://github.com/NachoFLizaur/opencode-kiro && cd opencode-kiro
-npm install && npm run build
+npm install && npm run build && npm pack
 ```
 
 ```json
-{ "plugin": ["/absolute/path/to/opencode-kiro"] }
+{ "plugins": ["opencode-kiro@file:/absolute/path/to/opencode-kiro-0.5.0-beta.2.tgz"] }
 ```
 
-opencode resolves the right entrypoint per file from the package `exports`. Note that
-path-sourced TUI plugins **must export an `id`** (opencode rejects them otherwise);
-this package ships `{ id: "opencode-kiro", tui }`, so the id is identical across path
-and npm installs.
-
-Because the provider now comes from the catalog rather than the plugin, a local checkout
-also needs a catalog that includes `kiro`. opencode reads its catalog from
-`OPENCODE_MODELS_PATH` when set; point it at an `api.json` that contains the `kiro`
-provider (for example one generated from a [models.dev](https://models.dev) checkout):
-
-```bash
-OPENCODE_MODELS_PATH=/path/to/api.json opencode models | grep '^kiro/'
-```
+A bare path or bare `file:` spec is rejected at the tested SHA — the `name@file:` form
+is required. **Caveat (local `file:` installs only)**: the colon in the resulting
+install dirname defeats the host's OpenTUI loader shim, so the TUI surfaces render a
+contained per-slot error notice instead of the credits views (the rest of the TUI keeps
+working). Registry installs (`opencode-kiro@0.5.0-beta.2`) use colon-free paths and are
+fully green — this affects local tarball validation only.
 
-Until the catalog opencode loads contains `kiro`, the provider will not appear regardless
-of this plugin being installed (the plugin only adds auth, not the provider definition).
+The host resolves entrypoints from the package `exports` (`./server` for the server
+half, `./tui` for the auto-loaded TUI half). Each entry module exports its own `id`:
+the server plugin's id is `kiro` and the TUI plugin's id is `opencode-kiro`. Under
+`tui: true` there is no separate TUI directive to manage — `-kiro` (the server id) is
+the single kill-switch, and host logs use `kiro` for the server half and
+`opencode-kiro` for the TUI half.
 
 ## Auth
 
@@ -108,24 +136,33 @@ of this plugin being installed (the plugin only adds auth, not the provider defi
 opencode auth login
 ```
 
-Select the **Kiro (plugin)** provider, then the **Kiro CLI Login** method:
+Select the **Kiro** integration, then the **Kiro CLI Login** method:
 
 - **Already logged in to kiro-cli**: immediate success; the existing kiro-cli session is reused.
 - **Not logged in**: the plugin launches `kiro-cli login`, which opens a browser window.
-  Complete the login there; the plugin polls for up to 120 seconds and stores the
-  credential when kiro-cli reports success.
+  Complete the login there; the plugin polls for up to 120 seconds and stores a minimal
+  credential record when kiro-cli reports success.
+
+There is no configuration prompt during login anymore: the beta.1
+"Enable the Kiro credits sidebar?" consent select was removed (upstream deleted the
+prompts API in favor of forms — and the sidebar no longer needs consent-driven config,
+since `tui: true` auto-loads it).
 
 If the flow times out, authenticate directly with kiro-cli (`kiro-cli login`) and run
 `opencode auth login` again; the fast path then completes immediately.
 
-> **Note:** opencode will also surface `kiro` if the `KIRO_API_KEY` environment variable
-> is set, because the catalog entry declares `env: ["KIRO_API_KEY"]`. The intended auth
-> path for this plugin is still **Kiro CLI Login** above (it reuses your local kiro-cli
-> session); the env var is a secondary route opencode offers for any catalog provider.
+kiro-cli owns credential storage and refresh — OpenCode never stores real AWS tokens,
+and the plugin implements no refresh callback.
 
 ## Models
 
-After authentication, the plugin exposes the exact, case-sensitive intersection of Kiro's runtime `modelId` values and the models.dev catalog's `model.api.id` values. The runtime `listModels()` result is authoritative: `runtimeEfforts` is always an array, an empty array leaves the matching catalog model unchanged, and nonempty arrays merge exact effort variants into the catalog. Existing variant metadata survives key collisions while the runtime effort sets `reasoningEffort`; an optional runtime `baselineEffort` sets the model's base effort. Successful discovery keeps every matching catalog key and all other metadata while omitting runtime-only and catalog-only IDs. A discovery exception or duplicate runtime ID preserves the exact original catalog unchanged.
+After authentication, the plugin captures Kiro's runtime model list and transforms
+OpenCode's catalog to the exact, case-sensitive intersection of runtime `modelId`
+values and catalog model IDs. Runtime reasoning-effort levels are merged as model
+variants (per model family, native levels only); an optional runtime baseline effort
+sets the model's base effort. A discovery failure or duplicate runtime ID leaves the
+catalog unchanged (fail-open). If the loaded catalog has no `kiro` provider at all, the
+plugin self-registers a minimal fallback entry so discovered models remain usable.
 
 List the resulting models with:
 
@@ -134,95 +171,87 @@ opencode models
 opencode run -m kiro/<exact-model-id> "hello"
 ```
 
-Image input is capability-driven: paste an image path into the TUI prompt and
-image-capable models receive it as an attachment.
-
-### Reasoning effort
-
-Effort-capable models expose a reasoning-effort toggle: cycle it in opencode with the
-**Cycle model variants** action (default keybind `ctrl+t`). It is **per model**, showing
-each family's native levels.
+Effort-capable models expose their variants through OpenCode's model-variant selection.
+The chosen level reaches the SDK through the provider-settings path: OpenCode overlays
+the selected variant's `settings` onto the model's `settings`, hands them to the
+plugin's `aisdk` hook as `event.options`, and the plugin passes them verbatim to
+`createKiroAcp({ effort })`. That is why the plugin emits the SDK's own `effort` key
+(not `reasoningEffort`) — and why the SDK factory setting, not per-call provider
+options, is the working carrier: OpenCode builds per-call `providerOptions` only for
+the first-party `@ai-sdk/*` provider families, so `providerOptions.kiro.*` is never
+populated for an `aisdk:` package provider like this one. Kiro cannot disable thinking,
+so even the lowest level still produces a reasoning trail.
 
-Models without effort control show no effort option. opencode's **Default** (unset) returns the model to its native
-default effort. No config is required: the plugin's `provider.models` hook supplies the
-variants automatically and the chosen level flows to the SDK as
-`providerOptions.kiro.reasoningEffort`. Kiro cannot disable thinking, so even the lowest
-level still produces a reasoning trail.
-
-## Credits in the sidebar
+## Credits in the TUI
 
 Kiro is subscription-metered: requests consume **credits**, and the dollar cost
-opencode normally displays for Kiro turns is always $0.00. To surface credits the
-plugin **appends** a small Kiro credits box in the sidebar, rendered right below the
-native **Context** box. It does **not** replace or disable any builtin section: the
-native Context box stays and keeps showing the usual tokens, context percentage, and
-cost.
-
-The credits box renders only for Kiro sessions; for a non-Kiro session it shows nothing,
-so that session's sidebar is unchanged. The credits value and its unit come from the
-metadata the SDK attaches to each message part (kiro-cli reports the unit); nothing is
-hardcoded client-side.
-
-All you need in `tui.json` is the plugin entry:
-
-```json
-{
-  "plugin": ["opencode-kiro"]
-}
-```
-
-There is no `plugin_enabled` step anymore.
-
-### Migrating from 0.2.1 and earlier
-
-Older versions replaced the native Context box with a clone and disabled the builtin via:
-
-```json
-{
-  "plugin_enabled": { "internal:sidebar-context": false }
-}
-```
-
-If you upgraded from 0.2.1 or earlier and still have that line in your `tui.json`,
-remove it yourself: the plugin no longer manages `plugin_enabled`. Once the line is
-gone the native Context box returns and shows the usual tokens / context % / cost, and
-the Kiro credits box appears in a separate box right below it.
-
-## Known limitation
-
-**Credits render in the TUI only.** Two TUI surfaces show them: the sidebar credits
-box (above) and the input/prompt meta row chip (`session_prompt_right`), which sits
-above the host's `$` cost chip. Every other cost surface (ACP clients, the web app,
-desktop, web share pages, and CLI cost output) shows $0.00 for Kiro sessions. The
-models.dev catalog declares Kiro's per-token `cost` as 0 (it is a subscription-metered
-provider with no per-token pricing), so opencode core computes $0.00 everywhere it
-renders dollar cost. That is expected, not a defect. A cross-surface credits display
-would require opencode core changes and is intentionally out of scope for this plugin.
+OpenCode normally displays for Kiro turns is always $0.00. To surface credits the TUI
+plugin renders two surfaces:
+
+- a Kiro credits box in the sidebar (`sidebar.content` claim), showing the session's
+  live credits total and unit
+- a compact credits chip in the prompt footer row beside the host cost/context
+  display (`prompt.footer.status` claim, v1 placement restored) with the same total
+
+Both are additive `append` claims — they compose with the host's built-in content and
+never replace it — and both pick up the active theme's text tokens (feature-detected;
+with no theme they fall back to default terminal styling). They render only for
+sessions that carry Kiro credit data; other sessions are unchanged. The credits value
+and unit come from the provider state the host persists on each message part
+(`part.state.credits` / `part.state.creditsUnit`); nothing is hardcoded client-side.
+The only configuration needed is the single `plugins` entry from
+[Install](#install-and-configure) — the TUI half auto-loads via `tui: true`.
+
+Durable credits are read straight from host message state (the host persists provider
+state on text end — fixed upstream since beta.1). While a turn is still streaming,
+credits for just-ended text are picked up live through a transient overlay that works
+around a host reducer bug at the pinned snapshot (the live event path still drops
+provider state); once durable state arrives it is authoritative and nothing is
+double-counted. See the release notes for details.
+
+## Known limitations (prerelease)
+
+- **Live text credits use a transient overlay.** The durable credits path is fixed
+  upstream, but the live `session.text.ended` reducer still drops provider state at
+  the tested SHA, so in-turn updates come from the plugin's transient overlay
+  (durable state always wins on reconcile). See
+  [Credits in the TUI](#credits-in-the-tui) and the release notes.
+- **Credits render in the TUI only.** Every other cost surface (ACP clients, web,
+  desktop, share pages, CLI cost output) shows $0.00 for Kiro sessions because the
+  catalog declares Kiro's per-token `cost` as 0 (subscription-metered, no per-token
+  pricing). That is expected, not a defect.
+- **Local `file:` installs show a per-slot TUI error.** The colon in a `name@file:`
+  install dirname defeats the host's OpenTUI loader shim; the failure is contained to
+  the plugin's slots (dismissible error notice, host TUI unaffected). Registry
+  installs are colon-free and fully working — this affects local tarball validation
+  only.
+- **Reduced toast feedback.** Auth-flow feedback is delivered as connect-flow text
+  rather than toasts; this plugin's core deliberately does not depend on the churning
+  TUI toast API.
+- **One tested snapshot.** All pins are exact and the compatibility target is a single
+  OpenCode v2 SHA (see [Compatibility](#compatibility)); other snapshots may not work.
 
 ## How it works
 
-- **Provider metadata and runtime models**: opencode loads the `kiro` provider and model
-  metadata from models.dev. After auth, this plugin keeps only exact catalog/runtime ID
-  matches, preserves catalog metadata, and projects the runtime-authoritative effort
-  options; a discovery exception or duplicate runtime ID keeps the input catalog unchanged.
-- **SDK resolution (resolveSDK)**: opencode reads the catalog's `npm` field
-  (`kiro-acp-ai-provider`), installs that package into its package cache on first model
-  use, and imports it. This plugin's `auth` loader supplies the provider options
-  (`cwd`, `agent`, `trustAllTools`, `mcpTimeout`, `contextWindows`) that opencode forwards
-  into `createKiroAcp(...)`. The loader relays each model's `limit.context` (from
-  models.dev, via opencode's resolved catalog) into the SDK's `contextWindows` map keyed
-  by `api.id`, so the SDK keeps no hardcoded per-model data and falls back to 1,000,000
-  for any model absent from the relay.
-- **Auth (this plugin)**: registers the "Kiro CLI Login" OAuth method (kiro-cli login
-  flow) plus the options loader above. The same plugin also imports `verifyAuth` from
-  `kiro-acp-ai-provider` to check kiro-cli installation/login state.
-- **Session affinity & reset (in-SDK)**: the SDK keys kiro-cli sessions off opencode's
-  `x-session-affinity` header, isolates tool-less utility calls (title generation) on
-  an ephemeral session, detects prompt-history divergence (`fork/undo`), and starts a
-  fresh kiro session when needed. No host-side session plumbing.
-- **Credits metadata**: the SDK attaches `{ kiro: { credits, creditsUnit } }` to the
-  `metadata` of the final message part of each turn; opencode persists it, and the TUI
-  plugin sums it per assistant message (deduped across text/reasoning parts) for the sidebar.
+- **Auth (Integration + Credential)**: the plugin upserts the `kiro` integration with a
+  "Kiro CLI Login" OAuth method. `verifyAuth` from `kiro-acp-ai-provider` is the auth
+  authority (it delegates to kiro-cli); success is stored as a minimal
+  `Credential.OAuth` presence record.
+- **Model discovery (catalog transform)**: after login (and on later login events) the
+  plugin runs `listModels()` outside the transform, then applies the validated capture
+  via a catalog transform and reload — exact ID matching, catalog metadata preserved,
+  effort variants projected, fail-open on any discovery error.
+- **Provider ownership (AISDK hook)**: the plugin's SDK hook always constructs the
+  provider from `kiro-acp-ai-provider` with the plugin-supplied options and sets it as
+  the event's SDK, so the Kiro provider is always plugin-owned. The options relay each
+  model's context window into the SDK's `contextWindows` map keyed by model ID.
+- **Session affinity & reset (in-SDK)**: the SDK keys kiro-cli sessions off OpenCode's
+  session affinity, isolates tool-less utility calls on an ephemeral session, detects
+  prompt-history divergence, and starts a fresh kiro session when needed.
+- **Credits state**: the SDK reports `credits` / `creditsUnit` in each turn's provider
+  metadata; OpenCode persists them key-unwrapped on message part state
+  (`part.state.credits`, `part.state.creditsUnit`), and the TUI plugin sums them per
+  assistant message (deduped across parts).
 
 ## Troubleshooting
 
@@ -230,11 +259,21 @@ would require opencode core changes and is intentionally out of scope for this p
 |---|---|
 | `kiro-cli is not installed` during auth | Install kiro-cli from <https://kiro.dev/docs/cli/> and ensure it is on `PATH` for the opencode process. |
 | Auth times out after ~120s | Complete the browser login faster, or run `kiro-cli login` yourself, then re-run `opencode auth login` (fast path). |
-| No credits line / credits stay 0 | Credits appear after the first **completed** kiro turn; cancelled turns and turns without usage metadata contribute nothing. Check the TUI plugin is `active` in the Plugins dialog (and listed in `tui.json`). |
-| Credits box never appears (even with `tui.json` configured correctly) | The TUI credits box renders only when `opencode-kiro` is resolvable in opencode's package cache. If the package is missing from the cache the box silently does not appear. Fix: ensure `opencode-kiro` is installed so it resolves in the cache. Do **not** manually clear the package cache: clearing can trigger a flaky on-demand refetch that fails with an "unknown git error". |
-| `kiro` provider not showing in `opencode models` | The provider comes from the models.dev catalog, not this plugin. Ensure your opencode version ships a catalog that includes `kiro` (run `opencode models --refresh` to update the cache). For local development, point opencode at a kiro-inclusive catalog via `OPENCODE_MODELS_PATH=/path/to/api.json` (see [Local development](#local-development-path-source)). |
-| Path install rejected (`must export id`) | Run `npm run build` in your checkout first and reference the repo root (both entry modules export ids). |
-| Provider visible but runs fail | The provider is selectable (from the catalog) before any credential exists. Run `opencode auth login` first. |
+| No credits line / credits stay 0 | Credits appear after the first **completed** kiro turn; cancelled turns and turns without usage state contribute nothing. Check the plugin is active (no stray `"-kiro"` directive — note that directive residue can persist on a reused data dir). |
+| Credits surfaces never appear | The TUI half auto-loads from the server `plugins` entry via `tui: true` — no separate TUI config exists. If the box/chip are missing, the server plugin itself is not loading (check your `plugins` entry and restart opencode). For local `name@file:` tarball installs, a contained per-slot error notice instead of the credits views is the known colon-path caveat; use a registry install. |
+| `kiro` provider not showing in `opencode models` | Run `opencode auth login` first: models are discovered after auth. If the loaded catalog lacks a `kiro` entry, the plugin self-registers a minimal fallback during discovery. |
+| Path install rejected (`must export id`) | Use the `name@file:<absolute tarball path>` form after `npm run build && npm pack` in your checkout (both entry modules export ids). |
+| Provider visible but runs fail | The provider can be selectable before any credential exists. Run `opencode auth login` first. |
+| Worked yesterday, broken today | This prerelease targets one pinned OpenCode snapshot (see [Compatibility](#compatibility)). If your OpenCode build moved past the tested SHA, the v2 plugin surface may have changed underneath it. |
+
+## Legacy: v1 / OpenCode v1 users (`0.4.0`)
+
+`opencode-kiro@0.4.0` on the `main` branch is the supported stable line for OpenCode
+v1 (`opencode >= 1.16.0`). It uses the v1 contract throughout: singular `plugin`
+arrays in `opencode.json` and `tui.json`, the `opencode plugin opencode-kiro`
+installer, and `part.metadata.kiro` credits. Its full documentation is the README at
+the [`v0.4.0` tag](https://github.com/NachoFLizaur/opencode-kiro/tree/v0.4.0)
+(equivalently, `main`). Do not install `0.5.0-beta.2` into an OpenCode v1 setup.
 
 ## Development
 

package/dist/chunk-M7OUVABX.js

@@ -0,0 +1,40 @@
+// src/tui/credits.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readCreditState(state) {
+  if (!isRecord(state)) return void 0;
+  if (typeof state.credits !== "number" || !Number.isFinite(state.credits)) return void 0;
+  return {
+    credits: state.credits,
+    unit: typeof state.creditsUnit === "string" && state.creditsUnit.length > 0 ? state.creditsUnit : void 0
+  };
+}
+function readPartCredits(part) {
+  if (!isRecord(part)) return void 0;
+  if (part.type !== "text" && part.type !== "reasoning") return void 0;
+  return readCreditState(part.state);
+}
+function messageCredits(parts) {
+  const carriers = parts.map(readPartCredits).filter((value) => value !== void 0);
+  const last = carriers.at(-1);
+  if (!last) return void 0;
+  return {
+    credits: last.credits,
+    unit: last.unit ?? carriers.findLast((carrier) => carrier.unit !== void 0)?.unit
+  };
+}
+var creditsAmount = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+function formatCredits(value, unit) {
+  const amount = creditsAmount.format(Number.isFinite(value) ? value : 0);
+  if (!unit) return amount;
+  const label = value === 1 || unit.endsWith("s") ? unit : `${unit}s`;
+  return `${amount} ${label}`;
+}
+var money = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });
+
+export {
+  readCreditState,
+  messageCredits,
+  formatCredits
+};

package/dist/credits-box-view-GLFJSV6M.js

@@ -0,0 +1,37 @@
+import {
+  formatCredits
+} from "./chunk-M7OUVABX.js";
+
+// src/tui/credits-box-view.ts
+import { createElement, insert, insertNode, setProp } from "@opentui/solid";
+import { createMemo } from "solid-js";
+function createCreditsBoxView(credits, tokens) {
+  const current = createMemo(credits);
+  const root = createElement("box");
+  insertNode(
+    root,
+    headerLine(() => current().present ? "Kiro" : "", tokens?.default)
+  );
+  insertNode(
+    root,
+    plainLine(() => current().present ? formatCredits(current().total, current().unit) : "", tokens?.subdued)
+  );
+  return root;
+}
+function headerLine(content, fg) {
+  const line = createElement("text");
+  if (fg !== void 0) setProp(line, "fg", fg);
+  const bold = createElement("b");
+  insert(bold, content);
+  insertNode(line, bold);
+  return line;
+}
+function plainLine(content, fg) {
+  const line = createElement("text");
+  if (fg !== void 0) setProp(line, "fg", fg);
+  insert(line, content);
+  return line;
+}
+export {
+  createCreditsBoxView
+};

package/dist/credits-chip-view-YP4RPX26.js

@@ -0,0 +1,20 @@
+import {
+  formatCredits
+} from "./chunk-M7OUVABX.js";
+
+// src/tui/credits-chip-view.ts
+import { createElement, insert, setProp } from "@opentui/solid";
+import { createMemo } from "solid-js";
+function createCreditsChipView(credits, tokens) {
+  const current = createMemo(credits);
+  const chip = createElement("text");
+  setProp(chip, "height", 1);
+  setProp(chip, "wrapMode", "none");
+  setProp(chip, "flexShrink", 0);
+  if (tokens?.subdued !== void 0) setProp(chip, "fg", tokens.subdued);
+  insert(chip, () => current().present ? formatCredits(current().total, current().unit) : "");
+  return chip;
+}
+export {
+  createCreditsChipView
+};

package/dist/server.d.ts

@@ -1,20 +1,7 @@
-import { Plugin, PluginInput, Hooks } from '@opencode-ai/plugin';
+import { Plugin } from '@opencode-ai/plugin';
 
-declare function kiroTokenPath(): string;
-declare function readToken(tokenPath: string | undefined): Promise<{
-    type: "success";
-    refresh: string;
-    access: string;
-    expires: number;
-} | {
-    type: "failed";
-}>;
-declare function notifyIfTokenExpired(client: PluginInput["client"] | undefined): Promise<void>;
-declare function enableSidebarConfig(path: string, input: PluginInput): Promise<void>;
-declare const KiroAuthPlugin: Plugin;
-declare const _default: {
-    id: string;
-    server: (input: PluginInput) => Promise<Hooks>;
-};
+declare const plugin: Plugin.Plugin;
 
-export { KiroAuthPlugin, _default as default, enableSidebarConfig, kiroTokenPath, notifyIfTokenExpired, readToken };
+declare const KiroAuthPlugin: Plugin.Plugin;
+
+export { KiroAuthPlugin, plugin as default };