@elefunc/send 0.1.30 → 0.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elefunc/send",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "description": "Browser-compatible file transfer CLI and TUI powered by Bun, WebRTC, and Rezi.",
   "license": "MIT",
   "type": "module",
@@ -12,6 +12,7 @@
     "send": "./src/index.ts"
   },
   "files": [
+    "scripts",
     "src",
     "runtime",
     "README.md",
@@ -19,6 +20,8 @@
     "package.json"
   ],
   "scripts": {
+    "build:standalone": "bun run ./scripts/build-standalone.ts",
+    "build:standalone_all": "bun run ./scripts/build-standalone-all.ts",
     "start": "bun run ./src/index.ts",
     "test": "bun test",
     "fix:rezi": "bun run ./dia/rezi-fix.ts",

package/scripts/build-standalone-all.ts

@@ -0,0 +1,71 @@
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, rmSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const outRoot = join(packageRoot, "out")
+
+export const standaloneCompileTargets = [
+  "bun-darwin-x64",
+  "bun-darwin-x64-baseline",
+  "bun-darwin-x64-modern",
+  "bun-darwin-arm64",
+  "bun-linux-x64",
+  "bun-linux-x64-baseline",
+  "bun-linux-x64-modern",
+  "bun-linux-arm64",
+  "bun-linux-x64-musl",
+  "bun-linux-x64-musl-baseline",
+  "bun-linux-x64-musl-modern",
+  "bun-linux-arm64-musl",
+  "bun-windows-x64",
+  "bun-windows-x64-baseline",
+  "bun-windows-x64-modern",
+  "bun-windows-arm64",
+] as const
+
+export type StandaloneCompileTarget = (typeof standaloneCompileTargets)[number]
+
+export const standaloneTargetToBasename = (target: StandaloneCompileTarget) => `send-${target.replace(/^bun-/, "")}`
+
+export const standaloneTargetToArtifactName = (target: StandaloneCompileTarget) => {
+  const basename = standaloneTargetToBasename(target)
+  return target.includes("windows") ? `${basename}.exe` : basename
+}
+
+const runBuild = (target: StandaloneCompileTarget, outfile: string) => {
+  const proc = spawnSync(
+    process.execPath,
+    ["run", "./scripts/build-standalone.ts", "--outfile", outfile, "--target", target],
+    {
+      cwd: packageRoot,
+      stdio: "inherit",
+    },
+  )
+  if (proc.error) throw proc.error
+  if (proc.status !== 0) throw new Error(`build:standalone failed for ${target} with exit code ${proc.status}`)
+}
+
+const main = () => {
+  const args = process.argv.slice(2)
+  if (args.length > 0) throw new Error(`build:standalone_all does not accept arguments: ${args.join(" ")}`)
+
+  mkdirSync(outRoot, { recursive: true })
+
+  for (const [index, target] of standaloneCompileTargets.entries()) {
+    const basename = standaloneTargetToBasename(target)
+    const artifactName = standaloneTargetToArtifactName(target)
+    const outfile = join(outRoot, basename)
+    const artifactPath = join(outRoot, artifactName)
+    rmSync(outfile, { force: true })
+    if (artifactPath !== outfile) rmSync(artifactPath, { force: true })
+    console.log(`[${index + 1}/${standaloneCompileTargets.length}] Building ${target} -> out/${artifactName}`)
+    runBuild(target, outfile)
+    if (!existsSync(artifactPath)) throw new Error(`Expected artifact was not created for ${target}: ${artifactPath}`)
+  }
+
+  console.log(`Built ${standaloneCompileTargets.length} standalone binaries in ${outRoot}`)
+}
+
+if (import.meta.main) main()

package/scripts/build-standalone.ts

@@ -0,0 +1,117 @@
+import { spawnSync } from "node:child_process"
+import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { dirname, join, relative, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { buildRuntimeArchive, renderStandaloneBootstrapSource } from "./standalone-lib"
+
+type BuildOptions = {
+  keepTemp: boolean
+  outfile: string
+  target?: string
+}
+
+type PackageJsonShape = {
+  name: string
+  version: string
+}
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+
+const toImportSpecifier = (fromDir: string, targetPath: string) => {
+  const relativePath = relative(fromDir, targetPath).replaceAll("\\", "/")
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`
+}
+
+export const parseBuildArgs = (argv: readonly string[]): BuildOptions => {
+  let keepTemp = false
+  let outfile = resolve(packageRoot, "out/send")
+  let target: string | undefined
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index]
+    if (arg === "--keep-temp") {
+      keepTemp = true
+      continue
+    }
+    if (arg === "--outfile") {
+      const value = argv[index + 1]
+      if (!value) throw new Error("Missing value for --outfile")
+      outfile = resolve(packageRoot, value)
+      index += 1
+      continue
+    }
+    if (arg === "--target") {
+      const value = argv[index + 1]
+      if (!value) throw new Error("Missing value for --target")
+      target = value
+      index += 1
+      continue
+    }
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+  return { keepTemp, outfile, target }
+}
+
+const copyIfPresent = (sourcePath: string, targetPath: string) => {
+  if (!existsSync(sourcePath)) return
+  mkdirSync(dirname(targetPath), { recursive: true })
+  cpSync(sourcePath, targetPath, { recursive: true })
+}
+
+const runBun = (args: string[], cwd: string) => {
+  const proc = spawnSync(process.execPath, args, {
+    cwd,
+    stdio: "inherit",
+  })
+  if (proc.error) throw proc.error
+  if (proc.status !== 0) throw new Error(`bun ${args.join(" ")} failed with exit code ${proc.status}`)
+}
+
+const loadPackageJson = async () => JSON.parse(await Bun.file(join(packageRoot, "package.json")).text()) as PackageJsonShape
+
+const main = async () => {
+  const options = parseBuildArgs(process.argv.slice(2))
+  const packageJson = await loadPackageJson()
+  const workspaceRoot = mkdtempSync(join(tmpdir(), "send-standalone-build-"))
+  const stageRoot = join(workspaceRoot, "stage")
+  const generatedRoot = join(workspaceRoot, "generated")
+  mkdirSync(stageRoot, { recursive: true })
+  mkdirSync(generatedRoot, { recursive: true })
+
+  copyIfPresent(join(packageRoot, "LICENSE"), join(stageRoot, "LICENSE"))
+  copyIfPresent(join(packageRoot, "README.md"), join(stageRoot, "README.md"))
+  copyIfPresent(join(packageRoot, "package.json"), join(stageRoot, "package.json"))
+  copyIfPresent(join(packageRoot, "runtime"), join(stageRoot, "runtime"))
+  copyIfPresent(join(packageRoot, "src"), join(stageRoot, "src"))
+  copyIfPresent(join(packageRoot, "tsconfig.json"), join(stageRoot, "tsconfig.json"))
+
+  try {
+    runBun(["install", "--production"], stageRoot)
+
+    const runtimeArchive = buildRuntimeArchive(stageRoot, join(generatedRoot, "runtime.bin"))
+    const bootstrapPath = join(generatedRoot, "bootstrap.ts")
+    writeFileSync(
+      bootstrapPath,
+      renderStandaloneBootstrapSource({
+        archiveImportPath: toImportSpecifier(generatedRoot, runtimeArchive.archivePath),
+        entrypointRelativePath: "src/index.ts",
+        helperImportPath: toImportSpecifier(generatedRoot, join(packageRoot, "scripts/standalone-lib.ts")),
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        runtimeHash: runtimeArchive.hash,
+      }),
+    )
+
+    mkdirSync(dirname(options.outfile), { recursive: true })
+    const buildArgs = ["build", "--compile", bootstrapPath, "--outfile", options.outfile]
+    if (options.target) buildArgs.push("--target", options.target)
+    runBun(buildArgs, packageRoot)
+
+    console.log(`Built ${options.outfile}`)
+    console.log(`Embedded ${runtimeArchive.fileCount} files (${runtimeArchive.totalBytes} bytes) from ${workspaceRoot}`)
+  } finally {
+    if (!options.keepTemp) rmSync(workspaceRoot, { recursive: true, force: true })
+  }
+}
+
+if (import.meta.main) await main()

package/scripts/standalone-lib.ts

@@ -0,0 +1,247 @@
+import { spawnSync, type SpawnSyncOptionsWithBufferEncoding, type SpawnSyncReturns } from "node:child_process"
+import { createHash } from "node:crypto"
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs"
+import { tmpdir } from "node:os"
+import { basename, dirname, join, relative, resolve, sep } from "node:path"
+
+const ARCHIVE_MAGIC = Buffer.from("SENDRT1\0", "utf8")
+const READY_FILE = ".send-standalone-ready.json"
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+const ROOT_FILES = new Set(["LICENSE", "README.md", "package.json", "tsconfig.json"])
+
+export type RuntimeArchiveFile = {
+  absolutePath: string
+  relativePath: string
+  size: number
+}
+
+export type RuntimeArchiveInfo = {
+  archivePath: string
+  fileCount: number
+  hash: string
+  totalBytes: number
+}
+
+export type EnsureExtractedRuntimeOptions = {
+  archivePath: string
+  packageName: string
+  packageVersion: string
+  runtimeHash: string
+}
+
+export type RunExtractedRuntimeOptions = {
+  args?: readonly string[]
+  entrypointRelativePath: string
+  env?: NodeJS.ProcessEnv
+  execPath?: string
+  runtimeRoot: string
+  stdio?: SpawnSyncOptionsWithBufferEncoding["stdio"]
+}
+
+export type LaunchStandaloneRuntimeOptions = EnsureExtractedRuntimeOptions & {
+  args?: readonly string[]
+  entrypointRelativePath: string
+}
+
+const normalizeRelativePath = (path: string) => path.replaceAll("\\", "/").replace(/^\.\//, "")
+
+const writeUInt32 = (value: number) => {
+  if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) throw new Error(`Expected an unsigned 32-bit integer, got ${value}`)
+  const buffer = Buffer.allocUnsafe(4)
+  buffer.writeUInt32LE(value, 0)
+  return buffer
+}
+
+const readUInt32 = (bytes: Uint8Array, offset: number) => {
+  const view = new DataView(bytes.buffer, bytes.byteOffset + offset, 4)
+  return view.getUint32(0, true)
+}
+
+const safePackageDir = (packageName: string) => packageName.replace(/^@/, "").replace(/[\\/]+/g, "-")
+
+const resolveExtractTarget = (outputRoot: string, relativePath: string) => {
+  const target = resolve(outputRoot, relativePath)
+  const normalizedRoot = resolve(outputRoot)
+  const rootPrefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`
+  if (target !== normalizedRoot && !target.startsWith(rootPrefix)) throw new Error(`Refusing to extract outside runtime root: ${relativePath}`)
+  return target
+}
+
+export const shouldIncludeRuntimePath = (relativePath: string) => {
+  const normalized = normalizeRelativePath(relativePath)
+  if (!normalized || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) return false
+  if (normalized === "bun.lock" || normalized === "bun.lockb") return false
+  if (normalized.startsWith("node_modules/.bin/")) return false
+  if (ROOT_FILES.has(normalized)) return true
+  return normalized.startsWith("node_modules/") || normalized.startsWith("runtime/") || normalized.startsWith("src/")
+}
+
+export const collectRuntimeFiles = (root: string): RuntimeArchiveFile[] => {
+  const files: RuntimeArchiveFile[] = []
+  const walk = (dir: string) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const absolutePath = join(dir, entry.name)
+      if (entry.isSymbolicLink()) continue
+      if (entry.isDirectory()) {
+        walk(absolutePath)
+        continue
+      }
+      if (!entry.isFile()) continue
+      const relativePath = normalizeRelativePath(relative(root, absolutePath))
+      if (!shouldIncludeRuntimePath(relativePath)) continue
+      files.push({
+        absolutePath,
+        relativePath,
+        size: statSync(absolutePath).size,
+      })
+    }
+  }
+  walk(resolve(root))
+  files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
+  return files
+}
+
+export const buildRuntimeArchive = (root: string, archivePath: string): RuntimeArchiveInfo => {
+  const files = collectRuntimeFiles(root)
+  const chunks: Buffer[] = [ARCHIVE_MAGIC, writeUInt32(files.length)]
+  const hash = createHash("sha256")
+  let totalBytes = ARCHIVE_MAGIC.byteLength + 4
+  for (const file of files) {
+    const pathBytes = Buffer.from(file.relativePath, "utf8")
+    const data = readFileSync(file.absolutePath)
+    hash.update(pathBytes)
+    hash.update("\0")
+    hash.update(data)
+    chunks.push(writeUInt32(pathBytes.byteLength), pathBytes, writeUInt32(data.byteLength), data)
+    totalBytes += 8 + pathBytes.byteLength + data.byteLength
+  }
+  mkdirSync(dirname(archivePath), { recursive: true })
+  writeFileSync(archivePath, Buffer.concat(chunks, totalBytes))
+  return {
+    archivePath,
+    fileCount: files.length,
+    hash: hash.digest("hex").slice(0, 12),
+    totalBytes,
+  }
+}
+
+export const extractRuntimeArchive = async (archivePath: string, outputRoot: string) => {
+  const bytes = new Uint8Array(await Bun.file(archivePath).arrayBuffer())
+  if (bytes.byteLength < ARCHIVE_MAGIC.byteLength + 4) throw new Error(`Standalone runtime archive is too small: ${archivePath}`)
+  if (Buffer.compare(Buffer.from(bytes.subarray(0, ARCHIVE_MAGIC.byteLength)), ARCHIVE_MAGIC) !== 0) {
+    throw new Error(`Unsupported standalone runtime archive header in ${archivePath}`)
+  }
+  let offset = ARCHIVE_MAGIC.byteLength
+  const fileCount = readUInt32(bytes, offset)
+  offset += 4
+  for (let index = 0; index < fileCount; index++) {
+    if (offset + 8 > bytes.byteLength) throw new Error(`Standalone runtime archive truncated before file ${index + 1}`)
+    const pathLength = readUInt32(bytes, offset)
+    offset += 4
+    if (offset + pathLength > bytes.byteLength) throw new Error(`Standalone runtime archive truncated while reading file ${index + 1} path`)
+    const relativePath = decoder.decode(bytes.subarray(offset, offset + pathLength))
+    offset += pathLength
+    if (!shouldIncludeRuntimePath(relativePath)) throw new Error(`Unexpected runtime archive path: ${relativePath}`)
+    const fileSize = readUInt32(bytes, offset)
+    offset += 4
+    if (offset + fileSize > bytes.byteLength) throw new Error(`Standalone runtime archive truncated while reading ${relativePath}`)
+    const target = resolveExtractTarget(outputRoot, relativePath)
+    mkdirSync(dirname(target), { recursive: true })
+    await Bun.write(target, bytes.subarray(offset, offset + fileSize))
+    offset += fileSize
+  }
+  if (offset !== bytes.byteLength) throw new Error(`Standalone runtime archive has ${bytes.byteLength - offset} trailing bytes`)
+  return fileCount
+}
+
+export const ensureExtractedRuntime = async (options: EnsureExtractedRuntimeOptions) => {
+  const runtimeBase = join(tmpdir(), safePackageDir(options.packageName))
+  const runtimeRoot = join(runtimeBase, `${options.packageVersion}-${options.runtimeHash}`)
+  const readyPath = join(runtimeRoot, READY_FILE)
+  if (existsSync(readyPath)) return runtimeRoot
+  mkdirSync(runtimeBase, { recursive: true })
+  if (existsSync(runtimeRoot)) rmSync(runtimeRoot, { recursive: true, force: true })
+  const tempRoot = mkdtempSync(join(runtimeBase, `${basename(runtimeRoot)}.tmp-`))
+  try {
+    const fileCount = await extractRuntimeArchive(options.archivePath, tempRoot)
+    writeFileSync(
+      join(tempRoot, READY_FILE),
+      JSON.stringify(
+        {
+          files: fileCount,
+          packageName: options.packageName,
+          runtimeHash: options.runtimeHash,
+          version: options.packageVersion,
+        },
+        null,
+        2,
+      ),
+    )
+    try {
+      renameSync(tempRoot, runtimeRoot)
+    } catch (error) {
+      if (existsSync(readyPath)) {
+        rmSync(tempRoot, { recursive: true, force: true })
+        return runtimeRoot
+      }
+      throw error
+    }
+  } catch (error) {
+    rmSync(tempRoot, { recursive: true, force: true })
+    throw error
+  }
+  return runtimeRoot
+}
+
+export const runExtractedRuntime = (options: RunExtractedRuntimeOptions): SpawnSyncReturns<Buffer> => {
+  const entrypointPath = join(options.runtimeRoot, options.entrypointRelativePath)
+  return spawnSync(options.execPath ?? process.execPath, ["run", entrypointPath, ...(options.args ?? process.argv.slice(2))], {
+    cwd: process.cwd(),
+    env: { ...(options.env ?? process.env), BUN_BE_BUN: "1" },
+    stdio: options.stdio ?? "inherit",
+  })
+}
+
+export const launchStandaloneRuntime = async (options: LaunchStandaloneRuntimeOptions) => {
+  const runtimeRoot = await ensureExtractedRuntime(options)
+  const result = runExtractedRuntime({
+    args: options.args,
+    entrypointRelativePath: options.entrypointRelativePath,
+    runtimeRoot,
+  })
+  if (result.error) throw result.error
+  if (result.signal) process.kill(process.pid, result.signal)
+  return result.status ?? 1
+}
+
+export const renderStandaloneBootstrapSource = (options: {
+  archiveImportPath: string
+  entrypointRelativePath: string
+  helperImportPath: string
+  packageName: string
+  packageVersion: string
+  runtimeHash: string
+}) => `import runtimeArchive from ${JSON.stringify(options.archiveImportPath)} with { type: "file" }
+import { launchStandaloneRuntime } from ${JSON.stringify(options.helperImportPath)}
+
+const exitCode = await launchStandaloneRuntime({
+  archivePath: runtimeArchive,
+  packageName: ${JSON.stringify(options.packageName)},
+  packageVersion: ${JSON.stringify(options.packageVersion)},
+  runtimeHash: ${JSON.stringify(options.runtimeHash)},
+  entrypointRelativePath: ${JSON.stringify(options.entrypointRelativePath)},
+})
+
+process.exit(exitCode)
+`

