tingly-box-bundle 0.0.37-dev

package/bin.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+/**
+ * Tingly-Box Bundle Package
+ *
+ * This package has platform-specific packages as optionalDependencies.
+ * npm will automatically install the correct platform package when you install this.
+ *
+ * The platform package (@tingly-box/darwin-arm64, etc.) contains the pre-built binary.
+ * If the platform package is installed, we use it directly.
+ * Otherwise, we fall back to downloading from GitHub (same as CLI).
+ */
+
+import { run } from "@tingly-box/shared/cli.js";
+
+// Set release tag from package.json or environment
+const releaseTag = process.env.TINGLY_RELEASE_TAG || "latest";
+
+run("bundle", { releaseTag }).catch((error) => {
+  console.error(`❌ Fatal error: ${error.message}`);
+  process.exit(1);
+});

package/lib/cache.js

@@ -0,0 +1,49 @@
+/**
+ * Cache directory management
+ */
+
+import { join } from "path";
+import { homedir } from "os";
+
+/**
+ * Get cache directory
+ * @param {string} flavor - Flavor name (cli, gui, bundle)
+ * @param {string} version - Version string
+ * @returns {string} Cache directory path
+ */
+export function getCacheDir(flavor, version) {
+  let baseDir;
+
+  if (process.platform === "linux") {
+    baseDir = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+  } else if (process.platform === "darwin") {
+    baseDir = join(homedir(), "Library", "Caches");
+  } else if (process.platform === "win32") {
+    baseDir = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+  }
+
+  return join(baseDir, "tingly-box", flavor, version);
+}
+
+/**
+ * Get binary cache path
+ * @param {string} flavor - Flavor name
+ * @param {string} version - Version string
+ * @param {string} binaryName - Binary name
+ * @returns {string} Binary cache path
+ */
+export function getBinaryCachePath(flavor, version, binaryName) {
+  const cacheDir = getCacheDir(flavor, version);
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  return join(cacheDir, binaryName + suffix);
+}
+
+/**
+ * Get app bundle cache path (macOS GUI)
+ * @param {string} version - Version string
+ * @returns {string} App bundle path
+ */
+export function getAppCachePath(version) {
+  const cacheDir = getCacheDir("gui", version);
+  return join(cacheDir, "TinglyBox.app");
+}

package/lib/cli.js

