codex-autorunner 0.1.0__py3-none-any.whl

codex_autorunner/static/env.js

@@ -0,0 +1,99 @@
+const hasWindow = typeof window !== "undefined" && typeof window.location !== "undefined";
+const pathname = hasWindow ? window.location.pathname || "/" : "/";
+const AUTH_TOKEN_KEY = "car_auth_token";
+
+function getAuthToken() {
+  let token = null;
+  try {
+    token = sessionStorage.getItem(AUTH_TOKEN_KEY);
+  } catch (_err) {
+    token = null;
+  }
+  if (token) {
+    return token;
+  }
+  if (hasWindow && window.__CAR_AUTH_TOKEN) {
+    return window.__CAR_AUTH_TOKEN;
+  }
+  return null;
+}
+
+function normalizeBase(base) {
+  if (!base || base === "/") return "";
+  let normalized = base.startsWith("/") ? base : `/${base}`;
+  while (normalized.endsWith("/") && normalized.length > 1) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized === "/" ? "" : normalized;
+}
+
+function detectBasePrefix(path) {
+  const prefixes = ["/repos/", "/hub/", "/api/", "/static/", "/cat/"];
+  let idx = -1;
+  for (const prefix of prefixes) {
+    const found = path.indexOf(prefix);
+    if (found === 0) {
+      return "";
+    }
+    if (found > 0 && (idx === -1 || found < idx)) {
+      idx = found;
+    }
+  }
+  if (idx > 0) {
+    return normalizeBase(path.slice(0, idx));
+  }
+  const parts = path.split("/").filter(Boolean);
+  if (parts.length) {
+    return normalizeBase(`/${parts[0]}`);
+  }
+  return "";
+}
+
+const basePrefix =
+  hasWindow && typeof window.__CAR_BASE_PREFIX !== "undefined"
+    ? window.__CAR_BASE_PREFIX
+    : detectBasePrefix(pathname);
+
+const repoId =
+  hasWindow && typeof window.__CAR_REPO_ID !== "undefined"
+    ? window.__CAR_REPO_ID
+    : (() => {
+        const match = pathname.match(/\/repos\/([^/]+)/);
+        return match && match[1] ? match[1] : null;
+      })();
+
+const derivedBasePath = repoId ? `${basePrefix}/repos/${repoId}` : basePrefix;
+const basePath =
+  hasWindow && typeof window.__CAR_BASE_PATH !== "undefined"
+    ? window.__CAR_BASE_PATH
+    : derivedBasePath;
+
+export const REPO_ID = repoId;
+export const BASE_PATH = basePath;
+export const HUB_BASE = basePrefix || "/";
+
+let mode = repoId ? "repo" : "unknown";
+const hubEndpoint = `${basePrefix || ""}/hub/repos`;
+
+export async function detectContext() {
+  if (mode !== "unknown") {
+    return { mode, repoId: REPO_ID };
+  }
+  if (!hasWindow || typeof fetch !== "function") {
+    mode = "repo";
+    return { mode, repoId: REPO_ID };
+  }
+  try {
+    /** @type {Record<string, string>} */
+    const headers = {};
+    const token = getAuthToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const res = await fetch(hubEndpoint, { headers });
+    mode = res.ok ? "hub" : "repo";
+  } catch (err) {
+    mode = "repo";
+  }
+  return { mode, repoId: REPO_ID };
+}

codex_autorunner/static/github.js

