kaizen-agent 1.32.0 → 1.33.1

package/web/board/chat.ts

@@ -0,0 +1,108 @@
+import { load, post } from "./api.ts";
+import { key } from "./cards.ts";
+import { mic, stopDictation } from "./dictation.ts";
+import { $, esc } from "./dom.ts";
+import { DK, draft } from "./drafts.ts";
+import { attach, brief, md } from "./markdown.ts";
+import { toast } from "./toast.ts";
+
+// Notes are a chat: one entry per message, files attached by paste or picker.
+function parseNotes(src) {
+  const out = [];
+  for (const raw of (src || "").split("\n")) {
+    const m = /^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2})\]\s?(.*)$/.exec(raw);
+    if (m) {
+      out.push({ at: m[1], text: m[2] });
+      continue;
+    }
+    const last = out[out.length - 1];
+    if (last) last.text += "\n" + raw.replace(/^\s{2}/, "");
+    else if (raw.trim()) out.push({ at: "", text: raw });
+  }
+  return out.map((n) => ({ ...n, text: n.text.trim() })).filter((n) => n.text);
+}
+let nfocus = null;
+export function chat(c, src, ro) {
+  const fix = (t) => attach(t, c);
+  const entries = parseNotes(src);
+  const b = c.kind === "idea" ? brief(c.text) : { parts: [] };
+  let h =
+    (b.parts.length
+      ? `<section class="desc">${md(b.parts.map((p) => `### ${p.label}\n${p.body}`).join("\n\n"))}</section>`
+      : "") +
+    `<div class="chat">${entries.map((n) => `<div class="msg">${n.at ? `<time>${esc(n.at)}</time>` : ""}${md(fix(n.text))}</div>`).join("") || `<p style="color:var(--dim)">No notes yet.</p>`}</div>`;
+  if (!ro)
+    h += `<div class="notes"><textarea placeholder="Add a note. Paste a screenshot, or attach files."></textarea><div class="att" id="natt"></div><div class="tools"><input type="file" id="nfile" multiple hidden><button class="btn ghost" id="npick">Attach</button><span>Enter sends, Shift+Enter newline</span><button class="btn pri" id="nsend">Send</button></div></div>`;
+  $("pbody").innerHTML = h;
+  if (ro) return;
+  const ta = $("pbody").querySelector("textarea"),
+    files = [];
+  draft(ta, "n:" + key(c));
+  // Enter leaves focus in the box, and a focused box blocks the redraw: send blurs it
+  // so the note shows, and the new box takes focus back for the next note.
+  if (nfocus === key(c)) {
+    nfocus = null;
+    ta.focus();
+  }
+  {
+    const m = mic([ta]);
+    if (m) $("npick").before(m);
+  }
+  const show = () => {
+    $("natt").textContent = files.map((f) => f.name).join(" · ");
+  };
+  const add = (f) => {
+    files.push(f);
+    show();
+  };
+  $("npick").onclick = () => $("nfile").click();
+  $("nfile").onchange = (e) => {
+    [...e.target.files].forEach(add);
+    e.target.value = "";
+  };
+  ta.onpaste = (e) => {
+    for (const it of e.clipboardData.items)
+      if (it.kind === "file") {
+        const f = it.getAsFile();
+        add(new File([f], f.name === "image.png" ? `paste-${Date.now()}.png` : f.name, { type: f.type }));
+        e.preventDefault();
+      }
+  };
+  const send = async () => {
+    stopDictation(true);
+    const text = ta.value.trim();
+    if (!text && !files.length) return;
+    const enc = await Promise.all(
+      files.map(
+        (f) =>
+          new Promise((r) => {
+            const rd = new FileReader();
+            rd.onload = () => r({ name: f.name, data: rd.result });
+            rd.readAsDataURL(f);
+          }),
+      ),
+    );
+    const body =
+      c.kind === "run" ? { dir: c.state, id: c.id, text, files: enc } : { dir: c.state, for: c.text, text, files: enc };
+    const r = await post("/note", body);
+    if (r.ok) {
+      files.length = 0;
+      ta.value = "";
+      try {
+        sessionStorage.removeItem(DK + "n:" + key(c));
+      } catch (e) {}
+      toast("Noted");
+      nfocus = key(c);
+      ta.blur();
+      load();
+    }
+  };
+  $("nsend").onclick = send;
+  ta.onkeydown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      send();
+    }
+  };
+  $("pbody").scrollTop = 0;
+}

