@wular/coder 0.4.11 → 0.4.13

package/dist/review-Dxs-idTn.d.ts

@@ -1,566 +0,0 @@
-import { c as TaskStatus, d as TokenUsage, l as TurnResult, o as McpServerSpec, s as Task, u as TaskLogEntry } from "./types-C6NAqGqn.js";
-import { AsyncLocalStorage } from "node:async_hooks";
-import * as z from "zod";
-//#region src/flow/types.d.ts
-/** Anything with zod's parse shape; the flow runtime never imports zod itself. */
-interface FlowSchema<T> {
-  parse(value: unknown): T;
-}
-interface FlowTaskResult<T = unknown> {
-  taskId: string;
-  status: string;
-  output: string;
-  data?: T;
-  tokens: TokenUsage | null;
-  model: string | null;
-}
-interface GateResult {
-  ok: boolean;
-  code: number;
-  output: string;
-}
-/** Options shared with `coder run`, plus `returns`. */
-interface FlowTaskOptions<T = unknown> {
-  engine?: string;
-  model?: string;
-  effort?: string;
-  permissions?: string;
-  mcp?: string | McpServerSpec[];
-  name?: string;
-  system?: string;
-  cwd?: string;
-  addDirs?: string[];
-  returns?: FlowSchema<T>;
-}
-/** Overrides for one more turn, as `coder task steer` takes them. */
-interface FlowSteerOptions {
-  model?: string;
-  effort?: string;
-  permissions?: string;
-}
-type FlowRunStatus = 'running' | 'completed' | 'failed' | 'stopped';
-/** An event recorded by the flow runtime and delivered to its hooks and followers. */
-type FlowEvent = {
-  kind: 'task-start';
-  taskId: string;
-  name?: string;
-  prompt: string;
-  engine?: string;
-  depth?: number;
-} | {
-  kind: 'task-end';
-  taskId: string;
-  status: string;
-  tokens: TokenUsage | null;
-} | {
-  kind: 'gate-start';
-  gateId: string;
-  cmd: string;
-  depth?: number;
-} | {
-  kind: 'gate';
-  gateId?: string;
-  cmd: string;
-  ok: boolean;
-  code: number;
-  depth?: number;
-} | {
-  kind: 'log';
-  message: string;
-  depth?: number;
-} | {
-  kind: 'flow-start';
-  name: string;
-  depth: number;
-} | {
-  kind: 'replay';
-  count: number;
-};
-interface JournalEntry {
-  seq: number;
-  kind: 'task' | 'gate' | 'flow';
-  fingerprint: string;
-  result: unknown;
-  taskId?: string;
-  tokens?: TokenUsage | null;
-  startedAt: string;
-  endedAt: string;
-}
-/** flow.json: the persisted run record. */
-interface FlowRecord {
-  runId: string;
-  name: string;
-  script: string;
-  args: unknown;
-  status: FlowRunStatus;
-  startedAt: string;
-  endedAt?: string;
-  /** Orchestrator process while status is running; cleared on every terminal write. */
-  pid?: number;
-  pidStartedAt?: string;
-  concurrency: number;
-  concurrencySet?: boolean;
-  maxTasks: number;
-  taskCount: number;
-  ledger: Record<string, TokenUsage>;
-  result?: unknown;
-  error?: string;
-  /** Hidden from the default list; set by auto-archive or `flow archive`. */
-  archived?: boolean;
-  archivedAt?: string;
-}
-/** One `flow result` step row: a journaled task with its current status. */
-interface FlowStep {
-  taskId: string | null;
-  name: string | null;
-  status: string;
-  tokens: TokenUsage | null;
-}
-interface DiscoveredFlow {
-  name: string;
-  path: string;
-  /** `builtin` flows ship with coder; their `path` is `builtin:<name>`. */
-  scope: 'workspace' | 'global' | 'builtin';
-}
-//#endregion
-//#region src/flow/journal.d.ts
-/**
- * Prefix-order replay. A call matches the first unconsumed recorded entry with
- * an identical fingerprint (fingerprint match rather than strict positional
- * next, so concurrent pipelines resume correctly); a miss runs live. The file
- * is truncated on construction and rewritten in this run's completion order, so
- * every run leaves a clean journal for the next resume.
- */
-declare class Journal {
-  private file;
-  private recorded;
-  private seq;
-  constructor(recorded: JournalEntry[], file: string);
-  private write;
-  /** Recorded result for one of these fingerprints, or null to run live. */
-  replay(...fps: string[]): JournalEntry | null;
-  record(entry: Omit<JournalEntry, 'seq'>): void;
-}
-//#endregion
-//#region src/flow/runtime.d.ts
-/** Progress callbacks a foreground caller can attach to a run. */
-interface FlowHooks {
-  /** Fired once the run is armed, with a stop handle for a SIGINT handler. */
-  onStart?: (h: {
-    runId: string;
-    requestStop: () => void;
-    runningIds: () => string[];
-  }) => void;
-  onEvent?: (event: FlowEvent) => void;
-}
-interface RunContext {
-  runId: string;
-  runDir: string;
-  cwd: string;
-  journal: Journal;
-  semaphore: Semaphore;
-  /** The caller set no concurrency, so the flow's own `concurrency` export applies. */
-  flowConcurrency: boolean;
-  maxTasks: number;
-  dryRun: boolean;
-  ledger: Record<string, TokenUsage>;
-  running: Set<string>;
-  taskCount: number;
-  stopping: boolean;
-  hooks: FlowHooks;
-  /** Caller-owned platform credential; in memory only, never written to flow.json. */
-  integrationToken?: string;
-  connections?: {
-    mcp: Record<string, McpServerSpec>;
-    env: Record<string, string>;
-    ids: string[];
-  };
-  ceiling?: {
-    agent: string;
-    permissions: string;
-  };
-}
-declare class Semaphore {
-  limit: number;
-  private active;
-  private queue;
-  constructor(limit: number);
-  run<T>(fn: () => Promise<T>): Promise<T>;
-}
-/**
- * Dispatch one coder task and await its result. With a `returns` schema the
- * reply is validated and `data` is guaranteed (validation failure throws).
- * Inside a flow run, results are journaled and replayed on resume.
- */
-declare function task<T>(prompt: string, opts: FlowTaskOptions<T> & {
-  returns: FlowSchema<T>;
-}): Promise<FlowTaskResult<T> & {
-  data: T;
-}>;
-/** Dispatch one coder task and await its result. Mirrors `coder run`. */
-declare function task(prompt: string, opts?: FlowTaskOptions): Promise<FlowTaskResult>;
-/** Continue a task this run started, on the same id, and await the turn. Mirrors `coder task steer --wait`. */
-declare function steer(taskId: string, text: string, opts?: FlowSteerOptions): Promise<FlowTaskResult>;
-/**
- * Run a shell command as a checkpoint. Never throws. Inspect `ok`/`code`.
- * output is captured (capped) and journaled for resume.
- */
-declare function gate(cmd: string, opts?: {
-  cwd?: string;
-}): Promise<GateResult>;
-type Stage = (prev: any, item: any, index: number) => unknown;
-type S<P, T, R> = (prev: P, item: T, index: number) => R | Promise<R>;
-/**
- * Run each item through the stages independently, with no barrier between
- * stages. Each stage receives `(prev, item, index)`; a thrown stage drops
- * that item to `null` and skips its remaining stages.
- */
-declare function pipeline<T, A>(items: T[], s1: S<T, T, A>): Promise<(A | null)[]>;
-declare function pipeline<T, A, B>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>): Promise<(B | null)[]>;
-declare function pipeline<T, A, B, C>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>, s3: S<B, T, C>): Promise<(C | null)[]>;
-declare function pipeline<T, A, B, C, D>(items: T[], s1: S<T, T, A>, s2: S<A, T, B>, s3: S<B, T, C>, s4: S<C, T, D>): Promise<(D | null)[]>;
-declare function pipeline<T>(items: T[], ...stages: Stage[]): Promise<any[]>;
-/** Emit a progress line to the run's event stream. */
-declare function log(msg: string): void;
-/**
- * Run another flow inline as a sub-step and return its result. Nesting is one
- * level deep. A subflow cannot call `flow()` itself.
- */
-declare function flow(name: string, args?: unknown): Promise<unknown>;
-//#endregion
-//#region src/core/state.d.ts
-interface TurnResultEntry {
-  at?: string;
-  prompt?: string | null;
-  /** Steers the engine took into this turn while it ran. */
-  steers?: string[];
-  lastReply?: string;
-  finalMessage?: string;
-  error?: TurnResult['error'];
-  status?: number;
-  tokens?: TurnResult['tokens'];
-  model?: TurnResult['model'];
-  [key: string]: unknown;
-}
-declare function readTurnResults(cwd: string, taskId: string): TurnResultEntry[];
-//#endregion
-//#region src/flow/executor.d.ts
-interface RunOptions {
-  runId?: string;
-  args?: unknown;
-  concurrency?: number;
-  maxTasks?: number;
-  dryRun?: boolean;
-  cwd?: string;
-  /** Platform credential for built-in integrations; never persisted with the run. */
-  integrationToken?: string;
-  connections?: RunContext['connections'];
-  /** The agent whose permissions cap every task this run starts. */
-  ceiling?: {
-    agent: string;
-    permissions: string;
-  };
-}
-interface RunSummary {
-  runId: string;
-  name: string;
-  status: 'completed';
-  result: unknown;
-  tokens: Record<string, TokenUsage>;
-  taskCount: number;
-}
-interface StopSummary {
-  runId: string;
-  status: FlowRecord['status'];
-  stoppedTasks: string[];
-  keptTasks: string[];
-}
-declare const review$1: {
-  run(options?: ReviewArgs): Promise<ReviewResult & {
-    runId: string;
-  }>;
-};
-//#endregion
-//#region src/flow/runs.d.ts
-/** A run's record with its step rows, trimmed journal and recorded events. */
-type RunResult = FlowRecord & {
-  steps: FlowStep[];
-  journal: Array<Pick<JournalEntry, 'kind' | 'taskId' | 'tokens'>>;
-  events: FlowEvent[];
-};
-type Archived = {
-  runId: string;
-  archived: true;
-};
-type ArchivedAll = {
-  archived: string[];
-  count: number;
-};
-/** Archive one stopped run, or with `allStopped` every one. */
-declare function archiveRuns(runId: string, opts?: {
-  allStopped?: false;
-}): Archived;
-declare function archiveRuns(runId: string | undefined, opts: {
-  allStopped: true;
-}): ArchivedAll;
-declare function archiveRuns(runId?: string, opts?: {
-  allStopped?: boolean;
-}): Archived | ArchivedAll;
-type Deleted = {
-  runId: string;
-  deleted: boolean;
-};
-type DeletedAll = {
-  deleted: string[];
-  count: number;
-};
-/** Delete one stopped run's record (its tasks are left alone), or with `allArchived` every archived one. */
-declare function deleteRuns(runId: string, opts?: {
-  allArchived?: false;
-}): Deleted;
-declare function deleteRuns(runId: string | undefined, opts: {
-  allArchived: true;
-}): DeletedAll;
-declare function deleteRuns(runId?: string, opts?: {
-  allArchived?: boolean;
-}): Deleted | DeletedAll;
-//#endregion
-//#region src/core/errors.d.ts
-/** The run-native-subagent fallback payload the CLI prints on exit 3. */
-interface FallbackPayload {
-  error: string;
-  fallback: {
-    action: 'run-native-subagent';
-    reason: 'no-engine-available';
-    permissions: string;
-    instructions: string;
-    note: string;
-    system?: string;
-    task: string;
-  };
-}
-/** Recoverable errors with CLI exit codes. */
-type CoderErrorCode = 'nested-dispatch' | 'invalid-option' | 'read-only-unavailable' | 'startup-failed' | 'chain-exhausted' | 'approval-pending' | 'task-failed' | 'flow-failed' |
-/** A Coder server refused or failed a request; `status` carries the HTTP status. */
-'server' |
-/** Sign-in to a server did not complete. */
-'login-failed';
-declare class CoderError extends Error {
-  code: CoderErrorCode;
-  hint?: string | string[];
-  taskId?: string;
-  /** chain-exhausted: the run-native-subagent payload the CLI prints on exit 3. */
-  payload?: FallbackPayload;
-  /** approval-pending: the approval to answer. */
-  approval?: {
-    id: string;
-    summary: string;
-    cwd?: string | null;
-    networkHost?: string | null;
-  };
-  /** task-failed (flow task()): the failed task's result. */
-  result?: unknown;
-  /** flow-failed: the run to resume. */
-  runId?: string;
-  /** server: the HTTP status the server answered with. */
-  status?: number;
-  needs?: 'key';
-  constructor(code: CoderErrorCode, message: string, extra?: Partial<Pick<CoderError, 'hint' | 'taskId' | 'payload' | 'approval' | 'result' | 'runId' | 'status' | 'needs'>>);
-}
-//#endregion
-//#region src/core/dispatch.d.ts
-interface TaskResult {
-  taskId: string;
-  status: TaskStatus;
-  result: TurnResult | null;
-  /** The last `tail` progress-log entries; [] at the default tail of 0. */
-  steps: TaskLogEntry[];
-  /** One entry per finished turn (a steered task accretes turns). */
-  turns: TurnResultEntry[];
-  task: Task;
-}
-/** Read a task's current state and result.json without waiting. `tail` fills `steps`. */
-declare function readTask(cwd: string, taskId: string, opts?: {
-  tail?: number | 'all';
-}): TaskResult;
-//#endregion
-//#region src/flow/index.d.ts
-/**
- * The flow's `--args` value. A Proxy over the ALS-bound current args, so a
- * top-level `import { args }` reflects whichever run is executing.
- */
-declare const args$1: Record<string, unknown>;
-/** Run and inspect flows programmatically; mirrors `coder flow`. */
-declare const flowSdk: {
-  /** Run a flow and await its result. */
-  run(nameOrPath: string, opts?: RunOptions): Promise<RunSummary>;
-  /** Recent flow runs (mirrors `coder flow list`). */
-  list(opts?: {
-    archived?: boolean;
-    limit?: number | "all";
-  }): FlowRecord[];
-  /** Flows discoverable from a directory (workspace + global). */
-  discover(cwd?: string): DiscoveredFlow[];
-  /** A run's record with its step rows, journal and events (omit the id for the most recent run). `tail` caps steps (default 'all'; 0 → []). */
-  result(runId?: string, opts?: {
-    tail?: number | "all";
-  }): RunResult | null;
-  /** Follow a run live: an async iterable of flow events, ending when the run is terminal. `tail` replays only the last n (default 'all'). */
-  stream(runId?: string, opts?: {
-    tail?: number | "all";
-  }): AsyncGenerator<FlowEvent>;
-  /** Stop a running flow (and, by default, its still-running tasks). */
-  stop(runId?: string, opts?: {
-    keepTasks?: boolean;
-  }): Promise<StopSummary>;
-  /** Continue a stopped or edited run from its journal and await the result. */
-  resume(runId?: string, opts?: RunOptions): Promise<RunSummary>;
-  /** Archive a run (hide it from the default list), or with `allStopped` every stopped one. A running run must be stopped first. */
-  archive: typeof archiveRuns;
-  /** Delete a run's record from disk (its tasks are left alone), or with `allArchived` every archived one. A running run must be stopped first. */
-  delete: typeof deleteRuns;
-};
-//#endregion
-//#region src/flow/builtin/review.d.ts
-declare const description = "Review a code change.";
-declare const args: z.ZodObject<{
-  pr: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
-  base: z.ZodOptional<z.ZodString>;
-  head: z.ZodOptional<z.ZodString>;
-  since: z.ZodOptional<z.ZodString>;
-  post: z.ZodOptional<z.ZodBoolean>;
-  author: z.ZodOptional<z.ZodString>;
-  path: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  engine: z.ZodOptional<z.ZodString>;
-  model: z.ZodOptional<z.ZodString>;
-  effort: z.ZodOptional<z.ZodEnum<{
-    low: "low";
-    medium: "medium";
-    high: "high";
-  }>>;
-  cwd: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type ReviewArgs = z.infer<typeof args>;
-/** Tasks at once unless the caller sets a concurrency. */
-declare const concurrency = 4;
-declare const Finding: z.ZodObject<{
-  file: z.ZodString;
-  line: z.ZodNumber;
-  severity: z.ZodEnum<{
-    critical: "critical";
-    major: "major";
-    minor: "minor";
-    nit: "nit";
-  }>;
-  category: z.ZodEnum<{
-    correctness: "correctness";
-    security: "security";
-    reliability: "reliability";
-    performance: "performance";
-    maintainability: "maintainability";
-    testing: "testing";
-    documentation: "documentation";
-  }>;
-  summary: z.ZodString;
-  failure_scenario: z.ZodString;
-}, z.core.$strict>;
-type Finding = z.infer<typeof Finding> & {
-  fingerprint: string;
-};
-interface ReviewSummary {
-  baseSha: string;
-  headSha: string;
-  /** Also covers uncommitted and untracked files on top of `headSha`. */
-  worktree: boolean;
-  files: number;
-  model: string | null;
-  elapsedMs: number;
-  posted?: number;
-  /** Parts left out of the review, such as uninitialized submodules. */
-  warnings?: string[];
-}
-interface ReviewResult {
-  findings: Finding[];
-  summary: ReviewSummary;
-}
-/** New-side line ranges per file from a unified diff. */
-declare function changedLines(patch: string): Map<string, Array<[number, number]>>;
-/** Stable finding key from its file, category and neighbouring lines. */
-declare function fingerprint(file: string, text: string, category: string): string;
-/** AGENTS.md / CLAUDE.md, then .coder/review.md, all read at `sha`. */
-declare function repositoryRules(exec: ReviewExec, sha: string): Array<[name: string, text: string]>;
-interface ReviewServices {
-  exec?: ReviewExec;
-  reviewTask?: typeof task;
-  /** Test-only override for the transient task credential. */
-  integrationToken?: string;
-}
-declare function review(a: ReviewArgs, services?: ReviewServices): Promise<ReviewResult>;
-type ReviewExec = (command: string, args: string[], input?: string) => string;
-type ReviewPostFinding = Finding;
-type ReviewPostSummary = Pick<ReviewSummary, 'baseSha' | 'headSha' | 'model' | 'elapsedMs'> & {
-  author: string;
-};
-interface ReviewPostInput {
-  repo: string;
-  pr: number;
-  cwd?: string;
-  findings: ReviewPostFinding[];
-  summary: ReviewPostSummary;
-  since?: string;
-}
-interface ReviewTargetInput {
-  pr: number | string;
-  /** The only repository the target may be in. */
-  repo?: string;
-  cwd?: string;
-  since?: string;
-  author?: string;
-}
-interface ReviewTarget {
-  pr?: {
-    number: number;
-    repo: string;
-    author: string;
-  };
-  baseSha: string;
-  headSha: string;
-  since?: string;
-}
-interface ReviewAuth {
-  /** Installation token from the task context. Omit to use local gh auth. */
-  token?: string;
-  exec?: ReviewExec;
-}
-/** The platform reviews post to; its tool server holds the token. */
-declare const REVIEW_PLATFORM = "github";
-interface ReviewComment {
-  id: number;
-  body?: string | null;
-  user?: {
-    login?: string;
-  } | null;
-}
-declare function reviewCli(cwd?: string, token?: string): ReviewExec;
-declare function parseGithubPr(value: number | string): {
-  number: number;
-  repo?: string;
-};
-declare function reviewFingerprints(comments: Array<{
-  body?: string | null;
-}>): Set<string>;
-declare function lastReviewSummary(comments: Array<{
-  id: number;
-  body?: string | null;
-}>): {
-  id: number;
-  head: string;
-} | undefined;
-declare function ownReviewComments(comments: ReviewComment[], author: string): ReviewComment[];
-/** Resolve and fetch a GitHub pull request for the integration-generic review flow. */
-declare function resolveReviewTarget(input: ReviewTargetInput, auth?: ReviewAuth): ReviewTarget;
-/** Post unseen findings and upsert the sticky summary through GitHub's integration. */
-declare function postReview(input: ReviewPostInput, auth?: ReviewAuth): number;
-//#endregion
-export { FlowTaskResult as $, TaskResult as A, readTurnResults as B, repositoryRules as C, reviewFingerprints as D, reviewCli as E, deleteRuns as F, steer as G, gate as H, RunOptions as I, FlowEvent as J, task as K, RunSummary as L, CoderError as M, RunResult as N, args$1 as O, archiveRuns as P, FlowTaskOptions as Q, StopSummary as R, postReview as S, review as T, log as U, flow as V, pipeline as W, FlowSteerOptions as X, FlowRecord as Y, FlowStep as Z, description as _, ReviewExec as a, ownReviewComments as b, ReviewPostSummary as c, ReviewSummary as d, GateResult as et, ReviewTarget as f, concurrency as g, changedLines as h, ReviewAuth as i, readTask as j, flowSdk as k, ReviewResult as l, args as m, REVIEW_PLATFORM as n, ReviewPostFinding as o, ReviewTargetInput as p, DiscoveredFlow as q, ReviewArgs as r, ReviewPostInput as s, Finding as t, ReviewServices as u, fingerprint as v, resolveReviewTarget as w, parseGithubPr as x, lastReviewSummary as y, review$1 as z };

package/dist/rotate-key-CS1G6ReH.js

@@ -1 +0,0 @@
-import{i as e}from"./cli-BBlH53hA.js";import{n as t}from"./args-CURX44CA.js";import n from"node:process";const r=e({name:`server rotate-key`,globalFlags:{cwd:!1},help:{usage:`coder server rotate-key [--json]`,summary:`Re-seal stored app, installation, engine, and linked user secrets with the current key.`,env:[[`SERVER_ENCRYPTION_KEY`,`the new key`],[`SERVER_ENCRYPTION_KEY_PREVIOUS`,`the old key, still accepted while rotating`]]},options:{json:t},run:async()=>{let{rotateKey:e}=await import(`./maintenance-DYOstY6V.js`).then(e=>e.t);return e()},json:({moved:e})=>({ok:!0,moved:e}),print:({moved:e})=>n.stdout.write(`Re-sealed ${e} secret${e===1?``:`s`}.\n`)});export{r as commandServerRotateKey};

package/dist/run-BKUd6B8S.js

@@ -1,2 +0,0 @@
-import{m as e}from"./prompt-PEgcMJO7.js";import{i as t,r as n}from"./cli-BBlH53hA.js";import{p as r,s as i}from"./output-BKeyLbvt.js";import{c as a,i as o,n as s,t as c}from"./args-CURX44CA.js";import{i as l}from"./result-D0dpv2O_.js";import{printLine as u}from"./watch-DJXu13jK.js";import d from"node:process";const f={...c,flow:a,server:o,workspace:a,wait:s,task:a,yes:s},p=t({name:`agent run --task`,options:f,run:async({options:e,cwd:t})=>{let{agents:n}=await import(`./agent-6GooVMsq.js`).then(e=>e.t);return n.runTask(e.task,{cwd:t})}}),m=t({name:`agent run`,help:{usage:`coder agent run <agent> <file> [--server [url] [--wait]] [--flow <name>] [--json] [--cwd <dir>]`,summary:`Run a recorded platform event (AgentEvent JSON) through an agent. With --server it goes through your Coder server exactly like a webhook: real app, tokens, runner, and the reply is posted. Without it the engine runs here on the agent's prompt and this checkout, platform tools off, and the reply is printed.`,flags:[n,[`--wait`,`with --server: follow the task log here until it finishes, then print the reply`],[`--flow <name>`,`override the matched flow`]],examples:[[`coder agent run helper sample-slack-mention.json`,`offline: print what the agent would reply`],[`coder agent run helper event.json --server`,`for real, through the server`]]},options:f,args:2,run:async({options:e,args:[t,n],cwd:i})=>{let{agents:a}=await import(`./agent-6GooVMsq.js`).then(e=>e.t);return a.run(t,n,{...e,cwd:i,organization:e.workspace,...e.json?{}:{onLog:e=>u(e,r),onDone:e=>l(e,r)}})},json:e=>Array.isArray(e)&&e.length===1?e[0]:e,print(t,{options:n}){if(!Array.isArray(t)){if(`tasks`in t){if(!t.tasks.length)return void d.stdout.write(`The server accepted the event but no agent matched it.
-`);d.stdout.write(`${r.bold(`Queued on the server`)} as task ${t.tasks.join(`, `)}.\n\n${i([`Watch it: coder task watch ${t.tasks[0]} --server ${e(n.server)}`],r)}\n`);return}t.reply===void 0?t.result!==void 0&&d.stdout.write(`${JSON.stringify(t.result,null,2)}\n`):d.stdout.write(`${t.reply.trim()}\n`)}}}),h=Object.assign(e=>(e.some(e=>e===`--task`||e.startsWith(`--task=`))?p:m)(e),{commandName:`agent run`,help:m.help});export{h as commandAgentRun};

package/dist/run-DjTTb8oA.js

@@ -1,5 +0,0 @@
-import{U as e}from"./dispatch-CFZ9Crvg.js";import{i as t}from"./cli-BBlH53hA.js";import{p as n,s as r}from"./output-BKeyLbvt.js";import{c as i,n as a,t as o}from"./args-CURX44CA.js";import{FlowStepRenderer as s,printFollow as c,printRunSummary as l}from"./watch-BiyN4NxE.js";import u from"node:process";const d={...o,args:i,wait:a,concurrency:i,"max-tasks":i,"dry-run":a};function f(t){let n={};for(let r of t){let t=r.indexOf(`=`);if(t===-1)throw new e(`invalid-option`,`Invalid argument "${r}": expected key=value.`,{hint:`Help: coder flow run --help`});let i=r.slice(0,t),a=r.slice(t+1);try{n[i]=JSON.parse(a)}catch{n[i]=a}}return n}function p(t,n){if(t!==void 0)try{return JSON.parse(t)}catch(t){throw new e(`invalid-option`,`Invalid --args JSON: ${t instanceof Error?t.message:String(t)}`)}return n.length?f(n):{}}const m=e=>e?Number(e):void 0,h=(e,t)=>({cwd:t,dryRun:e[`dry-run`],concurrency:m(e.concurrency),maxTasks:m(e[`max-tasks`]),detached:!0,wait:e.wait}),g=e=>e[`dry-run`]&&!e.json?v():{},_=t({name:`flow run`,help:{usage:`coder flow run <name|path> [--args '<json>' | key=value...] [--wait] [--concurrency N] [--max-tasks N] [--json] [--dry-run]`,summary:`Run a flow: a TypeScript file that orchestrates many coder tasks with gates,
-journaling, and resume. Prints the run id and orchestrates in the background;
---wait follows the run in the foreground with live progress (Ctrl-C detaches;
-it keeps running), and \`coder flow watch\` shows the same lines any time.
-Stop a run with \`coder flow stop\`.`,flags:[[`--wait`,`follow the run in the foreground (Ctrl-C detaches; it keeps running)`],[`--args <json>`,`the flow's input as a JSON value (or pass bare key=value pairs)`],[`--concurrency <n>`,`tasks running at once (default: CPU count)`],[`--max-tasks <n>`,`total tasks the run may dispatch (default: CPU count x 10)`],[`--dry-run`,`print every resolved prompt and gate command without dispatching`]],examples:[[`coder flow run audit-routes --wait`,`run a discovered flow`],[`coder flow run ./scratch/one-off.ts --wait`,`run a flow by path`],[`coder flow run verify --args '{"clusters":["a","b"]}' --wait`,`pass structured input`]]},options:d,args:1/0,required:[`<name|path>`],async run({options:e,args:[t,...n],cwd:r}){let{startRun:i}=await import(`./executor-3QMa-XRY.js`).then(e=>e.S),a=await i(t,{...h(e,r),args:p(e.args,n)},g(e));return a.status===`running`&&a.watch&&await c(a.watch,e),a},print:e=>e.status===`running`?y(e):l(e)});function v(){let e=new s;return{onEvent:t=>e.emit(t)}}function y(e){u.stdout.write(`${n.dim(`[flow]`)} run ${n.cyan(e.runId)} started in the background (running).\n`),u.stdout.write(`\n${r([`Result: coder flow result ${e.runId}`,`Runs: coder flow list`],n)}\n`)}export{d as RUN_FLAGS,_ as commandRun,g as hooks,p as parseRunArgs,y as printDetached,h as runOptions};

package/dist/run-UPW-7pKo.js

@@ -1,2 +0,0 @@
-import{d as e,i as t,n,p as r}from"./cli-BBlH53hA.js";import{p as i,r as a,s as o,u as s}from"./output-BKeyLbvt.js";import{c,i as l,l as u,n as d,t as f}from"./args-CURX44CA.js";import{i as p,n as m,r as h}from"./result-D0dpv2O_.js";import{printLine as g}from"./watch-DJXu13jK.js";import{TASK_FLAGS as _}from"./task-DeFLNmQH.js";import v from"node:process";function y(t){let n=e([{usage:`coder task result ${t} --wait`,blurb:`run this in its own background shell, one per task (never wait on several tasks in one call). Returns with the answer or a pending approval.`},{usage:`coder task steer ${t} "<follow-up>"`,blurb:`steer the task with a message (use 'ask' without interrupting main thread)`},{usage:`coder task stop ${t}`,blurb:`stop the task`},{usage:`coder task list`,blurb:`recent tasks`},{usage:`coder task --help`,blurb:`all task commands`}],i,i.blue);return[...r(`Next step`,n.slice(0,1),i),...r(`Related`,n.slice(1),i)].join(`
-`)}function b(e,t){v.stdout.write(`${i.dim(`[coder]`)} task ${i.blue(e)} started in the background (${t}).\n`),v.stdout.write(`${y(e)}\n`)}function x(e){v.stderr.write(`${i.dim(`[coder]`)} Task ${i.cyan(e)} started and is waiting to finish. Press Ctrl-C to detach. It keeps running.\n`),v.stderr.write(`${y(e)}\n`)}function S(e){v.stderr.write(`\n${i.dim(`[coder] Detached. The task is still running.`)}\n\n${o([`Wait in its own background shell, one per task: coder task result ${e} --wait`],a)}\n`)}function C(e){v.stdout.write(`\n${m({finalMessage:e.finalMessage??void 0},e.error,`(no final message)`)}\n\n`);let t=e.tokens?` tokens=${s(e.tokens,e.model)}`:``;v.stderr.write(`${i.dim(`[coder] task=${e.taskId} status=${e.status}${t}`)}\n\n${h(e.taskId,a)}\n`)}const w=t({name:`task run`,help:{usage:`coder task run "<task text>"`,summary:`Dispatch a coding task to the configured engine. Backgrounds by default and\nprints a task id; --wait runs in the foreground and prints the answer.\nShortcut: \`coder run "<text>"\`.\n\nWriting a task: one task per focused goal, independent goals as parallel runs.\nThe worker starts with nothing but the text, so include the goal, file paths,\nconstraints and any context only you have. Delegate rather than doing the work\nyourself first, however small it looks.\n\nWaiting: run \`coder task result <task-id> --wait\` in its own background shell, one\nper task. Never wait on several tasks in one call, or their approvals and answers\nnever reach you one by one.\n\n${n}`,flags:[[`--output-schema <json>`,`JSON Schema for the task answer`],[`--name <name>`,`label the task (shown in list/result)`],[`--agent <id>`,`run as that agent: its system.md, engine settings, MCP servers and flows; flags override them`],[`--system <text>`,`standing instructions prepended to the task (kept out of prompt previews)`],..._,[`--server [url] [--workspace <slug>]`,`run the task on your Coder server and follow it here (--background prints its id)`],[`--repo <owner/name>`,`with --server: check out a repo from the workspace's installs`],[`--runner <name>`,`with --server: where it runs (a runner kind or a registered runner)`]],exitCodes:[[`0`,`The task started, or --wait printed a successful answer.`],[`1`,`Dispatch or the task failed.`],[`3`,`No engine could start; follow fallback.instructions in the JSON payload.`],[`4`,`An approval is pending; answer it, then run result --wait again.`],[`130`,`The foreground wait was detached and the task is still running.`]],examples:[[`coder run "add a /health endpoint"`,`dispatch in the background, print a task id`],[`coder result <task-id> --wait`,`then block until it finishes and print the answer`],[`coder run --wait "fix the failing test"`,`or block on the run itself`],[`coder task run --model luna --system "tests live in test/, don't touch anything outside of it" "rename foo to bar"`,`pick an engine via its model alias; --system adds standing instructions`],[`coder task run --agent reviewer "review the last commit"`,`run a repo agent from .coder/agents/reviewer`],[`coder run --add-dir ../api --add-dir ../shared "update the client for the new endpoint"`,`let the task reach sibling repos too`]]},options:{...f,agent:c,"output-schema":c,engine:c,model:c,effort:c,permissions:c,name:c,system:c,mcp:c,connections:c,"add-dir":u,background:d,wait:d,"simulate-approval":d,server:l,workspace:c,yes:d,repo:c,runner:c},args:1/0,async run({options:e,args:t}){let{tasks:n}=await import(`./task-DJ6nruuA.js`).then(e=>e.t),r=e.json,a;return v.on(`SIGINT`,()=>{a&&S(a),v.exit(130)}),n.run(t.join(` `).trim(),{cwd:e.cwd,agent:e.agent,outputSchema:e[`output-schema`]?JSON.parse(e[`output-schema`]):void 0,engine:e.engine,model:e.model,effort:e.effort,permissions:e.permissions,name:e.name,system:e.system,mcp:e.mcp,connections:e.connections?.split(`,`).map(e=>e.trim()).filter(Boolean),addDirs:e[`add-dir`],wait:e.server===void 0?e.wait:!e.background,simulateApproval:e[`simulate-approval`],repo:e.repo,runner:e.runner,server:e.server,yes:e.yes,organization:e.workspace,onFallback:({engine:e,detail:t,next:n})=>v.stderr.write(`[coder] ${e} failed to start (${t}); falling back to ${n}.\n`),onNote:e=>v.stderr.write(`[coder] ${e}\n`),onWaiting:e=>{a=e,r||x(e)},onLog:e=>r?v.stdout.write(`${JSON.stringify(e,null,2)}\n`):g(e,i)})},print(e,{options:t}){if(`attempts`in e)return t.background?void v.stdout.write(`${e.task.id}\n`):p(e,i);t.wait?C(e):b(e.taskId,e.status)},exit:(e,{options:t})=>(`attempts`in e?!t.background:t.wait)?e.status===`completed`?0:1:void 0});export{w as commandTask};

package/dist/runner-BLS_ReEw.js

@@ -1 +0,0 @@
-import{s as e}from"./cli-BBlH53hA.js";const t=e(`runner`,{add:async()=>(await import(`./add-B6vPKZEr.js`)).commandRunnerAdd,default:async()=>(await import(`./default-Ojx5oFuw.js`)).commandRunnerDefault,test:async()=>(await import(`./test-BD9rvefN.js`)).commandRunnerTest,serve:async()=>(await import(`./serve-mXTjboT1.js`)).commandRunnerServe,list:async()=>(await import(`./list-BTjIMvNs.js`)).commandRunnerList,rename:async()=>(await import(`./rename-DJaf5SwH.js`)).commandRunnerRename,remove:async()=>(await import(`./remove-DxCv9BB4.js`)).commandRunnerRemove},{menu:[{usage:`add <kind>`,blurb:`connect a runner`},{usage:`default <id>`,blurb:`set the default in its scope`},{usage:`test <id>`,blurb:`check a runner connection`},{usage:`serve --url <public url>`,blurb:`run your server's tasks on this machine`},{usage:`list`,blurb:`list your runners and the workspace's`},{usage:`rename <id> <name>`,blurb:`rename a runner`},{usage:`remove <id>`,blurb:`remove a runner`}],description:[`Run your Coder server's tasks on your own machine, reached through any tunnel.`],exampleCommand:`runner serve`});export{t as commandRunner};

package/dist/runner-BM_98EQl.js

@@ -1 +0,0 @@
-import{qi as e}from"./core-DwsAMCnL.js";import{U as t}from"./dispatch-CFZ9Crvg.js";import{t as n}from"./remote-D3JZ4MMQ.js";import{t as r}from"./serve-DE1cKoGa.js";var i=e({addRunner:()=>o,addRunnerFields:()=>d,listRunners:()=>a,pairRunner:()=>s,removeRunner:()=>u,runners:()=>f,testRunner:()=>l,updateRunner:()=>c});const a=(e={})=>n(e).runners.list(),o=(e,t={})=>n(t).runners.add(e),s=(e,t={})=>n(t).runners.pair(e),c=(e,t,r={})=>n(r).runners.update(e,t),l=(e,t={})=>n(t).runners.test(e),u=(e,t={})=>n(t).runners.remove(e);async function d(e,r){let i=n(r),{catalog:a}=await i.runners.list(),o=a.find(t=>t.kind===e);if(!o)throw new t(`invalid-option`,`Unknown runner kind.`);if(!o.available)throw new t(`invalid-option`,o.reason??`Runner unavailable.`);let s={};for(let e of r.field??[]){let n=e.indexOf(`=`);if(n<1)throw new t(`invalid-option`,`Use --field key=value.`);let r=e.slice(0,n),i=e.slice(n+1),a=o.fields.find(e=>e.key===r);if(!a)throw new t(`invalid-option`,`Unknown runner field ${r}.`);if(a.secret){if(!/^env:[A-Z_][A-Z0-9_]*$/.test(i)||!process.env[i.slice(4)])throw new t(`invalid-option`,`Read ${r} from the environment with --field ${r}=env:VARIABLE.`);s[r]=process.env[i.slice(4)]}else s[r]=i}let c=r.scope??((await i.me()).user?`personal`:`workspace`);if(c!==`personal`&&c!==`workspace`)throw new t(`invalid-option`,`Scope must be personal or workspace.`);return o.connect===`pair`?i.runners.pair({name:r.name,scope:c}):i.runners.add({kind:o.kind,name:r.name??o.name,scope:c,config:s})}const f={list:a,add:o,pair:s,update:c,default:(e,t={})=>c(e,{default:!0},t),test:l,rename:(e,t,n={})=>c(e,{name:t},n),remove:u,serve:r};export{f as n,i as t};