opencode-worker 0.1.6 → 0.1.7

package/README.md

@@ -12,7 +12,9 @@ A set-but-empty `--opencode-bin`/`OPENCODE_WORKER_BIN` fails with `BIN_EMPTY` in
 
 - Child env is rebuilt from scratch: only `PATH`, `LANG`, `LC_ALL`, `TMPDIR` pass through. No API keys or credentials.
 - `HOME` and `XDG_{CONFIG,DATA,CACHE,STATE}_HOME` point into `<dir>/.opencode-worker/`.
-- Generated config: `model` = `small_model` = requested model, `enabled_providers: ["opencode"]`, `permission.external_directory: "deny"`.
+- Generated config: `model` = `small_model` = requested model, `enabled_providers: ["opencode"]`.
+- Project config is ignored: `opencode.json`, `.opencode/` agents, plugins and MCP in the task dir are not loaded (`OPENCODE_DISABLE_PROJECT_CONFIG=1`, private `OPENCODE_CONFIG_DIR`). `AGENTS.md` still applies.
+- Tools are default-deny: only `read`, `list`, `glob`, `grep`, `edit` (incl. write/patch), `bash`, `todowrite`, `todoread` are allowed; `external_directory` is denied. No web fetch, no sub-agents.
 - Models outside the `opencode` provider are rejected (`PROVIDER_NOT_ALLOWED`); there is no fallback.
 - No job time limit by default: a job runs until it finishes, `worker_cancel`, or the MCP session closes — like a subagent. Opt in to a limit with `OPENCODE_WORKER_TIMEOUT_SEC` (per install) or `--timeout` / `worker_start.timeoutSec` (per job); on expiry: SIGTERM, then SIGKILL after 5 s, plus an `alarm()` 10 s later that fires even if this process died.
 - Cancel and timeout stop the whole process tree: opencode plus every command it spawned (tool shells run in their own process groups, so the tree is walked by parent pid).
@@ -20,6 +22,20 @@ A set-but-empty `--opencode-bin`/`OPENCODE_WORKER_BIN` fails with `BIN_EMPTY` in
 
 Defaults: model `opencode/deepseek-v4.1-flash-free`, variant `low`, agent `build`.
 