package/web/board/dictation.ts

@@ -0,0 +1,300 @@
+import { ico } from "./dom.ts";
+import { toast } from "./toast.ts";
+
+// ---- dictation: Whisper in the page. Audio never leaves the browser; the model is
+// fetched once from huggingface.co and cached. Library and model are pinned here.
+const TFJS = "https://cdn.jsdelivr.net/npm/@huggingface/transformers@4.3.0",
+  ASR_MODELS = {
+    tiny: "onnx-community/whisper-tiny",
+    base: "onnx-community/whisper-base",
+    small: "onnx-community/whisper-small",
+    "large-v3-turbo": "onnx-community/whisper-large-v3-turbo",
+  };
+// The model is a setting (dictation.model); the worker is rebuilt when it changes.
+let asrModel = null;
+// Inference lives in a module Worker so a slow chunk never freezes the board.
+const WORKER_SRC = `import{pipeline}from"${TFJS}";let asr=null;
+onmessage=async e=>{const m=e.data;try{
+ if(m.type==="load"){const prog=p=>{if(p.status==="progress")postMessage({type:"progress",file:p.file,pct:p.progress||0})};
+  // WebGPU first, with the encoder in fp16 only where the adapter has shader-f16; any GPU failure falls back to the CPU.
+  const gpu=m.webgpu?{device:"webgpu",dtype:{encoder_model:m.f16?"fp16":"fp32",decoder_model_merged:"q4"}}:null,cpu={device:"wasm",dtype:"q8"};
+  try{if(!gpu)throw 0;asr=await pipeline("automatic-speech-recognition",m.model,{...gpu,progress_callback:prog})}
+  catch(e){if(gpu)postMessage({type:"fallback",why:String(e&&e.message||e)});asr=await pipeline("automatic-speech-recognition",m.model,{...cpu,progress_callback:prog})}
+  postMessage({type:"ready"})}
+ if(m.type==="run"){const r=await asr(m.audio,{chunk_length_s:30,return_timestamps:false});postMessage({type:"text",sid:m.sid,seq:m.seq,text:(r.text||"").trim()})}
+}catch(err){postMessage({type:"error",sid:m.sid,seq:m.seq,error:String(err&&err.message||err)})}}`;
+// The worklet only forwards 128-frame blocks; chunking and silence detection stay on the main thread.
+const WORKLET_SRC = `class T extends AudioWorkletProcessor{process(i){const c=i[0]&&i[0][0];if(c)this.port.postMessage(c.slice(0));return true}}registerProcessor("kz-tap",T)`;
+const HAS_MIC = !!(
+  navigator.mediaDevices &&
+  navigator.mediaDevices.getUserMedia &&
+  window.AudioWorkletNode &&
+  window.WebAssembly &&
+  window.Worker
+);
+// `active` is the one session listening; `sessions` also holds stopped ones still waiting on a chunk.
+let asrWorker = null,
+  asrReady = null,
+  asrProgress = () => {},
+  active = null,
+  starting = false;
+const sessions = new Set();
+// One worker for the page; loading is awaited by whoever pressed first, later presses join.
+// Loads the model named in settings; a model changed since the last load replaces the worker.
+async function loadAsr() {
+  let want = "small";
+  try {
+    const cfg = await fetch("/settings").then((r) => r.json());
+    want = (cfg.rows.find((r) => r.key === "dictation.model") || {}).value || want;
+  } catch (e) {}
+  if (!ASR_MODELS[want]) want = "small";
+  if (asrReady && asrModel !== want) {
+    try {
+      asrWorker.terminate();
+    } catch (e) {}
+    asrWorker = null;
+    asrReady = null;
+    sessions.clear();
+    active = null;
+  }
+  if (asrReady) return asrReady;
+  asrModel = want;
+  asrReady = new Promise(async (res, rej) => {
+    asrWorker = new Worker(URL.createObjectURL(new Blob([WORKER_SRC], { type: "text/javascript" })), {
+      type: "module",
+    });
+    const files = {};
+    asrWorker.onmessage = (e) => {
+      const m = e.data;
+      if (m.type === "progress") {
+        files[m.file] = m.pct;
+        const v = Object.values(files);
+        asrProgress(Math.round(v.reduce((a, b) => a + b, 0) / v.length));
+      } else if (m.type === "ready") res();
+      else if (m.type === "fallback") toast("GPU could not run the model, using the CPU: " + m.why);
+      else if (m.type === "error" && m.seq == null) rej(new Error(m.error));
+      for (const s of sessions) s.onmsg(m);
+    };
+    asrWorker.onerror = (e) => rej(new Error(e.message || "worker failed"));
+    // Ask the adapter what it can do: no adapter means the CPU path; no shader-f16 means an fp32 encoder.
+    let adapter = null;
+    try {
+      adapter = navigator.gpu && (await navigator.gpu.requestAdapter());
+    } catch (e) {}
+    if (!adapter) toast("No WebGPU: dictation will run on the CPU and be slower");
+    asrWorker.postMessage({
+      type: "load",
+      model: ASR_MODELS[asrModel],
+      webgpu: !!adapter,
+      f16: !!(adapter && adapter.features.has("shader-f16")),
+    });
+  });
+  asrReady.catch(() => {
+    asrReady = null;
+    try {
+      asrWorker.terminate();
+    } catch (e) {}
+    asrWorker = null;
+  });
+  return asrReady;
+}
+// After a re-render only a listener whose field is gone is stopped; closing the panel stops any.
+export function stopDictation(all) {
+  if (active && (all || !active.field.isConnected)) active.stop();
+}
+// mic(fields): a button that dictates into the last-focused of `fields` at its caret.
+export function mic(fields) {
+  if (!HAS_MIC) return null;
+  const b = document.createElement("button");
+  b.className = "ib sm mic";
+  b.title = "Dictate";
+  b.setAttribute("aria-label", "Dictate");
+  b.type = "button";
+  const idle = () => {
+    b.innerHTML = ico("mic");
+    b.classList.remove("on", "busy");
+  };
+  idle();
+  let target = fields[0];
+  fields.forEach((f) => f.addEventListener("focus", () => (target = f)));
+  b.onclick = async (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    if (active) {
+      const mine = active.btn === b;
+      active.stop();
+      if (mine) return;
+    }
+    // One press at a time: the model load and the permission prompt are both awaits a second press could slip through.
+    if (starting) return;
+    starting = true;
+    b.classList.add("busy");
+    asrProgress = (pct) => {
+      b.innerHTML = `<i>${pct}%</i>`;
+    };
+    try {
+      await loadAsr();
+    } catch (err) {
+      idle();
+      asrProgress = () => {};
+      starting = false;
+      toast("Dictation model could not load: " + err.message);
+      return;
+    }
+    asrProgress = () => {};
+    b.innerHTML = ico("mic");
+    if (!b.isConnected) {
+      idle();
+      starting = false;
+      return;
+    }
+    let stream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: { channelCount: 1, noiseSuppression: true, echoCancellation: true },
+      });
+    } catch (err) {
+      idle();
+      starting = false;
+      toast("Microphone not available: " + (err.name === "NotAllowedError" ? "permission denied" : err.message));
+      return;
+    }
+    if (active) active.stop();
+    const ctx = new AudioContext({ sampleRate: 16000 });
+    await ctx.audioWorklet.addModule(URL.createObjectURL(new Blob([WORKLET_SRC], { type: "text/javascript" })));
+    const src = ctx.createMediaStreamSource(stream),
+      tap = new AudioWorkletNode(ctx, "kz-tap");
+    src.connect(tap);
+    // Text lands where the caret is when each chunk arrives (or after the last insertion when the
+    // field is not focused), so typing while the mic is on is kept.
+    const f = target;
+    let at = f.selectionStart ?? f.value.length;
+    const vu = document.createElement("span");
+    vu.className = "vu";
+    vu.setAttribute("aria-hidden", "true");
+    vu.innerHTML = [0.5, 0.9, 1.3, 0.8, 0.45].map((w) => `<i style="--w:${w}"></i>`).join("");
+    let buf = [],
+      len = 0,
+      voiced = 0,
+      quiet = 0,
+      seq = 0,
+      done = 0,
+      pending = new Map(),
+      stopping = false;
+    const SR = 16000,
+      MAX = 6 * SR,
+      SIL = 0.8 * SR,
+      MIN = 1 * SR;
+    const insert = (t) => {
+      if (!t || !f.isConnected) return;
+      const v = f.value;
+      if (document.activeElement === f) at = f.selectionStart;
+      at = Math.min(at, v.length);
+      const head = v.slice(0, at),
+        sep = head && !/\s$/.test(head) ? " " : "";
+      f.value = head + sep + t + v.slice(at);
+      at = head.length + sep.length + t.length;
+      f.selectionStart = f.selectionEnd = at;
+      f.dispatchEvent(new Event("input", { bubbles: true }));
+    };
+    const flush = () => {
+      if (!len || voiced < MIN) {
+        buf = [];
+        len = 0;
+        voiced = 0;
+        quiet = 0;
+        return;
+      }
+      const a = new Float32Array(len);
+      let o = 0;
+      for (const c of buf) {
+        a.set(c, o);
+        o += c.length;
+      }
+      buf = [];
+      len = 0;
+      voiced = 0;
+      quiet = 0;
+      pending.set(seq, null);
+      asrWorker.postMessage({ type: "run", sid, seq, audio: a }, [a.buffer]);
+      seq++;
+      b.classList.add("busy");
+    };
+    const drain = () => {
+      while (pending.has(done) && pending.get(done) !== null) {
+        insert(pending.get(done));
+        pending.delete(done);
+        done++;
+      }
+      if (!pending.size) {
+        b.classList.remove("busy");
+        if (stopping) {
+          idle();
+          sessions.delete(sess);
+        }
+      }
+    };
+    tap.port.onmessage = (e) => {
+      const c = e.data;
+      buf.push(c);
+      len += c.length;
+      let s = 0;
+      for (let i = 0; i < c.length; i++) s += c[i] * c[i];
+      const rms = Math.sqrt(s / c.length);
+      if (rms > 0.01) {
+        voiced += c.length;
+        quiet = 0;
+      } else quiet += c.length;
+      {
+        const l = Math.min(1, rms * 8).toFixed(2);
+        f.style.setProperty("--lvl", l);
+        vu.style.setProperty("--lvl", l);
+      }
+      if (len >= MAX || (voiced >= MIN && quiet >= SIL)) flush();
+    };
+    // Chunk seqs are per session, so a result is matched by session id too.
+    const sid = Math.random().toString(36).slice(2);
+    const sess = {
+      btn: b,
+      field: f,
+      onmsg: (m) => {
+        if (m.sid !== sid) return;
+        if (m.type === "text") {
+          pending.set(m.seq, m.text);
+          drain();
+        } else if (m.type === "error" && m.seq != null) {
+          pending.set(m.seq, "");
+          toast("Dictation failed: " + m.error);
+          drain();
+        }
+      },
+      stop: () => {
+        if (stopping) return;
+        stopping = true;
+        b.classList.remove("on");
+        f.classList.remove("dictating");
+        f.style.removeProperty("--lvl");
+        b.innerHTML = ico("mic");
+        try {
+          tap.port.onmessage = null;
+          src.disconnect();
+          tap.disconnect();
+          stream.getTracks().forEach((t) => t.stop());
+          ctx.close();
+        } catch (e) {}
+        active = null;
+        flush();
+        drain();
+      },
+    };
+    sessions.add(sess);
+    active = sess;
+    starting = false;
+    b.classList.remove("busy");
+    b.classList.add("on");
+    f.classList.add("dictating");
+    b.replaceChildren(vu);
+    f.focus();
+  };
+  return b;
+}

