@coreplane/switchboard 1.213.0 → 1.215.0

package/dist/assets/config/config.example.yaml

@@ -341,10 +341,14 @@ workspaceDir: ./workspaces
 # preset, the card saying why (`routed: <reason>`) and how to run it another way.
 # `ship` is never routed. The one way off, so every plain message runs
 # `defaults.agent` as before the router: `auto: false`. `model` is the router's
-# model; default `defaults.models.general`.
+# model; default `defaults.models.general`. `answer` is how that model answers:
+# `tool` (default) forces a call to the router's `route` tool, whose schema is
+# the answer, so prose cannot occur; `text` is the one-JSON-object text contract
+# alone — set it for a provider or model that cannot take a forced tool call.
 # routing:
 #   auto: false
 #   model: anthropic/claude-haiku-4-5
+#   answer: text
 
 # Spend reporting: GET /costs (Access-gated). Optional. See docs/reference/specs/costs.md.
 # costs:
@@ -434,6 +438,8 @@ workspaceDir: ./workspaces
 #   retentionDays: 30    # days a finished run stays readable (1–365; default 30)
 #   maxRuns: 5000        # newest runs kept (1–20000; default 5000)
 #   maxBytes: 2147483648 # total stored bytes kept (16 MiB–8 GiB; default 2 GiB)
+#   sessionLogMaxBytes: 209715200 # the most bytes one thread-and-agent session log holds before its
+#                                 # oldest tool results are replaced by a marker (16 MiB–2 GiB; default 200 MiB)
 #   includeContext: true # include the thread-context turns fed to the model in the
 #                        # run stream — live page and persisted record (default true)
 #   store: worker        # `worker` (default when `worker` is set) or `file` — an

package/dist/assets/deploy/cloudflare/artifactsCopy.ts

