termcut 0.2.2 → 0.3.0

package/README.md

@@ -21,6 +21,8 @@ tcut rec -o demo.gif                    # opens a shell, records until you `exit
 tcut rec -o demo.mp4 -- npm create vite # or just one command
 ```
 
+You get `demo.gif`, the exact recording (`demo.cast`) and an editable script (`demo.video.ts`) of what you typed.
+
 Or script it:
 
 ```ts
@@ -38,10 +40,17 @@ export default defineVideo({ output: "demo.gif" }, async (t) => {
 tcut demo.video.ts
 ```
 
-Re-render any recording without re-running it:
+Re-render any recording without re-running it — ~600 themes ([Ghostty's collection](https://github.com/mbadolato/iTerm2-Color-Schemes)), `tcut themes` lists them:
+
+```sh
+tcut render demo.cast --theme "Gruvbox Dark" -o demo.svg
+```
+
+Share it:
 
 ```sh
-tcut render demo.cast --theme dracula -o demo.svg
+tcut publish --setup        # once: your S3-compatible bucket (RustFS, MinIO, R2, S3)
+tcut publish demo.gif       # → https://…/3f9a1c2b7d4e/demo.gif
 ```
 
 ## More

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termcut",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Script terminal sessions in TypeScript, render them to reproducible MP4/GIF/WebM/SVG/HTML with Bun.",
   "license": "MIT",
   "author": "Aman Varshney",
@@ -33,7 +33,7 @@
     ".": "./src/index.ts"
   },
   "bin": {
-    "tcut": "./bin/tcut.mjs"
+    "tcut": "bin/tcut.mjs"
   },
   "files": [
     "bin",

package/scripts/build-themes.ts

@@ -0,0 +1,86 @@
+// Generates src/themes.generated.json from the Ghostty-format themes in mbadolato/iTerm2-Color-Schemes (MIT) —
+// the same collection Ghostty bundles. Run: `bun scripts/build-themes.ts` (network). Output is committed.
+import path from "node:path";
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+
+const SOURCE = "https://github.com/mbadolato/iTerm2-Color-Schemes/archive/refs/heads/master.tar.gz";
+const out = path.resolve(import.meta.dir, "..", "src", "themes.generated.json");
+
+const KEYS = [
+  "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+  "brightBlack", "brightRed", "brightGreen", "brightYellow", "brightBlue", "brightMagenta", "brightCyan", "brightWhite",
+] as const;
+
+const slug = (name: string) =>
+  name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+const hex = (v: string) => {
+  const h = v.trim().replace(/^#/, "");
+  return /^[0-9a-f]{6}$/i.test(h) ? `#${h.toLowerCase()}` : null;
+};
+
+function parse(name: string, text: string): Record<string, string> | null {
+  const palette: Record<number, string> = {};
+  const props: Record<string, string> = {};
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq < 0) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    if (key === "palette") {
+      const m = /^(\d+)\s*=\s*(.+)$/.exec(value);
+      if (m) {
+        const c = hex(m[2]!);
+        if (c) palette[Number(m[1])] = c;
+      }
+    } else {
+      props[key] = value;
+    }
+  }
+  const background = hex(props.background ?? "");
+  const foreground = hex(props.foreground ?? "");
+  if (!background || !foreground) return null;
+  for (let i = 0; i < 16; i++) if (!palette[i]) return null;
+  const theme: Record<string, string> = { name, background, foreground };
+  const cursor = hex(props["cursor-color"] ?? "");
+  if (cursor) theme.cursor = cursor;
+  const cursorText = hex(props["cursor-text"] ?? "");
+  if (cursorText) theme.cursorAccent = cursorText;
+  const selection = hex(props["selection-background"] ?? "");
+  if (selection) theme.selectionBackground = selection;
+  KEYS.forEach((k, i) => (theme[k] = palette[i]!));
+  return theme;
+}
+
+const tmp = await mkdtemp(path.join(tmpdir(), "tcut-themes-"));
+const tgz = path.join(tmp, "schemes.tgz");
+const res = await fetch(SOURCE);
+if (!res.ok) throw new Error(`download failed: ${res.status}`);
+await Bun.write(tgz, await res.arrayBuffer());
+const untar = Bun.spawn(["tar", "-xzf", tgz, "-C", tmp], { stdout: "ignore", stderr: "pipe" });
+if ((await untar.exited) !== 0) throw new Error(await new Response(untar.stderr).text());
+const root = (await readdir(tmp)).find((d) => d.startsWith("iTerm2-Color-Schemes"));
+if (!root) throw new Error("unexpected archive layout");
+const dir = path.join(tmp, root, "ghostty");
+
+const themes: Record<string, Record<string, string>> = {};
+let skipped = 0;
+for (const file of (await readdir(dir)).sort()) {
+  const text = await Bun.file(path.join(dir, file)).text();
+  const theme = parse(file, text);
+  if (!theme) {
+    skipped++;
+    continue;
+  }
+  themes[slug(file)] = theme;
+}
+await rm(tmp, { recursive: true, force: true });
+
+await Bun.write(out, JSON.stringify(themes) + "\n");
+console.log(`wrote ${path.relative(process.cwd(), out)}: ${Object.keys(themes).length} themes (${skipped} skipped), ${(Bun.file(out).size / 1024).toFixed(0)} KB`);

