@virtengine/openfleet 0.25.0

package/get-telegram-chat-id.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const token = process.env.TELEGRAM_BOT_TOKEN;
+
+if (!token) {
+  console.error("Missing TELEGRAM_BOT_TOKEN environment variable.");
+  process.exit(1);
+}
+
+const url = `https://api.telegram.org/bot${token}/getUpdates`;
+
+async function main() {
+  let res;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    console.error(`Fetch error: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`Request failed: ${res.status} ${body}`);
+    process.exit(1);
+  }
+
+  const data = await res.json();
+  if (!data.result || data.result.length === 0) {
+    console.log(
+      "No updates found. Send a message to the bot first, then retry.",
+    );
+    return;
+  }
+
+  const chats = new Map();
+  for (const update of data.result) {
+    const message =
+      update.message || update.channel_post || update.edited_message;
+    if (!message || !message.chat) {
+      continue;
+    }
+    const chat = message.chat;
+    if (!chats.has(chat.id)) {
+      chats.set(chat.id, {
+        id: chat.id,
+        type: chat.type,
+        title: chat.title || "",
+        username: chat.username || "",
+      });
+    }
+  }
+
+  if (chats.size === 0) {
+    console.log(
+      "No chat IDs found in updates. Send a message to the bot first.",
+    );
+    return;
+  }
+
+  console.log("Found chat IDs:");
+  for (const chat of chats.values()) {
+    const titlePart = chat.title ? ` title=\"${chat.title}\"` : "";
+    const userPart = chat.username ? ` username=@${chat.username}` : "";
+    console.log(`- id=${chat.id} type=${chat.type}${userPart}${titlePart}`);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Error: ${err.message || err}`);
+  process.exit(1);
+});

package/git-safety.mjs

@@ -0,0 +1,170 @@
+import { spawnSync } from "node:child_process";
+
+function runGit(args, cwd, timeout = 15_000) {
+  return spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout,
+    shell: false,
+  });
+}
+
+function countTrackedFiles(cwd, ref) {
+  const result = runGit(["ls-tree", "-r", "--name-only", ref], cwd, 30_000);
+  if (result.status !== 0) return null;
+  const out = (result.stdout || "").trim();
+  if (!out) return 0;
+  return out.split("\n").filter(Boolean).length;
+}
+
+function getNumstat(cwd, rangeSpec) {
+  const result = runGit(["diff", "--numstat", rangeSpec], cwd, 30_000);
+  if (result.status !== 0) return null;
+  const out = (result.stdout || "").trim();
+  if (!out) {
+    return { files: 0, inserted: 0, deleted: 0 };
+  }
+
+  let files = 0;
+  let inserted = 0;
+  let deleted = 0;
+  for (const line of out.split("\n")) {
+    if (!line.trim()) continue;
+    const [addRaw, delRaw] = line.split("\t");
+    files += 1;
+    const add = Number.parseInt(addRaw, 10);
+    const del = Number.parseInt(delRaw, 10);
+    if (Number.isFinite(add)) inserted += add;
+    if (Number.isFinite(del)) deleted += del;
+  }
+  return { files, inserted, deleted };
+}
+
+function isSafeGitBranchName(rawBranch) {
+  const branch = String(rawBranch || "").trim();
+  if (!branch) return false;
+
+  // Disallow anything that looks like a git option
+  if (branch.startsWith("-")) return false;
+
+  // Disallow whitespace and obvious ref/metacharacters that can change semantics
+  if (
+    /[\s]/.test(branch) ||
+    branch.includes("..") ||
+    branch.includes(":") ||
+    branch.includes("~") ||
+    branch.includes("^") ||
+    branch.includes("?") ||
+    branch.includes("*") ||
+    branch.includes("[") ||
+    branch.includes("\\")
+  ) {
+    return false;
+  }
+
+  // Disallow URL-like or SSH-style prefixes to avoid transport/URL interpretation
+  const lower = branch.toLowerCase();
+  if (
+    lower.startsWith("http://") ||
+    lower.startsWith("https://") ||
+    lower.startsWith("ssh://") ||
+    lower.startsWith("git@") ||
+    lower.startsWith("file://")
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+export function normalizeBaseBranch(baseBranch = "main", remote = "origin") {
+  let branch = String(baseBranch || "main").trim();
+  if (!branch) branch = "main";
+
+  branch = branch.replace(/^refs\/heads\//, "");
+  branch = branch.replace(/^refs\/remotes\//, "");
+
+  while (branch.startsWith(`${remote}/`)) {
+    branch = branch.slice(remote.length + 1);
+  }
+
+  if (!branch) branch = "main";
+
+  if (!isSafeGitBranchName(branch)) {
+    throw new Error(`Invalid base branch name: ${branch}`);
+  }
+
+  return { branch, remoteRef: `${remote}/${branch}` };
+}
+
+/**
+ * Prevent catastrophic pushes when a worktree is in a corrupted state
+ * (for example, a branch that suddenly tracks only README and would
+ * delete the whole repo on push).
+ */
+export function evaluateBranchSafetyForPush(worktreePath, opts = {}) {
+  const { baseBranch = "main", remote = "origin" } = opts;
+
+  if (process.env.VE_ALLOW_DESTRUCTIVE_PUSH === "1") {
+    return {
+      safe: true,
+      bypassed: true,
+      reason: "VE_ALLOW_DESTRUCTIVE_PUSH=1",
+    };
+  }
+
+  const { remoteRef } = normalizeBaseBranch(baseBranch, remote);
+  const baseFiles = countTrackedFiles(worktreePath, remoteRef);
+  const headFiles = countTrackedFiles(worktreePath, "HEAD");
+  const diff = getNumstat(worktreePath, `${remoteRef}...HEAD`);
+
+  // If we can't assess reliably, do not block the push.
+  if (baseFiles == null || headFiles == null || diff == null) {
+    return {
+      safe: true,
+      bypassed: true,
+      reason: "safety assessment unavailable",
+      stats: { baseFiles, headFiles, ...diff },
+    };
+  }
+
+  const reasons = [];
+  if (baseFiles >= 500 && headFiles <= Math.max(25, Math.floor(baseFiles * 0.15))) {
+    reasons.push(`HEAD tracks only ${headFiles}/${baseFiles} files vs ${remoteRef}`);
+  }
+
+  const deletedToInserted =
+    diff.inserted > 0 ? diff.deleted / diff.inserted : diff.deleted > 0 ? Infinity : 0;
+  const manyFilesChanged = diff.files >= Math.max(2_000, Math.floor(baseFiles * 0.5));
+  const deletionHeavy = diff.deleted >= 200_000 && deletedToInserted > 50;
+  if (manyFilesChanged && deletionHeavy) {
+    reasons.push(
+      `diff vs ${remoteRef} is deletion-heavy (${diff.deleted} deleted, ${diff.inserted} inserted across ${diff.files} files)`,
+    );
+  }
+
+  if (reasons.length > 0) {
+    return {
+      safe: false,
+      reason: reasons.join("; "),
+      stats: {
+        baseFiles,
+        headFiles,
+        filesChanged: diff.files,
+        inserted: diff.inserted,
+        deleted: diff.deleted,
+      },
+    };
+  }
+
+  return {
+    safe: true,
+    stats: {
+      baseFiles,
+      headFiles,
+      filesChanged: diff.files,
+      inserted: diff.inserted,
+      deleted: diff.deleted,
+    },
+  };
+}

package/github-reconciler.mjs

@@ -0,0 +1,403 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import {
+  addComment as addKanbanComment,
+  getKanbanAdapter,
+  getKanbanBackendName,
+  updateTaskStatus,
+} from "./kanban-adapter.mjs";
+
+const execFileAsync = promisify(execFile);
+const TAG = "[gh-reconciler]";
+
+const DEFAULT_INTERVAL_MS = 5 * 60 * 1000;
+const DEFAULT_MERGED_LOOKBACK_HOURS = 72;
+
+function parseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseRepoSlug(raw) {
+  const text = String(raw || "").trim().replace(/^https?:\/\/github\.com\//i, "");
+  if (!text) return "";
+  const cleaned = text.replace(/\.git$/i, "").replace(/^\/+|\/+$/g, "");
+  const [owner, repo] = cleaned.split("/", 2);
+  if (!owner || !repo) return "";
+  return `${owner}/${repo}`;
+}
+
+function parseIssueRefs(text) {
+  const refs = new Set();
+  const raw = String(text || "");
+  const re = /\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s*#(\d+)\b/gi;
+  let match = re.exec(raw);
+  while (match) {
+    refs.add(String(match[1]));
+    match = re.exec(raw);
+  }
+  return refs;
+}
+
+function parseIssueFromBranch(branchName) {
+  const match = String(branchName || "").trim().match(/^ve\/(\d+)-/i);
+  return match?.[1] || null;
+}
+
+function normalizeIssueLabels(issue) {
+  const labels = Array.isArray(issue?.labels) ? issue.labels : [];
+  return labels
+    .map((label) =>
+      typeof label === "string" ? label : String(label?.name || "").trim(),
+    )
+    .map((label) => label.toLowerCase())
+    .filter(Boolean);
+}
+
+function isIssueInReview(issue) {
+  const labels = new Set(normalizeIssueLabels(issue));
+  return labels.has("inreview") || labels.has("in-review");
+}
+
+function isTrackingIssue(issue, trackingLabels) {
+  const title = String(issue?.title || "").toLowerCase();
+  if (title.includes("meta issue") || title.includes("tracker")) {
+    return true;
+  }
+  const labels = new Set(normalizeIssueLabels(issue));
+  for (const label of trackingLabels) {
+    if (labels.has(label)) return true;
+  }
+  return false;
+}
+
+async function defaultGh(args) {
+  const { stdout } = await execFileAsync("gh", args, {
+    encoding: "utf8",
+    maxBuffer: 20 * 1024 * 1024,
+    timeout: 120_000,
+  });
+  const raw = String(stdout || "").trim();
+  if (!raw) return [];
+  return JSON.parse(raw);
+}
+
+function buildIssueMappings(openPrs, mergedPrs) {
+  const map = new Map();
+
+  function ensure(issueNumber) {
+    if (!map.has(issueNumber)) {
+      map.set(issueNumber, {
+        openPrs: [],
+        mergedPrs: [],
+      });
+    }
+    return map.get(issueNumber);
+  }
+
+  function refsForPr(pr) {
+    const refs = new Set();
+    for (const issue of parseIssueRefs(pr?.title)) refs.add(issue);
+    for (const issue of parseIssueRefs(pr?.body)) refs.add(issue);
+    const fromBranch = parseIssueFromBranch(pr?.headRefName);
+    if (fromBranch) refs.add(fromBranch);
+    return refs;
+  }
+
+  for (const pr of openPrs) {
+    for (const issueNumber of refsForPr(pr)) {
+      ensure(issueNumber).openPrs.push(pr);
+    }
+  }
+  for (const pr of mergedPrs) {
+    for (const issueNumber of refsForPr(pr)) {
+      ensure(issueNumber).mergedPrs.push(pr);
+    }
+  }
+  return map;
+}
+
+export class GitHubReconciler {
+  constructor(options = {}) {
+    this.enabled = options.enabled !== false;
+    this.intervalMs = Math.max(
+      30_000,
+      parseNumber(options.intervalMs, DEFAULT_INTERVAL_MS),
+    );
+    this.mergedLookbackHours = Math.max(
+      1,
+      parseNumber(
+        options.mergedLookbackHours,
+        DEFAULT_MERGED_LOOKBACK_HOURS,
+      ),
+    );
+    this.repoSlug =
+      parseRepoSlug(options.repoSlug) ||
+      parseRepoSlug(process.env.GITHUB_REPOSITORY) ||
+      parseRepoSlug(
+        process.env.GITHUB_REPO_OWNER && process.env.GITHUB_REPO_NAME
+          ? `${process.env.GITHUB_REPO_OWNER}/${process.env.GITHUB_REPO_NAME}`
+          : "",
+      ) ||
+      "unknown/unknown";
+    this.trackingLabels = new Set(
+      (Array.isArray(options.trackingLabels)
+        ? options.trackingLabels
+        : String(options.trackingLabels || "tracking").split(",")
+      )
+        .map((value) => String(value || "").trim().toLowerCase())
+        .filter(Boolean),
+    );
+    this.addComment = options.addComment || addKanbanComment;
+    this.updateTaskStatus = options.updateTaskStatus || updateTaskStatus;
+    this.gh = options.gh || defaultGh;
+    this.sendTelegram = options.sendTelegram || null;
+    this.timer = null;
+    this.running = false;
+  }
+
+  async _listOpenIssues() {
+    return await this.gh([
+      "issue",
+      "list",
+      "--repo",
+      this.repoSlug,
+      "--state",
+      "open",
+      "--limit",
+      "200",
+      "--json",
+      "number,title,labels,url",
+    ]);
+  }
+
+  async _listOpenPrs() {
+    return await this.gh([
+      "pr",
+      "list",
+      "--repo",
+      this.repoSlug,
+      "--state",
+      "open",
+      "--limit",
+      "200",
+      "--json",
+      "number,title,body,headRefName,url",
+    ]);
+  }
+
+  async _listMergedPrs() {
+    const since = new Date(
+      Date.now() - this.mergedLookbackHours * 60 * 60 * 1000,
+    )
+      .toISOString()
+      .slice(0, 10);
+    return await this.gh([
+      "pr",
+      "list",
+      "--repo",
+      this.repoSlug,
+      "--state",
+      "merged",
+      "--search",
+      `merged:>=${since}`,
+      "--limit",
+      "200",
+      "--json",
+      "number,title,body,headRefName,mergedAt,url",
+    ]);
+  }
+
+  async reconcileOnce() {
+    const backend = String(getKanbanBackendName() || "").toLowerCase();
+    if (!this.enabled) {
+      return { status: "skipped", reason: "disabled" };
+    }
+    if (backend !== "github") {
+      return { status: "skipped", reason: `backend=${backend || "unknown"}` };
+    }
+
+    const summary = {
+      status: "ok",
+      checked: 0,
+      closed: 0,
+      inreview: 0,
+      normalized: 0,
+      skippedTracking: 0,
+      projectMismatches: 0,
+      errors: 0,
+    };
+
+    // Build a map of project board statuses for issues when in kanban mode
+    /** @type {Map<string, string>} issueNumber → project board status */
+    const projectStatusMap = new Map();
+    const projectMode = String(process.env.GITHUB_PROJECT_MODE || "issues").trim().toLowerCase();
+    if (projectMode === "kanban") {
+      try {
+        const adapter = getKanbanAdapter();
+        if (typeof adapter.listTasksFromProject === "function") {
+          const projectNumber =
+            process.env.GITHUB_PROJECT_NUMBER ||
+            process.env.GITHUB_PROJECT_ID ||
+            null;
+          if (projectNumber) {
+            const projectTasks = await adapter.listTasksFromProject(projectNumber);
+            for (const task of projectTasks) {
+              if (task?.id && task?.status) {
+                projectStatusMap.set(String(task.id), task.status);
+              }
+            }
+          }
+        }
+      } catch (err) {
+        console.warn(`${TAG} failed to read project board for reconciliation: ${err?.message || err}`);
+      }
+    }
+
+    const [issuesRaw, openPrsRaw, mergedPrsRaw] = await Promise.all([
+      this._listOpenIssues(),
+      this._listOpenPrs(),
+      this._listMergedPrs(),
+    ]);
+
+    const issues = Array.isArray(issuesRaw) ? issuesRaw : [];
+    const openPrs = Array.isArray(openPrsRaw) ? openPrsRaw : [];
+    const mergedPrs = Array.isArray(mergedPrsRaw) ? mergedPrsRaw : [];
+    const mappings = buildIssueMappings(openPrs, mergedPrs);
+
+    for (const issue of issues) {
+      const issueNumber = String(issue?.number || "").trim();
+      if (!issueNumber) continue;
+      summary.checked += 1;
+      const mapped = mappings.get(issueNumber) || {
+        openPrs: [],
+        mergedPrs: [],
+      };
+      const hasOpenPr = mapped.openPrs.length > 0;
+      const hasMergedPr = mapped.mergedPrs.length > 0;
+
+      try {
+        if (hasMergedPr) {
+          if (isTrackingIssue(issue, this.trackingLabels)) {
+            summary.skippedTracking += 1;
+            continue;
+          }
+          await this.updateTaskStatus(issueNumber, "done");
+          if (this.addComment) {
+            const mergedUrls = mapped.mergedPrs
+              .slice(0, 3)
+              .map((pr) => pr?.url)
+              .filter(Boolean);
+            const suffix =
+              mergedUrls.length > 0
+                ? `\n\nMerged PR(s):\n${mergedUrls.map((url) => `- ${url}`).join("\n")}`
+                : "";
+            await this.addComment(
+              issueNumber,
+              `## ✅ Auto-Reconciled\nThis issue was auto-closed by openfleet after detecting merged PR linkage.${suffix}`,
+            );
+          }
+          summary.closed += 1;
+          continue;
+        }
+
+        if (hasOpenPr) {
+          if (!isIssueInReview(issue)) {
+            await this.updateTaskStatus(issueNumber, "inreview");
+            summary.inreview += 1;
+          }
+          continue;
+        }
+
+        if (isIssueInReview(issue)) {
+          await this.updateTaskStatus(issueNumber, "todo");
+          summary.normalized += 1;
+          continue;
+        }
+
+        // Project board mismatch detection (kanban mode only)
+        if (projectStatusMap.size > 0) {
+          const projectStatus = projectStatusMap.get(issueNumber);
+          if (projectStatus) {
+            const issueStatus = isIssueInReview(issue) ? "inreview" : "todo";
+            if (projectStatus !== issueStatus && projectStatus !== "todo") {
+              // Project board says a different status than issue labels — reconcile
+              try {
+                await this.updateTaskStatus(issueNumber, projectStatus);
+                summary.projectMismatches += 1;
+              } catch (syncErr) {
+                console.warn(
+                  `${TAG} failed to sync project status for #${issueNumber}: ${syncErr?.message || syncErr}`,
+                );
+              }
+            }
+          }
+        }
+      } catch (err) {
+        summary.errors += 1;
+        console.warn(
+          `${TAG} failed reconciling issue #${issueNumber}: ${err?.message || err}`,
+        );
+      }
+    }
+
+    console.log(
+      `${TAG} cycle complete: checked=${summary.checked} closed=${summary.closed} inreview=${summary.inreview} normalized=${summary.normalized} skippedTracking=${summary.skippedTracking} projectMismatches=${summary.projectMismatches} errors=${summary.errors}`,
+    );
+    return summary;
+  }
+
+  start() {
+    if (this.running) return this;
+    this.running = true;
+    console.log(
+      `${TAG} started (repo=${this.repoSlug}, interval=${this.intervalMs}ms, lookback=${this.mergedLookbackHours}h)`,
+    );
+    void this.reconcileOnce().catch((err) => {
+      console.warn(`${TAG} initial cycle failed: ${err?.message || err}`);
+    });
+    this.timer = setInterval(() => {
+      void this.reconcileOnce().catch((err) => {
+        console.warn(`${TAG} cycle failed: ${err?.message || err}`);
+        if (this.sendTelegram) {
+          void this.sendTelegram(
+            `⚠️ GitHub reconciler cycle failed: ${err?.message || err}`,
+          );
+        }
+      });
+    }, this.intervalMs);
+    if (this.timer?.unref) this.timer.unref();
+    return this;
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.running = false;
+    console.log(`${TAG} stopped`);
+  }
+}
+
+let _singleton = null;
+
+export function startGitHubReconciler(options = {}) {
+  if (_singleton) {
+    _singleton.stop();
+  }
+  _singleton = new GitHubReconciler(options);
+  return _singleton.start();
+}
+
+export function stopGitHubReconciler() {
+  if (_singleton) {
+    _singleton.stop();
+    _singleton = null;
+  }
+}
+
+export async function runGitHubReconcilerOnce(options = {}) {
+  const reconciler = new GitHubReconciler(options);
+  return await reconciler.reconcileOnce();
+}