binary-collections 2.0.13 → 2.0.15

package/.opencode/plugins/opencode-request-logger/README.md

@@ -0,0 +1,44 @@
+# opencode-request-logger
+
+An [OpenCode](https://opencode.ai) plugin that logs raw LLM request bodies to disk for debugging and analysis.
+
+## What it does
+
+Intercepts outgoing fetch calls to LLM providers (Anthropic, OpenAI, Google, Bedrock, etc.) and writes each request body as a timestamped JSON file. Logs are organized by session ID.
+
+**Log location:** `~/.config/opencode/logs/request-logger/<sessionId>/<timestamp>_<seq>.json`
+
+Each file contains:
+
+```json
+{
+  "timestamp": "2026-03-04T12:00:00.000Z",
+  "url": "https://api.anthropic.com/v1/messages",
+  "body": { "...raw request body..." }
+}
+```
+
+## How it works
+
+Two interception layers ensure coverage across all providers:
+
+1. **`globalThis.fetch` wrapper** -- catches most providers since the AI SDK routes through fetch
+2. **`chat.params` hook** -- wraps the per-request fetch passed to `streamText`, catching providers that bypass `globalThis.fetch` (e.g. AWS Bedrock)
+
+Only requests with an AI-shaped body (containing `messages`, `input`, or `contents` arrays) are logged.
+
+## Installation
+
+```bash
+# From the plugin directory
+bun install
+bun run build
+```
+
+Then add to your OpenCode config (`~/.config/opencode/opencode.jsonc`):
+
+```json
+{
+  "plugin": [ "./plugin/opencode-request-logger" ]
+}
+```

package/.venv/Lib/site-packages/pyarrow/tests/data/orc/README.md

@@ -0,0 +1,22 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+The ORC and JSON files come from the `examples` directory in the Apache ORC
+source tree:
+https://github.com/apache/orc/tree/main/examples

package/binaries/binary-executor.cjs

@@ -1,254 +1,323 @@
 #!/usr/bin/env node
+'use strict';
 
-/**
- * Built-in Node.js modules:
- *
- * - child_process:
- *   Used to launch external scripts/programs.
- *
- * - path:
- *   Safely handles file paths across operating systems.
- *
- * - fs:
- *   Used to check whether files exist.
- */
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const which = require('which');
-const { isWindows } = require('../src/utils/isWindows.js');
-
-/**
- * __dirname
- *   Absolute directory path of this launcher script.
- *
- * __filename
- *   Absolute path of this launcher file itself.
- *
- * base
- *   Filename without extension.
- *
- * Example:
- *   File = "/tools/mytool.js"
- *
- *   binDir = "/tools"
- *   base   = "mytool"
- */
-const binDir = __dirname;
-const base = path.basename(__filename, path.extname(__filename));
+var require$$0 = require('child_process');
+var require$$1 = require('path');
+var require$$2 = require('fs');
+var require$$3 = require('which');
 
-/**
- * Determine which script extensions to search for
- * based on the current operating system.
- *
- * Windows:
- *   .cmd
- *   .bat
- *   .ps1
- *   .vbs
- *
- * Linux/macOS:
- *   .sh
- *   executable file without extension
- */
-const candidates = process.platform === 'win32' ? ['.cmd', '.bat', '.ps1', '.vbs'] : ['.sh', ''];
-
-/**
- * Search for the first matching script
- * in the same directory as this launcher.
- *
- * Example:
- *   If base = "mytool"
- *
- *   Windows checks:
- *     mytool.cmd
- *     mytool.bat
- *     mytool.ps1
- *     mytool.vbs
- *
- *   Linux/macOS checks:
- *     mytool.sh
- *     mytool
- */
-let found = null;
-
-for (const ext of candidates) {
-  const script = path.join(binDir, base + ext);
-  const exists = fs.existsSync(script);
-  // console.log(`Checking for ${script}: ${exists ? 'found' : 'not found'}`);
-  if (exists) {
-    found = script;
-    break;
-  }
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/**
- * If no matching script was found,
- * try check if `bash` is available and if so, check for a .sh script.
- */
-if (!found) {
-  try {
-    spawnSync('bash', ['--version'], { stdio: 'ignore' });
-    const bashScript = [path.join(binDir, base), path.join(binDir, base + '.sh')].find((script) =>
-      fs.existsSync(script)
-    );
-    if (bashScript) {
-      found = bashScript;
-    }
-  } catch {
-    // bash is not available, do nothing
-  }
+function getAugmentedNamespace(n) {
+  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			var isInstance = false;
+      try {
+        isInstance = this instanceof a;
+      } catch (e) {}
+			if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
 }
 
+var binaryExecutor$1 = {};
+
 /**
- * If no matching script was found,
- * print an error and exit with failure code 1.
+ * Determines if the current platform is Windows
+ * @returns {boolean} true if running on Windows, false otherwise
  */
-if (!found) {
-  console.error(`No script found for ${base} in ${binDir}`);
-  process.exit(1);
+function isWindows() {
+  return process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE || '');
 }
 
-/**
- * Detect special script types
- * that require a shell/interpreter.
- */
-const isPs1 = found.endsWith('.ps1');
-const isCmd = found.endsWith('.cmd');
-const isUnixShell = found.endsWith('.sh') || path.extname(found) === '';
+var isWindows$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	isWindows: isWindows
+});
 
-/**
- * cmd
- *   The executable program to launch.
- *
- * args
- *   Arguments passed to the executable.
- */
-let cmd, args;
+var require$$4 = /*@__PURE__*/getAugmentedNamespace(isWindows$1);
 
-/**
- * PowerShell scripts:
- *
- * Run through powershell.exe because .ps1 files
- * are not directly executable like binaries.
- *
- * Flags:
- *   -NoProfile
- *     Prevent loading user profile scripts.
- *
- *   -ExecutionPolicy Bypass
- *     Allow script execution even if policy blocks it.
- *
- *   -File
- *     Specifies the script to execute.
- *
- * process.argv.slice(2)
- *   Forward all user-provided command-line arguments.
- */
-if (isPs1) {
-  cmd = 'powershell.exe';
-
-  args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', found, ...process.argv.slice(2)];
-
-  /**
-   * CMD batch files:
-   *
-   * Run through cmd.exe using:
-   *   /c
-   * which means:
-   *   "execute command and terminate"
-   */
-} else if (isCmd) {
-  cmd = 'cmd.exe';
-
-  args = ['/c', found, ...process.argv.slice(2)];
-
-  /**
-   * Other scripts:
-   *
-   * Usually:
-   *   - shell scripts (.sh)
-   *   - executable binaries
-   *
-   * These can be executed directly.
-   */
-} else if (isUnixShell) {
-  // Capture shebang scripts (no extension) and .sh scripts
-  const shebang = fs.readFileSync(found, 'utf8').split('\n')[0].trim();
-  const interpreter = shebang.startsWith('#!')
-    ? shebang
-        .slice(2)
-        .trim()
-        .replace(/^\/usr\/bin\/env\s+/, '')
-        .replace(/^\/bin\/env\s+/, '')
-        .replace(/^\/usr\/bin\//, '')
-        .replace(/^\/bin\//, '')
-    : null;
-
-  if (interpreter) {
-    const resolvedOrNull = which.sync(interpreter, { nothrow: true });
-    if (!resolvedOrNull) {
-      if (['bash', 'sh'].includes(interpreter) && isWindows()) {
-        const locationsToCheck = [
-          'C:\\Program Files\\Git\\usr\\bin',
-          'C:\\Program Files\\Git\\bin',
-          'C:\\Program Files (x86)\\Git\\usr\\bin',
-          'C:\\msys64\\usr\\bin',
-          'C:\\msys64\\bin',
-          'C:\\cygwin64\\bin',
-          'C:\\cygwin\\bin',
-          'C:\\MinGW\\bin',
-          'C:\\MinGW\\msys\\1.0\\bin'
-        ];
-        for (const location of locationsToCheck) {
-          const potentialPath = path.join(location, 'bash.exe');
-          if (fs.existsSync(potentialPath)) {
-            cmd = potentialPath;
-            args = [found, ...process.argv.slice(2)];
-            break;
-          }
-        }
-      }
-    } else {
-      cmd = resolvedOrNull || interpreter;
-      args = [found, ...process.argv.slice(2)];
-    }
-  } else {
-    cmd = found;
-    args = process.argv.slice(2);
-  }
-} else {
-  cmd = found;
-  args = process.argv.slice(2);
-}
+var hasRequiredBinaryExecutor;
 
-console.log(
-  `Executing: ${path.isAbsolute(cmd) ? path.relative(process.cwd(), cmd) : cmd} ${args
-    .map((f) => {
-      if (path.isAbsolute(f)) return path.relative(process.cwd(), f);
-      return f;
-    })
-    .join(' ')}`
-);
+function requireBinaryExecutor () {
+	if (hasRequiredBinaryExecutor) return binaryExecutor$1;
+	hasRequiredBinaryExecutor = 1;
+	/**
+	 * Built-in Node.js modules:
+	 *
+	 * - child_process:
+	 *   Used to launch external scripts/programs.
+	 *
+	 * - path:
+	 *   Safely handles file paths across operating systems.
+	 *
+	 * - fs:
+	 *   Used to check whether files exist.
+	 */
+	const { spawnSync } = require$$0;
+	const path = require$$1;
+	const fs = require$$2;
+	const which = require$$3;
+	const { isWindows } = require$$4;
 
-/**
- * Execute the selected script synchronously.
- *
- * stdio: "inherit"
- *   Shares the current terminal with the child process,
- *   so stdout/stderr/input behave normally.
- *
- * spawnSync waits until the child process exits.
- */
-const result = spawnSync(cmd, args, {
-  stdio: 'inherit'
-});
+	/**
+	 * __dirname
+	 *   Absolute directory path of this launcher script.
+	 *
+	 * __filename
+	 *   Absolute path of this launcher file itself.
+	 *
+	 * base
+	 *   Filename without extension.
+	 *
+	 * Example:
+	 *   File = "/tools/mytool.js"
+	 *
+	 *   binDir = "/tools"
+	 *   base   = "mytool"
+	 */
+	const binDir = __dirname;
+	const base = path.basename(__filename, path.extname(__filename));
 
-/**
- * Exit using the same exit code
- * returned by the child process.
- *
- * If result.status is null/undefined,
- * default to exit code 1.
- */
-process.exit(result.status ?? 1);
+	/**
+	 * Determine which script extensions to search for
+	 * based on the current operating system.
+	 *
+	 * Windows:
+	 *   .cmd
+	 *   .bat
+	 *   .ps1
+	 *   .vbs
+	 *
+	 * Linux/macOS:
+	 *   .sh
+	 *   executable file without extension
+	 */
+	const candidates = process.platform === 'win32' ? ['.cmd', '.bat', '.ps1', '.vbs'] : ['.sh', ''];
+
+	/**
+	 * Search for the first matching script
+	 * in the same directory as this launcher.
+	 *
+	 * Example:
+	 *   If base = "mytool"
+	 *
+	 *   Windows checks:
+	 *     mytool.cmd
+	 *     mytool.bat
+	 *     mytool.ps1
+	 *     mytool.vbs
+	 *
+	 *   Linux/macOS checks:
+	 *     mytool.sh
+	 *     mytool
+	 */
+	let found = null;
+
+	for (const ext of candidates) {
+	  const script = path.join(binDir, base + ext);
+	  const exists = fs.existsSync(script);
+	  // console.log(`Checking for ${script}: ${exists ? 'found' : 'not found'}`);
+	  if (exists) {
+	    found = script;
+	    break;
+	  }
+	}
+
+	/**
+	 * If no matching script was found,
+	 * try check if `bash` is available and if so, check for a .sh script.
+	 */
+	if (!found) {
+	  try {
+	    spawnSync('bash', ['--version'], { stdio: 'ignore' });
+	    const bashScript = [path.join(binDir, base), path.join(binDir, base + '.sh')].find((script) =>
+	      fs.existsSync(script)
+	    );
+	    if (bashScript) {
+	      found = bashScript;
+	    }
+	  } catch {
+	    // bash is not available, do nothing
+	  }
+	}
+
+	/**
+	 * If no matching script was found,
+	 * print an error and exit with failure code 1.
+	 */
+	if (!found) {
+	  console.error(`No script found for ${base} in ${binDir}`);
+	  process.exit(1);
+	}
+
+	/**
+	 * Detect special script types
+	 * that require a shell/interpreter.
+	 */
+	const isPs1 = found.endsWith('.ps1');
+	const isCmd = found.endsWith('.cmd');
+	const isUnixShell = found.endsWith('.sh') || path.extname(found) === '';
+
+	/**
+	 * cmd
+	 *   The executable program to launch.
+	 *
+	 * args
+	 *   Arguments passed to the executable.
+	 */
+	let cmd, args;
+
+	/**
+	 * PowerShell scripts:
+	 *
+	 * Run through powershell.exe because .ps1 files
+	 * are not directly executable like binaries.
+	 *
+	 * Flags:
+	 *   -NoProfile
+	 *     Prevent loading user profile scripts.
+	 *
+	 *   -ExecutionPolicy Bypass
+	 *     Allow script execution even if policy blocks it.
+	 *
+	 *   -File
+	 *     Specifies the script to execute.
+	 *
+	 * process.argv.slice(2)
+	 *   Forward all user-provided command-line arguments.
+	 */
+	if (isPs1) {
+	  cmd = 'powershell.exe';
+
+	  args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', found, ...process.argv.slice(2)];
+
+	  /**
+	   * CMD batch files:
+	   *
+	   * Run through cmd.exe using:
+	   *   /c
+	   * which means:
+	   *   "execute command and terminate"
+	   */
+	} else if (isCmd) {
+	  cmd = 'cmd.exe';
+
+	  args = ['/c', found, ...process.argv.slice(2)];
+
+	  /**
+	   * Other scripts:
+	   *
+	   * Usually:
+	   *   - shell scripts (.sh)
+	   *   - executable binaries
+	   *
+	   * These can be executed directly.
+	   */
+	} else if (isUnixShell) {
+	  // Capture shebang scripts (no extension) and .sh scripts
+	  const shebang = fs.readFileSync(found, 'utf8').split('\n')[0].trim();
+	  const interpreter = shebang.startsWith('#!')
+	    ? shebang
+	        .slice(2)
+	        .trim()
+	        .replace(/^\/usr\/bin\/env\s+/, '')
+	        .replace(/^\/bin\/env\s+/, '')
+	        .replace(/^\/usr\/bin\//, '')
+	        .replace(/^\/bin\//, '')
+	    : null;
+
+	  if (interpreter) {
+	    const resolvedOrNull = which.sync(interpreter, { nothrow: true });
+	    if (!resolvedOrNull) {
+	      if (['bash', 'sh'].includes(interpreter) && isWindows()) {
+	        const locationsToCheck = [
+	          'C:\\Program Files\\Git\\usr\\bin',
+	          'C:\\Program Files\\Git\\bin',
+	          'C:\\Program Files (x86)\\Git\\usr\\bin',
+	          'C:\\msys64\\usr\\bin',
+	          'C:\\msys64\\bin',
+	          'C:\\cygwin64\\bin',
+	          'C:\\cygwin\\bin',
+	          'C:\\MinGW\\bin',
+	          'C:\\MinGW\\msys\\1.0\\bin'
+	        ];
+	        for (const location of locationsToCheck) {
+	          const potentialPath = path.join(location, 'bash.exe');
+	          if (fs.existsSync(potentialPath)) {
+	            cmd = potentialPath;
+	            args = [found, ...process.argv.slice(2)];
+	            break;
+	          }
+	        }
+	      }
+	    } else {
+	      cmd = resolvedOrNull || interpreter;
+	      args = [found, ...process.argv.slice(2)];
+	    }
+	  } else {
+	    cmd = found;
+	    args = process.argv.slice(2);
+	  }
+	} else {
+	  cmd = found;
+	  args = process.argv.slice(2);
+	}
+
+	console.log(
+	  `Executing: ${path.isAbsolute(cmd) ? path.relative(process.cwd(), cmd) : cmd} ${args
+	    .map((f) => {
+	      if (path.isAbsolute(f)) return path.relative(process.cwd(), f);
+	      return f;
+	    })
+	    .join(' ')}`
+	);
+
+	/**
+	 * Execute the selected script synchronously.
+	 *
+	 * stdio: "inherit"
+	 *   Shares the current terminal with the child process,
+	 *   so stdout/stderr/input behave normally.
+	 *
+	 * spawnSync waits until the child process exits.
+	 */
+	const result = spawnSync(cmd, args, {
+	  stdio: 'inherit'
+	});
+
+	/**
+	 * Exit using the same exit code
+	 * returned by the child process.
+	 *
+	 * If result.status is null/undefined,
+	 * default to exit code 1.
+	 */
+	process.exit(result.status ?? 1);
+	return binaryExecutor$1;
+}
+
+var binaryExecutorExports = requireBinaryExecutor();
+var binaryExecutor = /*@__PURE__*/getDefaultExportFromCjs(binaryExecutorExports);
+
+module.exports = binaryExecutor;
+//# sourceMappingURL=binary-executor.cjs.map