binary-collections 2.0.13 → 2.0.15

package/lib/{chunk-TBWXE7ST.mjs → chunk-NHD4HLSU.mjs}

@@ -3,8 +3,8 @@ import {
   require_fetchResponse
 } from "./chunk-KLKAIFKI.mjs";
 import {
-  require_findEnvFiles
-} from "./chunk-H44UWUFY.mjs";
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
 import {
   require_utils
 } from "./chunk-6RK5UCTP.mjs";
@@ -15,30 +15,14 @@ import {
 
 // src/package-resolutions-updater.mjs
 init_esm_shims();
-var utils = __toESM(require_utils(), 1);
+var import_config = __toESM(require_config(), 1);
 var import_fetchResponse = __toESM(require_fetchResponse(), 1);
-var import_findEnvFiles = __toESM(require_findEnvFiles(), 1);
-import * as dotenv from "dotenv";
+var utils = __toESM(require_utils(), 1);
 import fs from "fs";
+import { parseGitHubUrl } from "git-command-helper";
 import os from "os";
 import path from "upath";
-import { parseGitHubUrl } from "git-command-helper";
-var projectDir = process.cwd();
-var envPath = path.join(projectDir, ".env");
 var args = utils.getArgs();
-if (!fs.existsSync(envPath)) {
-  const envFiles = (0, import_findEnvFiles.findEnvFiles)(projectDir, (file) => {
-    const content = fs.readFileSync(file, "utf-8");
-    return /GITHUB_TOKEN|ACCESS_TOKEN/.test(content);
-  });
-  if (envFiles.length > 0) {
-    envPath = envFiles[0];
-  }
-}
-if (fs.existsSync(envPath)) {
-  dotenv.config({ path: envPath, quiet: true, override: true });
-}
-var ACCESS_TOKEN = process.env.ACCESS_TOKEN || process.env.GITHUB_TOKEN;
 if (args.help || args.h) {
   showHelp();
 }
@@ -62,7 +46,6 @@ Requirements:
   - Node.js v18+ recommended
 Dependencies:
   - ansi-colors \u2013 for styled terminal output
-  - dotenv \u2013 to load GitHub token from .env
 Examples:
   node src/package-resolutions-updater.mjs
   node src/package-resolutions-updater.mjs --help
@@ -103,7 +86,7 @@ async function fetchJson(url) {
       "User-Agent": selectedUserAgent,
       Accept: "application/vnd.github.v3+json",
       "X-GitHub-Api-Version": "2022-11-28",
-      ...ACCESS_TOKEN ? { Authorization: `token ${ACCESS_TOKEN}` } : {}
+      ...import_config.GITHUB_ACCESS_TOKEN ? { Authorization: `token ${import_config.GITHUB_ACCESS_TOKEN}` } : {}
     },
     responseType: "json"
   });