@@ -0,0 +1,180 @@
+// The artifact copy route (docs/reference/specs/execution.md item 20, record
+// 0033): `POST /artifacts/copy { url, size, key }` streams a Slack file into
+// the artifacts bucket without the bot's container ever holding the bytes.
+// The bot asks (`R2ArtifactStore.copyFromUrl`, bearer ARTIFACTS_COPY_TOKEN);
+// this Worker holds the two things the copy needs — the R2 binding and the
+// Slack bot token that `url_private` requires — and answers `{ key, size }`
+// only once the bucket holds exactly `size` bytes under `key`.
+//
+// Pure over its deps so it is tested in plain Node (this directory's tests
+// run no workerd): the bucket, the upstream fetch, the length pipe (workerd's
+// `FixedLengthStream`, which refuses a body of another length) and the tokens
+// are handed in; `worker.ts` binds them from `env`.
+
+/** What the route needs from the bucket: R2's `put` with a stream and the object's type. */
+export interface CopyBucket {
+  put(
+    key: string,
+    value: ReadableStream<Uint8Array>,
+    options?: { httpMetadata?: { contentType?: string } },
+  ): Promise<unknown>;
+}
+
+export interface CopyDeps {
+  /** The `ARTIFACTS` R2 binding; absent when the deployment configures no bucket. */
+  bucket: CopyBucket | undefined;
+  /** The bucket's name as the Worker was deployed with (`ARTIFACTS_BUCKET_NAME`), for `GET`. */
+  bucketName: string | undefined;
+  /** The bearer the bot presents (`ARTIFACTS_COPY_TOKEN`). */
+  copyToken: string | undefined;
+  /** The Slack bot token `url_private` requires. Read from the Worker's env, never from the request. */
+  slackToken: string | undefined;
+  fetch: typeof fetch;
+  /** A pipe that carries exactly `size` bytes and fails on any other count:
+   *  `new FixedLengthStream(size)` in workerd, whose reader R2 accepts as a
+   *  stream of known length; a `TransformStream` in tests. */
+  lengthPipe: (size: number) => { readable: ReadableStream<Uint8Array>; writable: WritableStream<Uint8Array> };
+  /** The largest copy accepted; default `MAX_COPY_BYTES`. */
+  maxBytes?: number;
+}
+
+export const COPY_PATH = "/artifacts/copy";
+
+/** Slack's own per-file ceiling; a larger declared size is refused before any fetch. */
+export const MAX_COPY_BYTES = 1_073_741_824;
+
+/** The hosts a `url_private` may name: Slack's file host and the workspace's own. */
+export function slackFileHost(hostname: string): boolean {
+  return hostname === "files.slack.com" || hostname === "slack.com" || hostname.endsWith(".slack.com");
+}
+
+/** Inbound keys as `inboundKey` (src/artifacts/keys.ts) builds them and nothing
+ *  else: under `threads/`, one character class, no empty or dot segments. */
+const KEY_RE = /^threads\/[A-Za-z0-9._-]+\/in\/[A-Za-z0-9._-]+\/\d+-[A-Za-z0-9._-]+$/;
+export function validCopyKey(key: string): boolean {
+  return KEY_RE.test(key) && !key.split("/").some((s) => s === "" || /^\.+$/.test(s));
+}
+
+/** Constant-time equality over the two strings' UTF-8 bytes (a length difference is a mismatch). */
+export function sameToken(a: string, b: string): boolean {
+  const x = new TextEncoder().encode(a);
+  const y = new TextEncoder().encode(b);
+  let diff = x.length ^ y.length;
+  for (let i = 0; i < Math.max(x.length, y.length); i++) diff |= (x[i] ?? 0) ^ (y[i] ?? 0);
+  return diff === 0;
+}
+
+export type CopyRequest = { url: URL; size: number; key: string };
+
+/** Pure: the body parsed and checked, or the 4xx that refuses it — before any fetch. */
+export function parseCopyRequest(
+  raw: string,
+  maxBytes: number,
+): { ok: true; value: CopyRequest } | { ok: false; status: 400 | 413; reason: string } {
+  let body: unknown;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    return { ok: false, status: 400, reason: "body is not JSON" };
+  }
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return { ok: false, status: 400, reason: "body is not an object" };
+  }
+  const { url, size, key } = body as Record<string, unknown>;
+  if (typeof url !== "string") return { ok: false, status: 400, reason: "url must be a string" };
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { ok: false, status: 400, reason: "url is not a URL" };
+  }
+  if (parsed.protocol !== "https:" || !slackFileHost(parsed.hostname)) {
+    return { ok: false, status: 400, reason: `url host ${parsed.hostname} is not a Slack file host` };
+  }
+  if (typeof size !== "number" || !Number.isInteger(size) || size < 1) {
+    return { ok: false, status: 400, reason: "size must be a positive integer" };
+  }
+  if (size > maxBytes) return { ok: false, status: 413, reason: `size ${size} is over the ${maxBytes}-byte ceiling` };
+  if (typeof key !== "string" || !validCopyKey(key)) {
+    return { ok: false, status: 400, reason: "key is not an inbound artifact key" };
+  }
+  return { ok: true, value: { url: parsed, size, key } };
+}
+
+const json = (status: number, body: Record<string, unknown>) =>
+  new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+
+/** The route. WHO: the copy bearer, checked in constant time before anything
+ *  else (401, and never the bucket's existence). WHAT: a Slack `url_private`,
+ *  a positive size within the ceiling and an inbound key (400/413, before any
+ *  fetch). THEN the upstream: Slack answers the login page (`text/html`) when
+ *  the token does not reach the file — refused as unauthorized, nothing put;
+ *  a status other than 200 is Slack's word (502); a `Content-Length` absent or
+ *  other than `size` is a 409 before any `put`. The body flows through the
+ *  length pipe into one `put` with Slack's content type; a stream that ends
+ *  short fails the pipe, the put rejects and the bucket keeps nothing (502). */
+export async function handleArtifactsCopy(request: Request, deps: CopyDeps): Promise<Response> {
+  const bearer = /^Bearer\s+(\S+)$/.exec(request.headers.get("authorization") ?? "")?.[1];
+  if (!deps.copyToken || !bearer || !sameToken(bearer, deps.copyToken)) {
+    return json(401, { ok: false, error: "artifacts copy: bearer refused" });
+  }
+  if (request.method === "GET") {
+    return deps.bucket && deps.bucketName
+      ? json(200, { ok: true, bucket: deps.bucketName })
+      : json(503, { ok: false, error: "artifacts copy: this Worker has no ARTIFACTS bucket binding" });
+  }
+  if (request.method !== "POST") return json(405, { ok: false, error: `method not allowed: POST ${COPY_PATH}` });
+  if (!deps.bucket)
+    return json(503, { ok: false, error: "artifacts copy: this Worker has no ARTIFACTS bucket binding" });
+  if (!deps.slackToken)
+    return json(503, { ok: false, error: "artifacts copy: SLACK_BOT_TOKEN is not set on this Worker" });
+  const parsed = parseCopyRequest(await request.text().catch(() => ""), deps.maxBytes ?? MAX_COPY_BYTES);
+  if (!parsed.ok) return json(parsed.status, { ok: false, error: `artifacts copy: ${parsed.reason}` });
+  const { url, size, key } = parsed.value;
+
+  let upstream: Response;
+  try {
+    upstream = await deps.fetch(url.toString(), {
+      headers: { authorization: `Bearer ${deps.slackToken}` },
+      redirect: "manual",
+    });
+  } catch (err) {
+    return json(502, { ok: false, error: `artifacts copy: slack did not answer: ${describe(err)}` });
+  }
+  const contentType = upstream.headers.get("content-type") ?? "application/octet-stream";
+  if (upstream.status === 200 && /^text\/html\b/i.test(contentType)) {
+    await upstream.body?.cancel().catch(() => {});
+    return json(502, {
+      ok: false,
+      error: "artifacts copy: slack answered its login page — the bot token is not authorized for this file",
+    });
+  }
+  if (upstream.status !== 200 || !upstream.body) {
+    await upstream.body?.cancel().catch(() => {});
+    return json(502, { ok: false, error: `artifacts copy: slack answered HTTP ${upstream.status}` });
+  }
+  const declared = Number(upstream.headers.get("content-length"));
+  if (!upstream.headers.has("content-length") || !Number.isInteger(declared)) {
+    await upstream.body.cancel().catch(() => {});
+    return json(409, { ok: false, error: "artifacts copy: slack stated no length for the file" });
+  }
+  if (declared !== size) {
+    await upstream.body.cancel().catch(() => {});
+    return json(409, { ok: false, error: `artifacts copy: slack states ${declared} bytes, not the ${size} declared` });
+  }
+
+  // The bytes: upstream → the fixed-length pipe → one put. Either side failing
+  // rejects the whole copy; R2 keeps nothing for a stream that did not complete.
+  const { readable, writable } = deps.lengthPipe(size);
+  try {
+    await Promise.all([
+      upstream.body.pipeTo(writable),
+      deps.bucket.put(key, readable, { httpMetadata: { contentType } }),
+    ]);
+  } catch (err) {
+    return json(502, { ok: false, error: `artifacts copy: the copy of ${key} failed mid-stream: ${describe(err)}` });
+  }
+  return json(200, { ok: true, key, size });
+}
+
+const describe = (err: unknown): string => (err instanceof Error ? err.message : String(err));

