binary-collections 2.0.12 → 2.0.14

package/lib/chunk-UYNBNLV5.mjs

@@ -0,0 +1,113 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_utils as require_utils2
+} from "./chunk-A3VUZEJK.mjs";
+import {
+  require_config
+} from "./chunk-SWUAEY4H.mjs";
+import {
+  require_utils
+} from "./chunk-6RK5UCTP.mjs";
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/git/user-config.cjs
+var require_user_config = __commonJS({
+  "src/git/user-config.cjs"(exports, module) {
+    init_esm_shims();
+    var { loadDotenv } = require_config();
+    var gch = __require("git-command-helper");
+    var { runGitCommand, runGitCommandOutput } = require_utils2();
+    var { getArgs } = require_utils();
+    loadDotenv();
+    function configureGitUser(cliUser = null, cliEmail = null, options = {}) {
+      console.log("\n=== Configuring Git User ===");
+      let username, email;
+      if (cliUser && cliEmail) {
+        username = cliUser.trim();
+        email = cliEmail.trim();
+        console.log("[i] Using CLI-provided user configuration");
+      } else {
+        username = process.env.GITHUB_USER ? process.env.GITHUB_USER.trim() : void 0;
+        email = process.env.GITHUB_EMAIL ? process.env.GITHUB_EMAIL.trim() : void 0;
+        if (username || email) {
+          console.log("[i] Using environment variable user configuration");
+        }
+      }
+      if (!username && !email) {
+        console.log("[i] No Git user configuration needed (no CLI args or environment variables set)");
+        return;
+      }
+      if (username) {
+        const success = runGitCommand(["config", "user.name", username], `Set Git username to "${username}"`);
+        if (!success) {
+          console.log("[i] Failed to set Git username, but continuing...");
+        }
+      } else {
+        console.log("[i] No username provided, skipping username configuration");
+      }
+      if (email) {
+        const success = runGitCommand(["config", "user.email", email], `Set Git email to "${email}"`);
+        if (!success) {
+          console.log("[i] Failed to set Git email, but continuing...");
+        }
+      } else {
+        console.log("[i] No email provided, skipping email configuration");
+      }
+      if (username || email) {
+        console.log("[\u2713] Git user configuration completed");
+      }
+      if (username) {
+        const remoteUrl = runGitCommandOutput(["remote", "get-url", "origin"], "Fetching remote URL for verification");
+        if (remoteUrl) {
+          console.log(`[i] Remote URL: ${remoteUrl}`);
+          const parsedUrl = gch.parseGitHubUrl(remoteUrl);
+          if (parsedUrl && parsedUrl.owner && username && parsedUrl.owner.toLowerCase() !== username.toLowerCase()) {
+            console.warn(
+              `
+[!] The GitHub remote owner ("${parsedUrl.owner}") does not match the configured username ("${username}").`
+            );
+            console.warn(`[!] If this is not intentional, consider updating the remote URL to use your username.`);
+            console.warn(`[!] Example: git remote set-url origin https://github.com/${username}/<repo>.git
+`);
+            const args = getArgs();
+            const updateRemote = options.updateRemote || args["update-remote"] === true;
+            if (updateRemote) {
+              let newUrl = remoteUrl;
+              if (/^https:\/\//.test(remoteUrl)) {
+                newUrl = remoteUrl.replace(/https:\/\/(?:[^@]+@)?github.com/, `https://${username}@github.com`);
+              } else if (/^git@github.com:/.test(remoteUrl)) {
+                console.warn(
+                  `[!] For SSH remotes, set your SSH config or use HTTPS with username if you want to change authentication user.`
+                );
+                return;
+              }
+              if (newUrl !== remoteUrl) {
+                const updated = runGitCommand(["remote", "set-url", "origin", newUrl], `Set origin to ${newUrl}`);
+                if (updated) {
+                  console.log(`[\u2713] Remote URL updated to: ${newUrl}`);
+                } else {
+                  console.warn(`[!] Failed to update remote URL. Please update it manually if needed.`);
+                }
+              } else {
+                console.log(`[i] Remote URL does not use HTTPS or already contains the username.`);
+              }
+            } else {
+              console.log(`[i] Remote URL not changed. Use --update-remote to update automatically.`);
+            }
+          }
+        }
+      }
+    }
+    module.exports = {
+      configureGitUser
+    };
+  }
+});
+
+export {
+  require_user_config
+};