+## Reasoning
+
+`--variant` / `worker_start.variant` selects reasoning effort. Valid values are the model's own variants (read from `opencode models`) plus `none`:
+
+| variant | effect |
+|---|---|
+| `none` | reasoning off (added by opencode-worker as `reasoningEffort: "none"`) |
+| `low` (default) | light reasoning |
+| `high` | more reasoning |
+| `max` | most reasoning |
+
+Unknown values (e.g. `medium`, which this model does not define) fail with `BAD_VARIANT` instead of silently using the provider default.
+On short tasks the difference is small: in our runs `low`/`high`/`max` averaged roughly 30/45/70 reasoning tokens and `none` produced 0, with the same answers.
+
 ## CLI
 
 ```sh
@@ -96,6 +112,8 @@ Closing stdin or SIGINT/SIGTERM/SIGHUP cancels running jobs and records them as
 
 - `<dir>/.opencode-worker/` holds state, snapshots and logs per run; delete it when done.
 - The before-snapshot copies the whole directory: use small, task-scoped directories.
+- Parallel jobs are allowed but share the free endpoint and your CPU: with 6 concurrent jobs a ~10 s task took up to ~30 s. Run a few at a time.
+- Two jobs writing the same `dir` at once will overwrite each other's files and snapshots; give each job its own directory.
 
 ## Releasing
 

package/lib/worker.mjs

@@ -54,14 +54,38 @@ function isolatedEnv(stateRoot, configPath) {
     XDG_CACHE_HOME: path.join(stateRoot, "xdg/cache"),
     XDG_STATE_HOME: path.join(stateRoot, "xdg/state"),
     OPENCODE_CONFIG: configPath,
+    // Without these, an opencode.json / .opencode/ in the task dir is merged in
+    // (agents, providers, MCP, plugins) and can override our free-only config.
+    OPENCODE_CONFIG_DIR: path.join(stateRoot, "xdg/config/opencode"),
+    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
     TERM: "dumb",
   };
   for (const k of ["LANG", "LC_ALL", "TMPDIR"]) if (process.env[k]) env[k] = process.env[k];
-  for (const k of ["HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME"])
+  for (const k of ["HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME", "OPENCODE_CONFIG_DIR"])
     fs.mkdirSync(env[k], { recursive: true });
   return env;
 }
 
+// Default-deny: tools added later by OpenCode, plugins or MCP never become available implicitly.
+export const ALLOWED_TOOLS = ["read", "list", "glob", "grep", "edit", "bash", "todowrite", "todoread"];
+const NO_REASONING_VARIANT = "none";
+const variantCache = new Map();
+
+/** Variants OpenCode defines for the model, plus our "none" (reasoning off). */
+function modelVariants(bin, env, model) {
+  if (variantCache.has(model)) return variantCache.get(model);
+  const [provider] = model.split("/");
+  const r = spawnSync(bin, ["models", provider, "--verbose"], { encoding: "utf8", env, timeout: 30000, maxBuffer: 16 * 1024 * 1024 });
+  const at = r.stdout?.indexOf(`${model}\n{`) ?? -1;
+  if (r.status !== 0 || at < 0) throw new WorkerError("MODEL_NOT_FOUND", `model ${model} is not listed by 'opencode models ${provider}'`);
+  // The JSON object for this model ends at the first line that is exactly "}".
+  const body = r.stdout.slice(at + model.length + 1);
+  const meta = JSON.parse(body.slice(0, body.indexOf("\n}") + 2));
+  const variants = [...Object.keys(meta.variants ?? {}), NO_REASONING_VARIANT];
+  variantCache.set(model, variants);
+  return variants;
+}
+
 function snapshot(dir, dest) {
   fs.mkdirSync(dest, { recursive: true });
   for (const name of fs.readdirSync(dir)) {
@@ -201,14 +225,22 @@ export async function runWorker(o) {
   const runDir = path.join(stateRoot, "runs", runId);
   fs.mkdirSync(runDir, { recursive: true });
   const configPath = path.join(stateRoot, "opencode.json");
-  fs.writeFileSync(configPath, JSON.stringify({
+  const modelId = model.split("/").slice(1).join("/");
+  const permission = Object.fromEntries([["*", "deny"], ...ALLOWED_TOOLS.map((t) => [t, "allow"]), ["external_directory", "deny"]]);
+  const config = {
     $schema: "https://opencode.ai/config.json",
     model,
     small_model: model,
     enabled_providers: DEFAULTS.providers,
-    permission: { external_directory: "deny" },
-  }, null, 2));
+    permission,
+  };
+  if (variant === NO_REASONING_VARIANT)
+    config.provider = { [provider]: { models: { [modelId]: { variants: { [NO_REASONING_VARIANT]: { reasoningEffort: "none" } } } } } };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
   const env = isolatedEnv(stateRoot, configPath);
+  const variants = modelVariants(bin, env, model);
+  if (!variants.includes(variant))
+    throw new WorkerError("BAD_VARIANT", `variant '${variant}' is not defined for ${model}; available: ${variants.join(", ")}`);
   const before = path.join(runDir, "before");
   snapshot(dir, before);
 
@@ -246,7 +278,6 @@ export async function runWorker(o) {
   if (cancelled) errors.push({ type: "cancelled" });
   if (exit !== 0 && !timedOut && !cancelled) errors.push({ type: "nonzero_exit", detail: stderr.trim().slice(-2000) || `exit ${exit} signal ${signal}` });
   if (diffError) errors.push({ type: "diff_failed", detail: diffError });
-  const modelId = model.split("/").slice(1).join("/");
   if (actual && actual.some((a) => a.provider !== provider || a.model !== modelId))
     errors.push({ type: "model_mismatch", detail: actual });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worker",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Run the official OpenCode CLI as an isolated, time-boxed worker. CLI + MCP stdio server.",
   "repository": {
     "type": "git",