@@ -181,15 +164,25 @@ function replaceRawWithLatestHash(url, latestHash) {
 }
 async function resolvePackageResolutionUpdates(resolutions, specialPackageOverrides = []) {
   const updates = [];
-  for (const [currentPkgName, url] of Object.entries(resolutions || {})) {
+  for (const [currentPkgName, version] of Object.entries(resolutions || {})) {
+    const isUrl = typeof version === "string" && (version.startsWith("http://") || version.startsWith("https://"));
+    if (!isUrl) {
+      updates.push({
+        skipped: true,
+        currentPkgName,
+        url: version,
+        error: new Error("Version is not a URL, skipping")
+      });
+      continue;
+    }
     let repo;
     try {
-      repo = parseGitHubUrl(url);
+      repo = parseGitHubUrl(version);
     } catch (error) {
       updates.push({
         skipped: true,
         currentPkgName,
-        url,
+        url: version,
         error
       });
       continue;
@@ -197,25 +190,25 @@ async function resolvePackageResolutionUpdates(resolutions, specialPackageOverri
     try {
       const override = specialPackageOverrides.find((p) => p.pkg === currentPkgName);
       const latest = override ? await getLatestCommit(override.owner, override.repo, override.branch) : await getLatestCommitAcrossBranches(repo.owner, repo.repo);
-      const new_url = replaceRawWithLatestHash(url, latest.sha);
+      const new_url = replaceRawWithLatestHash(version, latest.sha);
       const response = await (0, import_fetchResponse.default)(new_url);
       if (response.status < 200 || response.status >= 300) {
         updates.push({
           failed: true,
           currentPkgName,
-          url,
+          url: version,
           new_url,
           repo,
           latest,
           error: new Error(`New URL not accessible (status ${response.status}).
-original: ${url}
+original: ${version}
 new: ${new_url}`)
         });
         continue;
       }
       updates.push({
         currentPkgName,
-        url,
+        url: version,
         new_url,
         repo,
         latest
@@ -224,7 +217,7 @@ new: ${new_url}`)
       updates.push({
         failed: true,
         currentPkgName,
-        url,
+        url: version,
         repo,
         error
       });

package/lib/{chunk-RDGDLSPD.mjs → chunk-OWNVMKAA.mjs}

@@ -1,21 +1,22 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
+import {
+  __toESM,
   init_esm_shims
 } from "./chunk-QQ4A6DLD.mjs";
 
 // src/rmpath.mjs
 init_esm_shims();
-import dotenv from "dotenv";
+var import_config = __toESM(require_config(), 1);
 import fs from "fs-extra";
 import * as glob from "glob";
 import path from "upath";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
-var dotenvPath = path.resolve(process.cwd(), ".env");
-if (fs.existsSync(dotenvPath)) {
-  dotenv.config({ path: dotenvPath, override: true, quiet: true });
-}
+(0, import_config.loadDotenv)();
 var deletePatterns = [];
 function resolveDeletePatterns(targetPath) {
   if (fs.existsSync(targetPath) && fs.lstatSync(targetPath).isFile()) {

package/lib/chunk-SKVF4TMD.mjs

@@ -0,0 +1,59 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/print-tarball-tree.mjs
+init_esm_shims();
+import fs from "fs";
+import * as zlib from "zlib";
+import { pipeline } from "stream/promises";
+import tar from "tar-stream";
+function addToTree(tree, parts) {
+  let node = tree;
+  for (const part of parts) {
+    if (!node[part]) node[part] = {};
+    node = node[part];
+  }
+  return tree;
+}
+function formatTree(node, prefix = "") {
+  const lines = [];
+  const entries = Object.keys(node).sort();
+  entries.forEach(function(key, index) {
+    const isLast = index === entries.length - 1;
+    const child = node[key];
+    const line = prefix + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ") + key;
+    const newPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    lines.push(line);
+    lines.push(...formatTree(child, newPrefix));
+  });
+  return lines;
+}
+function printTree(node, prefix = "", logger = console.log) {
+  for (const line of formatTree(node, prefix)) {
+    logger(line);
+  }
+}
+async function printTgzTree(filePath, options = {}) {
+  const logger = options.logger || console.log;
+  const extract = tar.extract();
+  const tree = {};
+  extract.on("entry", function(header, stream, next) {
+    const parts = header.name.split("/").filter(Boolean);
+    if (parts.length) addToTree(tree, parts);
+    stream.once("end", next);
+    stream.once("error", next);
+    stream.resume();
+  });
+  await pipeline(fs.createReadStream(filePath), zlib.createGunzip(), extract);
+  printTree(tree, "", logger);
+  return tree;
+}
+
+export {
+  addToTree,
+  formatTree,
+  printTree,
+  printTgzTree
+};

package/lib/{chunk-BZWVHODJ.mjs → chunk-TDUUOAQD.mjs}

@@ -1,4 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  require_config
+} from "./chunk-3T6AMFI3.mjs";
 import {
   __commonJS,
   __require,
@@ -12,11 +15,8 @@ var require_submodule_remove = __commonJS({
     var { spawnAsync } = __require("cross-spawn");
     var path = __require("upath");
     var fs = __require("fs-extra");
-    var dotenv = __require("dotenv");
-    var envPath = path.resolve(process.cwd(), ".env");
-    if (fs.existsSync(envPath)) {
-      dotenv.config({ path: envPath, override: true, quiet: true });
-    }
+    var { loadDotenv } = require_config();
+    loadDotenv();
     async function removeSubmodule(submodulePath) {
       try {
         await spawnAsync("git", ["submodule", "deinit", "-f", submodulePath], { stdio: "inherit" });

package/lib/chunk-TP3O2JGW.mjs

@@ -0,0 +1,88 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/github-workflows/workflow-test-data.cjs
+var require_workflow_test_data = __commonJS({
+  "src/github-workflows/workflow-test-data.cjs"(exports, module) {
+    init_esm_shims();
+    var workflow = {
+      name: "Node.js Package Test",
+      concurrency: {
+        group: "test-${{ github.event_name }}",
+        "cancel-in-progress": true
+      },
+      on: {
+        workflow_dispatch: {},
+        push: {
+          paths: ["**/test*/**", "**/test*", "**/src/**"]
+        }
+      },
+      env: {
+        CI_NODE_VERSION: "24.16.0",
+        CI_PYTHON_VERSION: "3.11",
+        ACCESS_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}",
+        GH_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}"
+      },
+      jobs: {
+        ci: {
+          name: "\u{1F528} Build, Pack & Test",
+          "runs-on": "ubuntu-latest",
+          steps: [
+            {
+              name: "\u2B07\uFE0F Checkout workflow repository",
+              uses: "actions/checkout@v6"
+            },
+            {
+              name: "\u2B07\uFE0F Setup CI Environment",
+              uses: "./.github/actions/setup-environments",
+              with: {
+                "node-version": "${{ env.CI_NODE_VERSION }}",
+                "python-version": "${{ env.CI_PYTHON_VERSION }}",
+                token: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}",
+                "prefix-cache-key": "${{ runner.os }}-test-"
+              }
+            },
+            {
+              name: "\u{1F4E6} Install dependencies",
+              run: `touch yarn.lock && corepack yarn install`
+            },
+            {
+              name: "\u{1F528} Build project",
+              run: "corepack yarn build"
+            },
+            {
+              name: "\u{1F4E6} Pack project",
+              run: "corepack yarn pack"
+            },
+            // {
+            //   name: '🧪 Run committed composite tests action',
+            //   uses: './.github/actions/run-tests',
+            //   env: {
+            //     ACCESS_TOKEN: '${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}',
+            //     GH_TOKEN: '${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}'
+            //   }
+            // },
+            {
+              name: "\u{1F9F9} Clean GitHub Actions Cache",
+              // if: 'always()',
+              "continue-on-error": true,
+              env: {
+                GH_TOKEN: "${{ secrets.ACCESS_TOKEN || secrets.GITHUB_TOKEN || github.token }}"
+              },
+              shell: "bash",
+              run: `npx --legacy-peer-deps -y binary-collections@https://raw.githubusercontent.com/dimaslanjaka/bin/master/releases/bin.tgz clean-github-actions-caches --repo "\${{ github.repository }}" --sha "\${{ github.sha }}"`
+            }
+          ]
+        }
+      }
+    };
+    module.exports = workflow;
+  }
+});
+
+export {
+  require_workflow_test_data
+};