package/web/board/dom.ts

@@ -0,0 +1,5 @@
+// Small DOM helpers every part of the board uses.
+export const $ = <T extends HTMLElement = any>(id: string) => document.getElementById(id) as T;
+export const esc = (s) =>
+  String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+export const ico = (n) => `<svg><use href="#i-${n}"/></svg>`;

package/web/board/drafts.ts

@@ -0,0 +1,21 @@
+// Half-typed text outlives a redraw and a page reload. Per tab, so two tabs cannot
+// overwrite each other; form drafts are under "f:", notes under "n:".
+export const DK = "kz-d:";
+export function draft(el, k) {
+  try {
+    const v = sessionStorage.getItem(DK + k);
+    if (v != null) el.value = v;
+  } catch (e) {}
+  el.addEventListener("input", () => {
+    try {
+      sessionStorage.setItem(DK + k, el.value);
+    } catch (e) {}
+  });
+}
+export function undraft(p) {
+  try {
+    Object.keys(sessionStorage).forEach((k) => {
+      if (k.startsWith(DK + p)) sessionStorage.removeItem(k);
+    });
+  } catch (e) {}
+}

package/web/board/fixes.ts

@@ -0,0 +1,90 @@
+import { store } from "./store.ts";
+import { where } from "./agent-term.ts";
+import { post } from "./api.ts";
+import { key, via } from "./cards.ts";
+import { $ } from "./dom.ts";
+import { md } from "./markdown.ts";
+import { openRun } from "./panel.ts";
+import { askNotify, toast } from "./toast.ts";
+
+// Fix picked findings, under the review: open ones ticked, closed and sent ones ticked but
+// locked. Unticked and sent findings live outside the form, which every refresh rebuilds,
+// keyed "run:number"; sent ones also survive a reload of this tab. A finding is one line,
+// so md() gives one paragraph; its wrapper is dropped to sit inline in the label.
+export const SK = "kz-sent",
+  fixOff = new Set(),
+  fixSent = new Set(
+    (() => {
+      try {
+        return JSON.parse(sessionStorage.getItem(SK)) || [];
+      } catch (e) {
+        return [];
+      }
+    })(),
+  );
+export function fixForm(c) {
+  const k = (n) => c.id + ":" + n,
+    sent = (f) => fixSent.has(k(f.n)),
+    fs = store.runDoc.findings || [],
+    open = fs.filter((f) => !f.done && !sent(f));
+  if (
+    c.archived ||
+    !fs.some((f) => !f.done) ||
+    !(c.status === "done" || c.awaiting === "findings" || c.awaiting === "approvals.review")
+  )
+    return;
+  const el = document.createElement("div");
+  el.className = "inl fix";
+  el.innerHTML =
+    `<div class="q">Fix findings</div><div class="q dim">Opens your agent in this project, told to fix the ticked findings and recheck them.</div>${c.status === "waiting" ? `<div class="q dim">A session is already waiting on this run in a terminal; this opens another one.</div>` : ""}` +
+    fs
+      .map((f) => {
+        const x = f.done ? " (closed)" : sent(f) ? " (sent)" : "";
+        return `<label class="${x ? "off" : ""}"><input type="checkbox" data-n="${f.n}" ${x ? "checked disabled" : fixOff.has(k(f.n)) ? "" : "checked"}><span>${f.n}. ${md(f.text).replace(/^<p>|<\/p>$/g, "")}${x}</span></label>`;
+      })
+      .join("") +
+    (open.length
+      ? `<div class="row"><button class="btn ghost" data-a="all"></button><button class="btn pri" data-a="s"></button></div>`
+      : "");
+  if (!open.length) return $("pbody").appendChild(el);
+  const go = el.querySelector("[data-a=s]"),
+    allb = el.querySelector("[data-a=all]"),
+    picks = () => open.filter((f) => !fixOff.has(k(f.n))).map((f) => f.n);
+  const sync = () => {
+    const n = picks().length;
+    go.textContent = n === open.length ? "Fix all " + n : "Fix " + n + " selected";
+    go.disabled = !n;
+    allb.textContent = n === open.length ? "Select none" : "Select all";
+    el.querySelectorAll("input:not(:disabled)").forEach((i) => (i.checked = !fixOff.has(k(i.dataset.n))));
+  };
+  el.onchange = (e) => {
+    const n = k(e.target.dataset.n);
+    e.target.checked ? fixOff.delete(n) : fixOff.add(n);
+    sync();
+  };
+  allb.onclick = () => {
+    const none = picks().length === open.length;
+    open.forEach((f) => (none ? fixOff.add(k(f.n)) : fixOff.delete(k(f.n))));
+    sync();
+  };
+  go.onclick = async () => {
+    const nums = picks();
+    go.disabled = true;
+    askNotify();
+    const r = await post("/fix", { dir: c.state, id: c.id, nums });
+    // Sent findings lock as sent, so a second press cannot open a second agent on them.
+    if (r.ok) {
+      toast(
+        "Fixing " + nums.length + " finding" + (nums.length === 1 ? "" : "s") + ", " + where(r) + ": " + via(r.agent),
+      );
+      if (r.pty) store.wantTerm = key(c);
+      nums.forEach((n) => fixSent.add(k(n)));
+      try {
+        sessionStorage.setItem(SK, JSON.stringify([...fixSent]));
+      } catch (e) {}
+      openRun(c, true);
+    } else sync();
+  };
+  sync();
+  $("pbody").appendChild(el);
+}

