opencode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228// The `opencode` command line, asked when the server cannot answer (the
// Rust `cli.rs`).
//
// A second **source** for the same live data, never a substitute for it:
// every model, mode and skill below is read out of the CLI's own output.
// When the CLI fails too, the failure is reported rather than papered
// over with a catalog nobody installed.
import * as Effect from "effect/Effect";
import * as Result from "effect/Result";
import { runProcess } from "../sdk/effect.ts";
import { errorMessage } from "../sdk/errors.ts";
import { isRefusal } from "./client.ts";
import { obj } from "./map.ts";

export interface AgentEntry {
  name: string;
  description: string | null;
  mode: string;
  hidden: boolean;
}

export interface ProviderCatalog {
  providers: ProviderEntry[];
  default: Record<string, unknown>;
}

export interface Inventory {
  providers: ProviderCatalog;
  agents: AgentEntry[];
}

export interface SkillEntry {
  name: string;
  description: string;
  location: string;
}

/// How long one command may run: `models --verbose` prints the whole
/// catalog, which is slow on a first run that has to fetch it.
const COMMAND_TIMEOUT = 90_000;
/// Wait before the single retry. Every command opens the same SQLite
/// database, so one that lost the lock usually wins it a moment later.
const RETRY_DELAY = 1_000;
/// OpenCode is built with Bun, which flushes one 64 KiB buffer to a pipe
/// and then stops when the program exits: `debug skill` arrives cut at
/// exactly 65536 bytes. Output of a whole multiple of this size that does
/// not parse was cut.
const PIPE_CHUNK = 65_536;

/// The model catalog and the agents of `workspace`, as
/// `{ providers: { providers, default }, agents }`. The commands run one
/// at a time on purpose: they share one SQLite database and fail with a
/// lock error when they overlap.
export const inventory = Effect.fn("OpenCode.inventory")(function* (binary: string, workspace: string) {
  const read = yield* command(binary, workspace, ["models", "--verbose"]).pipe(Effect.result);
  if (Result.isFailure(read))
    return yield* Effect.fail(new Error(`reading the opencode model catalog: ${errorMessage(read.failure)}`));
  const models: string = read.success;
  const providers = parseModels(models);
  if (!providers.providers.length) {
    if (byteLength(models) % PIPE_CHUNK === 0)
      return yield* Effect.fail(new Error(cutMessage(["models", "--verbose"])));
    return yield* Effect.fail(
      new Error("`opencode models --verbose` listed no models; run `opencode auth login` first"),
    );
  }
  // Modes are a nicety next to the catalog, so a workspace whose agents
  // cannot be read still gets its models.
  let agents: AgentEntry[] = [];
  const listed = yield* command(binary, workspace, ["agent", "list"]).pipe(Effect.result);
  if (Result.isFailure(listed)) {
    console.warn(`opencode: could not read the agents from the command line: ${errorMessage(listed.failure)}`);
  } else {
    agents = parseAgents(listed.success);
  }
  return { providers, agents };
});

/// The skills of `workspace`, as `[{ name, description, location }]`.
export const skills = Effect.fn("OpenCode.skills")(function* (binary: string, workspace: string) {
  return parseSkills(yield* command(binary, workspace, ["debug", "skill"]));
});

/// The entries of `opencode debug skill`, which prints the same fields as
/// `GET /skill` plus the body, which is dropped.
export function parseSkills(text: unknown): SkillEntry[] {
  let parsed: unknown;
  try {
    parsed = JSON.parse(String(text));
  } catch (error) {
    if (byteLength(text) % PIPE_CHUNK === 0) throw new Error(cutMessage(["debug", "skill"]));
    throw new Error(`decoding the output of \`opencode debug skill\`: ${errorMessage(error)}`);
  }
  if (!Array.isArray(parsed)) throw new Error("`opencode debug skill` did not print a list");
  return parsed
    .filter((entry) => typeof (entry as { name?: unknown })?.name === "string")
    .map((entry) => {
      const record = entry as { name: string; description?: unknown; location?: unknown };
      return {
        name: record.name,
        description: typeof record.description === "string" ? record.description : "",
        location: typeof record.location === "string" ? record.location : "",
      };
    });
}

function cutMessage(args: string[]): string {
  return (
    `the output of \`opencode ${args.join(" ")}\` was cut at ${PIPE_CHUNK} bytes (opencode stops writing to a pipe ` +
    "after one buffer), so it cannot be read"
  );
}