package/lib/{chunk-FLYSZFLW.mjs → chunk-UAEKSLAX.mjs}

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

package/lib/chunk-UDZBVKXH.mjs

@@ -0,0 +1,94 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/vscode/storage.ts
+init_esm_shims();
+import * as path from "upath";
+import * as os from "os";
+import * as process from "process";
+import fs from "fs-extra";
+function getAppDataDir() {
+  if (process.env.VSCODE_APP_DATA) return process.env.VSCODE_APP_DATA;
+  const platform2 = os.platform();
+  if (platform2 === "win32") return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData/Roaming"), "Code");
+  if (platform2 === "darwin") return path.join(os.homedir(), "Library/Application Support/Code");
+  return path.join(os.homedir(), ".config/Code");
+}
+function getCacheDir() {
+  const platform2 = os.platform();
+  if (platform2 === "win32")
+    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData/Roaming"), "Code/Cache");
+  if (platform2 === "darwin") return path.join(os.homedir(), "Library/Caches/Code");
+  return path.join(os.homedir(), ".cache/Code");
+}
+var APP_DATA_DIR = getAppDataDir();
+var USER_DIR = path.join(APP_DATA_DIR, "User");
+var SETTINGS_PATH = path.join(USER_DIR, "settings.json");
+var KEYBINDINGS_PATH = path.join(USER_DIR, "keybindings.json");
+var SNIPPETS_DIR = path.join(USER_DIR, "snippets");
+var WORKSPACE_STORAGE_DIR = path.join(USER_DIR, "workspaceStorage");
+var GLOBAL_STORAGE_DIR = path.join(USER_DIR, "globalStorage");
+var HISTORY_DIR = path.join(USER_DIR, "History");
+var SYNC_DIR = path.join(USER_DIR, "sync");
+var EXTENSIONS_DIR = path.join(os.homedir(), ".vscode/extensions");
+var CACHE_DIR = getCacheDir();
+var CACHED_DATA_DIR = path.join(CACHE_DIR, "CachedData");
+var CACHED_EXTENSIONS_DIR = path.join(CACHE_DIR, "CachedExtensions");
+var CACHED_VSIXS_DIR = path.join(CACHE_DIR, "CachedExtensionVSIXs");
+var LOGS_DIR = path.join(APP_DATA_DIR, "logs");
+var DATABASE_PATH = path.join(APP_DATA_DIR, "state.vscdb");
+var MACHINE_ID_PATH = path.join(APP_DATA_DIR, "machineid");
+function fileUriToPath(uri) {
+  if (!uri.startsWith("file:///")) return uri;
+  return decodeURIComponent(uri.slice(8));
+}
+async function listWorkspaceProjects() {
+  const entries = [];
+  let dirEntries;
+  try {
+    dirEntries = await fs.readdir(WORKSPACE_STORAGE_DIR);
+  } catch {
+    return entries;
+  }
+  for (const storageId of dirEntries) {
+    const wsPath = path.join(WORKSPACE_STORAGE_DIR, storageId, "workspace.json");
+    try {
+      const content = await fs.readFile(wsPath, "utf8");
+      const data = JSON.parse(content);
+      if (typeof data.folder === "string" && data.folder.length > 0) {
+        const storagePath = path.join(WORKSPACE_STORAGE_DIR, storageId);
+        const entry = { folder: fileUriToPath(data.folder), storageId, storagePath };
+        const copilotMemoryDir = path.join(storagePath, "GitHub.copilot-chat", "memory-tool", "memories");
+        if (await fs.pathExists(copilotMemoryDir)) {
+          entry.copilotMemoryDir = copilotMemoryDir;
+        }
+        entries.push(entry);
+      }
+    } catch {
+    }
+  }
+  return entries;
+}
+
+export {
+  APP_DATA_DIR,
+  USER_DIR,
+  SETTINGS_PATH,
+  KEYBINDINGS_PATH,
+  SNIPPETS_DIR,
+  WORKSPACE_STORAGE_DIR,
+  GLOBAL_STORAGE_DIR,
+  HISTORY_DIR,
+  SYNC_DIR,
+  EXTENSIONS_DIR,
+  CACHE_DIR,
+  CACHED_DATA_DIR,
+  CACHED_EXTENSIONS_DIR,
+  CACHED_VSIXS_DIR,
+  LOGS_DIR,
+  DATABASE_PATH,
+  MACHINE_ID_PATH,
+  listWorkspaceProjects
+};

