sproutboat 0.53.1 → 0.55.0

package/src/options.ts

@@ -0,0 +1,242 @@
+/**
+ * What each command accepts after the global flags are out (global-flags.ts), checked once, before the command runs.
+ * A flag a command does not know is an error, never a quiet no-op: a typo or a flag from another tool must not turn
+ * into a different action (`deploy --api-url=<url>` used to be ignored and deployed to the saved endpoint).
+ *
+ * `--flag=value` is rewritten to `--flag value`, so every command parses one form. A positional that looks like a
+ * URL is refused for the commands that take a project directory or a name, so `deploy https://dash.example.com` is
+ * never read as a folder.
+ *
+ * The table is documentation too: `surface.test.ts` fails when a flag in a command's grammar (surface.ts) is not here.
+ */
+export type Options = {
+  /** Flags that take the next argument (or `=value`) as their value. */
+  readonly value?: readonly string[];
+  /** Flags that stand alone. */
+  readonly flag?: readonly string[];
+  /**
+   * Subcommands with options of their own, keyed by their leading words (`"execute"`, `"migrations apply"`): when the
+   * arguments start with one, its entry is what is checked, and the command's own `value`/`flag` are not.
+   * Arguments that start with none of them are checked against the command's own options.
+   */
+  readonly sub?: Readonly<Record<string, Options>>;
+  /**
+   * The command's subcommands parse (and refuse) their own options, so only the plain verbs are checked, where the
+   * command itself does it (`storage` in main.ts).
+   */
+  readonly own?: true;
+};
+
+export const COMMAND_OPTIONS = {
+  // As in create-cloudflare: --template picks a starter, --git and --install (and their --no-) decide the two steps
+  // after scaffolding, -y takes every default. --list-templates prints the starters and exits.
+  init: {
+    value: ["--template"],
+    flag: ["--list-templates", "--git", "--no-git", "--install", "--no-install", "--yes", "-y", "--accept-defaults"],
+  },
+  check: {},
+  // The booleans take `--strict-vars=false` as in Wrangler (types-cmd.ts reads the pair); `--no-...` is the short way.
+  types: {
+    value: ["--env-interface", "--strict-vars", "--include-runtime", "--include-env"],
+    flag: ["--check", "--no-strict-vars", "--no-include-runtime", "--no-include-env"],
+  },
+  dev: { value: ["--port", "--ip"], flag: ["--no-watch"] },
+  run: { value: ["--binary", "--port", "--data-dir", "--require"], flag: ["--check"] },
+  build: {
+    value: ["--target"],
+    flag: ["--standalone", "--release", "--deploy-files", "--with-restore", "--emit-only"],
+  },
+  toolchain: { flag: ["--json"] },
+  deploy: {
+    value: ["--account", "--artifact", "--module", "--sproutd", "--generation", "--secrets-file"],
+    flag: ["--dry-run", "--no-wait", "--no-provision"],
+  },
+  versions: {},
+  deployments: {
+    sub: {
+      list: { value: ["--account"], flag: ["--json"] },
+      status: { value: ["--account"], flag: ["--json"] },
+      tail: { value: ["--account"] },
+    },
+  },
+  rollback: {},
+  tail: {
+    value: ["--format", "--status", "--method", "--sampling-rate", "--search", "--outcome", "--file", "--lines"],
+    flag: ["--recent", "--sprout", "--no-follow"],
+  },
+  delete: { value: ["--name"], flag: ["--yes", "-y"] },
+  domains: { value: ["--account"] },
+  // `secret` is the same command (surface.ts); `list | put | delete | bulk` share these, `--value` is put's.
+  secrets: { value: ["--value", "--account"], flag: ["--no-deploy"] },
+  kv: {
+    value: ["--output", "--path", "--prefix", "--cursor", "--limit"],
+    flag: ["--force", "--text", "--yes"],
+  },
+  d1: {
+    sub: {
+      execute: {
+        value: ["--command", "--file", "--persist-to", "--account"],
+        flag: ["--json", "--local", "--remote", "--yes", "-y"],
+      },
+      "migrations create": {},
+      "migrations list": { value: ["--persist-to", "--account"], flag: ["--local", "--remote"] },
+      "migrations apply": { value: ["--persist-to", "--account"], flag: ["--local", "--remote"] },
+    },
+  },
+  // The Wrangler flags that are not supported yet (--local, --jurisdiction, -J, --storage-class, -s, --persist-to) are
+  // listed so the command answers with its own reason instead of "unknown option".
+  r2: {
+    sub: {
+      "object get": {
+        value: ["--file", "-f", "--account", "--jurisdiction", "-J", "--storage-class", "-s", "--persist-to"],
+        flag: ["--pipe", "-p", "--remote", "--local"],
+      },
+      "object put": {
+        value: [
+          "--file",
+          "-f",
+          "--content-type",
+          "--ct",
+          "--content-disposition",
+          "--cd",
+          "--content-encoding",
+          "--ce",
+          "--content-language",
+          "--cl",
+          "--cache-control",
+          "--cc",
+          "--expires",
+          "--account",
+          "--jurisdiction",
+          "-J",
+          "--storage-class",
+          "-s",
+          "--persist-to",
+        ],
+        flag: ["--pipe", "-p", "--remote", "--local"],
+      },
+      "object delete": {
+        value: ["--account", "--jurisdiction", "-J", "--storage-class", "-s", "--persist-to"],
+        flag: ["--remote", "--local"],
+      },
+    },
+  },
+  queues: {},
+  login: { value: ["--token", "--account"] },
+  logout: { value: ["--account"] },
+  whoami: { value: ["--account"] },
+  profile: {},
+  complete: {},
+} as const satisfies Record<string, Options>;
+
+/** The commands that talk to a control plane, so `--api-url` means something to them. */
+export const ENDPOINT_COMMANDS: ReadonlySet<string> = new Set([
+  "deploy",
+  "versions",
+  "deployments",
+  "rollback",
+  "tail",
+  "delete",
+  "domains",
+  "secrets",
+  "kv",
+  "d1",
+  "r2",
+  "queues",
+  "login",
+  "logout",
+  "whoami",
+]);
+
+/** Commands whose positionals are never URL-valued (`kv key put <key> <value>` may take one, so `kv` is not here). */
+const URL_REFUSED = new Set(Object.keys(COMMAND_OPTIONS).filter((name) => name !== "kv"));
+
+const URL_WITH_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+export type OptionsCheck = { args: string[] } | { error: string };
+
+const flagsOf = (spec: Options) => [...(spec.value ?? []), ...(spec.flag ?? [])];
+
+/** The subcommand's options when `args` start with one of the command's `sub` entries (one or two words). */
+function subOptions(spec: Options, args: readonly string[]): Options | undefined {
+  if (!spec.sub) return undefined;
+  const named = [args.slice(0, 2).join(" "), args.slice(0, 1).join(" ")];
+  for (const key of named) if (Object.hasOwn(spec.sub, key)) return spec.sub[key];
+  return undefined;
+}
+
+/** Every flag a command takes in any of its forms: its own and its subcommands'. */
+export function allFlags(spec: Options): string[] {
+  return [...new Set([...flagsOf(spec), ...Object.values(spec.sub ?? {}).flatMap(flagsOf)])];
+}
+
+/** The closest known flag to a mistyped one, when one is near enough to be a typo. */
+function suggest(name: string, known: readonly string[]): string | undefined {
+  const distance = (a: string, b: string) => {
+    const row = Array.from({ length: b.length + 1 }, (_, at) => at);
+    for (let i = 1; i <= a.length; i += 1) {
+      let diagonal = row[0]!;
+      row[0] = i;
+      for (let j = 1; j <= b.length; j += 1) {
+        const above = row[j]!;
+        row[j] = Math.min(row[j]! + 1, row[j - 1]! + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+        diagonal = above;
+      }
+    }
+    return row[b.length]!;
+  };
+  const best = known
+    .map((candidate) => ({ candidate, away: distance(name, candidate) }))
+    .sort((left, right) => left.away - right.away)[0];
+  return best && best.away <= 2 ? best.candidate : undefined;
+}
+
+/**
+ * Check `args` (what is left after the global flags) for `command`. Returns them with `--flag=value` split in two, or
+ * the first problem. A command that is not in the table is not checked here.
+ */
+export function checkOptions(command: string, args: readonly string[]): OptionsCheck {
+  if (!Object.hasOwn(COMMAND_OPTIONS, command)) return { args: [...args] };
+  // SAFETY: `command` is a key of the table, checked above.
+  const top: Options = COMMAND_OPTIONS[command as keyof typeof COMMAND_OPTIONS];
+  if (top.own) return { args: [...args] };
+  const spec = subOptions(top, args) ?? top;
+  const values = new Set(spec.value);
+  const flags = new Set(spec.flag);
+  const out: string[] = [];
+  for (let at = 0; at < args.length; at += 1) {
+    const arg = args[at]!;
+    if (arg === "--") {
+      out.push(...args.slice(at));
+      break;
+    }
+    if (!arg.startsWith("-") || arg === "-") {
+      if (URL_REFUSED.has(command) && URL_WITH_SCHEME.test(arg))
+        return {
+          error: `"${arg}" looks like a URL, not a project directory or a name. To pick the control plane use --api-url <url>, --profile <name> or SPROUTBOAT_API_URL`,
+        };
+      out.push(arg);
+      continue;
+    }
+    const equals = arg.startsWith("--") ? arg.indexOf("=") : -1;
+    const name = equals > 0 ? arg.slice(0, equals) : arg;
+    if (values.has(name)) {
+      out.push(name);
+      if (equals > 0) out.push(arg.slice(equals + 1));
+      else if (at + 1 < args.length) out.push(args[(at += 1)]!);
+      continue;
+    }
+    if (flags.has(name)) {
+      if (equals > 0) return { error: `${name} takes no value` };
+      out.push(name);
+      continue;
+    }
+    const near = suggest(name, flagsOf(spec));
+    return {
+      error: `unknown option ${name}${near ? ` (did you mean ${near}?)` : ""}${
+        flagsOf(spec).length === 0 ? `; \`${command}\` takes no options` : ""
+      }`,
+    };
+  }
+  return { args: out };
+}

package/src/r2-objects.ts

@@ -0,0 +1,365 @@
+/**
+ * `sproutboat r2 object get | put | delete <bucket>/<key>`, with Wrangler's flags. On a Cloud endpoint an object lives in the
+ * app's own bucket on its host (`/v1/apps/<app>/r2/<BUCKET>/objects/<key>`, docs/host-data.md in the cloud repo), and
+ * `<bucket>` is the binding name from `r2_buckets`. Self-hosted Community can read an object (`/api/r2/<id>/objects/<key>`)
+ * but has no route to write or delete one: its 404 is reported as not supported yet.
+ */
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { authHeaders, CloudError, explainApiFailure, parseBody } from "./cloud";
+import { dataErrorMessage } from "./data-errors";
+import { isString } from "./json";
+import { dim, ok } from "./style";
+
+export const GET_USAGE = "r2 object get <bucket>/<key> [--file <path> | --pipe]";
+export const PUT_USAGE =
+  "r2 object put <bucket>/<key> (--file <path> | --pipe) [--content-type <type>] [--cache-control <v>] [--content-disposition <v>] [--content-encoding <v>] [--content-language <v>] [--expires <date>]";
+export const DELETE_USAGE = "r2 object delete <bucket>/<key>";
+/** What one object may be through the Cloud API (a PUT is refused over it before any host is called). */
+export const OBJECT_MAX_BYTES = 64 * 1024 * 1024;
+/** The longest key, in bytes of UTF-8. */
+export const KEY_MAX_BYTES = 1024;
+
+export class R2UsageError extends Error {
+  constructor(
+    message: string,
+    readonly usage: string,
+  ) {
+    super(message);
+  }
+}
+
+export type ObjectFlags = {
+  file?: string;
+  pipe: boolean;
+  contentType?: string;
+  contentDisposition?: string;
+  contentEncoding?: string;
+  contentLanguage?: string;
+  cacheControl?: string;
+  expires?: string;
+  account?: string;
+};
+
+/** `{bucket}/{key}`: the bucket is everything before the first slash, the key everything after it. */
+export type ObjectPath = { bucket: string; key: string };
+
+/**
+ * The rules the Cloud applies to a key (docs/host-data.md, "R2 keys"), so a bad one is refused here with a reason
+ * instead of coming back as a 400: 1 to 1024 bytes of UTF-8, no control character (C0, DEL, C1), no backslash, and no
+ * empty, `.` or `..` segment. Returns the problem, or undefined when the key is fine.
+ */
+export function keyProblem(key: string): string | undefined {
+  if (key.length === 0) return "the key is empty";
+  try {
+    encodeURIComponent(key); // throws on a lone surrogate, which has no UTF-8 form
+  } catch {
+    return "the key is not valid UTF-8";
+  }
+  const bytes = new TextEncoder().encode(key).length;
+  if (bytes > KEY_MAX_BYTES) return `the key is ${bytes} bytes; at most ${KEY_MAX_BYTES}`;
+  for (let at = 0; at < key.length; at += 1) {
+    const code = key.charCodeAt(at);
+    if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+      return `the key has a control character (U+${code.toString(16).toUpperCase().padStart(4, "0")}) at position ${at + 1}`;
+    if (code === 0x5c) return "the key has a backslash; use / between folders";
+  }
+  const segments = key.split("/");
+  if (segments.some((part) => part === "")) return 'the key has an empty segment: no leading, trailing or doubled "/"';
+  const dots = segments.find((part) => part === "." || part === "..");
+  if (dots) return `the key has a "${dots}" segment; a key is a name, not a path`;
+  return undefined;
+}
+
+export function parseObjectPath(path: string | undefined, usage: string): ObjectPath {
+  const slash = path?.indexOf("/") ?? -1;
+  if (path === undefined || slash <= 0) throw new R2UsageError("the object path must be <bucket>/<key>", usage);
+  const key = path.slice(slash + 1);
+  const problem = keyProblem(key);
+  if (problem)
+    throw new R2UsageError(
+      `${path.slice(0, slash)}/${key.length > 60 ? `${key.slice(0, 57)}...` : key}: ${problem}`,
+      usage,
+    );
+  return { bucket: path.slice(0, slash), key };
+}
+
+/** Read stdin up to `max` bytes; a longer input stops the read instead of filling memory. */
+export async function readCapped(
+  stream: ReadableStream<Uint8Array>,
+  max: number,
+  tooLong: () => Error,
+): Promise<Uint8Array<ArrayBuffer>> {
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  for await (const chunk of stream) {
+    size += chunk.byteLength;
+    if (size > max) throw tooLong();
+    chunks.push(chunk);
+  }
+  const out = new Uint8Array(size);
+  let at = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, at);
+    at += chunk.byteLength;
+  }
+  return out;
+}
+
+export function parseObjectArgs(args: readonly string[], usage: string) {
+  const flags: ObjectFlags = { pipe: false };
+  const positional: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]!;
+    const equals = arg.startsWith("--") ? arg.indexOf("=") : -1;
+    const name = equals > 0 ? arg.slice(0, equals) : arg;
+    const inline = equals > 0 ? arg.slice(equals + 1) : undefined;
+    const value = () => {
+      const next = inline ?? args[(index += 1)];
+      if (next === undefined || (inline === undefined && next.startsWith("--")))
+        throw new R2UsageError(`${name} needs a value`, usage);
+      return next;
+    };
+    switch (name) {
+      case "--file":
+      case "-f":
+        flags.file = value();
+        break;
+      case "--pipe":
+      case "-p":
+        flags.pipe = true;
+        break;
+      case "--content-type":
+      case "--ct":
+        flags.contentType = value();
+        break;
+      case "--content-disposition":
+      case "--cd":
+        flags.contentDisposition = value();
+        break;
+      case "--content-encoding":
+      case "--ce":
+        flags.contentEncoding = value();
+        break;
+      case "--content-language":
+      case "--cl":
+        flags.contentLanguage = value();
+        break;
+      case "--cache-control":
+      case "--cc":
+        flags.cacheControl = value();
+        break;
+      case "--expires":
+        flags.expires = value();
+        break;
+      case "--account":
+        flags.account = value();
+        break;
+      case "--remote":
+        break;
+      case "--local":
+        throw new R2UsageError(
+          "--local is not supported for R2 objects yet (dev keeps them in its broker store); objects are read and written on the Cloud, so --remote is the only mode",
+          usage,
+        );
+      case "--jurisdiction":
+      case "-J":
+      case "--storage-class":
+      case "-s":
+      case "--persist-to":
+        throw new R2UsageError(`${name} is not supported`, usage);
+      default:
+        if (arg.startsWith("-")) throw new R2UsageError(`unknown option ${name}`, usage);
+        positional.push(arg);
+    }
+  }
+  return { positional, flags };
+}
+
+/** The headers a PUT carries: the object's HTTP metadata, as the Cloud route reads them. */
+/** The object metadata headers a PUT carries; `x-object-cache-control` is the object's Cache-Control (docs/host-data.md). */
+export type ObjectHeaders = {
+  "content-type"?: string;
+  "content-disposition"?: string;
+  "content-encoding"?: string;
+  "content-language"?: string;
+  "x-object-cache-control"?: string;
+  expires?: string;
+};
+
+export function metadataHeaders(flags: ObjectFlags, fileType: string | undefined): ObjectHeaders {
+  const headers: ObjectHeaders = {};
+  const type = flags.contentType ?? fileType;
+  if (type) headers["content-type"] = type;
+  if (flags.contentDisposition) headers["content-disposition"] = flags.contentDisposition;
+  if (flags.contentEncoding) headers["content-encoding"] = flags.contentEncoding;
+  if (flags.contentLanguage) headers["content-language"] = flags.contentLanguage;
+  if (flags.cacheControl) headers["x-object-cache-control"] = flags.cacheControl;
+  if (flags.expires) {
+    const time = Date.parse(flags.expires);
+    if (Number.isNaN(time)) throw new R2UsageError(`--expires: "${flags.expires}" is not a date`, PUT_USAGE);
+    headers.expires = new Date(time).toUTCString();
+  }
+  return headers;
+}
+
+export type ObjectIo = {
+  log(line: string): void;
+  note(line: string): void;
+  stdout: { write(bytes: Uint8Array): void };
+};
+
+/** How the command reaches the objects of one bucket. */
+export type ObjectTarget = {
+  community: boolean;
+  bucket: string;
+  app: string;
+  request(
+    method: "GET" | "PUT" | "DELETE",
+    key: string,
+    init?: { body?: Uint8Array<ArrayBuffer>; headers?: ObjectHeaders },
+  ): Promise<Response>;
+};
+
+async function explain(target: ObjectTarget, response: Response, method: string, key: string): Promise<never> {
+  const text = await response.text().catch(() => "");
+  const body = parseBody(text);
+  if (target.community) {
+    if (response.status === 404) {
+      if (method !== "GET")
+        throw new CloudError(
+          `${method === "PUT" ? "writing" : "deleting"} R2 objects is not supported on self-hosted Community yet (this endpoint has no such route); read-only: r2 object get`,
+        );
+      throw new CloudError(isString(body?.error) ? `${key}: not found` : `no R2 bucket "${target.bucket}"`);
+    }
+    throw new CloudError(explainApiFailure(response.status, text, false));
+  }
+  const message = dataErrorMessage(
+    { status: response.status, body, headers: response.headers },
+    { project: target.app, product: "R2", noun: "bucket", name: target.bucket, write: method !== "GET" },
+  );
+  if (message) throw new CloudError(message);
+  if (response.status === 404) {
+    if (isString(body?.error) && /no such app/i.test(body.error))
+      throw new CloudError(`${target.app} is not deployed yet, so it has no bucket: run \`sproutboat deploy\` first`);
+    throw new CloudError(`${key}: not found`);
+  }
+  throw new CloudError(explainApiFailure(response.status, text, false));
+}
+
+/** The object's own type: the `x-object-content-type` header, present only when one was stored (`content-type` is always octet-stream). */
+export function storedContentType(headers: Headers): string | undefined {
+  return headers.get("x-object-content-type") ?? undefined;
+}
+
+/** Where `get` writes: --file, stdout with --pipe, otherwise ./<key> (Wrangler's default), creating folders. */
+export async function getObject(
+  target: ObjectTarget,
+  key: string,
+  flags: ObjectFlags,
+  io: ObjectIo,
+  cwd: string,
+): Promise<void> {
+  if (flags.file !== undefined && flags.pipe) throw new R2UsageError("pass --file or --pipe, not both", GET_USAGE);
+  const response = await target.request("GET", key);
+  if (!response.ok) return explain(target, response, "GET", key);
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (flags.pipe) {
+    io.stdout.write(bytes);
+    return;
+  }
+  const path = resolve(cwd, flags.file ?? key);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, bytes);
+  // The response's own content-type is always application/octet-stream; the object's type is x-object-content-type.
+  const type = storedContentType(response.headers);
+  io.note(
+    `${ok(`Downloaded "${key}" from "${target.bucket}"`)} ${dim(`to ${path} (${bytes.byteLength} bytes${type ? `, ${type}` : ""})`)}`,
+  );
+}
+
+export async function putObject(
+  target: ObjectTarget,
+  key: string,
+  flags: ObjectFlags,
+  io: ObjectIo,
+  cwd: string,
+  readStdin: () => Promise<Uint8Array<ArrayBuffer>>,
+): Promise<void> {
+  if ((flags.file === undefined) === !flags.pipe)
+    throw new R2UsageError("you must provide either --file or --pipe", PUT_USAGE);
+  let bytes: Uint8Array<ArrayBuffer>;
+  let fileType: string | undefined;
+  if (flags.file !== undefined) {
+    const path = resolve(cwd, flags.file);
+    if (!existsSync(path) || !statSync(path).isFile()) throw new CloudError(`${flags.file}: no such file`);
+    if (statSync(path).size > OBJECT_MAX_BYTES)
+      throw new CloudError(
+        `${flags.file} is larger than ${OBJECT_MAX_BYTES / 1024 / 1024} MiB, the most the Cloud takes`,
+      );
+    bytes = new Uint8Array(readFileSync(path));
+    fileType = Bun.file(path).type.split(";")[0];
+    if (fileType === "application/octet-stream") fileType = undefined;
+  } else {
+    bytes = await readStdin();
+    if (bytes.byteLength > OBJECT_MAX_BYTES)
+      throw new CloudError(
+        `the piped object is larger than ${OBJECT_MAX_BYTES / 1024 / 1024} MiB, the most the Cloud takes`,
+      );
+  }
+  const headers = metadataHeaders(flags, fileType);
+  const response = await target.request("PUT", key, { body: bytes, headers });
+  if (!response.ok) return explain(target, response, "PUT", key);
+  const answer = parseBody(await response.text().catch(() => ""));
+  const etag = isString(answer?.etag) ? `, etag ${answer.etag}` : "";
+  io.note(`${ok(`Uploaded "${key}" to "${target.bucket}"`)} ${dim(`(${bytes.byteLength} bytes${etag})`)}`);
+}
+
+export async function deleteObject(target: ObjectTarget, key: string, io: ObjectIo): Promise<void> {
+  const response = await target.request("DELETE", key);
+  if (!response.ok) return explain(target, response, "DELETE", key);
+  await response.body?.cancel();
+  io.note(ok(`Deleted "${key}" from "${target.bucket}"`));
+}
+
+/**
+ * A Cloud app's bucket: `/v1/apps/<app>/r2/<BUCKET>/objects/<key>` with the key's slashes kept. A key never holds a dot
+ * segment, a backslash or a control character (checked before this), so `encodeURIComponent` never writes the `%2e`,
+ * `%2f` or `%5c` the Cloud refuses. The body is whole bytes, so the request always carries `content-length` (an
+ * `x-declared-length` is only for a chunked body, which this never sends). A GET is not decompressed: the bytes written are
+ * the bytes stored, whatever the transport says.
+ */
+export function cloudTarget(apiUrl: string, token: string, app: string, bucket: string): ObjectTarget {
+  return {
+    community: false,
+    bucket,
+    app,
+    request: (method, key, init = {}) => {
+      const headers = new Headers({ ...authHeaders(token), ...init.headers });
+      if (init.body !== undefined) headers.set("content-length", String(init.body.byteLength));
+      const path = key.split("/").map(encodeURIComponent).join("/");
+      return fetch(`${apiUrl}/v1/apps/${app}/r2/${encodeURIComponent(bucket)}/objects/${path}`, {
+        method,
+        headers,
+        body: init.body,
+        decompress: false,
+      });
+    },
+  };
+}
+
+/** A Community bucket by its resource id: the read route exists, the write and delete routes do not (their 404 says so). */
+export function communityTarget(apiUrl: string, token: string, app: string, bucket: string, id: string): ObjectTarget {
+  return {
+    community: true,
+    bucket,
+    app,
+    request: (method, key, init = {}) =>
+      fetch(`${apiUrl}/api/r2/${id}/objects/${encodeURIComponent(key)}`, {
+        method,
+        headers: { "x-api-key": token, ...init.headers },
+        body: init.body === undefined ? undefined : init.body,
+        decompress: false,
+      }),
+  };
+}

