srcpack 0.1.1 → 0.1.2

package/README.md

@@ -5,7 +5,7 @@ Zero-config CLI for bundling code into LLM-optimized context files.
 ## Quick Start
 
 ```bash
-npx srcpack --init       # Create config interactively
+npx srcpack init         # Create config interactively
 npx srcpack              # Bundle all
 ```
 
@@ -143,7 +143,7 @@ export function utils() {
 npx srcpack              # Bundle all, upload if gdrive configured
 npx srcpack web api      # Bundle specific bundles only
 npx srcpack --dry-run    # Preview without writing files
-npx srcpack --init       # Interactive config setup
+npx srcpack init         # Interactive config setup
 ```
 
 ## API

package/dist/cli.js

@@ -2067,14 +2067,14 @@ var require_binary = __commonJS((exports, module) => {
     }
     return result;
   }
-  function isBinary(obj) {
+  function isBinary2(obj) {
     return Object.prototype.toString.call(obj) === "[object Uint8Array]";
   }
   module.exports = new Type("tag:yaml.org,2002:binary", {
     kind: "scalar",
     resolve: resolveYamlBinary,
     construct: constructYamlBinary,
-    predicate: isBinary,
+    predicate: isBinary2,
     represent: representYamlBinary
   });
 });
@@ -173852,6 +173852,15 @@ import { dirname as dirname3, join as join6 } from "path";
 var import_ignore = __toESM(require_ignore(), 1);
 import { join } from "path";
 var {Glob } = globalThis.Bun;
+var BINARY_CHECK_SIZE = 8192;
+async function isBinary(filePath) {
+  const file = Bun.file(filePath);
+  const size = file.size;
+  if (size === 0)
+    return false;
+  const chunk = await file.slice(0, Math.min(size, BINARY_CHECK_SIZE)).bytes();
+  return chunk.includes(0);
+}
 function normalizePatterns(config) {
   let patterns;
   if (typeof config === "string") {
@@ -173898,7 +173907,10 @@ async function resolvePatterns(config, cwd) {
     const glob = new Glob(pattern);
     for await (const match of glob.scan({ cwd, onlyFiles: true })) {
       if (!isExcluded(match, exclude) && !gitignore.ignores(match)) {
-        files.add(match);
+        const fullPath = join(cwd, match);
+        if (!await isBinary(fullPath)) {
+          files.add(match);
+        }
       }
     }
   }
@@ -187602,31 +187614,35 @@ import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join4 } from "path";
 
 // node_modules/oauth-callback/dist/index.js
-import process6 from "process";
-import { Buffer as Buffer2 } from "buffer";
+import process7 from "process";
 import path from "path";
 import { fileURLToPath } from "url";
-import { promisify as promisify5 } from "util";
-import childProcess from "child_process";
+import childProcess3 from "child_process";
 import fs5, { constants as fsConstants2 } from "fs/promises";
-import process22 from "process";
+import { promisify as promisify2 } from "util";
+import childProcess2 from "child_process";
 import fs4, { constants as fsConstants } from "fs/promises";
 import process3 from "process";
 import os from "os";
 import fs3 from "fs";
 import fs2 from "fs";
 import fs from "fs";
-import { promisify as promisify4 } from "util";
-import process5 from "process";
-import { execFile as execFile4 } from "child_process";
+import process22 from "process";
+import { Buffer as Buffer2 } from "buffer";
 import { promisify } from "util";
-import process32 from "process";
-import { execFile } from "child_process";
-import process4 from "process";
-import { promisify as promisify2 } from "util";
-import { execFile as execFile2, execFileSync } from "child_process";
+import childProcess from "child_process";
+import { promisify as promisify6 } from "util";
+import process5 from "process";
+import { execFile as execFile6 } from "child_process";
 import { promisify as promisify3 } from "util";
+import process32 from "process";
 import { execFile as execFile3 } from "child_process";
+import process4 from "process";
+import { promisify as promisify4 } from "util";
+import { execFile as execFile4, execFileSync } from "child_process";
+import { promisify as promisify5 } from "util";
+import { execFile as execFile5 } from "child_process";
+import process6 from "process";
 import * as fs6 from "fs/promises";
 import * as path2 from "path";
 import * as os2 from "os";
@@ -187695,6 +187711,45 @@ var isWsl = () => {
   }
 };
 var is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+var execFile = promisify(childProcess.execFile);
+var powerShellPath = () => `${process22.env.SYSTEMROOT || process22.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+executePowerShell.argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
+executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+var execFile2 = promisify2(childProcess2.execFile);
 var wslDrivesMountPoint = (() => {
   const defaultMountPoint = "/mnt/";
   let mountPoint;
@@ -187712,11 +187767,11 @@ var wslDrivesMountPoint = (() => {
       return defaultMountPoint;
     }
     const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
-    const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
-    if (!configMountPoint) {
+    const parsedMountPoint = parseMountPointFromConfig(configContent);
+    if (parsedMountPoint === undefined) {
       return defaultMountPoint;
     }
-    mountPoint = configMountPoint.groups.mountPoint.trim();
+    mountPoint = parsedMountPoint;
     mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
     return mountPoint;
   };
@@ -187725,11 +187780,36 @@ var powerShellPathFromWsl = async () => {
   const mountPoint = await wslDrivesMountPoint();
   return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
 };
-var powerShellPath = async () => {
-  if (is_wsl_default) {
-    return powerShellPathFromWsl();
+var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+};
+var convertWslPathToWindows = async (path3) => {
+  if (/^[a-z]+:\/\//i.test(path3)) {
+    return path3;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path3], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path3;
   }
-  return `${process22.env.SYSTEMROOT || process22.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
 };
 function defineLazyProperty(object2, propertyName, valueGetter) {
   const define = (value) => Object.defineProperty(object2, propertyName, { value, enumerable: true, writable: true });
@@ -187747,7 +187827,7 @@ function defineLazyProperty(object2, propertyName, valueGetter) {
   });
   return object2;
 }
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify3(execFile3);
 async function defaultBrowserId() {
   if (process32.platform !== "darwin") {
     throw new Error("macOS only");
@@ -187756,7 +187836,7 @@ async function defaultBrowserId() {
   const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
   return match?.groups.id ?? "com.apple.Safari";
 }
-var execFileAsync2 = promisify2(execFile2);
+var execFileAsync2 = promisify4(execFile4);
 async function runAppleScript(script, { humanReadableOutput = true } = {}) {
   if (process4.platform !== "darwin") {
     throw new Error("macOS only");
@@ -187769,18 +187849,26 @@ async function bundleName(bundleId) {
   return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
 tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
 }
-var execFileAsync3 = promisify3(execFile3);
+var execFileAsync3 = promisify5(execFile5);
 var windowsBrowserProgIds = {
-  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
-  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
   MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
-  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
-  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
   ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
   BraveHTML: { name: "Brave", id: "com.brave.Browser" },
   BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
-  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
+  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
 };
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
 
 class UnknownBrowserError extends Error {
 }
@@ -187802,7 +187890,7 @@ async function defaultBrowser(_execFileAsync = execFileAsync3) {
   }
   return browser;
 }
-var execFileAsync4 = promisify4(execFile4);
+var execFileAsync4 = promisify6(execFile6);
 var titleize = (string4) => string4.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 async function defaultBrowser2() {
   if (process5.platform === "darwin") {
@@ -187821,41 +187909,25 @@ async function defaultBrowser2() {
   }
   throw new Error("Only macOS, Linux, and Windows are supported");
 }
-var execFile5 = promisify5(childProcess.execFile);
-var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+var isInSsh = Boolean(process6.env.SSH_CONNECTION || process6.env.SSH_CLIENT || process6.env.SSH_TTY);
+var is_in_ssh_default = isInSsh;
+var fallbackAttemptSymbol = Symbol("fallbackAttempt");
+var __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
 var localXdgOpenPath = path.join(__dirname2, "xdg-open");
-var { platform, arch } = process6;
-async function getWindowsDefaultBrowserFromWsl() {
-  const powershellPath = await powerShellPath();
-  const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const encodedCommand = Buffer2.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile5(powershellPath, [
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand",
-    encodedCommand
-  ], { encoding: "utf8" });
-  const progId = stdout.trim();
-  const browserMap = {
-    ChromeHTML: "com.google.chrome",
-    BraveHTML: "com.brave.Browser",
-    MSEdgeHTM: "com.microsoft.edge",
-    FirefoxURL: "org.mozilla.firefox"
-  };
-  return browserMap[progId] ? { id: browserMap[progId] } : {};
-}
-var pTryEach = async (array2, mapper) => {
-  let latestError;
-  for (const item of array2) {
+var { platform, arch } = process7;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors3 = [];
+  for (const app of apps) {
     try {
-      return await mapper(item);
+      return await opener(app);
     } catch (error48) {
-      latestError = error48;
+      errors3.push(error48);
     }
   }
-  throw latestError;
+  throw new AggregateError(errors3, "Failed to open in all supported apps");
 };
 var baseOpen = async (options) => {
   options = {
@@ -187865,34 +187937,39 @@ var baseOpen = async (options) => {
     allowNonzeroExitCode: false,
     ...options
   };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
   if (Array.isArray(options.app)) {
-    return pTryEach(options.app, (singleApp) => baseOpen({
+    return tryEachApp(options.app, (singleApp) => baseOpen({
       ...options,
-      app: singleApp
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
     }));
   }
   let { name: app, arguments: appArguments = [] } = options.app ?? {};
   appArguments = [...appArguments];
   if (Array.isArray(app)) {
-    return pTryEach(app, (appName) => baseOpen({
+    return tryEachApp(app, (appName) => baseOpen({
       ...options,
       app: {
         name: appName,
         arguments: appArguments
-      }
+      },
+      [fallbackAttemptSymbol]: true
     }));
   }
   if (app === "browser" || app === "browserPrivate") {
     const ids = {
       "com.google.chrome": "chrome",
       "google-chrome.desktop": "chrome",
-      "com.brave.Browser": "brave",
+      "com.brave.browser": "brave",
       "org.mozilla.firefox": "firefox",
       "firefox.desktop": "firefox",
       "com.microsoft.msedge": "edge",
       "com.microsoft.edge": "edge",
       "com.microsoft.edgemac": "edge",
-      "microsoft-edge.desktop": "edge"
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
     };
     const flags = {
       chrome: "--incognito",
@@ -187900,10 +187977,20 @@ var baseOpen = async (options) => {
       firefox: "--private-window",
       edge: "--inPrivate"
     };
-    const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
     if (browser.id in ids) {
-      const browserName = ids[browser.id];
+      const browserName = ids[browser.id.toLowerCase()];
       if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
         appArguments.push(flags[browserName]);
       }
       return baseOpen({
@@ -187919,6 +188006,10 @@ var baseOpen = async (options) => {
   let command;
   const cliArguments = [];
   const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
   if (platform === "darwin") {
     command = "open";
     if (options.wait) {
@@ -187933,29 +188024,35 @@ var baseOpen = async (options) => {
     if (app) {
       cliArguments.push("-a", app);
     }
-  } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
-    command = await powerShellPath();
-    cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
     if (!is_wsl_default) {
       childProcessOptions.windowsVerbatimArguments = true;
     }
-    const encodedArguments = ["Start"];
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
     if (options.wait) {
       encodedArguments.push("-Wait");
     }
     if (app) {
-      encodedArguments.push(`"\`"${app}\`""`);
+      encodedArguments.push(executePowerShell.escapeArgument(app));
       if (options.target) {
         appArguments.push(options.target);
       }
     } else if (options.target) {
-      encodedArguments.push(`"${options.target}"`);
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
     }
     if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
       encodedArguments.push("-ArgumentList", appArguments.join(","));
     }
-    options.target = Buffer2.from(encodedArguments.join(" "), "utf16le").toString("base64");
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
   } else {
     if (app) {
       command = app;
@@ -187966,7 +188063,7 @@ var baseOpen = async (options) => {
         await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {}
-      const useSystemXdgOpen = process6.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      const useSystemXdgOpen = process7.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
       command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
     }
     if (appArguments.length > 0) {
@@ -187983,12 +188080,12 @@ var baseOpen = async (options) => {
   if (options.target) {
     cliArguments.push(options.target);
   }
-  const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
     return new Promise((resolve, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode > 0) {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
@@ -187996,8 +188093,30 @@ var baseOpen = async (options) => {
       });
     });
   }
+  if (isFallbackAttempt) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve(subprocess);
+        });
+      });
+    });
+  }
   subprocess.unref();