@@ -0,0 +1,175 @@
+/**
+ * Main CLI runner - shared logic for all flavor packages
+ */
+
+import { existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createReadStream } from "fs";
+import { mkdir } from "fs/promises";
+import { pipeline } from "stream/promises";
+import unzipper from "unzipper";
+
+import {
+  getPlatformInfo,
+  getPlatformIdentifier,
+  getPlatformPackageName,
+  getBinaryName,
+  isPlatformSupported,
+} from "./platform.js";
+import {
+  getCacheDir,
+  getBinaryCachePath,
+  getAppCachePath,
+} from "./cache.js";
+import {
+  downloadAndExtractZip,
+  findBinary,
+  ensureExecutable,
+} from "./downloader.js";
+import {
+  executeBinary,
+  launchApp,
+  ensureAppExecutable,
+} from "./executor.js";
+import {
+  getFlavorConfig,
+  getReleaseBranch,
+  getBaseUrl,
+  parseTransportVersion,
+} from "./config.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Check if platform-specific package is installed
+ * @returns {boolean}
+ */
+async function isPlatformPackageInstalled() {
+  try {
+    const pkgName = getPlatformPackageName();
+    const pkgPath = join(process.cwd(), "node_modules", pkgName);
+    return existsSync(pkgPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get binary from platform-specific package
+ * @returns {string|null} Binary path or null
+ */
+async function getPlatformPackageBinary() {
+  try {
+    const pkgName = getPlatformPackageName();
+    const pkgPath = join(process.cwd(), "node_modules", pkgName);
+    const binaryName = getBinaryName();
+    const binaryPath = join(pkgPath, binaryName);
+
+    if (existsSync(binaryPath)) {
+      return binaryPath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Run CLI for a flavor
+ * @param {string} flavor - Flavor name (cli, gui, bundle)
+ * @param {Object} options - Options
+ * @param {string} [options.releaseTag] - Override release tag
+ * @param {string} [options.zipDir] - Local zip directory (for bundle)
+ */
+export async function run(flavor, options = {}) {
+  const config = getFlavorConfig(flavor);
+  const platformInfo = getPlatformInfo();
+  const { version, remainingArgs } = parseTransportVersion(process.argv.slice(2));
+
+  // Use provided release tag or default
+  const releaseTag = options.releaseTag || getReleaseBranch();
+
+  // Validate platform support
+  if (!isPlatformSupported(config.platforms)) {
+    console.error(`\n❌ This package does not support ${platformInfo.platform}`);
+    console.error(`┌─ Status:`);
+    console.error(`│  Supported platforms: ${config.platforms.join(", ")}`);
+    console.error(`│  Your platform: ${platformInfo.platform} (${platformInfo.arch})`);
+    console.error(`└─ Try: npx tingly-box ${remainingArgs.join(" ")}`);
+    process.exit(1);
+  }
+
+  // Try platform-specific package first
+  const platformBinary = await getPlatformPackageBinary();
+  if (platformBinary) {
+    console.log(`✅ Using platform package: ${getPlatformPackageName()}`);
+    executeBinary(platformBinary, remainingArgs, config.defaultArgs);
+    return;
+  }
+
+  // Otherwise, use remote download or local bundle
+  const cacheDir = getCacheDir(flavor, releaseTag);
+  mkdirSync(cacheDir, { recursive: true });
+
+  if (flavor === "gui") {
+    await runGui(releaseTag, remainingArgs);
+  } else if (flavor === "bundle" || options.zipDir) {
+    await runBundle(releaseTag, remainingArgs, options.zipDir);
+  } else {
+    await runCli(releaseTag, remainingArgs, config);
+  }
+}
+
+/**
+ * Run CLI flavor
+ */
+async function runCli(version, args, config) {
+  const platformInfo = getPlatformInfo();
+  const cacheDir = getCacheDir("cli", version);
+  const binaryName = getBinaryName(config.binaryName);
+  const binaryPath = getBinaryCachePath("cli", version, config.binaryName);
+
+  if (!existsSync(binaryPath)) {
+    const zipFileName = `${config.binaryName}-${platformInfo.platformDir}-${platformInfo.archDir}.zip`;
+    const downloadUrl = `${getBaseUrl()}${version}/${zipFileName}`;
+    await downloadAndExtractZip(downloadUrl, cacheDir, "Downloading binary");
+    ensureExecutable(binaryPath);
+    console.log(`✅ Downloaded to ${binaryPath}`);
+  }
+
+  executeBinary(binaryPath, args, config.defaultArgs);
+}
+
+/**
+ * Run GUI flavor
+ */
+async function runGui(version, args) {
+  const cacheDir = getCacheDir("gui", version);
+  const appPath = getAppCachePath(version);
+
+  if (!existsSync(appPath)) {
+    const platformInfo = getPlatformInfo();
+    const zipFileName = `tingly-box-gui-${platformInfo.platformDir}-${platformInfo.archDir}.zip`;
+    const downloadUrl = `${getBaseUrl()}${version}/${zipFileName}`;
+    await downloadAndExtractZip(downloadUrl, cacheDir, "Downloading GUI");
+    ensureAppExecutable(appPath);
+    console.log(`✅ Downloaded to ${appPath}`);
+  }
+
+  launchApp(appPath);
+}
+
+/**
+ * Run Bundle flavor
+ * Bundle is just a router - it tries to use platform package first,
+ * then falls back to GitHub download like CLI
+ */
+async function runBundle(version, args, localZipDir) {
+  // Bundle = CLI with better defaults for platform packages
+  // The platform package is installed as optionalDependency
+  await runCli(version, args, getFlavorConfig("bundle"));
+}
+
+export default { run };

package/lib/config.js

@@ -0,0 +1,122 @@
+/**
+ * Configuration management
+ */
+
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Load flavor configurations
+let flavorsConfig = null;
+
+try {
+  const flavorsPath = join(__dirname, "..", "flavors");
+  const cliConfig = JSON.parse(readFileSync(join(flavorsPath, "cli.json"), "utf8"));
+  const guiConfig = JSON.parse(readFileSync(join(flavorsPath, "gui.json"), "utf8"));
+  const bundleConfig = JSON.parse(readFileSync(join(flavorsPath, "bundle.json"), "utf8"));
+
+  flavorsConfig = {
+    cli: cliConfig,
+    gui: guiConfig,
+    bundle: bundleConfig,
+  };
+} catch (error) {
+  // Fallback configurations
+  flavorsConfig = {
+    cli: {
+      binaryName: "tingly-box",
+      platforms: ["darwin", "linux", "win32"],
+      defaultArgs: ["restart", "--daemon"],
+      action: "execute",
+    },
+    gui: {
+      binaryName: "tingly-box-gui",
+      platforms: ["darwin"],
+      defaultArgs: [],
+      action: "launch",
+    },
+    bundle: {
+      binaryName: "tingly-box",
+      platforms: ["darwin", "linux", "win32"],
+      defaultArgs: ["restart", "--daemon"],
+      action: "execute",
+    },
+  };
+}
+
+/**
+ * Get flavor configuration
+ * @param {string} flavor - Flavor name (cli, gui, bundle)
+ * @returns {Object} Flavor configuration
+ */
+export function getFlavorConfig(flavor) {
+  return flavorsConfig[flavor];
+}
+
+/**
+ * Get release branch/tag
+ * @returns {string} Release branch (e.g., "latest" or "v1.6.1")
+ */
+export function getReleaseBranch() {
+  // This can be replaced during build
+  return process.env.TINGLY_RELEASE_BRANCH || "latest";
+}
+
+/**
+ * Get base download URL
+ * @returns {string} Base URL for downloads
+ */
+export function getBaseUrl() {
+  return "https://github.com/tingly-dev/tingly-box/releases/download/";
+}
+
+/**
+ * Parse transport version from arguments
+ * @param {string[]} args - Command line arguments
+ * @returns {Object} { version, remainingArgs }
+ */
+export function parseTransportVersion(args) {
+  let transportVersion = "latest";
+  const remainingArgs = [...args];
+
+  const versionArgIndex = args.findIndex((arg) => arg.startsWith("--transport-version"));
+
+  if (versionArgIndex !== -1) {
+    const versionArg = args[versionArgIndex];
+
+    if (versionArg.includes("=")) {
+      transportVersion = versionArg.split("=")[1];
+      remainingArgs.splice(versionArgIndex, 1);
+    } else if (versionArgIndex + 1 < args.length) {
+      transportVersion = args[versionArgIndex + 1];
+      remainingArgs.splice(versionArgIndex, 2);
+    }
+  }
+
+  return {
+    version: validateVersion(transportVersion),
+    remainingArgs,
+  };
+}
+
+/**
+ * Validate version format
+ * @param {string} version - Version string
+ * @returns {string} Validated version
+ */
+export function validateVersion(version) {
+  if (version === "latest") {
+    return version;
+  }
+
+  const versionRegex = /^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+  if (versionRegex.test(version)) {
+    return version;
+  }
+
+  console.error(`Invalid version format: ${version}`);
+  console.error(`Version must be either "latest" or "v{x.x.x}"`);
+  throw new Error(`Invalid version: ${version}`);
+}

package/lib/downloader.js

@@ -0,0 +1,156 @@
+/**
+ * Download and extraction utilities
+ */
+
+import { chmodSync, mkdirSync, createWriteStream } from "fs";
+import { join } from "path";
+import { Readable } from "stream";
+import { ProxyAgent } from "undici";
+import unzipper from "unzipper";
+
+/**
+ * Get proxy dispatcher
+ * @returns {ProxyAgent|undefined}
+ */
+export function getDispatcher() {
+  const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+  const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+  const proxyUri = httpsProxy || httpProxy;
+  return proxyUri ? new ProxyAgent(proxyUri) : undefined;
+}
+
+/**
+ * Download and extract a ZIP file
+ * @param {string} url - Download URL
+ * @param {string} extractDir - Destination directory
+ * @param {string} [progressPrefix] - Prefix for progress messages
+ */
+export async function downloadAndExtractZip(url, extractDir, progressPrefix = "Downloading") {
+  const dispatcher = getDispatcher();
+  const fetchOptions = {
+    redirect: "follow",
+    headers: { "User-Agent": "tingly-box-npx" },
+  };
+  if (dispatcher) {
+    fetchOptions.dispatcher = dispatcher;
+  }
+
+  const res = await fetch(url, fetchOptions);
+
+  if (!res.ok) {
+    console.error(`❌ Download failed: ${res.status} ${res.statusText}`);
+    console.error(`   URL: ${url}`);
+    throw new Error(`Download failed: ${res.status}`);
+  }
+
+  const contentLength = res.headers.get("content-length");
+  const totalSize = contentLength ? parseInt(contentLength, 10) : null;
+  let downloadedSize = 0;
+
+  const nodeStream = Readable.fromWeb(res.body);
+  const chunks = [];
+
+  for await (const chunk of nodeStream) {
+    chunks.push(chunk);
+    downloadedSize += chunk.length;
+    if (totalSize) {
+      const progress = ((downloadedSize / totalSize) * 100).toFixed(1);
+      process.stdout.write(`\r⏱️ ${progressPrefix}: ${progress}% (${formatBytes(downloadedSize)}/${formatBytes(totalSize)})`);
+    } else {
+      process.stdout.write(`\r⏱️ ${progressPrefix}: ${formatBytes(downloadedSize)}`);
+    }
+  }
+
+  const zipBuffer = Buffer.concat(chunks);
+
+  await extractZipBuffer(zipBuffer, extractDir);
+}
+
+/**
+ * Extract ZIP buffer to directory
+ * @param {Buffer} zipBuffer - ZIP data
+ * @param {string} extractDir - Destination directory
+ */
+export async function extractZipBuffer(zipBuffer, extractDir) {
+  console.log(`\n📦 Extracting to ${extractDir}...`);
+
+  const directory = await unzipper.Open.buffer(zipBuffer);
+
+  for (const file of directory.files) {
+    // Skip metadata
+    if (file.type === "Directory" || file.path.startsWith("__MACOSX/") || file.path.includes(".DS_Store")) {
+      continue;
+    }
+
+    const filePath = join(extractDir, file.path);
+    const pathParts = file.path.split("/");
+    pathParts.pop();
+    const fileDir = pathParts.length > 0 ? join(extractDir, ...pathParts) : extractDir;
+
+    // Create parent directory if needed
+    if (fileDir !== extractDir) {
+      mkdirSync(fileDir, { recursive: true });
+    }
+
+    // Extract file
+    const content = await file.buffer();
+    const fileStream = createWriteStream(filePath);
+    await new Promise((resolve, reject) => {
+      fileStream.write(content, (err) => {
+        if (err) reject(err);
+        else {
+          fileStream.end();
+          resolve();
+        }
+      });
+    });
+
+    // Set permissions
+    if (process.platform !== "win32" && file.unixPermissions && file.unixPermissions > 0) {
+      chmodSync(filePath, file.unixPermissions);
+    }
+  }
+
+  console.log(`✅ Extracted successfully`);
+}
+
+/**
+ * Recursively find binary in directory
+ * @param {string} dir - Directory to search
+ * @param {string} binaryName - Binary name to find
+ * @returns {string|null} Binary path or null
+ */
+export function findBinary(dir, binaryName) {
+  const { readdirSync, statSync } = await import("fs");
+  const entries = readdirSync(dir);
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (stat.isFile() && entry === binaryName) {
+        return fullPath;
+      }
+      if (stat.isDirectory()) {
+        const found = findBinary(fullPath, binaryName);
+        if (found) return found;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Format bytes to human-readable string
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Formatted string
+ */
+export function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}

package/lib/executor.js

@@ -0,0 +1,122 @@
+/**
+ * Binary and app execution
+ */
+
+import { execFileSync } from "child_process";
+import { existsSync, chmodSync } from "fs";
+import { join } from "path";
+
+/**
+ * Execute binary with arguments
+ * @param {string} binaryPath - Path to binary
+ * @param {string[]} args - Command line arguments
+ * @param {string[]} defaultArgs - Default arguments if none provided
+ */
+export function executeBinary(binaryPath, args = [], defaultArgs = []) {
+  console.log(`🔍 Executing: ${binaryPath}`);
+
+  const argsToUse = args.length > 0 ? args : defaultArgs;
+
+  try {
+    execFileSync(binaryPath, argsToUse, {
+      stdio: "inherit",
+      encoding: "utf8",
+    });
+  } catch (execError) {
+    handleExecutionError(execError, binaryPath);
+  }
+}
+
+/**
+ * Launch macOS app bundle
+ * @param {string} appPath - Path to .app bundle
+ */
+export function launchApp(appPath) {
+  console.log(`🔍 Launching: ${appPath}`);
+
+  try {
+    // Sign the app first
+    console.log(`🔐 Signing app...`);
+    execFileSync("codesign", ["--force", "--deep", "--sign", "-", appPath], {
+      stdio: "inherit",
+    });
+
+    console.log(`🚀 Launching app...`);
+    execFileSync("open", ["-a", appPath], {
+      stdio: "inherit",
+    });
+    console.log(`✅ App launched!`);
+  } catch (execError) {
+    handleExecutionError(execError, appPath);
+  }
+}
+
+/**
+ * Handle execution errors
+ * @param {Error} execError - Execution error
+ * @param {string} binaryPath - Binary or app path
+ */
+function handleExecutionError(execError, binaryPath) {
+  console.error(`\n❌ Execution failed`);
+  console.error(`┌─ Error Details:`);
+  console.error(`│  Message: ${execError.message}`);
+
+  if (execError.code) {
+    console.error(`│  Code: ${execError.code}`);
+    switch (execError.code) {
+      case "ENOENT":
+        console.error(`│  └─ Binary not found at: ${binaryPath}`);
+        console.error(`│     Try clearing cache and reinstalling`);
+        break;
+      case "EACCES":
+        console.error(`│  └─ Permission denied`);
+        console.error(`│     Try: chmod +x "${binaryPath}"`);
+        break;
+      case "ETXTBSY":
+        console.error(`│  └─ Binary file is busy`);
+        break;
+    }
+  }
+
+  if (execError.status !== null && execError.status !== undefined) {
+    console.error(`│  Exit Code: ${execError.status}`);
+  }
+
+  if (execError.signal) {
+    console.error(`│  Signal: ${execError.signal}`);
+  }
+
+  console.error(`└─ Path: ${binaryPath}`);
+  console.error(`   Platform: ${process.platform} (${process.arch})`);
+
+  const exitCode = execError.status !== undefined ? execError.status : 1;
+  process.exit(exitCode);
+}
+
+/**
+ * Ensure binary is executable
+ * @param {string} binaryPath - Path to binary
+ */
+export function ensureExecutable(binaryPath) {
+  if (process.platform !== "win32" && existsSync(binaryPath)) {
+    try {
+      chmodSync(binaryPath, 0o755);
+    } catch (e) {
+      console.warn(`⚠️  Failed to set executable permission: ${e.message}`);
+    }
+  }
+}
+
+/**
+ * Ensure app bundle is properly signed and executable
+ * @param {string} appPath - Path to .app bundle
+ */
+export function ensureAppExecutable(appPath) {
+  if (!existsSync(appPath)) {
+    return;
+  }
+
+  // Ensure binary inside app is executable
+  const appBinaryPath = join(appPath, "Contents", "MacOS", "tingly-box");
+  ensureExecutable(appBinaryPath);
+}

package/lib/flavors/bundle.json

@@ -0,0 +1,6 @@
+{
+  "binaryName": "tingly-box",
+  "platforms": ["darwin", "linux", "win32"],
+  "defaultArgs": ["restart", "--daemon"],
+  "action": "execute"
+}

package/lib/flavors/cli.json

@@ -0,0 +1,6 @@
+{
+  "binaryName": "tingly-box",
+  "platforms": ["darwin", "linux", "win32"],
+  "defaultArgs": ["restart", "--daemon"],
+  "action": "execute"
+}

package/lib/flavors/gui.json

@@ -0,0 +1,6 @@
+{
+  "binaryName": "tingly-box-gui",
+  "platforms": ["darwin"],
+  "defaultArgs": [],
+  "action": "launch"
+}

package/lib/platform.js

@@ -0,0 +1,75 @@
+/**
+ * Platform detection and utilities
+ */
+
+/**
+ * Get platform information
+ * @returns {Object} Platform info
+ */
+export function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let platformDir;
+  let archDir;
+  let suffix = "";
+
+  if (platform === "darwin") {
+    platformDir = "macos";
+    if (arch === "arm64") archDir = "arm64";
+    else archDir = "amd64";
+  } else if (platform === "linux") {
+    platformDir = "linux";
+    if (arch === "x64") archDir = "amd64";
+    else if (arch === "arm64") archDir = "arm64";
+    else archDir = arch;
+  } else if (platform === "win32") {
+    platformDir = "windows";
+    if (arch === "x64") archDir = "amd64";
+    else if (arch === "ia32") archDir = "386";
+    else archDir = arch;
+    suffix = ".exe";
+  } else {
+    throw new Error(`Unsupported platform: ${platform}/${arch}`);
+  }
+
+  return { platform, arch, platformDir, archDir, suffix };
+}
+
+/**
+ * Get platform identifier for package naming
+ * @returns {string} Platform identifier (e.g., "darwin-arm64")
+ */
+export function getPlatformIdentifier() {
+  const info = getPlatformInfo();
+  const npmArch = info.arch === "x64" ? "amd64" : info.arch;
+  return `${info.platform}-${npmArch}`;
+}
+
+/**
+ * Get npm package name for platform
+ * @returns {string} Package name (e.g., "tingly-box-darwin")
+ */
+export function getPlatformPackageName() {
+  const info = getPlatformInfo();
+  return `tingly-box-${info.platform}`;
+}
+
+/**
+ * Get binary name for current platform
+ * @param {string} baseName - Base binary name
+ * @returns {string} Full binary name with extension
+ */
+export function getBinaryName(baseName = "tingly-box") {
+  return baseName + (process.platform === "win32" ? ".exe" : "");
+}
+
+/**
+ * Check if platform is supported
+ * @param {string[]} supportedPlatforms - List of supported platforms
+ * @returns {boolean}
+ */
+export function isPlatformSupported(supportedPlatforms) {
+  const info = getPlatformInfo();
+  return supportedPlatforms.includes(info.platform);
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "tingly-box-bundle",
+  "version": "0.0.37-dev",
+  "description": "Tingly-Box AI gateway CLI with bundled binaries (offline-ready)",
+  "keywords": [
+    "ai",
+    "gateway",
+    "openai",
+    "anthropic",
+    "claude",
+    "cli",
+    "tingly",
+    "offline"
+  ],
+  "homepage": "https://github.com/tingly-dev/tingly-box",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tingly-dev/tingly-box.git"
+  },
+  "license": "MPL-2.0",
+  "author": "Tingly Dev",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "tingly-box-bundle": "bin.js"
+  },
+  "type": "module",
+  "files": [
+    "bin.js",
+    "lib/"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "dependencies": {
+    "@tingly-box/shared": "workspace:*"
+  },
+  "optionalDependencies": {
+    "tingly-box-darwin": "^1.6.1",
+    "tingly-box-linux": "^1.6.1",
+    "tingly-box-win32": "^1.6.1"
+  }
+}