package/src/cli.ts

@@ -6,9 +6,11 @@ import { writeCast } from "./cast";
 import { resolveConfig } from "./config";
 import * as api from "./index";
 import { recordLive } from "./live";
+import { ensurePublicBucket, loadPublishConfig, publicUrlFor, publishFiles, savePublishConfig, type PublishConfig } from "./publish";
 import { renderOutputs } from "./render";
+import { generateScript } from "./scriptgen";
 import { runScriptTests } from "./testing";
-import { themeNames } from "./themes";
+import { findThemes, themeNames } from "./themes";
 import type { CoreName, ThemeName, VideoConfig, WindowBar } from "./types";
 import { Video, isVideo, renderCast } from "./video";
 
@@ -32,8 +34,10 @@ Usage:
   tcut record <script.ts> [options]   record only (writes the .cast)
   tcut render <file.cast> [options]   render an existing .cast (tcut or asciinema)
   tcut test <path...>                 run scripts in fast mode as tests (no video)
+  tcut publish <files...> [--open]    upload to your S3-compatible bucket and print share links
+  tcut publish --setup                configure the bucket (RustFS, MinIO, R2, S3 …) — once
   tcut init [name] [--template t]     scaffold a new script (basic | tour | test)
-  tcut themes                         list built-in themes
+  tcut themes [query]                 list the ~600 bundled themes (Ghostty collection)
 
 Options (override the script's config):
   -o, --output <path>      .mp4 .webm .gif .webp .svg .html .png .jpg or dir/ for PNG frames — repeatable
@@ -47,7 +51,11 @@ Options (override the script's config):
       --cols <n> --rows <n>  terminal size (rec: defaults to your terminal's size)
       --cast <path>        where to read/write the .cast
       --record-only        stop after writing the cast
+      --no-script          rec: don't write the editable <name>.video.ts next to the cast
       --force              ignore the cast cache and re-record
+      --open               publish: open the first link in the browser
+      --name <file>        publish: object name (default: the file's basename)
+      --endpoint --bucket --access-key --secret-key --public-url --region   publish --setup values
       --template <name>    for init: basic | tour | test
   -q, --quiet
   -h, --help
@@ -77,7 +85,17 @@ const { values, positionals } = parseArgs({
     rows: { type: "string" },
     cast: { type: "string" },
     "record-only": { type: "boolean" },
+    "no-script": { type: "boolean" },
     force: { type: "boolean" },
+    setup: { type: "boolean" },
+    open: { type: "boolean" },
+    name: { type: "string" },
+    endpoint: { type: "string" },
+    bucket: { type: "string" },
+    "access-key": { type: "string" },
+    "secret-key": { type: "string" },
+    "public-url": { type: "string" },
+    region: { type: "string" },
     template: { type: "string" },
     quiet: { type: "boolean", short: "q" },
     help: { type: "boolean", short: "h" },
@@ -281,7 +299,47 @@ async function main(): Promise<void> {
 
   switch (first) {
     case "themes": {
-      for (const name of themeNames) console.log(name);
+      const names = rest[0] ? findThemes(rest[0]) : themeNames;
+      if (names.length === 0) fail(`No theme matches "${rest[0]}"`);
+      for (const name of names) console.log(name);
+      if (!rest[0]) log(dim(`${names.length} themes · use any name with --theme, e.g. --theme "Gruvbox Dark"`));
+      return;
+    }
+    case "publish": {
+      if (values.setup) {
+        const ask = async (label: string, flag: string | undefined, fallback: string, secret = false): Promise<string> => {
+          if (flag) return flag;
+          if (!process.stdin.isTTY) return fallback;
+          const answer = prompt(`${label}${fallback ? ` [${fallback}]` : ""}:`) ?? "";
+          return answer.trim() || fallback;
+        };
+        const existing = await loadPublishConfig().catch(() => null);
+        const cfg: PublishConfig = {
+          endpoint: await ask("S3 endpoint", values.endpoint, existing?.endpoint ?? "https://s3.amanv.cloud"),
+          bucket: await ask("Bucket", values.bucket, existing?.bucket ?? "tcut"),
+          accessKeyId: await ask("Access key", values["access-key"], existing?.accessKeyId ?? ""),
+          secretAccessKey: await ask("Secret key", values["secret-key"], existing?.secretAccessKey ?? "", true),
+          region: values.region ?? existing?.region ?? "us-east-1",
+          ...(values["public-url"] || existing?.publicUrl ? { publicUrl: values["public-url"] ?? existing?.publicUrl } : {}),
+        };
+        if (!cfg.accessKeyId || !cfg.secretAccessKey) fail("publish --setup needs --access-key and --secret-key (or run it in a terminal to be prompted)");
+        const result = await ensurePublicBucket(cfg, log);
+        const file = await savePublishConfig(cfg);
+        ok(`saved ${file}`, "mode 600");
+        ok(`bucket ${cfg.bucket} on ${cfg.endpoint}`, result.bucketCreated ? "created" : "exists");
+        if (result.publicReadOk) ok("public read verified", `links will look like ${publicUrlFor(cfg, "x").replace(/\/x$/, "/<hash>/demo.gif")}`);
+        else log(`${red("✘")} anonymous read failed — set a public-read policy on the bucket or pass --public-url for a CDN/proxy in front of it`);
+        return;
+      }
+      if (rest.length === 0) fail("publish needs at least one file (or --setup)");
+      const cfg = await loadPublishConfig();
+      if (!cfg) fail("publish is not configured yet — run `tcut publish --setup` (or set TCUT_S3_ENDPOINT/BUCKET/ACCESS_KEY/SECRET_KEY)");
+      const published = await publishFiles(rest, cfg, { name: values.name, log });
+      for (const p of published) ok(p.url, dim(path.basename(p.file)));
+      if (values.open && published[0]) {
+        const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        Bun.spawn([opener, published[published.length - 1]!.url], { stdout: "ignore", stderr: "ignore" });
+      }
       return;
     }
     case "init": {
@@ -299,7 +357,8 @@ async function main(): Promise<void> {
     case "rec": {
       // Live mode: the user (or a pipe) drives the PTY; everything after `--` is the command to run.
       const overrides = overridesFromFlags();
-      const outputs = overrides.output ?? ["rec.mp4"];
+      const rawOutputs = overrides.output ?? ["rec.mp4"];
+      const outputs = Array.isArray(rawOutputs) ? rawOutputs : [rawOutputs];
       const config = resolveConfig({ ...overrides, output: outputs, cast: overrides.cast });
       const command = rest.length > 0 ? rest : undefined;
       // Size: --cols/--rows if given, else the terminal tcut runs in.
@@ -308,6 +367,11 @@ async function main(): Promise<void> {
       await writeCast(config.cast, recording);
       log("");
       ok(`wrote ${config.cast}`, `${recording.events.length} events, ${(recording.header.duration ?? 0).toFixed(1)}s`);
+      if (!values["no-script"]) {
+        const scriptPath = config.cast.replace(/\.cast$/, "") + ".video.ts";
+        await Bun.write(scriptPath, generateScript(recording, { output: outputs, cleanShell: !command, command, castPath: config.cast }));
+        ok(`wrote ${scriptPath}`, "editable script — tweak it, then `tcut " + scriptPath + "`");
+      }
       if (values["record-only"]) return;
       const result = await renderOutputs(recording, config, progressReporter());
       await reportOutputs(result.outputs, result.screenshots);

package/src/index.ts

@@ -9,7 +9,11 @@ export { replayFrames } from "./export/frames";
 export type { GridFrame, GridCell, GridReplay } from "./export/frames";
 export { runScriptTests, discoverScripts } from "./testing";
 export type { TestResult, TestSummary } from "./testing";
-export { themes, themeNames, resolveTheme } from "./themes";
+export { themes, themeNames, resolveTheme, findThemes, themeSlug, builtinThemes } from "./themes";
+export { generateScript, eventsToOps, tokenize } from "./scriptgen";
+export type { ScriptGenOptions } from "./scriptgen";
+export { publishFiles, loadPublishConfig, savePublishConfig, ensurePublicBucket, publicUrlFor, keyFor } from "./publish";
+export type { PublishConfig, Published, PublishOptions } from "./publish";
 export { readCast, writeCast, parseCast, serializeCast } from "./cast";
 export { buildTimeline } from "./timeline";
 export { resolveConfig } from "./config";

package/src/publish.ts

@@ -0,0 +1,226 @@
+import { chmod, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { readCast } from "./cast";
+import { applyOverrides, resolveConfig } from "./config";
+import { buildHtml } from "./export/html";
+
+/** Any S3-compatible target: RustFS, MinIO, Cloudflare R2, AWS S3, … */
+export interface PublishConfig {
+  /** e.g. https://s3.amanv.cloud */
+  endpoint: string;
+  bucket: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  /** Default "us-east-1" (what MinIO/RustFS expect). */
+  region?: string;
+  /** Base URL objects are served from. Default `${endpoint}/${bucket}` (path-style). */
+  publicUrl?: string;
+  /** Key prefix inside the bucket, e.g. "casts/". */
+  prefix?: string;
+}
+
+export const configDir = (): string => process.env.TCUT_CONFIG_DIR ?? path.join(homedir(), ".config", "tcut");
+export const configPath = (): string => path.join(configDir(), "publish.json");
+
+/** Env (TCUT_S3_*) overrides the config file; either source may provide each field. */
+export async function loadPublishConfig(): Promise<PublishConfig | null> {
+  let fromFile: Partial<PublishConfig> = {};
+  const file = Bun.file(configPath());
+  if (await file.exists()) {
+    try {
+      fromFile = (await file.json()) as Partial<PublishConfig>;
+    } catch {
+      throw new Error(`${configPath()} is not valid JSON`);
+    }
+  }
+  const env = process.env;
+  const merged: Partial<PublishConfig> = {
+    ...fromFile,
+    ...(env.TCUT_S3_ENDPOINT && { endpoint: env.TCUT_S3_ENDPOINT }),
+    ...(env.TCUT_S3_BUCKET && { bucket: env.TCUT_S3_BUCKET }),
+    ...(env.TCUT_S3_ACCESS_KEY && { accessKeyId: env.TCUT_S3_ACCESS_KEY }),
+    ...(env.TCUT_S3_SECRET_KEY && { secretAccessKey: env.TCUT_S3_SECRET_KEY }),
+    ...(env.TCUT_S3_REGION && { region: env.TCUT_S3_REGION }),
+    ...(env.TCUT_PUBLIC_URL && { publicUrl: env.TCUT_PUBLIC_URL }),
+    ...(env.TCUT_S3_PREFIX !== undefined && { prefix: env.TCUT_S3_PREFIX }),
+  };
+  if (!merged.endpoint || !merged.bucket || !merged.accessKeyId || !merged.secretAccessKey) return null;
+  return merged as PublishConfig;
+}
+
+export async function savePublishConfig(cfg: PublishConfig): Promise<string> {
+  await mkdir(configDir(), { recursive: true });
+  await Bun.write(configPath(), JSON.stringify(cfg, null, 2) + "\n");
+  await chmod(configPath(), 0o600);
+  return configPath();
+}
+
+export function publicUrlFor(cfg: PublishConfig, key: string): string {
+  const base = (cfg.publicUrl ?? `${cfg.endpoint.replace(/\/$/, "")}/${cfg.bucket}`).replace(/\/$/, "");
+  return `${base}/${key.split("/").map(encodeURIComponent).join("/")}`;
+}
+
+const MIME: Record<string, string> = {
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".html": "text/html; charset=utf-8",
+  ".cast": "application/x-asciicast",
+  ".txt": "text/plain; charset=utf-8",
+};
+
+export async function contentHash(file: string): Promise<string> {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(file).arrayBuffer());
+  return hasher.digest("hex");
+}
+
+/** Keys are content-addressed: publishing the same bytes twice yields the same URL. */
+export async function keyFor(cfg: PublishConfig, file: string, name?: string): Promise<string> {
+  const hash = (await contentHash(file)).slice(0, 12);
+  return `${cfg.prefix ?? ""}${hash}/${name ?? path.basename(file)}`;
+}
+
+function client(cfg: PublishConfig): Bun.S3Client {
+  return new Bun.S3Client({
+    endpoint: cfg.endpoint,
+    bucket: cfg.bucket,
+    region: cfg.region ?? "us-east-1",
+    accessKeyId: cfg.accessKeyId,
+    secretAccessKey: cfg.secretAccessKey,
+  });
+}
+
+export interface Published {
+  file: string;
+  key: string;
+  url: string;
+}
+
+export interface PublishOptions {
+  /** Override the object name (defaults to the file's basename). */
+  name?: string;
+  log?: (message: string) => void;
+}
+
+async function upload(cfg: PublishConfig, file: string, key: string): Promise<void> {
+  const s3 = client(cfg);
+  const type = MIME[path.extname(file).toLowerCase()] ?? "application/octet-stream";
+  try {
+    await s3.write(key, Bun.file(file), { type, acl: "public-read" });
+  } catch (err) {
+    // Some S3 clones reject ACL headers; public access then comes from the bucket policy (see ensurePublicBucket).
+    if (!/acl|NotImplemented|InvalidArgument/i.test(String(err))) throw err;
+    await s3.write(key, Bun.file(file), { type });
+  }
+}
+
+/** Upload files and return their public URLs. A `.cast` is also rendered to a playable `.html` next to it. */
+export async function publishFiles(files: string[], cfg: PublishConfig, opts: PublishOptions = {}): Promise<Published[]> {
+  const results: Published[] = [];
+  for (const file of files) {
+    if (!(await Bun.file(file).exists())) throw new Error(`File not found: ${file}`);
+    const key = await keyFor(cfg, file, opts.name);
+    await upload(cfg, file, key);
+    results.push({ file, key, url: publicUrlFor(cfg, key) });
+
+    if (file.endsWith(".cast")) {
+      const rec = await readCast(file);
+      const base = rec.header.bunVideo ?? resolveConfig({ output: "x.html", cols: rec.header.width, rows: rec.header.height });
+      const html = await buildHtml(rec, applyOverrides(base, {}));
+      const htmlFile = path.join(path.dirname(file), `${path.basename(file, ".cast")}.html`);
+      await Bun.write(htmlFile, html);
+      const htmlKey = `${key.replace(/\/[^/]+$/, "")}/${path.basename(htmlFile)}`;
+      await upload(cfg, htmlFile, htmlKey);
+      results.push({ file: htmlFile, key: htmlKey, url: publicUrlFor(cfg, htmlKey) });
+    }
+  }
+  return results;
+}
+
+// ---- Bucket bootstrap (create + public-read policy) with a minimal SigV4 signer; Bun.S3Client has no admin calls.
+
+function hmac(key: Uint8Array | string, data: string): Uint8Array {
+  return new Uint8Array(new Bun.CryptoHasher("sha256", key).update(data).digest());
+}
+const sha256Hex = (data: string | Uint8Array) => new Bun.CryptoHasher("sha256").update(data).digest("hex");
+
+export function signV4(cfg: PublishConfig, method: string, url: URL, body: string, now = new Date()): Record<string, string> {
+  const region = cfg.region ?? "us-east-1";
+  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const date = amzDate.slice(0, 8);
+  const payloadHash = sha256Hex(body);
+  const headers: Record<string, string> = {
+    host: url.host,
+    "x-amz-content-sha256": payloadHash,
+    "x-amz-date": amzDate,
+  };
+  const signedHeaders = Object.keys(headers).sort().join(";");
+  const canonicalHeaders = Object.keys(headers)
+    .sort()
+    .map((h) => `${h}:${headers[h]!.trim()}\n`)
+    .join("");
+  const canonicalQuery = [...url.searchParams.entries()]
+    .sort(([a], [b]) => (a < b ? -1 : 1))
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join("&");
+  const canonicalRequest = [method, url.pathname || "/", canonicalQuery, canonicalHeaders, signedHeaders, payloadHash].join("\n");
+  const scope = `${date}/${region}/s3/aws4_request`;
+  const stringToSign = ["AWS4-HMAC-SHA256", amzDate, scope, sha256Hex(canonicalRequest)].join("\n");
+  const kDate = hmac(`AWS4${cfg.secretAccessKey}`, date);
+  const kRegion = hmac(kDate, region);
+  const kService = hmac(kRegion, "s3");
+  const kSigning = hmac(kService, "aws4_request");
+  const signature = Buffer.from(hmac(kSigning, stringToSign)).toString("hex");
+  return {
+    ...headers,
+    authorization: `AWS4-HMAC-SHA256 Credential=${cfg.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`,
+  };
+}
+
+async function s3Request(cfg: PublishConfig, method: string, pathname: string, query = "", body = ""): Promise<Response> {
+  const url = new URL(`${cfg.endpoint.replace(/\/$/, "")}${pathname}${query}`);
+  const headers = signV4(cfg, method, url, body);
+  return fetch(url, { method, headers, body: body || undefined });
+}
+
+export interface BootstrapResult {
+  bucketCreated: boolean;
+  policyApplied: boolean;
+  publicReadOk: boolean;
+}
+
+/** Make sure the bucket exists and is publicly readable, then prove it with an anonymous GET. */
+export async function ensurePublicBucket(cfg: PublishConfig, log: (m: string) => void = () => {}): Promise<BootstrapResult> {
+  let bucketCreated = false;
+  const head = await s3Request(cfg, "HEAD", `/${cfg.bucket}`);
+  if (head.status === 404) {
+    const create = await s3Request(cfg, "PUT", `/${cfg.bucket}`);
+    if (!create.ok && create.status !== 409) throw new Error(`Creating bucket ${cfg.bucket} failed: ${create.status} ${await create.text()}`);
+    bucketCreated = create.ok;
+    log(`created bucket ${cfg.bucket}`);
+  } else if (head.status === 403) {
+    throw new Error(`Access denied to bucket ${cfg.bucket} — check the access key / secret.`);
+  }
+
+  const policy = JSON.stringify({
+    Version: "2012-10-17",
+    Statement: [{ Effect: "Allow", Principal: { AWS: ["*"] }, Action: ["s3:GetObject"], Resource: [`arn:aws:s3:::${cfg.bucket}/*`] }],
+  });
+  const put = await s3Request(cfg, "PUT", `/${cfg.bucket}`, "?policy", policy);
+  const policyApplied = put.ok;
+  if (!put.ok) log(`could not set a public-read bucket policy (${put.status}); objects may need a public URL configured differently`);
+
+  const probeKey = `${cfg.prefix ?? ""}.tcut-probe.txt`;
+  await client(cfg).write(probeKey, "tcut publish probe", { type: "text/plain" });
+  const anon = await fetch(publicUrlFor(cfg, probeKey));
+  const publicReadOk = anon.ok && (await anon.text()).includes("tcut publish probe");
+  await client(cfg).delete(probeKey).catch(() => undefined);
+  return { bucketCreated, policyApplied, publicReadOk };
+}

package/src/recorder.ts

@@ -327,7 +327,10 @@ export async function record(config: ResolvedConfig, script: Script, opts: Recor
   try {
     // Everything that happens before the first prompt is stamped at t=0.
     log(`starting ${Array.isArray(config.shell) ? config.shell.join(" ") : config.shell}`);
-    await waitFor(`initial prompt ${promptPattern}`, () => promptPattern.test(screen.line()), config.waitTimeout);
+    // Named shells get a known prompt; for an arbitrary command there is nothing to wait for — start at once.
+    if (!Array.isArray(config.shell)) {
+      await waitFor(`initial prompt ${promptPattern}`, () => promptPattern.test(screen.line()), config.waitTimeout);
+    }
     startedAt = performance.now();
     log("recording");
     await script(session);