termcut 0.2.0 → 0.3.0

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);

package/src/scriptgen.ts

@@ -0,0 +1,230 @@
+import path from "node:path";
+import type { Recording } from "./types";
+
+export interface ScriptGenOptions {
+  /** Output paths to put in the generated config. */
+  output: string[];
+  /** True when the recording drove the clean shell (so "text + Enter" can become `run()`). */
+  cleanShell: boolean;
+  /** The command that was recorded in `-- command` mode (becomes `shell: [...]`). */
+  command?: string[];
+  /** Gaps between keystrokes longer than this become `sleep()` calls. Default 400 ms. */
+  pauseThresholdMs?: number;
+  /** Where the cast lives, for the header comment. */
+  castPath?: string;
+}
+
+type Op =
+  | { kind: "type"; text: string }
+  | { kind: "run"; command: string }
+  | { kind: "key"; name: string; times: number }
+  | { kind: "ctrl"; letter: string; times: number }
+  | { kind: "alt"; key: string; times: number }
+  | { kind: "raw"; data: string }
+  | { kind: "sleep"; ms: number };
+
+const NAMED: Record<string, string> = {
+  "\r": "enter",
+  "\n": "enter",
+  "\t": "tab",
+  "\x7f": "backspace",
+  "\x1b": "escape",
+  "\x1b[A": "up",
+  "\x1b[B": "down",
+  "\x1b[C": "right",
+  "\x1b[D": "left",
+  "\x1bOA": "up",
+  "\x1bOB": "down",
+  "\x1bOC": "right",
+  "\x1bOD": "left",
+  "\x1b[H": "home",
+  "\x1b[F": "end",
+  "\x1b[1~": "home",
+  "\x1b[4~": "end",
+  "\x1b[3~": "delete",
+  "\x1b[5~": "pageUp",
+  "\x1b[6~": "pageDown",
+};
+
+/** Split a raw input chunk into individual key tokens (escape sequences, control chars, printable runs). */
+export function tokenize(input: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i]!;
+    if (ch === "\x1b") {
+      // CSI: ESC [ params final  |  SS3: ESC O x  |  Alt+key: ESC x
+      const csi = /^\x1b\[[0-9;?]*[A-Za-z~]/.exec(input.slice(i));
+      const ss3 = /^\x1bO[A-Za-z]/.exec(input.slice(i));
+      if (csi) {
+        tokens.push(csi[0]);
+        i += csi[0].length;
+      } else if (ss3) {
+        tokens.push(ss3[0]);
+        i += ss3[0].length;
+      } else if (i + 1 < input.length) {
+        tokens.push(input.slice(i, i + 2));
+        i += 2;
+      } else {
+        tokens.push(ch);
+        i += 1;
+      }
+      continue;
+    }
+    if (ch < " " || ch === "\x7f") {
+      tokens.push(ch);
+      i += 1;
+      continue;
+    }
+    let j = i;
+    while (j < input.length && input[j]! >= " " && input[j] !== "\x7f") j++;
+    tokens.push(input.slice(i, j));
+    i = j;
+  }
+  return tokens;
+}
+
+function roundMs(ms: number): number {
+  if (ms < 1000) return Math.round(ms / 100) * 100;
+  return Math.round(ms / 250) * 250;
+}
+
+function formatMs(ms: number): string {
+  return ms % 1000 === 0 ? `"${ms / 1000}s"` : ms >= 1000 ? `"${(ms / 1000).toFixed(2).replace(/0+$/, "")}s"` : `"${ms}ms"`;
+}
+
+const q = (s: string) => JSON.stringify(s);
+
+/** Turn the `i` (input) events of a recording into a list of script operations. */
+export function eventsToOps(rec: Recording, opts: ScriptGenOptions): Op[] {
+  const threshold = opts.pauseThresholdMs ?? 400;
+  const ops: Op[] = [];
+  let pendingText = "";
+  let lastTime: number | null = null;
+
+  const flushText = () => {
+    if (pendingText) ops.push({ kind: "type", text: pendingText });
+    pendingText = "";
+  };
+  const pushKey = (op: Op) => {
+    const last = ops[ops.length - 1];
+    if (last && last.kind === op.kind && op.kind !== "type" && op.kind !== "sleep" && op.kind !== "raw" && op.kind !== "run") {
+      const a = last as { name?: string; letter?: string; key?: string; times: number };
+      const b = op as { name?: string; letter?: string; key?: string; times: number };
+      if (a.name === b.name && a.letter === b.letter && a.key === b.key) {
+        a.times += b.times;
+        return;
+      }
+    }
+    ops.push(op);
+  };
+
+  for (const [time, type, data] of rec.events) {
+    if (type !== "i") continue;
+    if (lastTime !== null) {
+      const gap = (time - lastTime) * 1000;
+      if (gap > threshold) {
+        flushText();
+        ops.push({ kind: "sleep", ms: roundMs(gap) });
+      }
+    }
+    lastTime = time;
+
+    for (const token of tokenize(data)) {
+      if (token.length > 1 && token[0]! >= " ") {
+        pendingText += token;
+        continue;
+      }
+      if (token.length === 1 && token >= " " && token !== "\x7f") {
+        pendingText += token;
+        continue;
+      }
+      const named = NAMED[token];
+      if (named === "enter") {
+        if (opts.cleanShell && pendingText.trim()) {
+          const command = pendingText;
+          pendingText = "";
+          ops.push({ kind: "run", command });
+        } else {
+          flushText();
+          pushKey({ kind: "key", name: "enter", times: 1 });
+        }
+        continue;
+      }
+      flushText();
+      if (named) {
+        pushKey({ kind: "key", name: named, times: 1 });
+      } else if (token.length === 1 && token.charCodeAt(0) < 32) {
+        const letter = String.fromCharCode(token.charCodeAt(0) + 96);
+        pushKey({ kind: "ctrl", letter, times: 1 });
+      } else if (token.length === 2 && token[0] === "\x1b") {
+        pushKey({ kind: "alt", key: token[1]!, times: 1 });
+      } else {
+        ops.push({ kind: "raw", data: token });
+      }
+    }
+  }
+  flushText();
+
+  // Drop a trailing `run("exit")` from clean-shell sessions: the recorder ends the shell itself.
+  const last = ops[ops.length - 1];
+  if (opts.cleanShell && last?.kind === "run" && /^\s*exit\s*$/.test(last.command)) ops.pop();
+  while (ops.length && ops[ops.length - 1]!.kind === "sleep") ops.pop();
+  return ops;
+}
+
+function opToLine(op: Op): string {
+  switch (op.kind) {
+    case "type":
+      return `await t.type(${q(op.text)});`;
+    case "run":
+      return `await t.run(${q(op.command)});`;
+    case "key":
+      return op.times > 1 ? `await t.${op.name}(${op.times});` : `await t.${op.name}();`;
+    case "ctrl":
+      return op.times > 1 ? `await t.ctrl(${q(op.letter)}, ${op.times});` : `await t.ctrl(${q(op.letter)});`;
+    case "alt":
+      return op.times > 1 ? `await t.alt(${q(op.key)}, ${op.times});` : `await t.alt(${q(op.key)});`;
+    case "raw":
+      return `await t.raw(${q(op.data)});`;
+    case "sleep":
+      return `await t.sleep(${formatMs(op.ms)});`;
+  }
+}
+
+/** Generate an editable TypeScript script that replays the input side of a recording. */
+export function generateScript(rec: Recording, opts: ScriptGenOptions): string {
+  const ops = eventsToOps(rec, opts);
+  const cfg = rec.header.bunVideo;
+  const config: string[] = [`output: ${JSON.stringify(opts.output)}`];
+  if (opts.command) config.push(`shell: ${JSON.stringify(opts.command)}`);
+  else if (cfg && cfg.shell !== "bash") config.push(`shell: ${JSON.stringify(cfg.shell)}`);
+  config.push(`cols: ${rec.header.width}`, `rows: ${rec.header.height}`);
+  if (cfg) {
+    if (cfg.theme?.name) config.push(`theme: ${q(cfg.theme.name)}`);
+    if (cfg.fps !== 60) config.push(`fps: ${cfg.fps}`);
+    if (cfg.windowBar !== "none") config.push(`windowBar: ${q(cfg.windowBar)}`);
+    if (cfg.title) config.push(`title: ${q(cfg.title)}`);
+  }
+
+  const body = ops.length ? ops.map((op) => `    ${opToLine(op)}`).join("\n") : "    // (no input was recorded)";
+  const castNote = opts.castPath ? ` The exact recording is in ${path.basename(opts.castPath)}.` : "";
+  const modeNote = opts.command
+    ? "It runs the same command and replays your keys; waits are the pauses you took, so adjust them if the program is slower elsewhere."
+    : "Typed commands became run(), which waits for the prompt instead of guessing.";
+
+  return `import { defineVideo } from "tcut";
+
+// Generated by \`tcut rec\` from what you typed — edit freely, then re-run with \`tcut <this file>\`.
+// ${modeNote}${castNote}
+export default defineVideo(
+  {
+${config.map((c) => `    ${c},`).join("\n")}
+  },
+  async (t) => {
+${body}
+    await t.sleep("1s");
+  },
+);
+`;
+}