package/lib/chunk-WOC4FZ6F.mjs

@@ -0,0 +1,164 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-PAZH45HS.mjs";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/get-latest-workflow-status.mjs
+init_esm_shims();
+var import_config = __toESM(require_config(), 1);
+import axios from "axios";
+import { spawn } from "cross-spawn";
+if (!import_config.GITHUB_ACCESS_TOKEN) {
+  console.error("Missing env var: ACCESS_TOKEN or GITHUB_TOKEN");
+  process.exit(1);
+}
+var BASE = "https://api.github.com";
+var headers = {
+  Authorization: `Bearer ${import_config.GITHUB_ACCESS_TOKEN}`,
+  Accept: "application/vnd.github+json",
+  "X-GitHub-Api-Version": "2022-11-28"
+};
+async function request(url) {
+  try {
+    const res = await axios.get(url, { headers });
+    return res.data;
+  } catch (err) {
+    if (err == null ? void 0 : err.response) {
+      const statusText = err.response.statusText || "Request failed";
+      const responseText = typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data);
+      throw new Error(`${err.response.status} ${statusText}
+${responseText}`);
+    }
+    throw err;
+  }
+}
+function runGit(args) {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    const child = spawn("git", args, {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+        return;
+      }
+      reject(new Error(stderr.trim() || `git ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+function getOwnerFromRemoteUrl(remoteUrl) {
+  var _a;
+  const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+  const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+  return ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.owner) || null;
+}
+function getRepoFromRemoteUrl(remoteUrl) {
+  var _a;
+  const normalized = remoteUrl.trim().replace(/\.git$/i, "");
+  const match = normalized.match(/github\.com[:/](?<owner>[^/]+)\/(?<repo>[^/]+)$/i);
+  return ((_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.repo) || null;
+}
+async function getCurrentOwner() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const owner = getOwnerFromRemoteUrl(remoteUrl);
+      if (owner) {
+        return owner;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository owner from git remote.origin.url");
+}
+async function getCurrentRepo() {
+  const commands = [
+    ["config", "--local", "--get", "remote.origin.url"],
+    ["remote", "get-url", "origin"]
+  ];
+  for (const args of commands) {
+    try {
+      const remoteUrl = await runGit(args);
+      const repo = getRepoFromRemoteUrl(remoteUrl);
+      if (repo) {
+        return repo;
+      }
+    } catch {
+    }
+  }
+  throw new Error("Unable to determine repository name from git remote.origin.url");
+}
+async function getLatestRun(owner, repo, workflowId) {
+  var _a;
+  let url;
+  if (workflowId) {
+    url = `${BASE}/repos/${owner}/${repo}/actions/workflows/${encodeURIComponent(workflowId)}/runs?per_page=1`;
+  } else {
+    url = `${BASE}/repos/${owner}/${repo}/actions/runs?per_page=1`;
+  }
+  const data = await request(url);
+  return (_a = data.workflow_runs) == null ? void 0 : _a[0];
+}
+async function getJobs(owner, repo, runId) {
+  const url = `${BASE}/repos/${owner}/${repo}/actions/runs/${runId}/jobs`;
+  const data = await request(url);
+  return data.jobs || [];
+}
+function printReport(run, jobs) {
+  var _a;
+  console.log("\n==============================");
+  console.log("\u{1F680} Latest Workflow Run");
+  console.log("==============================");
+  console.log(`Name      : ${run.name}`);
+  console.log(`Status    : ${run.status}`);
+  console.log(`Conclusion: ${run.conclusion}`);
+  console.log(`Branch    : ${run.head_branch}`);
+  console.log(`Run ID    : ${run.id}`);
+  console.log(`URL       : ${run.html_url}`);
+  console.log("\n==============================");
+  console.log("\u{1F9E9} Jobs & Steps");
+  console.log("==============================\n");
+  for (const job of jobs) {
+    console.log(`\u{1F9F1} Job: ${job.name}`);
+    console.log(`   Status: ${job.status} | Conclusion: ${job.conclusion}`);
+    if (!((_a = job.steps) == null ? void 0 : _a.length)) {
+      console.log("   (no steps found)\n");
+      continue;
+    }
+    for (const step of job.steps) {
+      const icon = step.conclusion === "success" ? "\u2705" : step.conclusion === "failure" ? "\u274C" : step.conclusion === "skipped" ? "\u23ED\uFE0F" : "\u26AA";
+      console.log(`   ${icon} ${step.name} -> ${step.conclusion} (${step.status})`);
+    }
+    console.log("");
+  }
+}
+
+export {
+  request,
+  getOwnerFromRemoteUrl,
+  getRepoFromRemoteUrl,
+  getCurrentOwner,
+  getCurrentRepo,
+  getLatestRun,
+  getJobs,
+  printReport
+};

package/lib/chunk-WSHVPGNM.mjs

@@ -0,0 +1,44 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/hash.js
+init_esm_shims();
+import fs from "fs-extra";
+import * as glob from "glob";
+import upath from "upath";
+import path from "upath";
+import crypto from "crypto";
+function getAllFiles({ patterns, ignore, cwd }) {
+  const files = /* @__PURE__ */ new Set();
+  const root = cwd || process.cwd();
+  for (const pattern of patterns) {
+    const matched = glob.sync(pattern, {
+      cwd: root,
+      nodir: true,
+      ignore
+    });
+    for (const f of matched) {
+      files.add(upath.normalize(path.resolve(root, f)));
+    }
+  }
+  return [...files].sort();
+}
+function hashFile(file) {
+  const content = fs.readFileSync(file);
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function buildChecksum(files) {
+  const hash = crypto.createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update(hashFile(file));
+  }
+  return hash.digest("hex");
+}
+
+export {
+  getAllFiles,
+  buildChecksum
+};

package/lib/chunk-X7UVQ6ZC.mjs

@@ -0,0 +1,183 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/workflow-badge-generator.mjs
+init_esm_shims();
+var COLORS = {
+  success: "#2da44e",
+  failure: "#cf222e",
+  cancelled: "#656d76",
+  skipped: "#656d76",
+  inProgress: "#d4920b",
+  pending: "#656d76",
+  unknown: "#656d76",
+  text: "#1f2328",
+  textSecondary: "#656d76",
+  border: "#d0d7de",
+  bg: "#ffffff",
+  cardBg: "#f6f8fa"
+};
+function getStatusMeta(run) {
+  const { status, conclusion } = run;
+  if (conclusion === "success") return { label: "Passing", color: COLORS.success };
+  if (conclusion === "failure") return { label: "Failing", color: COLORS.failure };
+  if (conclusion === "cancelled") return { label: "Cancelled", color: COLORS.cancelled };
+  if (conclusion === "skipped") return { label: "Skipped", color: COLORS.skipped };
+  if (status === "in_progress") return { label: "In Progress", color: COLORS.inProgress };
+  if (status === "queued" || status === "pending") return { label: "Pending", color: COLORS.pending };
+  return { label: status || "Unknown", color: COLORS.unknown };
+}
+function esc(str) {
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function countSteps(jobs) {
+  let total = 0, passed = 0, failed = 0, skipped = 0, pending = 0;
+  for (const job of jobs) {
+    for (const step of job.steps || []) {
+      total++;
+      if (step.conclusion === "success") passed++;
+      else if (step.conclusion === "failure") failed++;
+      else if (step.conclusion === "skipped") skipped++;
+      else pending++;
+    }
+  }
+  return { total, passed, failed, skipped, pending };
+}
+function jobColor(job) {
+  if (job.conclusion === "success") return COLORS.success;
+  if (job.conclusion === "failure") return COLORS.failure;
+  if (job.status === "in_progress") return COLORS.inProgress;
+  return COLORS.pending;
+}
+function generateBadge(run, jobs, options = {}) {
+  const width = options.width || 520;
+  const maxSteps = options.maxSteps;
+  const { label: statusLabel, color: accentColor } = getStatusMeta(run);
+  const steps = countSteps(jobs);
+  const PAD = 20;
+  const W = width;
+  const RIGHT = width - PAD;
+  const INNER_W = RIGHT - PAD;
+  const els = [];
+  const el = (str) => els.push(str);
+  const LABEL_X = PAD;
+  const VALUE_X = 110;
+  let yCursor = 0;
+  const divider = () => {
+    yCursor += 4;
+    el(`<line x1="${PAD}" y1="${yCursor}" x2="${RIGHT}" y2="${yCursor}" stroke="${COLORS.border}" stroke-width="1"/>`);
+    yCursor += 5;
+  };
+  const sectionHeading = (text) => {
+    yCursor += 8;
+    el(
+      `<text x="${PAD}" y="${yCursor + 13}" font-size="11" font-weight="700" fill="${COLORS.textSecondary}" letter-spacing="0.5">${esc(text)}</text>`
+    );
+    yCursor += 22;
+  };
+  el(`<rect x="0" y="0" width="${W}" height="4" fill="${accentColor}"/>`);
+  yCursor = 4;
+  yCursor += 14;
+  const titleBaseline = yCursor + 15;
+  el(
+    `<text x="${PAD}" y="${titleBaseline}" font-size="15" font-weight="700" fill="${COLORS.text}">Workflow Status</text>`
+  );
+  const pillText = statusLabel;
+  const pillTextW = pillText.length * 7.8 + 32;
+  const pillX = RIGHT - pillTextW;
+  const pillY = titleBaseline - 12;
+  el(`<rect x="${pillX}" y="${pillY}" width="${pillTextW}" height="22" rx="11" fill="${accentColor}" opacity="0.12"/>`);
+  el(`<circle cx="${pillX + 14}" cy="${titleBaseline - 2}" r="4.5" fill="${accentColor}"/>`);
+  el(
+    `<text x="${pillX + 24}" y="${titleBaseline + 1}" font-size="12" font-weight="600" fill="${accentColor}">${esc(pillText)}</text>`
+  );
+  yCursor = titleBaseline + 4;
+  divider();
+  const metaRows = [
+    { label: "Workflow", value: run.name || "" },
+    { label: "Status", value: `${run.status}${run.conclusion ? ` (${run.conclusion})` : ""}` },
+    { label: "Branch", value: run.head_branch || "" },
+    { label: "Run ID", value: `#${run.id || ""}` }
+  ];
+  for (const row of metaRows) {
+    const rowBaseline = yCursor + 14;
+    el(
+      `<text x="${LABEL_X}" y="${rowBaseline}" font-size="12" fill="${COLORS.textSecondary}">${esc(row.label)}</text>`
+    );
+    el(
+      `<text x="${VALUE_X}" y="${rowBaseline}" font-size="13" fill="${COLORS.text}" font-weight="500">${esc(row.value)}</text>`
+    );
+    yCursor += 22;
+  }
+  divider();
+  sectionHeading("JOBS");
+  for (const job of jobs) {
+    const jColor = jobColor(job);
+    const jStatus = job.conclusion || job.status;
+    el(`<rect x="${PAD}" y="${yCursor}" width="${INNER_W}" height="28" rx="6" fill="${COLORS.cardBg}"/>`);
+    el(
+      `<text x="${PAD + 10}" y="${yCursor + 18}" font-size="13" font-weight="600" fill="${COLORS.text}">${esc(job.name)}</text>`
+    );
+    const jobStatusX = RIGHT - 14;
+    el(`<circle cx="${jobStatusX - 16}" cy="${yCursor + 14}" r="3.5" fill="${jColor}"/>`);
+    el(
+      `<text x="${jobStatusX}" y="${yCursor + 18}" font-size="11" fill="${COLORS.textSecondary}" text-anchor="end">${esc(jStatus)}</text>`
+    );
+    yCursor += 34;
+    if (job.steps && job.steps.length > 0) {
+      const stepsToRender = maxSteps ? job.steps.slice(0, maxSteps) : job.steps;
+      const hiddenCount = maxSteps ? job.steps.length - maxSteps : 0;
+      for (const step of stepsToRender) {
+        const sIcon = step.conclusion === "success" ? "\u2713" : step.conclusion === "failure" ? "\u2717" : step.conclusion === "skipped" ? "\u2013" : "\u25CB";
+        const sColor = step.conclusion === "success" ? COLORS.success : step.conclusion === "failure" ? COLORS.failure : step.conclusion === "skipped" ? COLORS.textSecondary : COLORS.inProgress;
+        el(`<text x="${PAD + 18}" y="${yCursor + 13}" font-size="12" fill="${sColor}">${sIcon}</text>`);
+        let stepName = step.name || "";
+        const maxChars = 52;
+        if (stepName.length > maxChars) {
+          stepName = stepName.slice(0, maxChars - 3) + "...";
+        }
+        el(`<text x="${PAD + 36}" y="${yCursor + 13}" font-size="12" fill="${COLORS.text}">${esc(stepName)}</text>`);
+        const stepStatus = step.conclusion || step.status || "";
+        el(
+          `<text x="${RIGHT}" y="${yCursor + 13}" font-size="11" fill="${COLORS.textSecondary}" text-anchor="end">${esc(stepStatus)}</text>`
+        );
+        yCursor += 20;
+      }
+      if (hiddenCount > 0) {
+        el(
+          `<text x="${PAD + 18}" y="${yCursor + 13}" font-size="12" fill="${COLORS.textSecondary}" font-style="italic">and ${hiddenCount} more step${hiddenCount !== 1 ? "s" : ""}...</text>`
+        );
+        yCursor += 20;
+      }
+      yCursor += 4;
+    }
+  }
+  divider();
+  const footerParts = [];
+  if (steps.passed > 0) footerParts.push(`${steps.passed} \u2713 passed`);
+  if (steps.failed > 0) footerParts.push(`${steps.failed} \u2717 failed`);
+  if (steps.pending > 0) footerParts.push(`${steps.pending} \u25CB pending`);
+  if (steps.skipped > 0) footerParts.push(`${steps.skipped} \u2013 skipped`);
+  const footerText = footerParts.length > 0 ? footerParts.join("  \xB7  ") : "No steps recorded";
+  el(`<text x="${PAD}" y="${yCursor + 13}" font-size="12" fill="${COLORS.textSecondary}">${esc(footerText)}</text>`);
+  yCursor += 22;
+  const totalHeight = yCursor + 6;
+  const svg = [
+    `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${totalHeight}" viewBox="0 0 ${W} ${totalHeight}" font-family="-apple-system,BlinkMacSystemFont,Segoe UI,Noto Sans,Helvetica,Arial,sans-serif">`,
+    `  <defs>`,
+    `    <filter id="badge-shadow" x="-2%" y="-2%" width="104%" height="104%">`,
+    `      <feDropShadow dx="0" dy="1" stdDeviation="3" flood-color="#000" flood-opacity="0.12"/>`,
+    `    </filter>`,
+    `  </defs>`,
+    `  <rect x="0.5" y="0.5" width="${W - 1}" height="${totalHeight - 1}" rx="8" fill="${COLORS.bg}" stroke="${COLORS.border}" stroke-width="1" filter="url(#badge-shadow)"/>`,
+    ...els,
+    `</svg>`
+  ].join("\n");
+  return svg;
+}
+
+export {
+  generateBadge
+};

package/lib/{chunk-NCZPTKDV.mjs → chunk-XI67TI46.mjs}

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_package
-} from "./chunk-ZOWVMII3.mjs";
+} from "./chunk-AJ3OIYYP.mjs";
 import {
   __commonJS,
   __dirname,

package/lib/chunk-XW5NZAKI.mjs

@@ -0,0 +1,82 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/storage.ts
+init_esm_shims();
+import path from "upath";
+import os from "os";
+import fs from "fs-extra";
+import { parse as parseJsonc } from "jsonc-parser";
+var OPCODE_DIR = path.join(os.homedir(), ".local/share/opencode");
+var CONFIG_DIR = path.join(os.homedir(), ".config/opencode");
+var CACHE_DIR = path.join(os.homedir(), ".cache/opencode");
+var LOG_DIR = path.join(OPCODE_DIR, "log");
+var AUTH_PATH = path.join(OPCODE_DIR, "auth.json");
+var PROJECT_DIR = path.join(OPCODE_DIR, "project");
+var STORAGE_PATH = path.join(OPCODE_DIR, "storage");
+var SESSION_PATH = path.join(STORAGE_PATH, "session");
+var SESSION_DIFF_DIR = path.join(STORAGE_PATH, "session_diff");
+var DATABASE_PATH = path.join(OPCODE_DIR, "opencode.db");
+async function scanJson(dir) {
+  const results = [];
+  try {
+    const entries = await fs.readdir(dir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const content = await fs.readFile(path.join(dir, entry), "utf-8");
+      results.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return results;
+}
+async function scanDirs(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readJson(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
+  }
+}
+function getSessionFileById(sessionId) {
+  return path.join(SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+function getOpenCodeAuth() {
+  const file = path.join(OPCODE_DIR, "auth.json");
+  if (!fs.existsSync(file)) return null;
+  return readJson(file);
+}
+async function saveOpenCodeAuth(auth) {
+  const file = path.join(OPCODE_DIR, "auth.json");
+  await fs.ensureFile(file);
+  await fs.writeFile(file, JSON.stringify(auth, null, 2), "utf-8");
+}
+
+export {
+  OPCODE_DIR,
+  CONFIG_DIR,
+  CACHE_DIR,
+  LOG_DIR,
+  AUTH_PATH,
+  PROJECT_DIR,
+  STORAGE_PATH,
+  SESSION_PATH,
+  SESSION_DIFF_DIR,
+  DATABASE_PATH,
+  scanJson,
+  scanDirs,
+  readJson,
+  getSessionFileById,
+  getOpenCodeAuth,
+  saveOpenCodeAuth
+};

package/lib/chunk-YLV4QATP.mjs

@@ -0,0 +1,86 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  getCacheFile,
+  loadCache,
+  saveCache
+} from "./chunk-QD4T255Z.mjs";
+import {
+  buildChecksum,
+  getAllFiles
+} from "./chunk-MCCMMZSM.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/run.js
+init_esm_shims();
+import { spawn } from "child_process";
+async function runChecksum({
+  patterns = [],
+  ignore = [],
+  exec,
+  cwd = process.env.INIT_CWD || process.cwd(),
+  dryRun = false
+}) {
+  if (!patterns.length && !exec) {
+    console.log("No patterns or command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!exec) {
+    console.log("No command provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  if (!patterns.length) {
+    console.log("No patterns provided, skipping checksum runner.");
+    process.exit(1);
+  }
+  const files = getAllFiles({ patterns, ignore, cwd });
+  const checksum = buildChecksum(files);
+  const cacheFile = getCacheFile({ patterns, ignore, cwd });
+  const cache = loadCache(cacheFile);
+  if ((cache == null ? void 0 : cache.checksum) === checksum) {
+    return {
+      changed: false,
+      cacheFile,
+      files
+    };
+  }
+  if (dryRun) {
+    return {
+      changed: true,
+      cacheFile,
+      files,
+      skipped: true
+    };
+  }
+  await runCommand(exec, cwd);
+  saveCache(cacheFile, {
+    checksum,
+    files,
+    patterns,
+    ignore,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    changed: true,
+    cacheFile,
+    files
+  };
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, {
+      shell: true,
+      stdio: "inherit",
+      cwd
+    });
+    child.on("exit", (code) => {
+      if (code === 0 || code === null) resolve();
+      else reject(new Error(`Command failed: ${code}`));
+    });
+  });
+}
+
+export {
+  runChecksum
+};