function byteLength(text: unknown): number {
  return new TextEncoder().encode(String(text ?? "")).length;
}

/// Runs one command in `workspace`, retrying once. The retry does not
/// depend on the error text: the lock shows up as a non-zero exit with a
/// message that changes between versions.
const command = Effect.fn("OpenCode.command")(function* (binary: string, workspace: string, args: string[]) {
  const first = yield* attempt(binary, workspace, args).pipe(Effect.result);
  if (Result.isSuccess(first)) return first.success;
  if (isRefusal(first.failure)) return yield* Effect.fail(first.failure);
  yield* Effect.sleep(RETRY_DELAY);
  return yield* attempt(binary, workspace, args);
});

const attempt = Effect.fn("OpenCode.attempt")(function* (binary: string, workspace: string, args: string[]) {
  const described = `\`opencode ${args.join(" ")}\``;
  const result = yield* runProcess(binary, args, { cwd: workspace || undefined, timeout: COMMAND_TIMEOUT }).pipe(
    Effect.scoped,
  );
  if (result.timedOut)
    return yield* Effect.fail(new Error(`${described} did not finish within ${COMMAND_TIMEOUT / 1000}s`));
  if (result.code !== 0)
    return yield* Effect.fail(
      new Error(`${described} failed with ${result.code ?? result.signal}: ${result.stderr.trim()}`),
    );
  // A command that lost the SQLite lock can still exit 0 and print nothing,
  // which the retry is for. None of these has an empty answer when it
  // worked.
  if (!result.stdout.trim()) return yield* Effect.fail(new Error(`${described} printed nothing`));
  return result.stdout;
});

/// The `<provider>/<model>` header of a model block. A body line is
/// rejected before the shape is tested: a model id may contain a slash
/// (`openrouter/qwen/qwen3-coder`), and so may the JSON describing it.
function modelSlug(line: string): string | null {
  if (/^\s/.test(line) || /^\s*[{}[\]]/.test(line)) return null;
  const slug = line.trimEnd();
  if (!slug || slug.split(/\s+/).length !== 1) return null;
  const at = slug.indexOf("/");
  if (at <= 0 || at === slug.length - 1) return null;
  return slug;
}

interface ProviderEntry {
  id: string;
  name: string;
  models: Record<string, unknown>;
}

/// Parses `opencode models --verbose`: a `<provider>/<model>` line
/// followed by that model's JSON, repeated. The CLI reports no provider
/// display name, so the id stands in for it. Answers the shape of
/// `GET /config/providers`, with no defaults.
export function parseModels(text: unknown): ProviderCatalog {
  const providers: ProviderEntry[] = [];
  let slug: string | null = null;
  let body: string[] = [];
  const flush = (): void => {
    if (!slug) {
      body = [];
      return;
    }
    const current = slug;
    const providerId = current.slice(0, current.indexOf("/"));
    const json = body.join("\n").trim();
    slug = null;
    body = [];
    let model: unknown;
    try {
      model = JSON.parse(json);
    } catch {
      return;
    }
    const id = obj(model)["id"];
    if (typeof id !== "string") return;
    let provider = providers.find((entry) => entry.id === providerId);
    if (!provider) {
      provider = { id: providerId, name: providerId, models: {} };
      providers.push(provider);
    }
    provider.models[id] = model;
  };
  for (const line of String(text ?? "").split(/\r?\n/)) {
    const found = modelSlug(line);
    if (found) {
      flush();
      slug = found;
    } else if (slug) {
      body.push(line);
    }
  }
  flush();
  return { providers, default: {} };
}

/// Parses `opencode agent list`: a `<name> (<mode>)` line followed by that
/// agent's permission rules, repeated. The CLI does not say which agents
/// are hidden, so none are filtered by name; the mode is the only signal.
export function parseAgents(text: unknown): AgentEntry[] {
  const agents: AgentEntry[] = [];
  for (const line of String(text ?? "").split(/\r?\n/)) {
    if (/^\s/.test(line)) continue;
    const trimmed = line.trimEnd();
    if (!trimmed.endsWith(")")) continue;
    const open = trimmed.lastIndexOf("(");
    if (open < 0) continue;
    const name = trimmed.slice(0, open).trimEnd();
    const mode = trimmed.slice(open + 1, -1);
    if (!name || !mode || /\s/.test(mode)) continue;
    agents.push({ name, description: null, mode, hidden: false });
  }
  return agents;
}