package/dist/assets/deploy/cloudflare/ensure-bucket.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Create the R2 buckets this Worker's wrangler.jsonc binds, before `wrangler
+// deploy` validates the bindings (docs/reference/specs/execution.md item 20,
+// record 0033). wrangler refuses a deploy whose `r2_buckets` names a bucket
+// that does not exist, and creating one by hand is the step an installation
+// forgets; `npm run deploy` runs this after the preflight. Idempotent: a bucket
+// that already exists is success (wrangler's own words for it are matched),
+// any other refusal is wrangler's, verbatim, and the deploy stops.
+//
+// Dependency-free Node. `bucketNamesOf()` and `decide()` are pure and
+// unit-tested (ensure-bucket.test.mjs); `main()` only does I/O around them.
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/** Every `bucket_name` the rendered config binds — the template renders the
+ *  block only when the deployment profile names a bucket, so an installation
+ *  without artifacts has none here and this script does nothing. */
+export function bucketNamesOf(wranglerJsonc) {
+  const names = [];
+  for (const m of wranglerJsonc.matchAll(/"bucket_name"\s*:\s*"([^"]+)"/g)) names.push(m[1]);
+  return [...new Set(names)];
+}
+
+/** Pure: what `wrangler r2 bucket create <name>` meant. Exit 0 → created; a
+ *  non-zero exit whose output says the bucket exists → already there (success);
+ *  anything else → wrangler's refusal, to print and stop on. */
+export function decide(name, code, output) {
+  if (code === 0) return { ok: true, kind: "created", name };
+  if (/already exists|10004/i.test(output)) return { ok: true, kind: "exists", name };
+  return { ok: false, name, reason: output.trim() || `wrangler exited ${code}` };
+}
+
+function wrangler(args, cwd) {
+  return new Promise((resolve) => {
+    execFile("npx", ["wrangler", ...args], { cwd, env: process.env, maxBuffer: 4 << 20 }, (err, stdout, stderr) => {
+      const code = err && typeof err.code === "number" ? err.code : err ? 1 : 0;
+      resolve({ code, output: `${stdout ?? ""}\n${stderr ?? ""}` });
+    });
+  });
+}
+
+export async function main(dir = dirname(fileURLToPath(import.meta.url))) {
+  let rendered;
+  try {
+    rendered = readFileSync(join(dir, "wrangler.jsonc"), "utf8");
+  } catch {
+    console.error("[ensure-bucket] wrangler.jsonc is not rendered — run `npm run deploy:gen` first");
+    return 2;
+  }
+  const names = bucketNamesOf(rendered);
+  if (names.length === 0) {
+    console.log("[ensure-bucket] no R2 buckets bound — nothing to create");
+    return 0;
+  }
+  for (const name of names) {
+    const r = await wrangler(["r2", "bucket", "create", name], dir);
+    const d = decide(name, r.code, r.output);
+    if (!d.ok) {
+      console.error(`[ensure-bucket] could not create bucket ${name}:\n${d.reason}`);
+      return 1;
+    }
+    console.log(`[ensure-bucket] bucket ${name} ${d.kind === "created" ? "created" : "already exists"}`);
+  }
+  return 0;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  process.exitCode = await main();
+}