package/lib/chunk-UEOWRYAN.mjs

@@ -0,0 +1,32 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  loadProjects
+} from "./chunk-LACQTD5V.mjs";
+import {
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/opencode/cli/list-projects.ts
+init_esm_shims();
+async function handleListProjects() {
+  const projects = await loadProjects();
+  console.log(`Projects (${projects.length}):
+`);
+  const rows = projects.map((p) => ({
+    id: p.id.slice(0, 8),
+    name: p.name || "-",
+    worktree: p.worktree
+  }));
+  const idWidth = Math.max(...rows.map((r) => r.id.length), 2);
+  const nameWidth = Math.max(...rows.map((r) => r.name.length), 4);
+  const sep = "\u2500".repeat(idWidth + nameWidth + 15);
+  console.log(`  ${"ID".padEnd(idWidth)}  ${"Name".padEnd(nameWidth)}  Worktree`);
+  console.log(`  ${sep}`);
+  for (const r of rows) {
+    console.log(`  ${r.id.padEnd(idWidth)}  ${r.name.padEnd(nameWidth)}  ${r.worktree}`);
+  }
+}
+
+export {
+  handleListProjects
+};

package/lib/chunk-V6PTSDW5.mjs

@@ -0,0 +1,82 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  __commonJS,
+  __require,
+  init_esm_shims
+} from "./chunk-QQ4A6DLD.mjs";
+
+// src/run-by-checksum/hash.cjs
+var require_hash = __commonJS({
+  "src/run-by-checksum/hash.cjs"(exports, module) {
+    init_esm_shims();
+    var fs = __require("fs-extra");
+    var glob = __require("glob");
+    var path = __require("upath");
+    var CryptoJS = __require("crypto-js");
+    var globSync = typeof glob.sync === "function" ? glob.sync : glob.globSync;
+    function getAllFiles({ patterns = [], ignore = [], cwd } = {}) {
+      const files = /* @__PURE__ */ new Set();
+      const root = path.resolve(cwd || process.cwd());
+      for (const pattern of patterns) {
+        const matched = globSync(pattern, {
+          cwd: root,
+          nodir: true,
+          ignore,
+          absolute: false
+        });
+        for (const f of matched) {
+          files.add(path.normalize(path.resolve(root, f)));
+        }
+      }
+      return Array.from(files).sort();
+    }
+    function isBinaryFile(filePath, bytesToCheck = 8e3) {
+      const size = Math.max(0, Number(bytesToCheck) || 0);
+      if (size === 0) {
+        return false;
+      }
+      const fd = fs.openSync(filePath, "r");
+      try {
+        const buffer = Buffer.allocUnsafe(size);
+        const bytesRead = fs.readSync(fd, buffer, 0, size, 0);
+        for (let i = 0; i < bytesRead; i++) {
+          if (buffer[i] === 0) {
+            return true;
+          }
+        }
+        return false;
+      } finally {
+        fs.closeSync(fd);
+      }
+    }
+    function hashFile(file) {
+      if (!isBinaryFile(file)) {
+        const content = fs.readFileSync(file, "utf8");
+        const normalized = content.replace(/\s+/g, " ").trim();
+        return CryptoJS.SHA256(normalized).toString(CryptoJS.enc.Hex);
+      }
+      const stats = fs.statSync(file);
+      const binHash = CryptoJS.algo.SHA256.create();
+      binHash.update(file);
+      binHash.update(String(stats.size));
+      return binHash.finalize().toString(CryptoJS.enc.Hex);
+    }
+    function buildChecksum(files = []) {
+      const hash = CryptoJS.algo.SHA256.create();
+      for (const file of files) {
+        hash.update(file);
+        hash.update(hashFile(file));
+      }
+      return hash.finalize().toString(CryptoJS.enc.Hex);
+    }
+    function sha256(data, trim = 128) {
+      const hash = CryptoJS.SHA256(String(data)).toString(CryptoJS.enc.Hex);
+      return trim ? hash.substring(0, trim) : hash;
+    }
+    module.exports = { getAllFiles, buildChecksum, sha256 };
+  }
+});
+
+export {
+  require_hash
+};