@@ -0,0 +1,168 @@
+import { api, flash, statusPill } from "./utils.js";
+import { registerAutoRefresh } from "./autoRefresh.js";
+import { CONSTANTS } from "./constants.js";
+
+function $(id) {
+  return document.getElementById(id);
+}
+
+function setText(el, text) {
+  if (!el) return;
+  el.textContent = text ?? "–";
+}
+
+function setLink(el, { href, text, title } = {}) {
+  if (!el) return;
+  if (href) {
+    el.href = href;
+    el.target = "_blank";
+    el.rel = "noopener noreferrer";
+    el.classList.remove("muted");
+    el.textContent = text || href;
+    if (title) el.title = title;
+  } else {
+    el.removeAttribute("href");
+    el.removeAttribute("target");
+    el.removeAttribute("rel");
+    el.classList.add("muted");
+    el.textContent = text || "–";
+    if (title) el.title = title;
+  }
+}
+
+async function copyToClipboard(text) {
+  if (!text) return false;
+  try {
+    if (navigator.clipboard?.writeText) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+  } catch (err) {
+    // ignore
+  }
+  return false;
+}
+
+async function loadGitHubStatus() {
+  const pill = $("github-status-pill");
+  const note = $("github-note");
+  const syncBtn = $("github-sync-pr");
+  const openFilesBtn = $("github-open-pr-files");
+  const copyPrBtn = $("github-copy-pr");
+
+  try {
+    const data = await api("/api/github/status");
+    const gh = data.gh || {};
+    const repo = data.repo || null;
+    const git = data.git || {};
+    const link = data.link || {};
+    const issue = link.issue || null;
+    const pr = data.pr || link.pr || null;
+    const prLinks = data.pr_links || null;
+
+    if (!gh.available) {
+      statusPill(pill, "error");
+      setText(note, "GitHub CLI (gh) not available.");
+      if (syncBtn) syncBtn.disabled = true;
+    } else if (!gh.authenticated) {
+      statusPill(pill, "warn");
+      setText(note, "GitHub CLI not authenticated.");
+      if (syncBtn) syncBtn.disabled = true;
+    } else {
+      statusPill(pill, "idle");
+      setText(note, git.clean ? "Clean working tree." : "Uncommitted changes.");
+      if (syncBtn) syncBtn.disabled = false;
+    }
+
+    setLink($("github-repo-link"), {
+      href: repo?.url,
+      text: repo?.nameWithOwner || "–",
+      title: repo?.url || "",
+    });
+    setText($("github-branch"), git.branch || "–");
+
+    setLink($("github-issue-link"), {
+      href: issue?.url,
+      text: issue?.number ? `#${issue.number}` : "–",
+      title: issue?.title || issue?.url || "",
+    });
+
+    const prUrl = prLinks?.url || pr?.url || null;
+    setLink($("github-pr-link"), {
+      href: prUrl,
+      text: pr?.number ? `#${pr.number}` : prUrl ? "PR" : "–",
+      title: pr?.title || prUrl || "",
+    });
+
+    const hasPr = !!prUrl;
+    if (openFilesBtn) openFilesBtn.disabled = !hasPr;
+    if (copyPrBtn) copyPrBtn.disabled = !hasPr;
+
+    if (openFilesBtn) {
+      openFilesBtn.onclick = () => {
+        const files = prLinks?.files || (prUrl ? `${prUrl}/files` : null);
+        if (!files) return;
+        window.open(files, "_blank", "noopener,noreferrer");
+      };
+    }
+    if (copyPrBtn) {
+      copyPrBtn.onclick = async () => {
+        if (!prUrl) return;
+        const ok = await copyToClipboard(prUrl);
+        flash(ok ? "Copied PR link" : "Copy failed", ok ? "info" : "error");
+      };
+    }
+
+    if (syncBtn) {
+      // Repo mode: PR sync always operates on the current working tree/branch.
+      syncBtn.dataset.mode = "current";
+    }
+  } catch (err) {
+    statusPill(pill, "error");
+    setText(note, err.message || "Failed to load GitHub status");
+    if (syncBtn) syncBtn.disabled = true;
+  }
+}
+
+async function syncPr() {
+  const syncBtn = $("github-sync-pr");
+  const note = $("github-note");
+  if (!syncBtn) return;
+
+  syncBtn.disabled = true;
+  syncBtn.classList.add("loading");
+  try {
+    const res = await api("/api/github/pr/sync", {
+      method: "POST",
+      body: { draft: true },
+    });
+    const created = res.created;
+    flash(created ? "PR created" : "PR synced");
+    setText(note, "");
+    await loadGitHubStatus();
+  } catch (err) {
+    flash(err.message || "PR sync failed", "error");
+  } finally {
+    syncBtn.disabled = false;
+    syncBtn.classList.remove("loading");
+  }
+}
+
+export function initGitHub() {
+  const card = $("github-card");
+  if (!card) return;
+  const syncBtn = $("github-sync-pr");
+  if (syncBtn) syncBtn.addEventListener("click", syncPr);
+
+  // Initial load + auto-refresh while dashboard is active.
+  loadGitHubStatus();
+  registerAutoRefresh("github-status", {
+    callback: loadGitHubStatus,
+    tabId: null, // global: keep PR link available while browsing other tabs (mobile-friendly)
+    interval: CONSTANTS.UI.AUTO_REFRESH_INTERVAL,
+    refreshOnActivation: true,
+    immediate: false,
+  });
+}
+
+