package/src/run.ts

@@ -22,7 +22,8 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { parseConfig } from "./config";
+import { parseProjectConfig } from "./account-field";
+import { locateProject } from "./global-flags";
 import {
   mergeEntries,
   MissingSecretsError,
@@ -108,20 +109,25 @@ export type RunPlan = {
 /** Resolve what to launch and with which environment, or throw. Starts nothing. */
 export async function planRun(
   args: RunArgs,
-  io: { cwd: string; inherited: Record<string, string | undefined> },
+  io: { cwd: string; inherited: Record<string, string | undefined>; config?: string },
 ): Promise<RunPlan> {
-  const directory = resolve(io.cwd, args.dir ?? ".");
-  const configPath = resolve(directory, "sproutboat.jsonc");
+  let located: { directory: string; configPath: string };
+  try {
+    located = locateProject(args.dir, io.config, io.cwd);
+  } catch (error) {
+    throw new RunError(error instanceof Error ? error.message : String(error));
+  }
+  const { directory, configPath } = located;
   let name: string | undefined;
   const declared: string[] = [];
   if (existsSync(configPath)) {
-    const parsed = parseConfig(await readFile(configPath, "utf8"));
+    const parsed = parseProjectConfig(await readFile(configPath, "utf8"));
     if (!parsed.ok) throw new RunError(parsed.errors.join("\n"));
     name = parsed.value.name;
     declared.push(...(parsed.value.secrets ?? []));
   } else if (args.binary === undefined) {
     throw new RunError(
-      `no sproutboat.jsonc found in ${directory}; pass --binary <file> to run a binary without a project`,
+      `no ${io.config === undefined ? "sproutboat.jsonc" : "config file"} found in ${io.config === undefined ? directory : configPath}; pass --binary <file> to run a binary without a project`,
     );
   }
   for (const required of args.require) if (!declared.includes(required)) declared.push(required);