@wular/coder 0.4.12 → 0.4.13

package/docs/sdk.md

@@ -21,36 +21,36 @@ SDK functions never print and never call `process.exit`; results come back as ty
 
 ## CLI to SDK mapping
 
-| CLI                                                                                    | SDK                                                                                                                                                                                                                                                   |
-| -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `coder run "<text>"`                                                                   | `task.run(prompt, opts?)`; `connections` narrows the task's connections                                                                                                                                                                              |
-| `coder list`                                                                           | `task.list(opts?)`                                                                                                                                                                                                                                    |
-| `coder result [id] [--wait] [--tail N] [--turns]`                                      | `task.result(id?, { wait?, tail? })` - returns `turns` (one entry per finished turn) alongside `result`                                                                                                                                               |
-| `coder task steer <id> "<text>"`                                                       | `task.steer(id, text, { model?, effort?, permissions?, wait? })` - live, or resumes a finished or archived task on the same id                                                                                                                        |
-| `coder task ask <id> "<question>"`                                                     | `task.ask(id, question, { model?, effort? })` - read-only sidecar answer; the task's thread is never touched                                                                                                                                          |
-| `coder task stop <id>`                                                                 | `task.stop(id)`                                                                                                                                                                                                                                       |
-| `coder task watch [id] [--tail N]`                                                     | `task.stream(id?, { tail? })` - async iterable of progress events                                                                                                                                                                                     |
-| `coder task approvals [id]`                                                            | `task.approvals(id?)`                                                                                                                                                                                                                                 |
-| `coder task approve <id> <appr>`                                                       | `task.approve(id, approvalId, { deny? })`                                                                                                                                                                                                             |
-| `coder task archive / delete <id>`                                                     | `task.archive(id)` / `task.delete(id)`                                                                                                                                                                                                                |
-| `coder flow run / list / discover / result / watch / stop / resume / archive / delete` | the matching `flow.*` function; `flow.run(nameOrPath, { args?, concurrency?, maxTasks? })`, `flow.stream(id?)` for `watch`                                                                                                                            |
-| `coder model add / update / remove / list / alias / unalias / disable / enable`        | the matching `model.*` function                                                                                                                                                                                                                       |
-| `coder config get / set`                                                               | `config.get(key?)` / `config.set(key, value)`                                                                                                                                                                                                         |
+| CLI                                                                                    | SDK                                                                                                                                                                                                                                                                                                           |
+| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `coder run "<text>"`                                                                   | `task.run(prompt, opts?)`; `connections` narrows the task's connections                                                                                                                                                                                                                                       |
+| `coder list`                                                                           | `task.list(opts?)` - one page, `{ items, next? }`; pass `next` as `cursor`                                                                                                                                                                                                                                    |
+| `coder result [id] [--wait] [--tail N] [--turns]`                                      | `task.result(id?, { wait?, tail? })` - returns `turns` (one entry per finished turn) alongside `result`                                                                                                                                                                                                       |
+| `coder task steer <id> "<text>"`                                                       | `task.steer(id, text, { model?, effort?, permissions?, wait? })` - live, or resumes a finished or archived task on the same id                                                                                                                                                                                |
+| `coder task ask <id> "<question>"`                                                     | `task.ask(id, question, { model?, effort? })` - read-only sidecar answer; the task's thread is never touched                                                                                                                                                                                                  |
+| `coder task stop <id>`                                                                 | `task.stop(id)`                                                                                                                                                                                                                                                                                               |
+| `coder task watch [id] [--tail N]`                                                     | `task.stream(id?, { tail? })` - async iterable of progress events                                                                                                                                                                                                                                             |
+| `coder task approvals [id]`                                                            | `task.approvals(id?)`                                                                                                                                                                                                                                                                                         |
+| `coder task approve <id> <appr>`                                                       | `task.approve(id, approvalId, { deny? })`                                                                                                                                                                                                                                                                     |
+| `coder task archive / delete <id>`                                                     | `task.archive(id)` / `task.delete(id)`                                                                                                                                                                                                                                                                        |
+| `coder flow run / list / discover / result / watch / stop / resume / archive / delete` | the matching `flow.*` function; `flow.run(nameOrPath, { args?, concurrency?, maxTasks? })`, `flow.stream(id?)` for `watch`                                                                                                                                                                                    |
+| `coder model add / update / remove / list / alias / unalias / disable / enable`        | the matching `model.*` function                                                                                                                                                                                                                                                                               |
+| `coder config get / set`                                                               | `config.get(key?)` / `config.set(key, value)`                                                                                                                                                                                                                                                                 |
 | `coder connection add / list / rm / reconnect / approve`                               | `connection.add(name, { env?, url?, command?, key?, askKey?, header?, access?, me?, credential?, onAuthorize?, server? })` / `connection.list()` / `connection.remove(name)` / `connection.reconnect(name, { key?, askKey?, onAuthorize? })` / `connection.approve(name, { agent? })`, all with `{ server? }` |
