@tmux-web/ext-git-workflow 0.1.0

package/dist/ui/app.js

@@ -0,0 +1,425 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // ../../packages/ext-sdk/src/bridge.ts
+  var ExtBridge = class {
+    constructor() {
+      __publicField(this, "extId");
+      __publicField(this, "contextCb", null);
+      __publicField(this, "configCb", null);
+      __publicField(this, "openCb", null);
+      __publicField(this, "closeCb", null);
+      __publicField(this, "_config", null);
+      __publicField(this, "pendingContext", null);
+      __publicField(this, "pendingConfig", null);
+      __publicField(this, "pendingOpen", false);
+      __publicField(this, "pendingClose", false);
+      const m = window.location.pathname.match(/^\/ext\/([^/]+)\//);
+      if (!m) throw new Error("[ext-sdk] cannot detect extension id from iframe URL");
+      this.extId = m[1];
+      window.addEventListener("message", this._onMessage.bind(this));
+    }
+    /** Call after all `on*` handlers are registered so early host messages are not lost. */
+    ready() {
+      window.parent.postMessage({ type: "ext:ready" }, "*");
+    }
+    _onMessage(event) {
+      const msg = event.data;
+      if (!msg?.type) return;
+      if (msg.type === "ext:context") {
+        if (this.contextCb) this.contextCb(msg.context);
+        else this.pendingContext = msg.context;
+      } else if (msg.type === "ext:config") {
+        this._config = msg.config;
+        if (this.configCb) this.configCb(msg.config);
+        else this.pendingConfig = msg.config;
+      } else if (msg.type === "ext:open") {
+        if (this.openCb) void this.openCb();
+        else this.pendingOpen = true;
+      } else if (msg.type === "ext:close") {
+        if (this.closeCb) void this.closeCb();
+        else this.pendingClose = true;
+      }
+    }
+    onContext(cb) {
+      this.contextCb = cb;
+      if (this.pendingContext) {
+        cb(this.pendingContext);
+        this.pendingContext = null;
+      }
+    }
+    onConfig(cb) {
+      this.configCb = cb;
+      if (this.pendingConfig !== null) {
+        this._config = this.pendingConfig;
+        void cb(this.pendingConfig);
+        this.pendingConfig = null;
+      }
+    }
+    onOpen(cb) {
+      this.openCb = cb;
+      if (this.pendingOpen) {
+        this.pendingOpen = false;
+        void cb();
+      }
+    }
+    onClose(cb) {
+      this.closeCb = cb;
+      if (this.pendingClose) {
+        this.pendingClose = false;
+        void cb();
+      }
+    }
+    getConfig() {
+      return this._config;
+    }
+    async request(path, options) {
+      const url = `/ext/${this.extId}/api${path}`;
+      const init = { method: options?.method ?? "GET" };
+      if (options?.body !== void 0) {
+        init.body = JSON.stringify(options.body);
+        init.headers = { "Content-Type": "application/json" };
+      }
+      const res = await fetch(url, init);
+      if (!res.ok) {
+        const text = await res.text().catch(() => res.statusText);
+        throw new Error(`[ext-sdk] ${url} \u2192 ${res.status}: ${text}`);
+      }
+      return res.json();
+    }
+    resize(height) {
+      const msg = { type: "ext:resize", height };
+      window.parent.postMessage(msg, "*");
+    }
+  };
+
+  // ../../packages/ext-sdk/src/index.ts
+  var _bridge = null;
+  function createExtension() {
+    if (_bridge) throw new Error("[ext-sdk] createExtension() called more than once");
+    _bridge = new ExtBridge();
+    return _bridge;
+  }
+
+  // ui/app.ts
+  var ext = createExtension();
+  var _session = "";
+  var _pollTimer = 0;
+  var _drawerOpen = false;
+  var _displayedPaneId = "";
+  var _currentData = null;
+  var _pendingHandoffBranch = "";
+  function esc(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  function setVisible(id, show) {
+    const el = document.getElementById(id);
+    if (!el) return;
+    if (show) el.removeAttribute("hidden");
+    else el.setAttribute("hidden", "");
+  }
+  function updateTimestamp() {
+    const el = document.getElementById("last-refresh");
+    if (el) el.textContent = "updated " + (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  }
+  function populateBranchSelect(branches, current) {
+    const sel = document.getElementById("branch-select");
+    if (!sel) return;
+    sel.innerHTML = branches.map(
+      (b) => `<option value="${esc(b)}"${b === current ? " selected" : ""}>${esc(b)}</option>`
+    ).join("");
+    if (!branches.length) {
+      sel.innerHTML = `<option value="${esc(current)}">${esc(current)}</option>`;
+    }
+  }
+  var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set(["failure", "timed_out", "action_required", "cancelled"]);
+  function checkStatusClass(check) {
+    if (check.status !== "completed") return "pending";
+    if (check.conclusion === "success" || check.conclusion === "neutral" || check.conclusion === "skipped") {
+      return check.conclusion === "skipped" ? "skipped" : "passing";
+    }
+    if (check.conclusion && FAILED_CONCLUSIONS.has(check.conclusion)) return "failing";
+    return "pending";
+  }
+  function checkStatusLabel(check) {
+    if (check.status === "queued") return "queued";
+    if (check.status === "in_progress") return "running";
+    return check.conclusion ?? "unknown";
+  }
+  async function sendCheckError(checkUrl) {
+    try {
+      await ext.request("/send-keys", {
+        method: "POST",
+        body: {
+          session: _session,
+          text: `The check failed with following error here: ${checkUrl}, do check the root cause for this issue`
+        }
+      });
+    } catch (e) {
+      console.error("[git-workflow] send-keys failed:", e);
+    }
+  }
+  function renderPrSection(data) {
+    const section = document.getElementById("pr-section");
+    const checksList = document.getElementById("checks-list");
+    checksList.innerHTML = "";
+    const src = data.pr ? { labelText: "PR", linkText: `#${data.pr.number}: ${data.pr.title}`, href: data.pr.url, checks: data.pr.checks } : data.branchChecks ? { labelText: "Branch", linkText: data.branchChecks.branch, href: data.branchChecks.url, checks: data.branchChecks.checks } : null;
+    if (!src) {
+      section.setAttribute("hidden", "");
+      return;
+    }
+    section.removeAttribute("hidden");
+    const label = document.getElementById("checks-label");
+    if (label) label.textContent = src.labelText;
+    const link = document.getElementById("pr-link");
+    link.textContent = src.linkText;
+    link.href = src.href;
+    for (const check of src.checks) {
+      const cls = checkStatusClass(check);
+      const row = document.createElement("div");
+      row.className = "check-row";
+      const name = document.createElement("span");
+      name.className = "check-name";
+      name.textContent = check.name;
+      name.title = check.name;
+      const badge = document.createElement("span");
+      badge.className = `check-status ${cls}`;
+      badge.textContent = checkStatusLabel(check);
+      row.appendChild(name);
+      row.appendChild(badge);
+      if (cls === "failing") {
+        const btn = document.createElement("button");
+        btn.className = "btn danger";
+        btn.style.padding = "2px 6px";
+        btn.style.fontSize = "10px";
+        btn.textContent = "\u21B3 Send";
+        btn.title = "Send failure prompt to active tmux window";
+        const url = check.url;
+        btn.addEventListener("click", () => {
+          void sendCheckError(url);
+        });
+        row.appendChild(btn);
+      }
+      checksList.appendChild(row);
+    }
+  }
+  function renderPanel(data) {
+    _currentData = data;
+    _displayedPaneId = data.paneId;
+    setVisible("loading", false);
+    setVisible("empty-state", false);
+    setVisible("panel", true);
+    const localBadge = document.getElementById("kind-local");
+    const worktreeBadge = document.getElementById("kind-worktree");
+    localBadge.classList.toggle("active", data.kind === "local");
+    worktreeBadge.classList.toggle("active", data.kind === "worktree");
+    const changesEl = document.getElementById("changes");
+    changesEl.innerHTML = `<span class="add">+${data.changes.added}</span> <span class="del">-${data.changes.removed}</span>`;
+    const branchEl = document.getElementById("branch-display");
+    branchEl.textContent = data.branch;
+    const sessionEl = document.getElementById("session-label");
+    if (sessionEl) {
+      sessionEl.textContent = `${data.session} \xB7 win ${data.windowIndex} \xB7 ${data.branch}`;
+    }
+    populateBranchSelect(data.branches, data.branch);
+    const pathEl = document.getElementById("path-display");
+    pathEl.textContent = data.panePath;
+    const mainRow = document.getElementById("main-repo-row");
+    const mainPath = document.getElementById("main-repo-path");
+    if (data.kind === "worktree" && data.mainRepoPath) {
+      mainRow.style.display = "";
+      mainPath.textContent = data.mainRepoPath;
+    } else {
+      mainRow.style.display = "none";
+      mainPath.textContent = "";
+    }
+    setVisible("branch-select-row", data.kind === "local");
+    setVisible("local-actions", data.kind === "local");
+    const btn = document.getElementById("commit-push-btn");
+    btn.disabled = !data.dirty && data.ahead === 0;
+    renderPrSection(data);
+    ext.resize(document.body.scrollHeight + 16);
+  }
+  function renderEmpty(message) {
+    _currentData = null;
+    setVisible("loading", false);
+    setVisible("panel", false);
+    setVisible("empty-state", true);
+    const empty = document.getElementById("empty-state");
+    empty.innerHTML = esc(message).replace(/\n/g, "<br>");
+    ext.resize(document.body.scrollHeight + 16);
+  }
+  async function fetchStatus() {
+    if (!_session) {
+      renderEmpty("Waiting for session context\u2026");
+      return;
+    }
+    try {
+      const res = await ext.request(
+        `/status?session=${encodeURIComponent(_session)}`
+      );
+      if (!res.isRepo || !res.isGithub || !res.data) {
+        renderEmpty(res.message ?? "Works with GitHub repositories only");
+        return;
+      }
+      if (_displayedPaneId && res.paneId !== _displayedPaneId) {
+        _pendingHandoffBranch = "";
+      }
+      renderPanel(res.data);
+      updateTimestamp();
+    } catch (e) {
+      console.error("[git-workflow] status failed:", e);
+      renderEmpty("Failed to load git status");
+    }
+  }
+  function stopPoll() {
+    if (_pollTimer) {
+      clearInterval(_pollTimer);
+      _pollTimer = 0;
+    }
+  }
+  function startPoll(intervalMs) {
+    stopPoll();
+    _pollTimer = setInterval(() => {
+      void fetchStatus();
+    }, intervalMs);
+  }
+  function openModal(id) {
+    document.getElementById(id)?.classList.add("open");
+  }
+  function closeModal(id) {
+    document.getElementById(id)?.classList.remove("open");
+  }
+  async function submitHandoff(confirmCreate = false) {
+    const errEl = document.getElementById("handoff-err");
+    errEl.textContent = "";
+    const branch = _pendingHandoffBranch || document.getElementById("handoff-branch").value.trim();
+    if (!branch) {
+      errEl.textContent = "Branch name is required";
+      return;
+    }
+    try {
+      await ext.request("/handoff", {
+        method: "POST",
+        body: { session: _session, branch, confirmCreate }
+      });
+      closeModal("handoff-modal");
+      closeModal("confirm-modal");
+      _pendingHandoffBranch = "";
+      await fetchStatus();
+    } catch (e) {
+      const msg = String(e?.message ?? e);
+      const jsonStart = msg.indexOf("{");
+      if (msg.includes("409") && jsonStart >= 0) {
+        try {
+          const body = JSON.parse(msg.slice(jsonStart));
+          if (body.needsConfirmation) {
+            closeModal("handoff-modal");
+            _pendingHandoffBranch = branch;
+            const confirmText = document.getElementById("confirm-text");
+            confirmText.textContent = `Branch "${body.branch ?? branch}" does not exist locally or on origin. Create it and open a worktree?`;
+            openModal("confirm-modal");
+            return;
+          }
+        } catch {
+        }
+      }
+      errEl.textContent = msg.replace(/^\[ext-sdk\][^:]+:\s*\d+:\s*/, "");
+    }
+  }
+  async function submitCommitPush() {
+    const errEl = document.getElementById("commit-err");
+    errEl.textContent = "";
+    const message = document.getElementById("commit-message").value.trim();
+    const dirty = _currentData?.dirty ?? false;
+    if (dirty && !message) {
+      errEl.textContent = "Commit message is required";
+      return;
+    }
+    try {
+      await ext.request("/commit-push", {
+        method: "POST",
+        body: { session: _session, message: message || void 0 }
+      });
+      closeModal("commit-modal");
+      document.getElementById("commit-message").value = "";
+      await fetchStatus();
+    } catch (e) {
+      errEl.textContent = String(e?.message ?? e).replace(/^\[ext-sdk\][^:]+:\s*/, "");
+    }
+  }
+  function wireUi() {
+    document.getElementById("handoff-btn")?.addEventListener("click", () => {
+      const sel = document.getElementById("branch-select");
+      const input = document.getElementById("handoff-branch");
+      input.value = sel?.value ?? _currentData?.branch ?? "";
+      document.getElementById("handoff-err").textContent = "";
+      openModal("handoff-modal");
+    });
+    document.getElementById("handoff-cancel")?.addEventListener("click", () => closeModal("handoff-modal"));
+    document.getElementById("handoff-submit")?.addEventListener("click", () => {
+      void submitHandoff(false);
+    });
+    document.getElementById("confirm-cancel")?.addEventListener("click", () => {
+      closeModal("confirm-modal");
+      _pendingHandoffBranch = "";
+    });
+    document.getElementById("confirm-submit")?.addEventListener("click", () => {
+      void submitHandoff(true);
+    });
+    document.getElementById("commit-push-btn")?.addEventListener("click", () => {
+      const dirty = _currentData?.dirty ?? false;
+      const ahead = _currentData?.ahead ?? 0;
+      const title = document.getElementById("commit-title");
+      const field = document.getElementById("commit-message-field");
+      const msg = document.getElementById("commit-message");
+      document.getElementById("commit-err").textContent = "";
+      if (dirty) {
+        title.textContent = "Commit and push";
+        field.style.display = "";
+        msg.required = true;
+      } else if (ahead > 0) {
+        title.textContent = "Push commits";
+        field.style.display = "none";
+        msg.required = false;
+      }
+      openModal("commit-modal");
+    });
+    document.getElementById("commit-cancel")?.addEventListener("click", () => closeModal("commit-modal"));
+    document.getElementById("commit-submit")?.addEventListener("click", () => {
+      void submitCommitPush();
+    });
+    document.getElementById("copy-main-btn")?.addEventListener("click", async () => {
+      const path = _currentData?.mainRepoPath;
+      if (path) await navigator.clipboard.writeText(path);
+    });
+  }
+  window.__refresh = () => {
+    void fetchStatus();
+  };
+  ext.onContext((ctx) => {
+    _session = ctx.session;
+    const el = document.getElementById("session-label");
+    if (el) el.textContent = `session: ${ctx.session}`;
+    if (_drawerOpen) void fetchStatus();
+  });
+  ext.onOpen(() => {
+    _drawerOpen = true;
+    void fetchStatus();
+    const cfg = ext.getConfig();
+    startPoll(cfg?.pollIntervalMs ?? 1e4);
+  });
+  ext.onClose(() => {
+    _drawerOpen = false;
+    stopPoll();
+  });
+  ext.onConfig((rawCfg) => {
+    const cfg = rawCfg;
+    if (_pollTimer) startPoll(cfg.pollIntervalMs ?? 1e4);
+  });
+  document.addEventListener("DOMContentLoaded", wireUi);
+  ext.ready();
+})();