package/dist/assets/deploy/cloudflare/package.json

@@ -7,7 +7,7 @@
   },
   "scripts": {
     "check:image": "docker build ../..",
-    "deploy": "node preflight.mjs && node write-build.mjs && wrangler deploy",
+    "deploy": "node preflight.mjs && node ensure-bucket.mjs && node write-build.mjs && wrangler deploy",
     "preflight": "node preflight.mjs",
     "test": "vitest run",
     "verify": "npm --prefix ../.. run --silent deploy:gen && npm run typecheck && npm test",

package/dist/assets/deploy/cloudflare/worker.ts

@@ -46,6 +46,7 @@ import {
 import { systemClock } from "../../src/core/trace/clock.ts";
 import { createTracer } from "../../src/core/trace/tracer.ts";
 import { shimRoute, stripTraceContext, withTraceContext, workerLogSink } from "../../src/core/trace/workerTrace.ts";
+import { COPY_PATH, handleArtifactsCopy } from "./artifactsCopy.ts";
 import type { ShipCoordinatorParams } from "./coordinator";
 import { INSTANCE, INTERNAL } from "./shared";
 
@@ -93,6 +94,12 @@ export interface Env {
   ARTIFACTS_R2_ACCESS_KEY_ID?: string; // artifact store: the bucket-scoped S3 token the bot signs presigned URLs with
   ARTIFACTS_R2_SECRET_ACCESS_KEY?: string; // artifact store: the secret half of that token
   ARTIFACTS_COPY_TOKEN?: string; // artifact store: the bearer the bot presents to this Worker's /artifacts/copy route
+  /** The artifacts bucket (artifactsCopy.ts), bound only when the deployment profile names one
+   *  (`artifacts.bucket` → the template's `r2_buckets` block); `ARTIFACTS_BUCKET_NAME` is the same
+   *  name as a var, what `GET /artifacts/copy` reports so `artifacts check` can hold it against the
+   *  bot's config. Worker-side only: neither reaches the container. */
+  ARTIFACTS?: R2Bucket;
+  ARTIFACTS_BUCKET_NAME?: string;
 }
 
 /** Every secret/var the Worker forwards into the container. Optional entries
@@ -429,7 +436,18 @@ export default {
             ? await handleCoordinatorInstances(forwarded, env)
             : statusId !== undefined
               ? await handleCoordinatorInstanceStatus(forwarded, env, statusId)
-              : await getContainer(env.SWITCHBOARD, INSTANCE).fetch(forwarded);
+              : pathname === COPY_PATH
+                ? // The artifact copy (artifactsCopy.ts): the R2 binding and the Slack
+                  // token are this Worker's; the bot only asks, with its copy bearer.
+                  await handleArtifactsCopy(inbound, {
+                    bucket: env.ARTIFACTS,
+                    bucketName: env.ARTIFACTS_BUCKET_NAME,
+                    copyToken: env.ARTIFACTS_COPY_TOKEN,
+                    slackToken: env.SLACK_BOT_TOKEN,
+                    fetch: (input, init) => fetch(input, init),
+                    lengthPipe: (size) => new FixedLengthStream(size),
+                  })
+                : await getContainer(env.SWITCHBOARD, INSTANCE).fetch(forwarded);
       root.end(res.status >= 500 ? "error" : "ok", { httpStatus: res.status });
       return res;
     } catch (err) {

package/dist/assets/deploy/cloudflare/wrangler.template.jsonc

@@ -34,6 +34,10 @@
     // The state Worker (deploy/cloudflare-memory/): where worker.ts records each
     // scheduled firing for the /runs Scheduled panel, with MEMORY_TOKEN.
     // A profile without a memory Worker renders no var: firings go unrecorded.
+    // The artifacts bucket's name, beside its binding below (rendered together).
+    // {{#if artifacts}}
+    "ARTIFACTS_BUCKET_NAME": "{{artifacts.bucket}}",
+    // {{/if}}
     // {{#if urls.stateWorkerUrl}}
     "STATE_WORKER_URL": "{{urls.stateWorkerUrl}}"
     // {{/if}}
@@ -54,6 +58,17 @@
   "durable_objects": {
     "bindings": [{ "name": "SWITCHBOARD", "class_name": "SwitchboardServer" }]
   },
+  // The artifacts bucket (docs/reference/specs/execution.md item 20, record
+  // 0033): where a run's files live by reference. Rendered only when the
+  // deployment profile names a bucket (`artifacts.bucket`) — the bot's
+  // config `artifacts.r2.bucket` must say the same name, and `artifacts
+  // check` holds the two against each other through `GET /artifacts/copy`.
+  // `npm run deploy` creates the bucket first (ensure-bucket.mjs); wrangler
+  // validates the binding on deploy. `ARTIFACTS_BUCKET_NAME` above is the
+  // same name as a var, so the Worker can say which bucket it binds.
+  // {{#if artifacts}}
+  "r2_buckets": [{ "binding": "ARTIFACTS", "bucket_name": "{{artifacts.bucket}}" }],
+  // {{/if}}
   "migrations": [{ "tag": "v1", "new_sqlite_classes": ["SwitchboardServer"] }],
   // The ship coordinator as a Workflow (coordinator.ts, re-exported by
   // worker.ts; docs/reference/specs/http-ingress.md item 9): `POST