-| `coder setup-host [hosts...]`                                                          | `setupHost(hosts?)`                                                                                                                                                                                                                                   |
-| `coder upgrade`                                                                        | `upgrade({ cliOnly?, pluginsOnly? })`                                                                                                                                                                                                                 |
-| `coder docs [topic]`                                                                   | `docs(topic?)`                                                                                                                                                                                                                                        |
-| `coder review [--base] [--head] [--pr] [--since] [--post]`                             | `review.run({ base?, head?, pr?, since?, post?, engine?, model?, effort? })` - returns `{ findings, summary, runId }`                                                                                                                                 |
-| `coder auth login [--server] [--workspace] [--device] [--yes]`                         | `auth.login({ server?, organization?, device?, yes?, onCode?, open?, save? })` - the same Wular Auth sign-in; `open` gets the browser URL, `device` switches to the code flow; pass the workspace slug as `organization` when the account has several |
-| `coder auth logout / status`                                                           | `auth.logout({ server? })` / `auth.status()` - the saved sessions, never their tokens                                                                                                                                                                 |
-| `coder task <verb> --server [url]`                                                     | every `task.*` above with `{ server: true \| url, organization?, token?, yes? }` - acts on your server's tasks instead of local tasks                                                                                                                 |
-| `coder agent list / show <id> / init [id] / push [id]`                                 | `agent.list({ server? })` / `agent.show(id, { server? })` / `agent.init(id)` / `agent.push(id?, { cwd?, server? })`                                                                                                                                  |
-| `coder agent integrations list / show <id>`                                            | `agent.integrations.list()` / `agent.integrations.show(id)`                                                                                                                                                                                           |
-| `coder agent run <agent> <event.json> [--server]`                                      | `agent.run(agent, event, { server?, wait?, flow?, cwd? })` - local, tools off; with `server`, a real task                                                                                                                                             |
-| `coder agent run --task <id>`                                                          | `agent.runTask(id, options?)` - the runner form, not for application code                                                                                                                                                                             |
-| `coder credentials list / add / remove`                                                | `credentials.list()` / `.add({ env, value?, workspace?, noCheck? })` / `.remove(name, { workspace? })`, all with `{ server? }`                                                                                                                       |
-| `coder agent usage [--since] [--by]`                                                   | `agent.usage({ since?, by?, server?, cwd? })`                                                                                                                                                                                                         |
-| `coder server serve / rotate-key`                                                                        | `server.serve(options?)` / `server.rotateKey(options?)`; `server.handler(env)` for serverless hosts, see [Self-hosting](self-host.md#deploy)                                                                                                                                                                                                                 |
+| `coder setup-host [hosts...]`                                                          | `setupHost(hosts?)`                                                                                                                                                                                                                                                                                           |
+| `coder upgrade`                                                                        | `upgrade({ cliOnly?, pluginsOnly? })`                                                                                                                                                                                                                                                                         |
+| `coder docs [topic]`                                                                   | `docs(topic?)`                                                                                                                                                                                                                                                                                                |
+| `coder review [--base] [--head] [--pr] [--since] [--post]`                             | `review.run({ base?, head?, pr?, since?, post?, engine?, model?, effort? })` - returns `{ findings, summary, runId }`                                                                                                                                                                                         |
+| `coder auth login [--server] [--workspace] [--device] [--yes]`                         | `auth.login({ server?, organization?, device?, yes?, onCode?, open?, save? })` - the same Wular Auth sign-in; `open` gets the browser URL, `device` switches to the code flow; pass the workspace slug as `organization` when the account has several                                                         |
+| `coder auth logout / status`                                                           | `auth.logout({ server? })` / `auth.status()` - the saved sessions, never their tokens                                                                                                                                                                                                                         |
+| `coder task <verb> --server [url]`                                                     | every `task.*` above with `{ server: true \| url, organization?, token?, yes? }` - acts on your server's tasks instead of local tasks                                                                                                                                                                         |
+| `coder agent list / show <id> / init [id] / push [id]`                                 | `agent.list({ server? })` / `agent.show(id, { server? })` / `agent.init(id)` / `agent.push(id?, { cwd?, server? })`                                                                                                                                                                                           |
+| `coder agent integrations list / show <id>`                                            | `agent.integrations.list()` / `agent.integrations.show(id)`                                                                                                                                                                                                                                                   |
+| `coder agent run <agent> <event.json> [--server]`                                      | `agent.run(agent, event, { server?, wait?, flow?, cwd? })` - local, tools off; with `server`, a real task                                                                                                                                                                                                     |
+| `coder agent run --task <id>`                                                          | `agent.runTask(id, options?)` - the runner form, not for application code                                                                                                                                                                                                                                     |
+| `coder credentials list / add / remove`                                                | `credentials.list()` / `.add({ env, value?, workspace?, noCheck? })` / `.remove(name, { workspace? })`, all with `{ server? }`                                                                                                                                                                                |
+| `coder agent usage [--since] [--by]`                                                   | `agent.usage({ since?, by?, server?, cwd? })`                                                                                                                                                                                                                                                                 |
+| `coder server serve / rotate-key`                                                      | `server.serve(options?)` / `server.rotateKey(options?)`; `server.handler(env)` for serverless hosts, see [Self-hosting](self-host.md#deploy)                                                                                                                                                                  |
 
 Options objects take the same names as the CLI flags, camelCased (`--max-tasks` becomes `maxTasks`, `--server` becomes `server`). Every server option accepts `organization`, the `--workspace` flag's slug, which overrides the saved workspace for that call. `server` falls back to `CODER_SERVER`, then the hosted service; authentication comes from `auth.login()`, or from `token` when supplied; `yes: true` acknowledges the first use of a new server origin in non-interactive code.
 

package/docs/self-host.md

@@ -21,7 +21,7 @@ Required variables carry a *.
 | `HOST`                                     | address                                                                    | `127.0.0.1` without a database, else all        | Listen address. A local server listens on loopback only ([Modes](#modes))                                                                                                                                                                                                                                                                                                                                                                           |
 | `ADMIN_TOKEN`                              | string                                                                     | minted and printed per run                      | Local and memory servers. The bearer the CLI and dashboard use, accepted from loopback only. Ignored with Postgres                                                                                                                                                                                                                                                                                                                                  |
 | `CODER_CACHE_HOME`                         | path                                                                       | OS cache directory for `wular-coder`            | Archived tasks, flows and usage                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `WORK_DIR`                                 | path                                                                       | `<tmp>/coder`                                   | Where the local runner checks out repositories                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `WORK_DIR`                                 | path                                                                       | `~/.coder/state/global/server-tasks`            | Where the local runner keeps each task's work folder: its working directory, or its checkout with a repository. The folder stays across turns and goes with `task delete`                                                                                                                                                                                                                                                                           |
 | `SERVER_NAME`                              | string                                                                     | `Coder`                                         | What the dashboard calls this server, in its sidebar server menu                                                                                                                                                                                                                                                                                                                                                                                    |
 | `ISSUES_URL`                               | URL                                                                        | `https://github.com/muzam1l/coder/issues/new`   | Where the dashboard sends bug reports from its Report issue button                                                                                                                                                                                                                                                                                                                                                                                  |
 | `SERVER_LIMITS`                            | JSON                                                                       | `{}`                                            | Request rates and task slots ([Limits and monitoring](#limits-and-monitoring))                                                                                                                                                                                                                                                                                                                                                                      |
@@ -32,7 +32,7 @@ Required variables carry a *.
 | `TASK_TIMEOUT`                             | ms                                                                         | `1800000` (30 minutes)                          | Longest a task may run                                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `TASK_STALL`                               | ms                                                                         | `300000` (5 minutes)                            | Silence before the runner is asked whether the task is still alive                                                                                                                                                                                                                                                                                                                                                                                  |
 | `TASK_ATTEMPTS`                            | number                                                                     | `2`                                             | Times a runner start is retried                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `SERVER_INTEGRATIONS`                      | comma-separated ids                                                        | every platform                                  | The platforms this server offers, from `github`, `slack` and `linear`.                   Others get no webhook, catalog entry or app creation. An unknown id stops the server                                                                                                                                                                                                                                                                       |
+| `SERVER_INTEGRATIONS`                      | comma-separated ids                                                        | every platform                                  | The platforms this server offers, from `github`, `slack` and `linear`. Others get no webhook, catalog entry or app creation. An unknown id stops the server                                                                                                                                                                                                                                                                                         |
 | `SERVER_OPERATORS`                         | comma-separated Wular Auth user ids                                        | none                                            | Postgres servers. Who may open the operator area. Only this variable grants it                                                                                                                                                                                                                                                                                                                                                                      |
 
 Settings, sign-in, pairings and live tasks live in ~/.coder (CODER_HOME). Archived tasks, flows and usage live in the OS cache directory, ~/Library/Caches/wular-coder on macOS, ~/.cache/wular-coder on Linux (CODER_CACHE_HOME overrides). Nothing is ever pruned.
@@ -124,28 +124,28 @@ A platform user who addresses an agent must be linked to a member of the workspa
 
 `RUNNER_CONFIG` is a JSON object read by the chosen runner. Every field is optional unless marked.
 
-| Runner           | Field               | Default                         | Purpose                                                                                                                                                       |
-| ---------------- | ------------------- | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `local`          |                     |                                 | none                                                                                                                                                          |
+| Runner           | Field               | Default                               | Purpose                                                                                                                           |
+| ---------------- | ------------------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| `local`          |                     |                                       | none                                                                                                                              |
 | `local-docker`   | `image`             | `ghcr.io/muzam1l/coder-runner:latest` | Image the task runs in                                                                                                            |
-|                  | `memory`            | `4g`                            | `--memory`                                                                                                                                                    |
-|                  | `cpus`              | `2`                             | `--cpus`                                                                                                                                                      |
-|                  | `pidsLimit`         | `512`                           | `--pids-limit`                                                                                                                                                |
-|                  | `network`           | `bridge`                        | `--network`                                                                                                                                                   |
-| `vercel-sandbox` | `image`             | the SDK's default image              | Image the task starts from                                                                                                        |
-|                  | `token`             | deployment OIDC                 | Vercel access token for Sandbox; install `@vercel/sandbox` in the adapter app                                                                                 |
-|                  | `team`              | `VERCEL_TEAM_ID`                | Team ID for access-token authentication                                                                                                                       |
-|                  | `projectId`         | `VERCEL_PROJECT_ID`             | Project ID for access-token authentication                                                                                                                    |
-|                  | `region`            | the database's region           | Sandbox region; inferred from an AWS region in the database host, else Vercel's default                                                                       |
-|                  | `timeoutMs`         | `1800000`                       | Sandbox lifetime                                                                                                                                              |
-|                  | `vcpus`             | `1`                                  | Sandbox size                                                                                                                      |
-| `github-actions` | `token` (required)  |                                      | GitHub token that may dispatch the workflow and read its status                                                                   |
-|                  | `repo`              | the event's repository          | `owner/name` holding the workflow                                                                                                                             |
-|                  | `workflow`          | `coder-agent.yml`               | Workflow file to dispatch (`coder server workflow` prints it)                                                                                                 |
-|                  | `ref`               | the repository's default branch | Branch to dispatch on                                                                                                                                         |
-| `http`           | `url` (required)    |                                      | Your controller's base URL; it implements `POST /start`, `POST /messages/<handle>`, `GET /status/<handle>`, `POST /stop/<handle>` |
-|                  | `secret` (required) |                                 | Shared secret that signs every request over body, timestamp, and nonce                                                                                        |
-|                  | `headers`           | `{}`                            | Extra headers sent with every request                                                                                                                         |
+|                  | `memory`            | `4g`                                  | `--memory`                                                                                                                        |
+|                  | `cpus`              | `2`                                   | `--cpus`                                                                                                                          |
+|                  | `pidsLimit`         | `512`                                 | `--pids-limit`                                                                                                                    |
+|                  | `network`           | `bridge`                              | `--network`                                                                                                                       |
+| `vercel-sandbox` | `image`             | the SDK's default image               | Image the task starts from                                                                                                        |
+|                  | `token`             | deployment OIDC                       | Vercel access token for Sandbox; install `@vercel/sandbox` in the adapter app                                                     |
+|                  | `team`              | `VERCEL_TEAM_ID`                      | Team ID for access-token authentication                                                                                           |
+|                  | `projectId`         | `VERCEL_PROJECT_ID`                   | Project ID for access-token authentication                                                                                        |
+|                  | `region`            | the database's region                 | Sandbox region; inferred from an AWS region in the database host, else Vercel's default                                           |
+|                  | `timeoutMs`         | `1800000`                             | Sandbox lifetime                                                                                                                  |
+|                  | `vcpus`             | `1`                                   | Sandbox size                                                                                                                      |
+| `github-actions` | `token` (required)  |                                       | GitHub token that may dispatch the workflow and read its status                                                                   |
+|                  | `repo`              | the event's repository                | `owner/name` holding the workflow                                                                                                 |
+|                  | `workflow`          | `coder-agent.yml`                     | Workflow file to dispatch (`coder server workflow` prints it)                                                                     |
+|                  | `ref`               | the repository's default branch       | Branch to dispatch on                                                                                                             |
+| `http`           | `url` (required)    |                                       | Your controller's base URL; it implements `POST /start`, `POST /messages/<handle>`, `GET /status/<handle>`, `POST /stop/<handle>` |
+|                  | `secret` (required) |                                       | Shared secret that signs every request over body, timestamp, and nonce                                                            |
+|                  | `headers`           | `{}`                                  | Extra headers sent with every request                                                                                             |
 
 `local-docker` and `github-actions` run in the runner image, which holds the engines and tools. A custom `image` needs `node`, `bun`, `git`, `curl`, `tar`, `claude`, `codex` and `github-mcp-server`.
 
@@ -165,7 +165,7 @@ A runner adapter declares delivery support through its optional `push` method. T
 
 ### Your own machine
 
-A member runs the server's tasks on their own machine with `coder runner serve`. It uses the machine's own `claude` and `codex` logins, so no credential is needed. Expose its port with any tunnel, such as `cloudflared tunnel --url http://localhost:4100`, `ngrok http 4100`, `tailscale funnel 4100` or a public VS Code port, and pass the tunnel's address with `--url`. Each start registers the current address with the server as you (`coder auth login`), and stopping marks the runner offline, so a changing tunnel address is fine. Every request to it is signed with its own secret, kept in `~/.coder/runners.json`.
+A member runs the server's tasks on their own machine with `coder runner serve`. It uses the machine's own `claude` and `codex` logins, so no credential is needed. Expose its port with any tunnel, such as `cloudflared tunnel --url http://localhost:4100`, `ngrok http 4100`, `tailscale funnel 4100` or a public VS Code port, and pass the tunnel's address with `--url`. Each start registers the current address with the server as you (`coder auth login`), and stopping marks the runner offline, so a changing tunnel address is fine. Every request to it is signed with its own secret, kept in `~/.coder/runners.json`. Each task keeps one work folder in `~/.coder/state/global/server-tasks/<task id>/work` across turns; deleting the task removes it at the runner's next registration, within a minute while it runs.
 
 A runner runs only its owner's tasks. An owner or admin can register one with `--workspace` for every member. A task runs on the runner it names, else its agent's runner, the requester's default, the workspace default, then `RUNNER`. Choose a default with `coder runner default <id>`. `coder runner list`, `rename` and `remove`, and the dashboard's Settings, manage them.
 
@@ -182,7 +182,7 @@ The server only verifies, dedupes, and dispatches; agents run in the runner with
 | `limits.principalPerMinute` | `300`   | Requests per minute for each signed-in user, the memory server's admin token, or an authenticated runner |
 | `limits.ipPerMinute`        | `60`    | Requests per minute for each unauthenticated IP                                                          |
 | `limits.authPerMinute`      | `20`    | Sign-in, token and login requests per minute for each IP, on top of `ipPerMinute`                        |
-| `limits.registerPerMinute`  | `10`    | Runner registrations per minute for each IP; includes pairing and returning-runner heartbeats                       |
+| `limits.registerPerMinute`  | `10`    | Runner registrations per minute for each IP; includes pairing and returning-runner heartbeats            |
 | `limits.pairingPerMinute`   | `5`     | Pairing tokens per minute for each principal at `/admin/runners/pair`                                    |
 | `limits.concurrentTasks`    | `10`    | Active task slots per workspace in cloud mode, or per server in local and memory modes                   |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wular/coder",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Delegating coding-agent runtime",
   "type": "module",
   "main": "./dist/sdk.js",
@@ -70,7 +70,7 @@
     "@types/node": "^26.1.2",
     "@wular/pnext": "0.1.9",
     "chat": "4.41.1",
-    "contextjsx": "0.2.2",
+    "contextjsx": "0.2.3",
     "drizzle-kit": "0.31.11",
     "drizzle-orm": "0.45.2",
     "jose": "6.2.12",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "coder",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Delegate coding tasks to supervised Coder subagents running on Codex, Claude, or any OpenAI-compatible model. Your main context stays clean.",
   "author": {
     "name": "muzam1l"

package/plugins/cursor/.cursor-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "coder",
   "displayName": "Coder",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Delegate coding tasks to supervised Coder subagents running on Codex, Claude, or any OpenAI-compatible model. Your main context stays clean.",
   "author": {
     "name": "muzam1l"

package/dist/actions-BT7_eKXm.js

@@ -1,10 +0,0 @@
-import{$ as e,A as t,At as n,Bt as r,C as i,D as a,E as o,En as s,I as c,K as l,L as u,M as d,O as f,Q as p,Sn as m,U as h,X as g,Z as _,at as v,d as y,et as b,f as x,it as S,j as ee,ot as te,p as ne,q as re,s as ie,v as ae,yn as oe}from"./errors-XBA-Ls4n.js";import{A as se,Ct as ce,G as le,H as C,J as w,Jt as T,K as E,M as D,N as O,St as k,Yt as A,Zt as j,at as M,it as N,jt as P,kt as F,nt as I,q as L,rt as R,st as z,yt as B}from"./output-D95NoAA9.js";import{i as V,r as H}from"./prompts-B8pKhMcu.js";import U from"node:path";import W from"node:process";import G from"node:fs";import K,{randomUUID as ue}from"node:crypto";import de from"node:readline";import fe from"node:http";function q(e){let t=[];typeof e.instructions==`string`&&e.instructions&&t.push({role:`system`,content:e.instructions});let n=Array.isArray(e.input)?e.input:[];for(let e of n)switch(e?.type){case`message`:{let n=Array.isArray(e.content)?e.content.map(e=>e?.text??``).join(``):String(e.content??``);t.push({role:e.role===`developer`?`system`:e.role,content:n});break}case`function_call`:{let n={id:e.call_id,type:`function`,function:{name:e.name,arguments:e.arguments??`{}`}},r=t.at(-1);r?.role===`assistant`&&r.tool_calls?r.tool_calls.push(n):t.push({role:`assistant`,content:null,tool_calls:[n]});break}case`function_call_output`:{let n=e.output;t.push({role:`tool`,tool_call_id:e.call_id,content:typeof n==`string`?n:JSON.stringify(n??``)});break}}return t}function pe(e){let t=(Array.isArray(e.tools)?e.tools:[]).filter(e=>e?.type===`function`).map(e=>({type:`function`,function:{name:e.name,description:e.description??``,parameters:e.parameters??{type:`object`,properties:{}}}})),n=e.text?.format;return{model:e.model,messages:q(e),...t.length?{tools:t,tool_choice:e.tool_choice??`auto`}:{},...typeof e.parallel_tool_calls==`boolean`?{parallel_tool_calls:e.parallel_tool_calls}:{},...n?.type===`json_schema`?{response_format:{type:`json_schema`,json_schema:{name:n.name,schema:n.schema,strict:n.strict??!1}}}:{},stream:!0,stream_options:{include_usage:!0}}}var me=class{send;model;responseId=`resp_bridge_${K.randomUUID()}`;text=``;textOpen=!1;toolCalls=new Map;usage=null;buffer=``;constructor(e,t){this.model=e,this.send=t,this.send({type:`response.created`,response:{id:this.responseId,object:`response`,status:`in_progress`,model:e,output:[]}})}push(e){this.buffer+=e;let t=this.buffer.split(`
-`);this.buffer=t.pop()??``;for(let e of t){let t=e.trim();if(!t.startsWith(`data:`))continue;let n=t.slice(5).trim();if(!n||n===`[DONE]`)continue;let r;try{r=JSON.parse(n)}catch{continue}r.usage&&(this.usage=r.usage);let i=r.choices?.[0]?.delta;if(i){typeof i.content==`string`&&i.content&&(this.textOpen||(this.textOpen=!0,this.send({type:`response.output_item.added`,output_index:0,item:{type:`message`,id:`msg_bridge_0`,status:`in_progress`,role:`assistant`,content:[]}})),this.text+=i.content,this.send({type:`response.output_text.delta`,item_id:`msg_bridge_0`,output_index:0,content_index:0,delta:i.content}));for(let e of i.tool_calls??[]){let t=this.toolCalls.get(e.index)??{id:``,name:``,args:``};e.id&&(t.id=e.id),e.function?.name&&(t.name+=e.function.name),e.function?.arguments&&(t.args+=e.function.arguments),this.toolCalls.set(e.index,t)}}}}finish(){let e=[];if(this.text){let t={type:`message`,id:`msg_bridge_0`,status:`completed`,role:`assistant`,content:[{type:`output_text`,text:this.text,annotations:[]}]};e.push(t),this.send({type:`response.output_item.done`,output_index:0,item:t})}let t=e.length;for(let n of this.toolCalls.values()){let r={type:`function_call`,id:`fc_bridge_${t}`,call_id:n.id||`call_bridge_${t}`,name:n.name,arguments:n.args||`{}`,status:`completed`};e.push(r),this.send({type:`response.output_item.done`,output_index:t,item:r}),t+=1}this.send({type:`response.completed`,response:{id:this.responseId,object:`response`,status:`completed`,model:this.model,output:e,usage:{input_tokens:this.usage?.prompt_tokens??0,input_tokens_details:{cached_tokens:this.usage?.prompt_tokens_details?.cached_tokens??0},output_tokens:this.usage?.completion_tokens??0,output_tokens_details:{reasoning_tokens:this.usage?.completion_tokens_details?.reasoning_tokens??0},total_tokens:this.usage?.total_tokens??0}}})}};async function J(e,t=`chat`){let n=t===`responses`,r=B(e.baseUrl,n?`responses`:`chat/completions`),i=null,a=!0,o=e.envKey?W.env[e.envKey]:void 0;async function s(e){let t=i?[i]:r,n=null;for(let r of t)if(n=await fetch(r,{method:`POST`,headers:{"content-type":`application/json`,...o?{authorization:`Bearer ${o}`}:{}},body:e}),n.status!==404)return i=r,n;return n}async function c(e){let t=e.text?.format,r=n?e:pe(e),i=()=>{let i=V(t.schema);if(n){let{format:t,...n}=e.text;return{...e,text:n,input:[...e.input??[],{type:`message`,role:`user`,content:[{type:`input_text`,text:i}]}]}}let{response_format:a,...o}=r;return{...o,messages:[...q(e),{role:`user`,content:i}]}};if(t?.type!==`json_schema`)return s(JSON.stringify(r));if(!a)return s(JSON.stringify(i()));let o=await s(JSON.stringify(r));if(![400,422,501].includes(o.status))return o;let c=await o.clone().text();return/(invalid.{0,30}schema|schema.{0,30}invalid|unsupported.{0,30}(keyword|constraint)|(keyword|constraint).{0,30}unsupported)/i.test(c)||!/(response_format|json_schema|text[.\s]format)/i.test(c)||!/(not supported|unsupported|unknown parameter|unrecognized|not available)/i.test(c)?o:(a=!1,await o.body?.cancel(),s(JSON.stringify(i())))}let l=K.randomBytes(16).toString(`hex`),u=fe.createServer((e,t)=>{if(e.method!==`POST`||!e.url?.startsWith(`/${l}/`)||!e.url.replace(/\/+$/,``).endsWith(`/responses`)){t.writeHead(404,{"content-type":`application/json`}),t.end(JSON.stringify({error:{message:`coder chat bridge: only POST /responses is supported`}}));return}let r=``;e.on(`data`,e=>r+=e),e.on(`end`,async()=>{let e;try{e=JSON.parse(r)}catch{t.writeHead(400,{"content-type":`application/json`}),t.end(JSON.stringify({error:{message:`invalid JSON`}}));return}try{if(n){let n=await c(e);if(t.writeHead(n.status,{"content-type":n.headers.get(`content-type`)??`application/json`,"cache-control":`no-store`}),n.body)for await(let e of n.body)t.write(e);t.end();return}let r=await c(e);if(!r.ok||!r.body){let e=await r.text().catch(()=>``);t.writeHead(r.status,{"content-type":`application/json`}),t.end(e||JSON.stringify({error:{message:`upstream HTTP ${r.status}`}}));return}t.writeHead(200,{"content-type":`text/event-stream`,"cache-control":`no-store`});let i=new me(e.model,e=>t.write(`data: ${JSON.stringify(e)}\n\n`)),a=new TextDecoder;for await(let e of r.body)i.push(a.decode(e,{stream:!0}));i.finish(),t.end()}catch(e){let n=e instanceof Error?e.message:String(e);t.writeHead(502,{"content-type":`application/json`}),t.end(JSON.stringify({error:{message:`coder chat bridge: ${n}`}}))}})});await new Promise(e=>u.listen(0,`127.0.0.1`,e));let d=u.address();return{url:`http://127.0.0.1:${typeof d==`object`&&d?d.port:0}/${l}/v1`,close:()=>new Promise(e=>{u.close(()=>e()),u.closeAllConnections?.()})}}const he=/^[A-Za-z0-9-]{1,128}$/;function Y(e){return[...new Set([...e.previousThreadIds??[],...e.threadId?[e.threadId]:[]])]}async function X(e,t){if(!/^[a-zA-Z0-9_-]+$/.test(t))return[];let n=e.engine===`claude`,r=n?L():v(),i=e.id?U.join(h(e.cwd??``,e.id),`history-files.json`):void 0,a=JSON.stringify([e.engine,r,t]),o=i?m(i)??{}:{},c=o[a];if(c?.length&&c.every(e=>e.startsWith(`${r}${U.sep}`)&&G.existsSync(e)))return c;let l=[],u=async(e,r)=>{for(let i of await G.promises.readdir(e,{withFileTypes:!0}).catch(()=>[])){let a=U.join(e,i.name);i.isDirectory()&&r?await u(a,r-1):i.isFile()&&(n?i.name===`${t}.jsonl`:i.name.endsWith(`-${t}.jsonl`))&&l.push(a)}};return n?await u(r,1):(await u(U.join(r,`sessions`),3),await u(U.join(r,`archived_sessions`),0)),i&&l.length&&s(i,{...o,[a]:l}),l}function ge(e,t){let n=t?e.message:e.type===`response_item`?e.payload:void 0;if(!n||!t&&n.type===`reasoning`)return;let r=n.content,i=Array.isArray(r)?r:[],a=n.role??(n.type?.endsWith(`_output`)?`tool`:`assistant`),o=i.filter(e=>e.type===`tool_use`).map(e=>String(e.id)),s=i.filter(e=>e.type===`tool_result`).map(e=>String(e.tool_use_id));[`function_call`,`custom_tool_call`].includes(n.type)&&o.push(String(n.call_id)),[`function_call_output`,`custom_tool_call_output`].includes(n.type)&&s.push(String(n.call_id));let c=typeof r==`string`?r:i.length?i.map(e=>typeof e.text==`string`?e.text:JSON.stringify(e)).join(`
-`):JSON.stringify(n);return{speaker:s.length&&!o.length?`tool`:a,time:String(e.timestamp??``),text:c,calls:o,results:s,startsExchange:a===`user`&&!s.length,reply:a===`assistant`&&(t?i.some(e=>e.type===`text`)||typeof r==`string`:n.type===`message`)}}async function*Z(e,t){for(let n of await X(e,t)){let t=G.createReadStream(n,{encoding:`utf8`}),r=de.createInterface({input:t,crlfDelay:1/0});try{for await(let t of r){let n;try{n=JSON.parse(t)}catch{continue}let r=ge(n,e.engine===`claude`);r&&(yield r)}}finally{r.close(),t.destroy()}}}async function _e(e,{exchanges:t=6,maxBytes:n=2e4}={}){if(!e.threadId)return{text:``,exchanges:0};let r=[],i=``,a=0,o=!1,s=new Set,c=()=>{if(a>n)r.length=0;else if(i&&o&&!s.size)for(r.push(i);r.length>t||Buffer.byteLength(r.join(`
-
-`))>n;)r.shift();i=``,a=0,o=!1,s.clear()};for await(let t of Z(e,e.threadId)){if(t.startsExchange&&!s.size&&c(),!i&&!t.startsExchange)continue;for(let e of t.calls)s.add(e);for(let e of t.results)s.delete(e);t.reply&&(o=!0);let e=`[${t.time}] ${t.speaker}\n${t.text}`;a+=Buffer.byteLength(e)+2,a<=n?i+=`${i?`
-
-`:``}${e}`:i=`[exchange exceeds the recent history budget]`}return a>n&&(i=``),c(),{text:r.join(`
-
-`),exchanges:r.length}}async function ve(e,{query:t,from:n=0,limit:r=10}={}){if(t!==void 0&&(typeof t!=`string`||!t.length||t.length>500))throw Error(`Provide a query of 1 to 500 characters`);if(!Number.isSafeInteger(n)||n<0)throw Error(`Provide from as a nonnegative message index`);if(!Number.isInteger(r)||r<1||r>20)throw Error(`Provide a limit of 1 to 20 messages`);let i=[],a=t?.toLowerCase(),o=0;for(let t of Y(e))for await(let s of Z(e,t)){let e=o++;if(e<n)continue;let t=a===void 0?0:s.text.toLowerCase().indexOf(a);if(t<0)continue;if(i.length===r)return{messages:i,next:i[i.length-1].index+1};let c=Math.max(0,t-200);i.push({index:e,speaker:s.speaker,time:s.time,text:s.text.slice(c,c+1200)})}return{messages:i}}function ye(e,t,r=e=>e){return async i=>({...n(Object.fromEntries(se(e,W.env,t).flatMap(e=>{let t=e.connection??e.name;return i.includes(t)?[[t,r(e)]]:[]}))),warnings:[]})}async function be(e,t,n,r,i={}){if(t.status!==`running`)return null;let a=t.engine===`claude`?await(i.claude??E)(t.steerEndpoint,n,void 0,r):await(i.codex??N)(e,{endpoint:t.steerEndpoint,threadId:t.threadId,turnId:t.turnId,text:n,command:r});if(a.steered)return y(e,t.id,{kind:`steer`,message:`${ie}${n}`}),{taskId:t.id,steered:`live`};if(!a.retryable)throw y(e,t.id,{kind:`error`,message:`Live steer failed: ${a.detail}`}),Error(`Could not steer running task ${t.id}: ${a.detail}`);return null}function xe(e,t,n){ae(e,t,n),y(e,t,{kind:`steer`,message:`Steer queued for the next turn:\n${n}`})}async function Q(e,t,n,r={},i={}){let a=f(e,t.id)??t;if(t=a.rollingOver?c(e,a):a,!t.threadId)throw new j(`invalid-option`,`Task ${t.id} has no thread to steer yet (status: ${t.status}).`,{hint:`Wait for it to start: coder task watch ${t.id}`});let o=await be(e,t,n,r.command,i);if(o){let n=f(e,t.id)??t;return n.archived&&g(e,n),o}return{taskId:t.id,steered:await Ce(e,t,n,r)}}function Se(e){let n=G.mkdtempSync(`${e}-`),r=`${W.pid}-${t(W.pid)??0}-${ue()}`;G.mkdirSync(U.join(n,r));try{for(let r=0;r<2;r++){try{return G.renameSync(n,e),!0}catch(e){if(![`EEXIST`,`ENOTEMPTY`,`ENOTDIR`].includes(e.code??``))throw e}try{if(G.statSync(e).isFile()){if(Date.now()-G.statSync(e).mtimeMs<6e4)return!1;G.unlinkSync(e);continue}for(let n of G.readdirSync(e)){let r=n.split(`-`),i=Number(r[0]),a=Number(r[1]),o=!1;if(Number.isInteger(i)&&i>0)try{W.kill(i,0),o=!0}catch(e){o=e.code===`EPERM`}let s=o?t(i):null;if(o&&(!a||s===null||s===a))return!1;G.rmdirSync(U.join(e,n))}G.rmdirSync(e)}catch(e){if(![`ENOENT`,`ENOTEMPTY`].includes(e.code??``))throw e}}return!1}finally{G.rmSync(n,{recursive:!0,force:!0})}}async function Ce(t,n,a,o){if(n.connectionSource===`server`&&!o.resolveConnections)throw Error(`Server connection resolver is required to resume this task`);let s=await p(t,n.id,()=>{let e=f(t,n.id)??n,r=[e?.completedAt,e?.resumedAt].map(e=>Date.parse(e??``)||0),o=U.join(h(t,n.id),`resume-${r.join(`-`)}`);if(e&&!e.steerClosed&&(b.includes(e.status)||e.rollingOver&&c(t,e).rollingOver||e.status===`completed`&&e.steerClosed===!1&&i(e.pid))||!Se(o)){e.archived&&g(t,e),xe(t,n.id,a);return}return{fresh:e,claim:o}});if(!s)return`queued`;let{fresh:l,claim:u}=s;n=l??n;let d=!1;try{for(let e of G.readdirSync(h(t,n.id)))/^resume-\d+-\d+$/.test(e)&&e!==U.basename(u)&&G.rmSync(U.join(h(t,n.id),e),{recursive:!0,force:!0});let i=n.agentId?await(await import(`./exec-iFssTO5V.js`).then(e=>e.i)).localAgentPrompt(t,n.agentId):void 0,s=o.resolveConnections?await o.resolveConnections(n.connections??[]):await r(void 0,n.connections??[],void 0,i?.access),c=n.mcp?.map(e=>{let t=e.connection??(e.resolved&&n.connections?.includes(e.name)?e.name:void 0);return t?{...e,connection:t,resolved:!1}:e})??[],l=n.mcpBindings??c.filter(e=>e.connection).map(({name:e,connection:t,tools:n})=>({name:e,connection:t,...n?{tools:n}:{}})),f=new Set(l.map(e=>e.connection)),p=D([...l,...c.filter(e=>!f.has(e.connection))],{},{},s.mcp);n.archived&&g(t,n),e(t,n.id,{...i?.developer&&n.promptParts?{promptParts:{...n.promptParts,developer:{...i.developer,notes:n.promptParts.developer?.notes}}}:{},mcp:p.mcp,mcpBindings:l,status:`queued`,pid:null,steerClosed:!1,resumedAt:new Date().toISOString(),currentPrompt:a,...o.outputSchema?{outputSchema:o.outputSchema}:{},resumeThreadId:n.threadId,steerEndpoint:null,model:o.model??n.model??null,effort:o.effort??n.effort??null,permissions:o.permissions??n.permissions,error:void 0}),d=!0,y(t,n.id,{kind:`steer`,message:`Resuming with steer:\n${a}`});for(let e of[...s.warnings,...p.warnings??[]])y(t,n.id,{kind:`status`,message:e});let m=O(n.cwd??t,n.id,s.env);o.onWorker?.(m)}catch(r){throw d&&e(t,n.id,{status:l?.status??n.status,resumedAt:l?.resumedAt,currentPrompt:l?.currentPrompt??null,resumeThreadId:l?.resumeThreadId??null,error:l?.error}),G.rmSync(U.join(h(t,n.id),U.basename(u)),{recursive:!0,force:!0}),r}return`resumed`}const we=[`Read`,`Glob`,`Grep`];function Te(e,t,n,r){return{prompt:n,model:r.model??e.model,effort:r.effort,permissions:`read-only`,additionalDirectories:[t],taskRoot:t,readOnlyAllowedTools:we}}async function Ee(e,t,n,r={}){let i=h(e,t.id),a=H(t,{log:U.join(i,`log.jsonl`),result:U.join(i,`result.json`),worker:U.join(i,`worker.log`)},n,r.command?z(r.command):void 0),o=r.command?e=>{let t=U.join(i,`inbox-control`);G.mkdirSync(t,{recursive:!0}),G.appendFileSync(U.join(t,`${z(r.command)}.transcript.jsonl`),JSON.stringify({command:r.command,result:e.finalMessage??e.error?.message??``})+`
-`)}:void 0,s=r.effort??t.effort??null;if(t.engine===`claude`)return le(t.cwd??e,{...Te(t,i,a,{model:r.model,effort:s}),command:r.command,onResult:o});let c=ce(e),l=r.model??t.model,u=l?c.models?.[l]:void 0,d=u&&k(u)?u:void 0;if(d?.envKey&&!W.env[d.envKey])throw Error(`Missing environment variable: \`${d.envKey}\`.`);let f=d?await J(d,d.wireApi??`chat`):null,p=P(c,l,f??void 0);try{return await R(t.cwd??e,{prompt:a,model:p?.model??F(l??null),modelProvider:p?.modelProvider??null,configOverrides:p?.configOverrides??null,effort:s,sandbox:`read-only`,approvalPolicy:`never`,ephemeral:!0,onResult:o})}finally{await f?.close()}}function De(e){return a(e).filter(e=>b.includes(e.status)).flatMap(t=>C(h(e,t.id)).filter(e=>!e.response).map(e=>({taskId:t.id,id:e.id,summary:String(e.summary??``),createdAt:e.createdAt?String(e.createdAt):void 0})))}function $(e){return a(e).filter(t=>!S.includes(t.status)||!x(Date.parse(t.completedAt??t.updatedAt??t.createdAt??``))||(ne(e,t,{auto:!0}),!1))}function Oe(e,t={}){let n=t.limit===`all`?void 0:t.limit,r=e=>S.includes(e.status),i=d(e),a=new Set(i.map(e=>e.id)),s=e=>e.filter(e=>!a.has(e.id)),c=[...s($(e)),...i.filter(e=>!e.archived)];if(t.archived?c=[...s(o(e)),...i.filter(e=>e.archived)]:t.running?c=c.filter(e=>b.includes(e.status)):t.stopped&&(c=c.filter(r)),t.dir){let e=l(U.resolve(String(t.dir))),n=new Map;c=c.filter(t=>t.cwd?(n.has(t.cwd)||n.set(t.cwd,l(t.cwd)),n.get(t.cwd)===e):!1)}let u=e=>({rank:A(e.status),createdAt:Date.parse(e.createdAt??``)||0,id:e.id});c=[...c].sort((e,t)=>T(u(e),u(t)));let f=n===void 0?0:Math.max(0,c.length-n);return n!==void 0&&(c=c.slice(0,n)),{tasks:c,clipped:f}}async function*ke(e,t,n={}){let r=_(e,t);try{let i=ee(),a=f(e,t);if(!a)throw Error(`No task found for "${t}".`);let o=n.tail??1,s=oe(U.join(h(e,t),`log.jsonl`)),l=!0,u=()=>{let e=s().map(e=>{try{return JSON.parse(e)}catch{return{message:e}}});return l?(l=!1,o===`all`?e:re(e,o)):e};for(yield*u();a=c(e,f(e,t)??a,i),!S.includes(a.status);)await r.wait(1e3),yield*u();yield*u()}finally{r.close()}}async function Ae(t,n,r={}){let i=n.engine===`claude`?{detail:`claude worker terminated`}:await(r.interrupt??I)(t,{endpoint:n.steerEndpoint,threadId:n.threadId,turnId:n.turnId});if(n.engine!==`claude`&&M(n.steerEndpoint),n.pid&&n.status===`running`)try{W.kill(n.pid,`SIGTERM`)}catch{}return e(t,n.id,{status:`cancelled`,error:`Stopped by user.`,steerEndpoint:null,completedAt:new Date().toISOString()}),{taskId:n.id,status:`cancelled`,interrupt:i.detail}}function je(e,t){for(let n of Y(t))t.engine===`claude`?w(n):te(e,n);return u(e,t.id)}export{ye as a,Ae as c,Y as d,ve as f,J as h,je as i,ke as l,X as m,De as n,$ as o,_e as p,Oe as r,Q as s,Ee as t,he as u};

package/dist/adapter-BT8ECcRG.js

@@ -1 +0,0 @@
-import{f as e,l as t,u as n}from"./slack-Bo5l13Rs.js";import{l as r}from"./dist-DAnSqY1s.js";import{createGitHubAdapter as i}from"./dist-B2jiMMxZ.js";function a(a){let o=a.credentials?.webhookSecret,s=a.installationId,c,l=i({userName:a.name,apiUrl:`https://api.github.com`,botUserId:0,installationToken:()=>s?c??=a.token(s,{tools:n.read}):Promise.reject(Error(`The webhook names no GitHub installation`)),webhookVerifier:(e,n)=>t(n,e.headers.get(`x-hub-signature-256`),o),logger:new r(`error`)});return e(l.octokit,a.fetch),l}export{a as githubAdapter};