@wular/coder 0.3.18 → 0.4.1

package/dist/types-I5Cwtl_K.d.ts

@@ -0,0 +1,389 @@
+import * as z from "zod/mini";
+import { SerializedMessage, SerializedThread } from "chat";
+//#region src/core/config.d.ts
+declare const engineSchema: z.ZodMiniEnum<{
+  codex: "codex";
+  claude: "claude";
+  custom: "custom";
+}>;
+declare const effortSchema: z.ZodMiniEnum<{
+  low: "low";
+  medium: "medium";
+  high: "high";
+}>;
+declare const permissionSchema: z.ZodMiniEnum<{
+  "read-only": "read-only";
+  "workspace-write": "workspace-write";
+  auto: "auto";
+}>;
+declare const customModelSchema: z.ZodMiniObject<{
+  baseUrl: z.ZodMiniURL;
+  model: z.ZodMiniString<string>;
+  envKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  wireApi: z.ZodMiniOptional<z.ZodMiniEnum<{
+    chat: "chat";
+    responses: "responses";
+  }>>;
+  disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+/** The merged, effective shape (everything present after DEFAULT_CONFIG). */
+declare const mcpEntrySchema: z.ZodMiniObject<{
+  command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+  env: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+  url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  type: z.ZodMiniOptional<z.ZodMiniEnum<{
+    stdio: "stdio";
+    http: "http";
+    sse: "sse";
+  }>>;
+  headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+  tools: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+  description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strict>;
+declare const effectiveConfigSchema: z.ZodMiniObject<{
+  chain: z.ZodMiniArray<z.ZodMiniEnum<{
+    codex: "codex";
+    claude: "claude";
+    custom: "custom";
+  }>>;
+  engines: z.ZodMiniObject<{
+    codex: z.ZodMiniOptional<z.ZodMiniObject<{
+      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+        auto: "auto";
+      }>>;
+      network: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$strict>>;
+    claude: z.ZodMiniOptional<z.ZodMiniObject<{
+      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+        auto: "auto";
+      }>>;
+    }, z.core.$strict>>;
+    custom: z.ZodMiniOptional<z.ZodMiniObject<{
+      model: z.ZodMiniOptional<z.ZodMiniString<string>>;
+      effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+      }>>;
+      permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+        "read-only": "read-only";
+        "workspace-write": "workspace-write";
+        auto: "auto";
+      }>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>;
+  models: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+    baseUrl: z.ZodMiniURL;
+    model: z.ZodMiniString<string>;
+    envKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    wireApi: z.ZodMiniOptional<z.ZodMiniEnum<{
+      chat: "chat";
+      responses: "responses";
+    }>>;
+    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+  }, z.core.$strict>, z.ZodMiniObject<{
+    provider: z.ZodMiniEnum<{
+      codex: "codex";
+      claude: "claude";
+    }>;
+    model: z.ZodMiniString<string>;
+    effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>>;
+    disabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+  }, z.core.$strict>, z.ZodMiniObject<{
+    disabled: z.ZodMiniBoolean<boolean>;
+  }, z.core.$strict>]>>>;
+  agents: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniObject<{
+    engine: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    model: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    effort: z.ZodMiniOptional<z.ZodMiniEnum<{
+      low: "low";
+      medium: "medium";
+      high: "high";
+    }>>;
+    permissions: z.ZodMiniOptional<z.ZodMiniEnum<{
+      "read-only": "read-only";
+      "workspace-write": "workspace-write";
+      auto: "auto";
+    }>>;
+    runner: z.ZodMiniOptional<z.ZodMiniEnum<{
+      local: "local";
+      "local-docker": "local-docker";
+      "vercel-sandbox": "vercel-sandbox";
+      "github-actions": "github-actions";
+    }>>;
+    integrations: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+      allowedTools: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
+        observe: "observe";
+        comment: "comment";
+        write: "write";
+      }>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+      allowedEvents: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    }, z.core.$strict>>>;
+  }, z.core.$strict>]>>>;
+  mcp: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniObject<{
+    command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    env: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    type: z.ZodMiniOptional<z.ZodMiniEnum<{
+      stdio: "stdio";
+      http: "http";
+      sse: "sse";
+    }>>;
+    headers: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    tools: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strict>>>;
+  approvals: z.ZodMiniObject<{
+    escalationTimeoutMs: z.ZodMiniNumber<number>;
+    allowedNetworkHosts: z.ZodMiniArray<z.ZodMiniString<string>>;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type McpConfigEntry = z.infer<typeof mcpEntrySchema>;
+type Engine = z.infer<typeof engineSchema>;
+type Effort = z.infer<typeof effortSchema>;
+type Permission = z.infer<typeof permissionSchema>;
+type CustomModelConfig = z.infer<typeof customModelSchema>;
+type CoderConfig = z.infer<typeof effectiveConfigSchema>;
+/** Flags of `coder mcp add`: a remote `url` or a stdio `command`; env, header and tools are comma lists. */
+interface McpAddOptions {
+  url?: string;
+  transport?: string;
+  header?: string;
+  env?: string;
+  tools?: string;
+  command?: string[];
+  user?: boolean;
+}
+//#endregion
+//#region src/client/types.d.ts
+type RunnerKind = 'local' | 'local-docker' | 'vercel-sandbox' | 'github-actions' | 'http';
+interface RunnerSpec {
+  kind: RunnerKind;
+  name: string;
+  description: string;
+  connect: 'pair' | 'fields';
+  /** One or two sentences on what this kind needs and where to get it. */
+  help?: string;
+  fields: Array<{
+    key: string;
+    label: string;
+    secret?: boolean;
+    placeholder?: string;
+    optional?: boolean;
+    hint?: string;
+  }>;
+  available: boolean;
+  reason?: string;
+}
+interface RunnerRow {
+  id: string;
+  kind: RunnerKind;
+  name: string;
+  scope: 'personal' | 'workspace';
+  default: boolean;
+  online: boolean;
+  lastSeen?: number;
+  config: Record<string, string>;
+  createdAt: number;
+}
+interface RunnerPairing {
+  token: string;
+  expiresAt: number;
+  command: string;
+}
+interface RunnerInput {
+  kind: RunnerKind;
+  name: string;
+  scope: RunnerRow['scope'];
+  config: Record<string, string>;
+}
+interface RunnerUpdate {
+  name?: string;
+  default?: true;
+  config?: Record<string, string>;
+}
+interface RunnerTest {
+  ok: boolean;
+  detail: string;
+  ms: number;
+}
+interface ProbeResult {
+  reachable: boolean;
+  modelListed: boolean | null;
+  /** Model ids the endpoint lists, or null when it has no list. */
+  models: string[] | null;
+  detail: string;
+}
+interface LocalFolder {
+  path: string;
+  name: string;
+  recent?: number;
+  /** The git URL a cloned checkout came from. */
+  url?: string;
+}
+interface LocalFolders {
+  current: LocalFolder;
+  recent: LocalFolder[];
+  /** The machine can open its own folder dialog. */
+  picker: boolean;
+}
+interface TaskTurn {
+  prompt: string;
+  result?: {
+    ok?: boolean;
+    output?: string;
+    diff?: string;
+  } | string;
+  error?: string;
+  finishedAt?: number;
+  /** First log sequence after this turn. */
+  logSeq?: number;
+}
+//#endregion
+//#region src/core/task/log-view.d.ts
+interface TaskLogEntry {
+  at?: string;
+  message?: string;
+  kind?: string;
+  [key: string]: unknown;
+}
+interface TokenUsage {
+  input: number;
+  cachedInput: number;
+  output: number;
+  total: number;
+}
+//#endregion
+//#region src/core/types.d.ts
+/** An extra MCP server attached to a task, with the tools the engine may call. */
+/** One MCP server in the `.mcp.json` entry shape: stdio (`command`) or remote (`url`). */
+interface McpServerSpec {
+  name: string;
+  command?: string;
+  args?: string[];
+  /** Values may hold `${VAR}` placeholders, resolved from the environment at spawn time. */
+  env?: Record<string, string>;
+  /** Remote server; `type` defaults to `http` (streamable HTTP), `sse` for legacy servers. */
+  url?: string;
+  type?: 'stdio' | 'http' | 'sse';
+  headers?: Record<string, string>;
+  /** Tool allowlist; omit or empty for every tool the server offers. */
+  tools?: string[];
+}
+type TaskKind = 'task';
+type TaskStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+/** A persisted task record (task.json). Most fields accrete over the lifecycle. */
+interface Task {
+  id: string;
+  createdAt: string;
+  updatedAt?: string;
+  status: TaskStatus;
+  kind?: TaskKind;
+  name?: string | null;
+  engine?: Engine;
+  prompt?: string;
+  outputSchema?: object;
+  currentPrompt?: string | null;
+  system?: string | null;
+  model?: string | null;
+  effort?: Effort | null;
+  permissions?: Permission;
+  resumeThreadId?: string | null;
+  cwd?: string;
+  background?: boolean;
+  pid?: number | null;
+  dispatchId?: string;
+  threadId?: string | null;
+  turnId?: string | null;
+  steerEndpoint?: string | null;
+  completedAt?: string;
+  resumedAt?: string;
+  error?: string;
+  fallbacks?: Array<{
+    engine: Engine;
+    detail: string;
+    next: Engine;
+  }>;
+  archived?: boolean;
+  archivedAt?: string;
+  simulateApproval?: boolean;
+  flowRunId?: string;
+  agentId?: string;
+  source?: string;
+  author?: string;
+  repo?: string;
+  mcp?: McpServerSpec[];
+  addDirs?: string[];
+}
+/** The outcome of running one engine turn. status 0 == success. */
+interface TurnResult {
+  status: number;
+  threadId: string | null;
+  turnId?: string | null;
+  finalMessage?: string;
+  touchedFiles?: string[];
+  tokens?: TokenUsage | null;
+  /** The model that ran the turn (tokens are only comparable per model). */
+  model?: string | null;
+  error?: {
+    message?: string;
+  } | null;
+  [key: string]: unknown;
+}
+/** Whether an engine binary is installed and usable. */
+interface Availability {
+  available: boolean;
+  detail: string;
+}
+/** A persisted approval escalation and its answer, if any. */
+interface Approval {
+  id: string;
+  summary: string;
+  /** Where an escalated command runs. */
+  cwd?: string;
+  createdAt?: string;
+  response?: {
+    decision: string;
+  } | null;
+  [key: string]: unknown;
+}
+/** A [flag-or-command, description] pair rendered in help tables. */
+type HelpRow = [string, string];
+/** Help metadata for one command. */
+interface CommandHelpSpec {
+  usage: string;
+  summary?: string;
+  flags?: HelpRow[];
+  globalFlags?: HelpRow[];
+  exitCodes?: HelpRow[];
+  examples?: HelpRow[];
+  /** Environment variables the command reads: name → what it does. */
+  env?: HelpRow[];
+  seeAlso?: string;
+}
+/** A subcommand handler. Receives the argv slice after the command name. */
+type CommandHandler = (argv: string[]) => Promise<void> | void;
+//#endregion
+export { CustomModelConfig as C, Permission as D, McpConfigEntry as E, CoderConfig as S, McpAddOptions as T, RunnerRow as _, HelpRow as a, RunnerUpdate as b, TurnResult as c, LocalFolder as d, LocalFolders as f, RunnerPairing as g, RunnerKind as h, CommandHelpSpec as i, TaskLogEntry as l, RunnerInput as m, Availability as n, Task as o, ProbeResult as p, CommandHandler as r, TaskStatus as s, Approval as t, TokenUsage as u, RunnerSpec as v, Effort as w, TaskTurn as x, RunnerTest as y };

package/dist/unalias-C9NqmSDq.js

@@ -0,0 +1 @@
+import{i as e}from"./cli-BilSDkvE.js";import{o as t}from"./models-_5LVGC3m.js";import{n}from"./add-U-pty9qJ.js";import{t as r}from"./remove-C5_xggx7.js";const i=e({name:`model unalias`,help:{usage:`coder model unalias <name> [--workspace]`,summary:`Remove a user-defined alias.`,flags:[[`--workspace`,`target <repo>/.coder/config.json instead of the user file`]]},options:n,args:1,run:({options:e,args:[n],cwd:r})=>t(r,n,e),print:e=>r(`unaliased`,e.unaliased,e.file)});export{i as commandModelUnalias};

package/dist/update-BTxYQj7Z.js

@@ -0,0 +1,2 @@
+import{i as e}from"./cli-BilSDkvE.js";import{s as t}from"./models-_5LVGC3m.js";import{a as n,i as r,n as i,r as a}from"./add-U-pty9qJ.js";const o=e({name:`model update`,help:{usage:`coder model update <name> [--base-url <url>] [--model <id>] [--env-key VAR]`,summary:`Update a configured custom model. Only the flags you pass change; the endpoint
+is re-probed and the wire protocol re-detected.`,flags:[[`--base-url <url>`,`new API base`],[`--model <id>`,`new provider model id`],[`--env-key <VAR>`,`new API-key env var`],[`--workspace`,`write to <repo>/.coder/config.json instead of the user file`]]},options:i,args:1,run:({options:e,args:[r],cwd:i})=>t(i,r,n(e)),json:a,print:e=>r(e,`updated`)});export{o as commandModelUpdate};

package/dist/upgrade-hA0yWBvx.js

@@ -0,0 +1,2 @@
+import{T as e}from"./dispatch-BKeAch9E.js";import{i as t}from"./cli-BilSDkvE.js";import{f as n,p as r,t as i}from"./output-BKeyLbvt.js";import{n as a,s as o}from"./args-BOEEdpWk.js";import s from"node:process";const c=t({name:`upgrade`,globalFlags:{json:!1,cwd:!1},help:{usage:`coder upgrade [--cli-only] [--plugins-only] [--codex] [--claude] [--pm <mgr>]`,summary:`Update the coder CLI through whichever package manager installed it, then refresh
+the host plugins to match. Alias: update.`,flags:[[`--cli-only`,`update just the CLI`],[`--plugins-only`,`refresh just the host plugins`],[`--codex`,`limit the refresh to the Agent Skills copy (Codex, Pi, ...)`],[`--claude`,`limit the refresh to the Claude Code plugin`],[`--pm <npm|pnpm|yarn|bun>`,`force a package manager instead of auto-detecting`]]},options:{pm:o,"cli-only":a,"plugins-only":a,codex:a,claude:a},run:({options:t})=>e({...t,cliOnly:t[`cli-only`],pluginsOnly:t[`plugins-only`]},l),print:u});function l(e){s.stdout.write(`${r.bold(`Updating coder CLI`)} ${r.dim(`${e}...`)}\n`)}function u(e){let t=r.bold,a=r.dim,o=(e,n)=>n&&e&&n!==e?`${e} ${a(`->`)} ${t(n)}`:`${n??e??`?`} ${a(`(unchanged)`)}`,c=(e,t)=>`${t.installed?n(`${e} ${o(t.from,t.to)} ${a(`- ${t.note}`)}`):i(`${e} ${t.note}`)}\n`;e.cli&&s.stdout.write(e.cli.changed?`${n(`coder CLI  ${o(e.cli.from,e.cli.to)}`)}\n`:`${n(`coder CLI  ${e.cli.from} ${a(`(already latest)`)}`)}\n`),e.claudePlugin&&s.stdout.write(c(`claude plugin`,e.claudePlugin)),e.agentsSkill&&s.stdout.write(c(`agents skill `,e.agentsSkill))}const d=async()=>(await import(`./refresh-BIrmrWYq.js`)).commandRefreshUpdate,f=Object.assign(async e=>e[0]===`refresh`?(await d())(e.slice(1)):c(e),c,{subcommands:{refresh:d}});export{f as commandUpgrade};

package/dist/usage-BhqoCjvE.js

@@ -0,0 +1 @@
+import{t as e}from"./rolldown-runtime-DT7IzrpZ.js";import{a as t,i as n}from"./load-BpEsAn51.js";import{a as r,d as i,f as a,n as o,u as s}from"./http-Bkg_OQ6r.js";import{g as c}from"./store-DzqXS2wT.js";var l=e({addUsage:()=>f,leaders:()=>m,readUsage:()=>x,readUsageTotals:()=>S,timeZone:()=>d,usageReport:()=>b,usageSummary:()=>_,usageTotals:()=>p});function u(e){return typeof e==`number`?e:!e||typeof e!=`object`||Array.isArray(e)?0:`total`in e&&typeof e.total==`number`?e.total:Object.values(e).reduce((e,t)=>e+u(t),0)}function d(e){if(!e)return`UTC`;try{return new Intl.DateTimeFormat(`en`,{timeZone:e}),e}catch{return`UTC`}}const f=(e,t)=>{e.tasks+=t.tasks,e.runnerMs+=t.runnerMs,e.tokenCount+=t.tokenCount};async function p(e,t){if(e.usageTotals)return e.usageTotals(t);if(t.top){let{top:n,...r}=t,i=(await p(e,{...r,by:`agent`,parts:void 0})).sort((e,t)=>t[n.by]-e[n.by]||e.key.localeCompare(t.key)).slice(0,n.count).map(e=>e.key);return p(e,{...r,parts:i})}let n=d(t.tz),r=new Intl.DateTimeFormat(`en-CA`,{timeZone:n,year:`numeric`,month:`2-digit`,day:`2-digit`}),i=new Set(t.parts),a=new Map;for(let{value:n}of await e.list(`usage`)){if(n.at<t.since||t.until!==void 0&&n.at>=t.until||t.agent&&n.agent!==t.agent)continue;let e=t.by===`agent`?n.agent:t.by===`installation`?n.installationId??`none`:t.by===`engine`?n.engine??`unknown`:r.format(n.at),o={tasks:1,runnerMs:n.runnerElapsedMs,tokenCount:u(n.tokens)},s=a.get(e)??{key:e,tasks:0,runnerMs:0,tokenCount:0};f(s,o),i.has(n.agent)&&(s.parts??={},f(s.parts[n.agent]??={tasks:0,runnerMs:0,tokenCount:0},o)),a.set(e,s)}return[...a.values()].sort((e,t)=>e.key.localeCompare(t.key))}function m(e,t){let n=new Map;for(let r of e)for(let[e,i]of Object.entries(r.parts??{}))n.set(e,(n.get(e)??0)+i[t]);return[...n].sort((e,t)=>t[1]-e[1]||e[0].localeCompare(t[0])).map(([e])=>e)}function h(e,t){if(typeof t==`number`)return(typeof e==`number`?e:0)+t;if(!t||typeof t!=`object`||Array.isArray(t))return e;let n=e&&typeof e==`object`&&!Array.isArray(e)?{...e}:{};for(let[e,r]of Object.entries(t))n[e]=h(n[e],r);return n}function g(e,t){let n=new Map;for(let r of e){let e=t===`agent`?r.agent:t===`installation`?r.installationId??`none`:r.engine??`unknown`,i=n.get(e)??{key:e,tasks:0,runnerMs:0};i.tasks++,i.runnerMs+=r.runnerElapsedMs,r.tokens!==void 0&&(i.tokens=h(i.tokens,r.tokens)),n.set(e,i)}return[...n.values()].sort((e,t)=>e.key.localeCompare(t.key))}function _(e,t,n){let r=e.filter(e=>e.at>=t);return{since:t,totals:n?g(r,n):{agent:g(r,`agent`),installation:g(r,`installation`),engine:g(r,`engine`)}}}const v={tasks:`tasks`,runner:`runnerMs`,tokens:`tokenCount`},y={tokens:e=>e.tokenCount,tasks:e=>e.tasks,runner:e=>e.runnerMs,name:e=>e.key};async function b(e,c){let l=e=>c.searchParams.get(e),u=Number(l(`since`)??0),f=l(`until`)===null?void 0:Number(l(`until`)),h=l(`by`)??`agent`;if(!Number.isFinite(u)||f!==void 0&&!Number.isFinite(f)||![`agent`,`installation`,`engine`,`day`].includes(h))return r({error:`Invalid usage query`},400);let g=l(`parts`)?.split(`,`).filter(Boolean),_=Math.min(Number(l(`top`)??0),8),b=v[l(`sort`)??`tokens`]??`tokenCount`,x=await p(e.store,{by:h,since:u,...f===void 0?{}:{until:f},...l(`agent`)?{agent:l(`agent`)}:{},...h===`day`?{tz:d(l(`tz`))}:{},...g?.length?{parts:g.slice(0,20)}:{},..._>0?{top:{count:_,by:b}}:{}}),S={since:u,...f===void 0?{}:{until:f}};if(h===`agent`){let r=new Set(e.local?(await t(e.local.cwd,e.integrations)).map(e=>e.id):(await e.store.list(`agent`)).map(e=>e.id));for(let e of Object.keys(n()))r.add(e);for(let e of x)r.has(e.key)||(e.deleted=!0)}if(_>0)return r({...S,totals:x,top:m(x,b)});if(!a(c)||h!==`agent`)return r({...S,totals:x});let C=y[l(`sort`)??`tokens`]??y.tokens,w=l(`sort`)===`name`,T=l(`q`)?.trim().toLowerCase(),E=([e,t],[n,r])=>(e<n?-1:+(e>n))*(w?1:-1)||t.localeCompare(r),D=e=>[C(e),e.key],O=o(c),k=x.filter(e=>!T||e.key.toLowerCase().includes(T)).filter(e=>!O||E(D(e),O)>0).sort((e,t)=>E(D(e),D(t))),A=i(c),j=e=>x.reduce((t,n)=>t+e(n),0);return r({...S,...s(k.slice(0,A+1),A,D),summary:{agents:x.length,tasks:j(e=>e.tasks),runnerMs:j(e=>e.runnerMs),tokenCount:j(e=>e.tokenCount)}})}async function x(e,t,n,i){t.local&&await c(t);let a=i.searchParams.get(`installation`),o=await t.store.list(`usage`);return r(a?o.filter(e=>e.value.installationId===a):o)}async function S(e,t,n,i){t.local&&await c(t);let a=Number(i.searchParams.get(`since`)??0),o=i.searchParams.get(`by`);if([`until`,`agent`,`tz`,`parts`,`top`,`cursor`].some(e=>i.searchParams.has(e))||o===`day`)return b(t,i);if(!Number.isFinite(a)||o&&![`agent`,`installation`,`engine`].includes(o))return r({error:`Invalid usage query`},400);let s=(await t.store.list(`usage`)).map(e=>e.value);return r(_(s,a,o))}export{l as a,d as i,x as n,S as r,f as t};

package/dist/usage-C4d9X2Uq.js

@@ -0,0 +1 @@
+import{i as e,r as t}from"./cli-BilSDkvE.js";import{g as n,p as r}from"./output-BKeyLbvt.js";import{i,n as a,s as o,t as s}from"./args-BOEEdpWk.js";import c from"node:process";const l={server:i,workspace:o,yes:a};function u(e,t){let i=Array.isArray(e.totals)?e.totals.map(e=>({group:t??``,...e})):Object.entries(e.totals).flatMap(([e,t])=>t.map(t=>({group:e,...t})));if(!i.length)return void c.stdout.write(`${r.dim(`No usage in this period.`)}\n`);c.stdout.write(`${n([{header:`by`,value:e=>e.group},{header:`key`,value:e=>e.key,paint:e=>r.cyan(e)},{header:`tasks`,value:e=>String(e.tasks)},{header:`runner ms`,value:e=>String(e.runnerMs)},{header:`tokens`,value:e=>e.tokens===void 0?``:JSON.stringify(e.tokens)}],i,r)}\n`)}const d=e({name:`agent usage`,help:{usage:`coder agent usage [--since 7d|24h|<ms>] [--by agent|installation|engine] [--server [url]] [--json] [--cwd <dir>]`,flags:[[`--since <period|ms>`,`period such as 7d or 24h, or milliseconds since epoch`],[`--by <group>`,`agent, installation, or engine`],t]},options:{...s,...l,since:o,by:o},run:async({options:e,cwd:t})=>{let{agents:n}=await import(`./agent-BsYx3Odz.js`).then(e=>e.t);return n.usage({...e,cwd:t,organization:e.workspace,since:e.since??`7d`})},print:(e,{options:t})=>u(e,t.by)});export{d as commandAgentUsage};

package/dist/watch-CSdj24ct.js

@@ -0,0 +1,5 @@
+import{Ht as e}from"./dispatch-BKeAch9E.js";import{i as t}from"./cli-BilSDkvE.js";import{_ as n,a as r,b as i,c as a,h as o,l as s,n as c,p as l,s as u,u as d,v as f,y as p}from"./output-BKeyLbvt.js";import{l as m,t as h}from"./args-BOEEdpWk.js";import g from"node:process";const _=t({name:`flow watch`,help:{usage:`coder flow watch [run-id] [--tail <n|all>] [--json]`,summary:`Watch a flow run live: replay its progress lines from the start, then keep
+following while it runs (Ctrl-C detaches; it keeps running). Blocks until it
+finishes; exits 0 on success, 1 otherwise. Defaults to the most recent run.
+For the result alone, prefer \`coder flow result\`. Alias: stream.`,flags:[[`--tail <n|all>`,`replay only the last n events first (default: all)`]],examples:[[`coder flow watch`,`follow the most recent run to completion`]]},options:{...h,tail:m},args:1,run:async({options:e,args:[t]})=>{let{watchRun:n}=await import(`./executor-BvAA7Cgw.js`).then(e=>e.y);return N(n(t,{tail:e.tail}),{json:e.json,stream:!0})}}),v=[`⣾`,`⣽`,`⣻`,`⢿`,`⡿`,`⣟`,`⣯`,`⣷`];function y(e,t=!1){let n=l;return t?c(`[${x(e)}]`,10):e===`completed`?n.bold(n.green(`✔`)):e===`failed`||e===`cancelled`||e===`stopped`?n.bold(n.red(`✘`)):e===`running`?n.bold(n.cyan(`●`)):n.dim(`○`)}function b(){return c(`[start]`,10)}function x(e){return e===`completed`?`done`:e===`cancelled`?`failed`:e}function S(e,t){return e??t.replace(/\s+/g,` `).trim().slice(0,60)}function C(e,t,n,r,i,a){let o=l,u=c(t??n,32);return[`${e} ${a?o.bold(u):u}`,o.dim(c(n,24)),o.light(c(i??``,20)),r?o.light(`${s(r.total)} tok`):``].join(` `).trimEnd()}function w(e,t=!1){let n=l;return`${y(e.ok?`completed`:`failed`,t)} ${n.dim(`gate`)} ${n.light(e.cmd)}${e.ok?``:n.dim(` · exit ${e.code}`)}`}function T(e,t,n){let i=l,a=n!==void 0&&n>=1e3?i.dim(` · ${r(n)}`):``;return`${t} ${i.dim(`gate`)} ${i.light(e)}${a}`}function E(e,t=!1){return l.dim(`${`│    `.repeat(e)}${t?`└─`:`├─`}`)}function D(e){return l.dim(`${`│    `.repeat(e)}│ `)}function O(e){return`${`  `.repeat(e.depth)}${e.log?`${c(`[log]`,10)} `:``}${e.body}`}function k(e,t,n=!1){return n?O(e):`${e.log?D(e.depth):E(e.depth,t)} ${e.body}`}function A(e){return l.dim(`${`│    `.repeat(Math.max(0,e))}│`)}var j=class{stream;names=new Map;active=new Map;activeGates=new Map;pending;previews=new Map;frame=0;hasCommitted=!1;timer;tty;region;constructor(e=g.stdout){this.stream=e,this.tty=!!e.isTTY,this.region=new n(e)}emit(e){let t=l;switch(e.kind){case`task-start`:{let t={name:S(e.name,e.prompt),engine:e.engine,depth:e.depth??0};if(this.names.set(e.taskId,t),!this.tty){this.final(t.depth,C(b(),t.name,e.taskId,null,t.engine));return}this.active.set(e.taskId,t),this.spin(!0),this.repaint();return}case`task-end`:{this.active.delete(e.taskId),this.previews.delete(e.taskId),this.idle();let t=this.names.get(e.taskId);this.final(t?.depth??0,C(y(e.status,!this.tty),t?.name??null,e.taskId,e.tokens,t?.engine));return}case`gate-start`:{let t={cmd:e.cmd,depth:e.depth??0,startedAt:Date.now()};if(!this.tty){this.final(t.depth,T(t.cmd,b()));return}this.activeGates.set(e.gateId,t),this.spin(!0),this.repaint();return}case`gate`:e.gateId&&this.activeGates.delete(e.gateId),this.idle(),this.final(e.depth??0,w(e,!this.tty));return;case`log`:for(let n of e.message.split(`
+`))this.final(e.depth??0,t.light(n),!0);return;case`flow-start`:this.final(e.depth-1,t.bold(`flow ${e.name}`));return;case`replay`:this.final(0,t.dim(`replayed ${e.count} steps from journal`),!0)}}done(){this.spin(!1),this.flush(0),this.tty&&this.repaint(),this.region.done()}flush(e){this.pending&&=(this.region.commit(`${k(this.pending,e<this.pending.depth,!this.tty)}\n`),this.hasCommitted=!0,void 0)}final(e,t,n=!1){if(!this.tty){this.region.commit(`${O({depth:e,body:t,log:n})}\n`),this.hasCommitted=!0;return}this.flush(e),this.pending={depth:e,body:t,log:n},this.tty&&this.repaint()}repaint(){let e=[],t=[];if(this.pending){let n=k(this.pending,!1);e.push(n),t.push(n)}let n=this.timer?l.bold(l.cyan(v[this.frame%v.length])):y(`running`);for(let[r,i]of this.active){let a=`${E(i.depth??0)} ${C(n,i.name,r,null,i.engine,!0)}`;(e.length||this.hasCommitted)&&e.push(A(i.depth??0)),e.push(a),t.push(a);let o=this.previews.get(r);o&&e.push(`${D(i.depth??0)} ${l.dim(o)}`)}for(let r of this.activeGates.values()){let i=`${E(r.depth)} ${T(r.cmd,n,Date.now()-r.startedAt)}`;(e.length||this.hasCommitted)&&e.push(A(r.depth)),e.push(i),t.push(i)}let r=(i(this.stream)??1/0)-1,a=e.length<=r?e:t;if(a.length>r){let e=Math.max(0,r-1);a=[l.dim(`… +${a.length-e} more running`),...a.slice(-e)]}this.region.set(a)}refreshPreviews(){for(let t of this.active.keys())try{let n=e(g.cwd(),t,1)[0]?.message?.replace(/\s+/g,` `).trim();if(!n)continue;let r=(p(this.stream)??120)-8;this.previews.set(t,n.length>r?`${n.slice(0,r-1)}…`:n)}catch{}}idle(){!this.active.size&&!this.activeGates.size&&this.spin(!1)}spin(e){e&&!this.timer?this.timer=setInterval(()=>{this.frame++,this.frame%4==0&&this.refreshPreviews(),this.repaint()},120).unref():!e&&this.timer&&(clearInterval(this.timer),this.timer=void 0)}};function M(e,t){if(t){o(e);return}let n=!g.stdout.isTTY,r=n?``:`${l.dim(`└─`)} `;g.stdout.write(`${r}${y(`completed`,n)} run ${l.cyan(e.runId)} completed ${l.dim(`(${e.taskCount} tasks)`)}\n`),g.stdout.write(`\n${a(e.result)}\n`),P(e.tokens)}async function N(e,t){let{runId:n}=e.record,r=!!(t.stream&&t.json);!t.json&&e.record.status===`running`&&g.stderr.write(`${l.dim(`[flow]`)} Run ${l.cyan(n)} started and is waiting to finish. Press Ctrl-C to detach. It keeps running.\n\n`);let i=t.json?()=>{}:f(),a=()=>{i(),r||(g.stderr.write(`\n${l.dim(`[flow] Detached. The run is still going.`)}\n`),g.stderr.write(`\n${u([`Result: coder flow result ${n}`,`Stop it: coder flow stop ${n}`],l)}\n`)),g.exit(130)};g.on(`SIGINT`,a);let s=new j;for await(let n of e.events)r?g.stdout.write(`${JSON.stringify(n)}\n`):t.json||s.emit(n);s.done(),i(),g.off(`SIGINT`,a);let c=e.final();r&&(g.stdout.write(`${JSON.stringify(F(c))}\n`),g.exit(c.status===`completed`?0:1)),c.status===`completed`&&(M({runId:n,name:c.name,status:`completed`,result:c.result,tokens:c.ledger,taskCount:c.taskCount},t.json),g.exit(0)),c.status===`stopped`&&(t.json?o({runId:n,name:c.name,status:`stopped`,taskCount:c.taskCount}):g.stdout.write(`\n${l.dim(`[flow] Run ${n} stopped.`)}\n\n${u([`Resume: coder flow resume ${n}`],l)}\n`),g.exit(1)),g.stdout.write(`\n${l.red(`error:`)} ${c.error??`unknown error`}\n`),g.stdout.write(`\n${u([`Resume: coder flow resume ${n}`],l)}\n`),g.exit(1)}function P(e){let t=Object.keys(e);if(t.length){g.stdout.write(`\n${l.bold(`Tokens:`)}\n`);for(let n of t)g.stdout.write(`  ${l.dim(d(e[n],n))}\n`)}}function F(e){let{steps:t,events:n,...r}=e;return r}export{j as FlowStepRenderer,_ as commandWatch,w as gateLine,T as gateRunningLine,O as paintPlain,N as printFollow,P as printLedger,M as printRunSummary,F as resultJson,y as stepSymbol,S as taskLabel,C as taskLine};

package/dist/watch-DtRuC0Wc.js

@@ -0,0 +1,8 @@
+import{Dn as e,cn as t}from"./dispatch-BKeAch9E.js";import{i as n,r}from"./cli-BilSDkvE.js";import{p as i,y as a}from"./output-BKeyLbvt.js";import{i as o,l as s,n as c,s as l,t as u}from"./args-BOEEdpWk.js";import{LogRenderer as d,finalMessageLine as f,printOutcome as p,promptBlock as m,taskHeaderLines as h,taskSummaryLines as g,trimStep as _}from"./result-BzaM3inj.js";import v from"node:process";import*as y from"zod/mini";const b={server:o,workspace:l,yes:c};function x(e,t){let n=e.level===`sys`?t.dim(`· ${e.line}`):e.level===`err`?t.light(e.line):e.line;v.stdout.write(`${n}\n`)}async function S(n,r,o){if(`attempts`in n.task){for await(let e of n.events)o.json?v.stdout.write(`${JSON.stringify(e,null,2)}\n`):x(e,i);let e=await n.final();o.json||p(e,i),v.exit(0)}let s=n.task,c=o.trim===void 0?500:o.trim===`none`?1/0:o.trim,l=await d.create({cwd:s.cwd??r,startedAt:Date.parse(s.createdAt??``)||void 0,trim:c,explicitTrim:o.trim!==void 0,width:a()});if(!o.json){let e=[...h(s,{status:s.status}),...t.includes(s.status)?[i.dim(`Watching. Press Ctrl-C to stop.`)]:[],...s.prompt?m(s.prompt,i,{truncate:!1}):[],``];v.stdout.write(`${e.join(`
+`)}\n`)}let u=null,y=null,b=e=>{let t=l.render(e);t.length&&v.stdout.write(`${t.join(`
+`)}\n`)};for await(let e of n.events){let t=e;if(t.kind===`usage`&&t.tokens&&(u=t.tokens),o.json){let e=t.kind===`steer`?1/0:c,n=t.message?{...t,message:_(t.message,e,{plain:!0})}:t;v.stdout.write(`${JSON.stringify(n)}\n`);continue}t.kind!==`usage`&&(y&&=(b(y),null),t.kind===`assistant`?y=t:b(t))}let{status:S,result:C,task:w}=await n.final();if(o.json)v.stdout.write(`${JSON.stringify({taskId:s.id,status:S,result:C},null,2)}\n`);else{let t=S===`completed`?`(no final message)`:`(task ${S})`,n=g(w,{tokens:C?.tokens??u,tokenModel:C?.model,files:C?.touchedFiles?.map(t=>e(s.cwd??r,t)),statusChanged:S!==s.status});n.length&&v.stderr.write(`\n${n.join(`
+`)}\n`);let i=f(C,w.error,t),a=y?String(y.message??``):``;v.stdout.write(`\n${i.trim()?i:a}\n`)}v.exit(S===`completed`?0:1)}const C=n({name:`task watch`,help:{usage:`coder task watch [task-id] [--server [url]]`,summary:`Stream a running task's transcript live (for you/debugging), then print its
+final answer. Replays the last line first so the current step is visible;
+--tail <n> replays the last n lines (--tail all for the whole transcript).
+Blocks until it finishes; exits 0 on success, 1 otherwise. For the answer
+alone, prefer \`coder result\`. Alias: stream.`,flags:[[`--tail <n|all>`,`replay the last n log lines first (default: 1)`],[`--trim <n|none>`,`budget for tool output and thinking (default: 1200 chars, 12 lines)`],r],examples:[[`coder task watch`,`follow the most recent task to completion`]]},options:{...u,tail:s,trim:y.optional(y.union([y.literal(`none`),y.coerce.number().check(y.int(),y.positive())],{error:`expected a positive integer or "none"`})),...b},args:1,async run({options:e,args:[t],cwd:n}){let{tasks:r}=await import(`./task-C6VAg5WU.js`).then(e=>e.t);await S(await r.watch(t,{...e,organization:e.workspace}),n,e)}});export{C as commandWatch,x as printLine};

package/dist/wire-BeT1Axeo.js

@@ -0,0 +1 @@
+import{Q as e}from"./dispatch-BKeAch9E.js";import t from"node:process";async function n(n,r,i){let a=n.envKey?t.env[n.envKey]:void 0,o=!1;for(let t of e(n.baseUrl,r))try{let e=await fetch(t,{method:`POST`,headers:{"content-type":`application/json`,...a?{Authorization:`Bearer ${a}`}:{}},body:JSON.stringify(i),signal:AbortSignal.timeout(5e3)});if(o=!0,e.status!==404&&e.status!==405&&e.status!==501)return{baseUrl:t.slice(0,-(r.length+1))}}catch{}return{reachable:o}}async function r(e){let t=await n(e,`responses`,{model:e.model,input:[],stream:!1});if(`baseUrl`in t)return{wireApi:`responses`,baseUrl:t.baseUrl};let r=await n(e,`chat/completions`,{model:e.model,messages:[],stream:!1});return`baseUrl`in r?{wireApi:`chat`,baseUrl:r.baseUrl}:t.reachable||r.reachable?{wireApi:`chat`}:null}export{r as t};

package/dist/worker-CXndxmGF.js

@@ -0,0 +1,9 @@
+import{F as e,I as t,J as n,M as r,O as i,On as a,Ot as o,Qt as s,S as c,Tt as l,_ as u,ft as d,in as f,l as p,mt as m,nt as h,pt as g,sn as _,tn as v,tt as y,ut as b,zt as x}from"./dispatch-BKeAch9E.js";import{t as S}from"./chat-bridge-BS9WtP3X.js";import{t as C}from"./wire-BeT1Axeo.js";import w from"node:path";import T from"node:process";import E from"node:fs";function D(e){if(e.resumeThreadId)return e.currentPrompt??e.prompt??``;let t=e.system?`\n-------\n${e.system}`:``;return`<system>
+You are running inside a coder task: do the work yourself, directly.
+Do not load the coder skill (recursive), and never dispatch through the \`coder\` CLI - nested dispatch is disabled.
+When finished, provide a concise implementation result summary.
+Your turn is one-shot: background processes will not re-invoke you after it ends, so verify synchronously before finishing.
+Never run git write operations (commit, checkout, stash, reset, rebase, merge, push, etc.); leave changes uncommitted for the caller to review.${e.agentId?"\nFlows are the exception: run one from your shell with `coder flow run <name> --wait --json --args '<json>'`; it runs as a script in your sandbox.":``}${t}
+</system>
+
+${e.prompt??``}`}function O(e,t){let n=0;return()=>{Date.now()-n>=1e4&&(n=Date.now(),f(e,t))}}function k(e,t,{echo:n}){return r=>{let i=typeof r==`string`?{message:r}:r;l(e,t,i),n&&i.message&&T.stderr.write(`[coder] ${i.message}\n`)}}async function A(i,a,{echo:o}){let c=v(i),f=s(i,a.id),x=h(i),w=k(i,a.id,{echo:o}),E=n[a.permissions??`auto`]??n.auto,A=E.approvalPolicy===`never`?void 0:u({workspaceRoot:c,taskDir:f,mode:E.approvalMode,escalationTimeoutMs:x.approvals.escalationTimeoutMs,allowedNetworkHosts:x.approvals.allowedNetworkHosts,onEvent:e=>{l(i,a.id,e),o&&e.message&&T.stderr.write(`[coder] ${e.message}\n`)}}),j=a.model?x.models?.[a.model]:void 0,N=j&&y(j)?j:void 0;if(N&&!N.wireApi&&a.model){let e=await C(N);e&&(N={...N,...e},x.models[a.model]=N,b(i,a.model,e),l(i,a.id,{kind:`info`,message:`detected wire api for ${a.model}: ${e.wireApi} @ ${N.baseUrl}`}))}if(N?.envKey&&!T.env[N.envKey])throw Error(`Missing environment variable: \`${N.envKey}\`.`);let P=N?await S(N,N.wireApi??`chat`):null,F=m(x,a.model,P??void 0),I=t(i,a);try{let t=await r(i,{prompt:D(a),outputSchema:a.outputSchema,model:F?.model??d(a.model),modelProvider:F?.modelProvider??null,configOverrides:I?{...F?.configOverrides,"shell_environment_policy.set":{[e]:I}}:F?.configOverrides??null,effort:a.effort,sandbox:E.sandbox,approvalPolicy:E.approvalPolicy,networkAccess:g(a.permissions??`auto`,x.engines.codex?.network),approvalsReviewer:E.approvalMode===`auto`?`auto_review`:null,mcpServers:p(a.mcp),writableRoots:[...E.sandbox===`read-only`?[]:a.addDirs??[],...I?[I]:[]],onApprovalRequest:A,onHeartbeat:O(i,a.id),resumeThreadId:a.resumeThreadId??null,onControlReady:(e,t,n)=>{_(i,a.id,{status:`running`,steerEndpoint:e,threadId:t,turnId:n})},onProgress:e=>{w(e);let t=typeof e==`object`?e.threadId:null,n=typeof e==`object`?e.turnId:null;(t||n)&&_(i,a.id,{status:`running`,...t?{threadId:t}:{},...n?{turnId:n}:{}})}});return _(i,a.id,{status:t.status===0?`completed`:`failed`,threadId:t.threadId,turnId:t.turnId,steerEndpoint:null,completedAt:new Date().toISOString()}),M(i,a,f,t),t}finally{_(i,a.id,{steerEndpoint:null}),await P?.close()}}async function j(r,a,{echo:o}){let c=s(r,a.id),l=h(r),u=k(r,a.id,{echo:o}),d=n[a.permissions??`auto`]??n.auto,f=t(r,a);try{let t=await i(r,{prompt:D(a),outputSchema:a.outputSchema,model:a.model,effort:a.effort,permissions:a.permissions,approvalTaskId:d.approvalMode===`auto`?a.id:null,allowedNetworkHosts:l.approvals.allowedNetworkHosts,additionalDirectories:a.addDirs,...f?{writableDirectories:[f],env:{[e]:f}}:{},mcpServers:p(a.mcp),taskRoot:c,resumeSessionId:a.resumeThreadId??null,onHeartbeat:O(r,a.id),onSteerReady:e=>{_(r,a.id,{status:`running`,steerEndpoint:e})},onProgress:e=>{u(e),e.threadId&&_(r,a.id,{status:`running`,threadId:e.threadId})}});return _(r,a.id,{status:t.status===0?`completed`:`failed`,threadId:t.threadId,steerEndpoint:null,completedAt:new Date().toISOString()}),M(r,a,c,t),t}finally{_(r,a.id,{steerEndpoint:null})}}function M(e,t,n,r){a(w.join(n,`result.json`),r);let i={at:new Date().toISOString(),prompt:t.currentPrompt??t.prompt??null,...r};E.appendFileSync(w.join(n,`results.jsonl`),`${JSON.stringify(i)}\n`,`utf8`)}function N(e){return e.engine===`claude`?j:A}async function P(e,t){for(let n=0;n<2;){let r=x(e,t);if(!r||r.status===`failed`||r.status===`cancelled`)return;let i=o(e,t);if(i.length===0){n+=1,await new Promise(e=>setTimeout(e,300));continue}n=0;for(let n of i){let i=_(e,t,{status:`running`,currentPrompt:n,resumeThreadId:r.threadId??null});l(e,t,{message:`Running steered follow-up.`});try{await N(i)(e,i,{echo:!1})}catch(n){let r=n instanceof Error?n.message:String(n);_(e,t,{status:`failed`,error:r}),l(e,t,{kind:`error`,message:r});return}}}}async function F(e,t,n){if(t.dispatchId&&!t.resumedAt)try{E.writeFileSync(w.join(s(e,t.id),`start-${t.dispatchId}`),``,{flag:`wx`})}catch(e){if(e.code===`EEXIST`)return;throw e}_(e,t.id,{status:`running`,pid:T.pid});let r=()=>{},i;try{if(r=n(e,t),t.name?.startsWith(`agent:`)){let{startInboxControl:n,applyTaskMessage:r}=await import(`./task-DeglY79z.js`).then(e=>e.d);i=n(s(e,t.id),t.name.slice(6),n=>r(e,x(e,t.id)??t,n))}if(t.simulateApproval){let n=await c(s(e,t.id),{onEvent:n=>l(e,t.id,n)});if(l(e,t.id,{message:`simulated approval: ${n}`}),n===`decline`){_(e,t.id,{status:`cancelled`,completedAt:new Date().toISOString(),error:`simulated approval denied`});return}}await N(t)(e,t,{echo:!1}),await P(e,t.id)}catch(n){let r=n instanceof Error?n.message:String(n);throw _(e,t.id,{status:`failed`,error:r}),l(e,t.id,{kind:`error`,message:r}),n}finally{r(),await i?.close()}}export{F as runWorker};

package/dist/worker-DX7P9kWl.js

@@ -0,0 +1 @@
+import{zt as e}from"./dispatch-BKeAch9E.js";import{i as t}from"./cli-BilSDkvE.js";import{i as n}from"./output-BKeyLbvt.js";import{s as r}from"./args-BOEEdpWk.js";import i from"node:process";const a=t({name:`task worker`,options:{cwd:r},args:1,async run({args:[t],cwd:r}){let{startAgentMailbox:a}=await import(`./exec-RZFLclKX.js`).then(e=>e.i),{runWorker:o}=await import(`./worker-CXndxmGF.js`),s=e(r,t);s||n(`Worker: task ${t} not found.`),await o(r,s,a).catch(()=>i.exit(1))}});export{a as commandWorker};

package/dist/workflow-Dcmdooi8.js

@@ -0,0 +1 @@
+import{i as e}from"./cli-BilSDkvE.js";import t from"node:process";const n=e({name:`server workflow`,globalFlags:{json:!1,cwd:!1},help:{usage:`coder server workflow`,summary:`Print the workflow the github-actions runner dispatches. Save it as .github/workflows/coder-agent.yml in every repo the agent runs on, and set RUNNER=github-actions on the server.`,examples:[[`coder server workflow > .github/workflows/coder-agent.yml`,`add it to a repo`]]},options:{},run:async()=>{let{ACTIONS_WORKFLOW_YAML:e}=await import(`./github-actions-DwUzm4hC.js`).then(e=>e.r);return e},print:e=>t.stdout.write(e)});export{n as commandServerWorkflow};

package/docs/agents/coder.md

@@ -0,0 +1,26 @@
+# The `coder` agent
+
+The built-in agent. On the hosted service it has an install link per platform; self-hosters create its shared apps once per server with `coder server app create <integration>` ([Self-hosting](../self-host.md#after-the-first-start)). Tune or disable it under `agents.coder` in `.coder/config.json` ([Usage](index.md#usage)).
+
+## On GitHub
+
+- A pull request opening, updating, or becoming ready runs the [review flow](../review.md) read-only and posts inline comments with a sticky summary. Reruns update the summary and never repeat a finding.
+- A review request for the agent does the same.
+- A mention (`@<app>` from a repository owner or member) answers from the diff and the repository, or makes the requested change on a branch and links the pull request.
+
+## On Slack
+
+- A mention or a direct message reads the thread and the linked repository, then answers, makes the change and links the pull request, or asks one clarifying question.
+- Replies stay in the thread they were asked in, in Slack's style, with short paragraphs and code spans and no headings.
+- When the workspace has connected GitHub from the [dashboard](../dash.md), it can read and change code there.
+
+## What it runs with
+
+|             |                                                                   |
+| ----------- | ----------------------------------------------------------------- |
+| Permissions | `workspace-write`; `read-only` for pull-request reviews           |
+| Tools       | GitHub `write`, Slack `comment`                                   |
+| Flows       | `review`                                                          |
+| Engine      | the workspace's default [credential](../self-host.md#credentials) |
+
+The definition is `src/agent/builtin/coder/{agent.json,system.md}` in the package; a custom agent is the same two files in your repo ([Your own agents](index.md#your-own-agents)).

package/docs/agents/index.md

@@ -0,0 +1,120 @@
+# Agents
+
+An agent is a reusable teammate. Its `system.md` holds the standing instructions every task starts from: who it is, what it knows, how it answers. Its definition adds engine, model, effort and permissions defaults, the MCP servers it attaches and the [flows](../flows.md) it may run. Run it from the CLI with `coder task run --agent <id> "…"`, where flags override the defaults, from the [dashboard](../dash.md), or from platform events like a Slack DM or a GitHub pull request.
+
+Connected to a platform, an agent listens for the events its triggers name. Each event runs as a task with a fresh checkout, the agent's instructions, the event as its request, and only the platform tools the agent declared; the reply goes back to the thread. A bigger task can run a flow instead, with the event as its `args`.
+
+On each platform an agent is its own app, a GitHub App or a Slack app for example, so it has its own handle and permissions and runs only where it is installed. Agents run on a Coder server: the hosted one, [your own](../self-host.md), or this machine's [dashboard](../dash.md).
+
+## Built-in agent
+
+[`coder`](coder.md) answers engineering questions, reviews pull requests, and makes requested changes. It is on by default wherever its apps are installed; tune or disable it under `agents.coder` in `.coder/config.json` ([Usage](#usage)).
+
+## Your own agents
+
+An agent comes from one of two sources:
+
+- **Dashboard**: made in the agent editor on the [dashboard](../dash.md).
+- **Repository**: `coder agent init` scaffolds one, asking its id, platforms, triggers and tools. It is a folder `.coder/agents/<id>/` with an `agent.json` and a `system.md`. A folder in `$CODER_HOME/agents/<id>/` (default `~/.coder/agents`) is yours in every repo, and a repo's folder of the same id wins.
+
+Here is a helper that answers in Slack and on GitHub issues:
+
+`.coder/agents/helper/agent.json`
+
+```json
+{
+  "name": "Helper",
+  "description": "Answers engineering questions about acme/app.",
+  "permissions": "read-only",
+  "integrations": {
+    "slack": {
+      "triggers": { "mention": true, "message": { "match": "^help\\b" } },
+      "tools": "comment"
+    },
+    "github": { "triggers": ["mention"], "tools": "observe" }
+  }
+}
+```
+
+`.coder/agents/helper/system.md`
+
+```md
+You answer questions about acme/app from its source. Cite file paths.
+If asked to change code, describe the change and stop; never promise a PR.
+```
+
+From there:
+
+1. Get the agent to a server. A local server reads it from the repo on disk. A cloud server imports it from the dashboard and again on each push to the agents repo once the agent's GitHub App is installed there; `coder agent push` uploads it without a repo.
+2. On the dashboard, the agent's Platforms tab creates its app on each platform it uses and installs it; the app's credentials go straight to the server.
+3. Events now reach the server, a task runs on its runner, and the reply is posted back. `coder agent run helper <event.json> --server --wait` fires one by hand; without `--server` it runs offline, platform tools off, reply printed. `--server` means `CODER_SERVER`, else the hosted service; give it a URL to pick another.
+
+Only pushes to the agents repo's configured branch are imported. An app created before push events existed needs the `push` event enabled once in its GitHub App settings.
+
+### Definition
+
+`agent.json`. The folder name is the id; the built-in id `coder` is reserved.
+
+| Key                          | Values                                                                                                                                                                                                  | Purpose                                                                                                                                                                                                                    |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `name`, `description`        | Text                                                                                                                                                                                                    | App name and handle; the description is added to the prompt                                                                                                                                                                |
+| `engine`, `model`, `effort`  | As in `coder task run`                                                                                                                                                                                  | Engine defaults                                                                                                                                                                                                            |
+| `permissions`                | `read-only` (default), `workspace-write`, `auto`                                                                                                                                                        | Agent sandbox mode inside the checkout                                                                                                                                                                                     |
+| `integrations.<id>.triggers` | Event names from the [integration](#integrations): a list, or a map of event → `true`, a flow name (repo `.coder/flows` or built-in such as `review`), or `{ "flow", "match", "permissions", "actAs" }` | A list or `true` runs the agent, a flow name runs that flow, `match` is a regex the event text must pass, `permissions` overrides the agent's for this event, `"actAs": "requester"` uses the requester's own GitHub token |
+| `integrations.<id>.tools`    | `observe` (default), `comment`, `write`, or tool names from the [integration](#integrations)                                                                                                            | Platform actions the agent uses; also the app's permissions                                                                                                                                                                |
+| `mcp`                        | A map of MCP servers in the `.mcp.json` entry shape, as in `coder mcp`                                                                                                                                  | Servers every task of the agent attaches                                                                                                                                                                                   |
+
+`permissions` is about the checkout, `tools` is about the platform. An agent can run any [flow](../flows.md#flows-run-by-an-agent), and the tasks it starts never exceed the agent's `permissions`. The server versions imported definitions and activates a new version when their content changes; recreate the app only when `triggers` or `tools` change.
+
+## Usage
+
+How a repo runs an agent goes under `agents` in its `.coder/config.json` ([Configuration](../config.md)), one entry per agent id. No entry or `true` runs the agent as defined, `false` disables it, an object overrides it:
+
+```json
+{
+  "agents": {
+    "coder": { "model": "sol" },
+    "helper": { "integrations": { "slack": { "allowedEvents": ["mention"] } } }
+  }
+}
+```
+
+| Key                                        | Values              | Purpose                                                    |
+| ------------------------------------------ | ------------------- | ---------------------------------------------------------- |
+| `engine`, `model`, `effort`, `permissions` | As above            | Override the definition                                    |
+| `integrations.<id>.allowedTools`           | Preset or tool list | Cap the definition's tools; omit to allow all it asks for  |
+| `integrations.<id>.allowedEvents`          | Event names         | Cap the definition's events; omit to allow all it asks for |
+
+Unknown ids, integrations, events, tools, and keys fail validation. Usage is read from the repo the event came from.
+
+## CLI
+
+| Command                                                             | Purpose                                                                |
+| ------------------------------------------------------------------- | ---------------------------------------------------------------------- |
+| `coder agent list [--server [url]]`                                 | List agents, with active versions on a server                          |
+| `coder agent show <id> [--server [url]]`                            | One agent in full: settings, integrations, triggers, tools             |
+| `coder agent init [id]`                                             | Scaffold an agent folder; interactive without flags                    |
+| `coder agent push [id] [--server [url]]`                            | Upload one agent, or all of them, without a source repo                |
+| `coder agent run <agent> <event.json> [--server [url] [--wait]]`    | Run a recorded event through an agent, on a server or offline          |
+| `coder agent usage [--since 7d] [--by agent\|installation\|engine]` | Aggregate usage of this machine's tasks, or a server's with `--server` |
+| `coder agent integrations <list\|show <id>>`                        | Integrations with their events and tool presets                        |
+| `coder task run --agent <id> "…"`                                   | Run an agent's definition locally; flags override it                   |
+
+## Integrations
+
+An integration gives an agent two things:
+
+1. **Chat.** The agent's own app on the platform. Its events start tasks, and the reply goes back to the same thread. Only linked workspace members can address an agent.
+2. **Platform tools.** Actions beyond replying, through the platform's own MCP server or API. They run outside the agent's sandbox, with a token narrowed to the task, and the token never reaches the agent. The presets add up: `comment` includes `observe`, and `write` includes `comment`.
+
+| Platform        | App                                                                                                                                                                              | Events                                                     | Tools                                                                                                                  |
+| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| GitHub          | A [GitHub App](https://docs.github.com/en/apps/sharing-github-apps/registering-a-github-app-from-a-manifest) per agent                                                           | `mention`, `pull_request`, `issue`, `comment`              | GitHub's [MCP server](https://github.com/github/github-mcp-server); `observe` runs it read-only                        |
+| Slack           | A [Slack app](https://api.slack.com/reference/manifests) per agent                                                                                                               | `mention`, `message`, `reaction`, `command`                | `slack_api(method, args)` over the [Web API](https://api.slack.com/methods), with writes limited to the event's thread |
+| Microsoft Teams | An [Azure Bot](https://learn.microsoft.com/en-us/azure/bot-service/bot-service-quickstart-registration) you create, with its endpoint at `<PUBLIC_URL>/hooks/teams?app=<app id>` | `mention`, `message`, `reaction`                           | None yet                                                                                                               |
+| Gmail           | Your Google OAuth client plus a [Pub/Sub push](https://developers.google.com/workspace/gmail/api/guides/push) to `<PUBLIC_URL>/hooks/gmail?app=<client id>`                      | `mail`: only from linked senders whose domain passes DMARC | None yet                                                                                                               |
+| Linear          | Your [Linear OAuth app](https://linear.app/developers/agents), with webhooks to `<PUBLIC_URL>/hooks/linear?app=<client id>`                                                      | `mention`: an agent session                                | None yet                                                                                                               |
+
+`coder agent integrations show <id>` lists each event and each preset's exact tools or scopes. A host turns platforms off with `SERVER_INTEGRATIONS` ([Self-hosting](../self-host.md)).
+
+Need another integration or a missing event or tool? [Open an issue](https://github.com/muzam1l/coder/issues).