package/web/board/git.ts

@@ -0,0 +1,76 @@
+import { store } from "./store.ts";
+import { post } from "./api.ts";
+import { key } from "./cards.ts";
+import { $, esc } from "./dom.ts";
+import { commitMsg } from "./markdown.ts";
+import { openRun } from "./panel.ts";
+import { toast } from "./toast.ts";
+
+// Commit and push, for a finished run in a project with a git remote. What the board
+// did is recorded per run, so the settled label outlives later changes to the tree.
+export function gitBtn(c) {
+  const g = store.runDoc.git,
+    k = store.runDoc.commit;
+  if (c.archived || !g || !g.repo || !(c.status === "done" || c.awaiting === "approvals.review")) return "";
+  // A run already pushed keeps saying so; work changed since is offered beside it.
+  if (k && k.pushed)
+    return (
+      `<button class="btn" disabled title="${esc(k.sha)}">Committed &amp; pushed</button>` +
+      (g.files.length
+        ? `<button class="btn" data-a="commit">Commit new changes</button>`
+        : g.ahead > 0
+          ? `<button class="btn" data-a="push">Push</button>`
+          : "")
+    );
+  if (g.files.length) return `<button class="btn pri" data-a="commit">Commit &amp; push</button>`;
+  if (g.ahead > 0) return `<button class="btn pri" data-a="push">Push</button>`;
+  // None of its files changed and level with the remote: it was committed and pushed
+  // somewhere else. With no record and no report, nothing says it was ever committed.
+  return k || store.runDoc.impl ? `<button class="btn" disabled>Committed &amp; pushed</button>` : "";
+}
+export function confirmCommit(c, msg) {
+  const g = store.runDoc.git,
+    foot = $("pfoot");
+  foot.innerHTML = `<div class="inl" style="flex:1"><div class="q">Commit ${g.files.length} changed file${g.files.length === 1 ? "" : "s"} on ${esc(g.branch || "this branch")} and push to ${esc(g.remote)}?</div><div class="q dim">Only the files this run's report names.${g.others ? ` ${g.others} other changed file${g.others === 1 ? " is" : "s are"} left alone.` : ""}</div><pre class="files">${esc(g.files.join("\n"))}</pre>${g.shared && g.shared.length ? `<div class="q">These files also hold other runs' changes, and a file is committed whole:</div><pre class="files">${esc(g.shared.join("\n"))}</pre>` : ""}<textarea aria-label="Commit message" placeholder="feat(scope): what changed">${esc(msg || commitMsg(store.runDoc.impl) || c.title || c.text)}</textarea><div class="q dim" id="clong" hidden>The first line is over 72 characters; logs will cut it short.</div><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Commit &amp; push</button></div></div>`;
+  const inp = foot.querySelector("textarea"),
+    go = foot.querySelector("[data-a=s]");
+  inp.focus();
+  // Tall enough to show the whole message, up to half the window.
+  const fit = () => {
+    inp.style.height = "auto";
+    inp.style.height = Math.min(inp.scrollHeight + 2, innerHeight / 2) + "px";
+    $("clong").hidden = inp.value.split("\n")[0].length <= 72;
+  };
+  inp.oninput = fit;
+  fit();
+  foot.querySelector("[data-a=c]").onclick = () => {
+    foot.innerHTML = "";
+    openRun(c, true);
+  };
+  go.onclick = () => {
+    if (!inp.value.trim()) {
+      toast("A commit message is required");
+      return;
+    }
+    commitPush(c, inp.value, go);
+  };
+  inp.onkeydown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      go.click();
+    }
+  };
+}
+export async function commitPush(c, message, b) {
+  b.disabled = true;
+  b.dataset.busy = 1;
+  b.textContent = "Pushing…";
+  const r = await post("/commit", { dir: c.state, id: c.id, message, files: store.runDoc.git.files });
+  if (r.ok) toast("Committed & pushed " + r.sha);
+  $("pfoot").innerHTML = "";
+  if (store.openKey !== key(c)) return;
+  await openRun(c, false);
+  // A refused message comes back for another try, beside the current file list.
+  if (!r.ok && message && store.openKey === key(c) && store.runDoc.git.files && store.runDoc.git.files.length)
+    confirmCommit(c, message);
+}