package/src/core/session.ts

@@ -103,6 +103,7 @@ interface IncomingDiskState {
   offset: number
   error: string
   closed: boolean
+  overwrite: boolean
 }
 
 export interface PeerSnapshot {
@@ -445,7 +446,7 @@ export class SendSession {
 
   private autoAcceptIncoming: boolean
   private autoSaveIncoming: boolean
-  private readonly overwriteIncoming: boolean
+  private overwriteIncoming: boolean
   private readonly reconnectSocket: boolean
   private iceServers: RTCIceServer[]
   private extraTurnServers: RTCIceServer[]
@@ -683,6 +684,14 @@ export class SendSession {
     return saved
   }
 
+  setOverwriteIncoming(enabled: boolean) {
+    const next = !!enabled
+    if (next === this.overwriteIncoming) return false
+    this.overwriteIncoming = next
+    this.notify()
+    return true
+  }
+
   cancelPendingOffers() {
     let cancelled = 0
     for (const transfer of this.transfers.values()) {
@@ -848,8 +857,9 @@ export class SendSession {
   }
 
   private async createIncomingDiskState(fileName: string): Promise<IncomingDiskState> {
-    const finalPath = await incomingOutputPath(this.saveDir, fileName || "download", this.overwriteIncoming, this.reservedSavePaths)
-    if (!this.overwriteIncoming) this.reservedSavePaths.add(finalPath)
+    const overwrite = this.overwriteIncoming
+    const finalPath = await incomingOutputPath(this.saveDir, fileName || "download", overwrite, this.reservedSavePaths)
+    if (!overwrite) this.reservedSavePaths.add(finalPath)
     for (let attempt = 0; ; attempt += 1) {
       const tempPath = `${finalPath}.part.${uid(6)}${attempt ? `.${attempt}` : ""}`
       try {
@@ -862,10 +872,11 @@ export class SendSession {
           offset: 0,
           error: "",
           closed: false,
+          overwrite,
         }
       } catch (error) {
         if ((error as NodeJS.ErrnoException | undefined)?.code === "EEXIST") continue
-        if (!this.overwriteIncoming) this.reservedSavePaths.delete(finalPath)
+        if (!overwrite) this.reservedSavePaths.delete(finalPath)
         throw error
       }
     }
@@ -935,12 +946,12 @@ export class SendSession {
         disk.closed = true
         await disk.handle.close()
       }
-      if (!this.overwriteIncoming && await pathExists(finalPath)) {
+      if (!disk.overwrite && await pathExists(finalPath)) {
         this.reservedSavePaths.delete(finalPath)
         finalPath = await uniqueOutputPath(this.saveDir, transfer.name || "download", this.reservedSavePaths)
         this.reservedSavePaths.add(finalPath)
       }
-      if (this.overwriteIncoming) await replaceOutputPath(disk.tempPath, finalPath)
+      if (disk.overwrite) await replaceOutputPath(disk.tempPath, finalPath)
       else await rename(disk.tempPath, finalPath)
       transfer.savedPath = finalPath
       transfer.savedAt ||= Date.now()

package/src/tui/app.ts

@@ -117,6 +117,7 @@ export interface TuiActions {
   toggleAutoOffer: TuiAction
   toggleAutoAccept: TuiAction
   toggleAutoSave: TuiAction
+  toggleOverwrite: TuiAction
   setDraftInput: (value: string, cursor?: number) => void
   addDrafts: TuiAction
   removeDraft: (draftId: string) => void
@@ -151,7 +152,7 @@ const ABOUT_BULLETS = [
   "• Join a room, see who is there, and filter or select exactly which peers to target before offering files.",
   "• File data does not travel through the signaling service; Send uses lightweight signaling to discover peers and negotiate WebRTC, then transfers directly peer-to-peer when possible, with TURN relay when needed.",
   "• Incoming transfers can be auto-accepted and auto-saved, and same-name files can either stay as numbered copies or overwrite the original when that mode is enabled.",
-  "• The CLI streams incoming saves straight to disk in the current save directory, with overwrite available through the CLI flag.",
+  "• The CLI streams incoming saves straight to disk in the current save directory, with overwrite available through the CLI flag and the TUI Ctrl+O shortcut.",
   "• Other features include copyable web and CLI invites, rendered-peer filtering and selection, TURN sharing, and live connection insight like signaling state, RTT, data state, and path labels.",
 ] as const
 const TRANSFER_DIRECTION_ARROW = {
@@ -293,6 +294,7 @@ export const createNoopTuiActions = (): TuiActions => ({
   toggleAutoOffer: noop,
   toggleAutoAccept: noop,
   toggleAutoSave: noop,
+  toggleOverwrite: noop,
   setDraftInput: noop,
   addDrafts: noop,
   removeDraft: noop,
@@ -1261,8 +1263,12 @@ const renderEventsCard = (state: TuiState, actions: TuiActions) => denseSection(
   ]),
 ])
 
+const footerKeycapWidth = (keycap: string) => keycap.length + 2
+
 const renderFooterHint = (id: string, keycap: string, label: string) => ui.row({ id, gap: 0, items: "center" }, [
-  ui.kbd(keycap),
+  ui.box({ id: `${id}-keycap`, width: footerKeycapWidth(keycap), border: "none" }, [
+    ui.kbd(keycap),
+  ]),
   ui.text(` ${label}`, { style: { dim: true } }),
 ])
 
@@ -1273,7 +1279,7 @@ const renderFooter = (state: TuiState) => ui.statusBar({
     ui.toolbar({ id: "footer-hints", gap: 3 }, [
       renderFooterHint("footer-hint-tab", "tab", "focus/accept"),
       renderFooterHint("footer-hint-enter", "enter", "accept/add"),
-      renderFooterHint("footer-hint-esc", "esc", "hide/reset"),
+      renderFooterHint("footer-hint-ctrl-o", "ctrl+o", "overwrite"),
       renderFooterHint("footer-hint-ctrlc", "ctrl+c", "quit"),
     ]),
   ],
@@ -1822,6 +1828,15 @@ export const startTui = async (initialConfig: SessionConfig, launchOptions: TuiL
         error => commit(current => withNotice(current, { text: `${error}`, variant: "error" })),
       )
     },
+    toggleOverwrite: () => {
+      const next = !state.overwriteIncoming
+      state.session.setOverwriteIncoming(next)
+      commit(current => withNotice({
+        ...current,
+        overwriteIncoming: next,
+        sessionSeed: { ...current.sessionSeed, overwriteIncoming: next },
+      }, { text: next ? "Overwrite on." : "Overwrite off.", variant: next ? "success" : "warning" }))
+    },
     setDraftInput: (value, cursor) => updateDraftInput(value, cursor),
     addDrafts,
     removeDraft: draftId => commit(current => withNotice({ ...current, drafts: current.drafts.filter(draft => draft.id !== draftId) }, { text: "Draft removed.", variant: "warning" })),
@@ -1971,6 +1986,12 @@ export const startTui = async (initialConfig: SessionConfig, launchOptions: TuiL
         commit(current => ({ ...current, filePreview: moveFilePreviewSelection(current.filePreview, 1) }))
       },
     },
+    "ctrl+o": {
+      description: "Toggle overwrite mode",
+      handler: () => {
+        actions.toggleOverwrite()
+      },
+    },
     enter: {
       description: "Commit focused input",
       when: ctx => ctx.focusedId === ROOM_INPUT_ID || ctx.focusedId === NAME_INPUT_ID || ctx.focusedId === DRAFT_INPUT_ID,