-  return subprocess;
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
 };
 var open = (target, options) => {
   if (typeof target !== "string") {
@@ -188018,7 +188137,7 @@ function detectArchBinary(binary) {
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
@@ -188027,11 +188146,14 @@ function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
   }
   return detectArchBinary(platformBinary);
 }
-var apps = {};
+var apps = {
+  browser: "browser",
+  browserPrivate: "browserPrivate"
+};
 defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
   darwin: "google chrome",
   win32: "chrome",
-  linux: ["google-chrome", "google-chrome-stable", "chromium"]
+  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
 }, {
   wsl: {
     ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
@@ -188062,8 +188184,9 @@ defineLazyProperty(apps, "edge", () => detectPlatformBinary({
 }, {
   wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
 }));
-defineLazyProperty(apps, "browser", () => "browser");
-defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+  darwin: "Safari"
+}));
 var open_default = open;
 
 class OAuthError extends Error {
@@ -188155,6 +188278,7 @@ class BaseCallbackServer {
   successHtml;
   errorHtml;
   onRequest;
+  callbackReceived = false;
   abortHandler;
   signal;
   setup(options) {
@@ -188180,6 +188304,7 @@ class BaseCallbackServer {
     for (const [key, value] of url2.searchParams)
       params[key] = value;
     listener.resolve(params);
+    this.callbackReceived = true;
     return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
       status: 200,
       headers: { "Content-Type": "text/html" }
@@ -188188,18 +188313,21 @@ class BaseCallbackServer {
   async waitForCallback(path22, timeout) {
     if (this.callbackListeners.has(path22))
       return Promise.reject(new Error(`A listener for the path "${path22}" is already active.`));
+    let timeoutId;
     try {
       return await Promise.race([
         new Promise((resolve, reject) => {
           this.callbackListeners.set(path22, { resolve, reject });
         }),
         new Promise((_, reject) => {
-          setTimeout(() => {
+          timeoutId = setTimeout(() => {
             reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path22}`));
           }, timeout);
         })
       ]);
     } finally {
+      if (timeoutId)
+        clearTimeout(timeoutId);
       this.callbackListeners.delete(path22);
     }
   }
@@ -188229,7 +188357,10 @@ class BunCallbackServer extends BaseCallbackServer {
   async stopServer() {
     if (!this.server)
       return;
-    this.server.stop();
+    if (this.callbackReceived) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    this.server.stop(true);
     this.server = undefined;
   }
 }
@@ -188279,6 +188410,7 @@ class NodeCallbackServer extends BaseCallbackServer {
   async stopServer() {
     if (!this.server)
       return;
+    this.server.closeAllConnections();
     return new Promise((resolve) => {
       this.server?.close(() => {
         this.server = undefined;
@@ -189356,10 +189488,12 @@ async function runInit() {
     }
   }
   const bundles = [];
+  const existingNames = new Set;
   while (true) {
-    const bundle = await promptBundle(bundles.length === 0);
+    const bundle = await promptBundle(bundles.length === 0, existingNames);
     if (!bundle)
       break;
+    existingNames.add(bundle.name);
     bundles.push(bundle);
     const another = await ye({
       message: "Add another bundle?",
@@ -189387,15 +189521,18 @@ async function runInit() {
   await addToGitignore(cwd, outDirValue);
   Se(`Created ${CONFIG_FILE}`);
 }
-async function promptBundle(isFirst) {
+async function promptBundle(isFirst, existingNames) {
   const name = await he({
     message: isFirst ? "Bundle name:" : "Next bundle name:",
     placeholder: "api",
     validate: (value) => {
       if (!value.trim())
         return "Name is required";
-      if (!/^[a-z][a-z0-9-]*$/i.test(value)) {
-        return "Use alphanumeric characters and hyphens";
+      if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+        return "Use lowercase alphanumeric characters and hyphens";
+      }
+      if (existingNames.has(value.trim())) {
+        return "Bundle name already exists";
       }
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "srcpack",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Zero-config CLI for bundling code into LLM-optimized context files",
   "keywords": [
     "llm",
@@ -51,8 +51,12 @@
     "build": "bun build ./src/cli.ts ./src/index.ts --outdir ./dist --target bun && tsc",
     "typecheck": "tsc -p tsconfig.check.json",
     "check": "tsc -p tsconfig.check.json",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
+    "test": "bun test tests/unit/ tests/e2e/",
+    "test:unit": "bun test tests/unit/",
+    "test:e2e": "bun test tests/e2e/",
+    "test:login": "bun test --env-file .env.local tests/manual/",
+    "test:all": "bun test --env-file .env.local tests/",
+    "test:watch": "bun test tests/unit/ tests/e2e/ --watch",
     "docs:dev": "vitepress dev",
     "docs:build": "vitepress build",
     "docs:preview": "vitepress preview",
@@ -62,7 +66,7 @@
     "@clack/prompts": "^0.11.0",
     "cosmiconfig": "^9.0.0",
     "ignore": "^7.0.5",
-    "oauth-callback": "^1.2.1",
+    "oauth-callback": "^1.2.5",
     "zod": "^4.3.5"
   },
   "devDependencies": {

package/src/bundle.ts

@@ -5,6 +5,18 @@ import { Glob } from "bun";
 import ignore, { type Ignore } from "ignore";
 import type { BundleConfigInput } from "./config.ts";
 
+// Binary file detection: check first 8KB for null bytes (same heuristic as git)
+const BINARY_CHECK_SIZE = 8192;
+
+async function isBinary(filePath: string): Promise<boolean> {
+  const file = Bun.file(filePath);
+  const size = file.size;
+  if (size === 0) return false;
+
+  const chunk = await file.slice(0, Math.min(size, BINARY_CHECK_SIZE)).bytes();
+  return chunk.includes(0);
+}
+
 export interface FileEntry {
   path: string; // Relative path from cwd
   lines: number; // Line count in source file
@@ -96,7 +108,10 @@ export async function resolvePatterns(
     const glob = new Glob(pattern);
     for await (const match of glob.scan({ cwd, onlyFiles: true })) {
       if (!isExcluded(match, exclude) && !gitignore.ignores(match)) {
-        files.add(match);
+        const fullPath = join(cwd, match);
+        if (!(await isBinary(fullPath))) {
+          files.add(match);
+        }
       }
     }
   }

package/src/init.ts

@@ -34,9 +34,11 @@ export async function runInit(): Promise<void> {
   const bundles: Bundle[] = [];
 
   // Collect bundles in a loop
+  const existingNames = new Set<string>();
   while (true) {
-    const bundle = await promptBundle(bundles.length === 0);
+    const bundle = await promptBundle(bundles.length === 0, existingNames);
     if (!bundle) break;
+    existingNames.add(bundle.name);
     bundles.push(bundle);
 
     const another = await p.confirm({
@@ -76,14 +78,20 @@ export async function runInit(): Promise<void> {
   p.outro(`Created ${CONFIG_FILE}`);
 }
 
-async function promptBundle(isFirst: boolean): Promise<Bundle | null> {
+async function promptBundle(
+  isFirst: boolean,
+  existingNames: Set<string>,
+): Promise<Bundle | null> {
   const name = await p.text({
     message: isFirst ? "Bundle name:" : "Next bundle name:",
     placeholder: "api",
     validate: (value) => {
       if (!value.trim()) return "Name is required";
-      if (!/^[a-z][a-z0-9-]*$/i.test(value)) {
-        return "Use alphanumeric characters and hyphens";
+      if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+        return "Use lowercase alphanumeric characters and hyphens";
+      }
+      if (existingNames.has(value.trim())) {
+        return "Bundle name already exists";
       }
     },
   });

package/dist/src/bundle.d.ts

@@ -1,37 +0,0 @@
-import type { BundleConfigInput } from "./config.ts";
-export interface FileEntry {
-    path: string;
-    lines: number;
-    startLine: number;
-    endLine: number;
-}
-export interface BundleResult {
-    content: string;
-    index: FileEntry[];
-}
-/**
- * Resolve bundle config to a list of file paths.
- * Respects .gitignore patterns in the working directory.
- */
-export declare function resolvePatterns(config: BundleConfigInput, cwd: string): Promise<string[]>;
-/**
- * Format the index header block.
- * Format designed for LLM context files (ChatGPT, Grok, Gemini):
- * - Numbered entries for cross-reference with file separators
- * - ASCII-only characters for broad compatibility
- * - Line locations that point to actual file content
- */
-export declare function formatIndex(index: FileEntry[]): string;
-export interface BundleOptions {
-    includeIndex?: boolean;
-}
-/**
- * Create a bundle from a list of files.
- * Line numbers in the index point to the first line of actual file content,
- * not to the separator line.
- */
-export declare function createBundle(files: string[], cwd: string, options?: BundleOptions): Promise<BundleResult>;
-/**
- * Bundle a single named bundle from config
- */
-export declare function bundleOne(name: string, config: BundleConfigInput, cwd: string): Promise<BundleResult>;

package/dist/src/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-export {};

package/dist/src/config.d.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-export declare function expandPath(p: string): string;
-declare const BundleConfigSchema: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodObject<{
-    include: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-    outfile: z.ZodOptional<z.ZodString>;
-    index: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>]>;
-declare const UploadConfigSchema: z.ZodObject<{
-    provider: z.ZodLiteral<"gdrive">;
-    folder: z.ZodOptional<z.ZodString>;
-    clientId: z.ZodString;
-    clientSecret: z.ZodString;
-}, z.core.$strip>;
-declare const ConfigSchema: z.ZodObject<{
-    outDir: z.ZodDefault<z.ZodString>;
-    upload: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-        provider: z.ZodLiteral<"gdrive">;
-        folder: z.ZodOptional<z.ZodString>;
-        clientId: z.ZodString;
-        clientSecret: z.ZodString;
-    }, z.core.$strip>, z.ZodArray<z.ZodObject<{
-        provider: z.ZodLiteral<"gdrive">;
-        folder: z.ZodOptional<z.ZodString>;
-        clientId: z.ZodString;
-        clientSecret: z.ZodString;
-    }, z.core.$strip>>]>>;
-    bundles: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodObject<{
-        include: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
-        outfile: z.ZodOptional<z.ZodString>;
-        index: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>]>>;
-}, z.core.$strip>;
-export type UploadConfig = z.infer<typeof UploadConfigSchema>;
-export type BundleConfig = z.infer<typeof BundleConfigSchema>;
-export type BundleConfigInput = z.input<typeof BundleConfigSchema>;
-export type Config = z.infer<typeof ConfigSchema>;
-export type ConfigInput = z.input<typeof ConfigSchema>;
-export declare function defineConfig(config: ConfigInput): ConfigInput;
-export declare class ConfigError extends Error {
-    constructor(message: string);
-}
-export declare function parseConfig(value: unknown): Config;
-export declare function loadConfig(searchFrom?: string): Promise<Config | null>;
-export declare function loadConfigFromFile(filepath: string): Promise<Config | null>;
-export {};

package/dist/src/gdrive.d.ts

@@ -1,33 +0,0 @@
-import { OAuthError } from "oauth-callback";
-import type { UploadConfig } from "./config.ts";
-export interface Tokens {
-    access_token: string;
-    refresh_token?: string;
-    expires_at?: number;
-    token_type: string;
-    scope: string;
-}
-/**
- * Loads stored tokens from disk.
- * Returns null if no tokens exist or they cannot be read.
- */
-export declare function loadTokens(): Promise<Tokens | null>;
-/**
- * Removes stored tokens from disk.
- */
-export declare function clearTokens(): Promise<void>;
-/**
- * Gets valid tokens, refreshing if necessary.
- * Returns null if no tokens exist or refresh fails.
- */
-export declare function getValidTokens(config: UploadConfig): Promise<Tokens | null>;
-/**
- * Performs OAuth login flow - opens browser for user consent.
- * Stores tokens on success for future use.
- */
-export declare function login(config: UploadConfig): Promise<Tokens>;
-/**
- * Ensures we have valid tokens - loads existing or triggers login.
- */
-export declare function ensureAuthenticated(config: UploadConfig): Promise<Tokens>;
-export { OAuthError };

package/dist/src/index.d.ts

@@ -1,2 +0,0 @@
-export { defineConfig, loadConfig, loadConfigFromFile } from "./config.ts";
-export type { Config, BundleConfig } from "./config.ts";

package/dist/src/init.d.ts

@@ -1 +0,0 @@
-export declare function runInit(): Promise<void>;

package/dist/tests/bundle.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/cli.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/config.test.d.ts

@@ -1 +0,0 @@
-export {};