tmpbox.me 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TmpBox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,222 @@
+# tmpbox.me
+
+Official TmpBox.me uploader SDK and CLI for Node.js.
+
+- No account required for guest uploads
+- Guest limit: **100MB per file**
+- Logged-in user limit: **500MB per file**
+- Uploads **4 chunks at the same time** by default
+- Supports CommonJS, ES Module, TypeScript types, and CLI
+
+## Installation
+
+```bash
+npm install tmpbox
+```
+
+Node.js 18 or newer is required.
+
+## Quick start as guest
+
+No username, password, or token is required.
+
+### CommonJS
+
+```js
+const { uploadFile } = require("tmpbox");
+
+const result = await uploadFile("./video.mp4");
+console.log(result.fullUrl);
+```
+
+### ES Module
+
+```js
+import { uploadFile } from "tmpbox";
+
+const result = await uploadFile("./video.mp4");
+console.log(result.fullUrl);
+```
+
+Guest uploads are limited to **100MB per file**.
+
+## Login with username and password
+
+Use username and password when you need the **500MB per file** user limit.
+
+```js
+import { uploadFile } from "tmpbox";
+
+const result = await uploadFile("./large-video.mp4", {
+  username: "your_username",
+  password: "your_password",
+});
+
+console.log(result.fullUrl);
+```
+
+You can also use an existing token:
+
+```js
+import { uploadFile } from "tmpbox";
+
+const result = await uploadFile("./large-video.mp4", {
+  token: "YOUR_TOKEN",
+});
+```
+
+## Upload progress
+
+```js
+import { uploadFile } from "tmpbox";
+
+const result = await uploadFile("./file.zip", {
+  onProgress(state) {
+    console.log(state.status, state.progress);
+  },
+});
+
+console.log(result.fullUrl);
+```
+
+## Chunk concurrency
+
+By default, the SDK uploads **4 chunks at once**.
+
+```js
+await uploadFile("./file.zip", {
+  chunkConcurrency: 4,
+});
+```
+
+## Upload multiple files
+
+```js
+import { uploadFiles } from "tmpbox";
+
+const results = await uploadFiles([
+  "./image.png",
+  "./video.mp4",
+  "./archive.zip",
+]);
+
+console.log(results.map((item) => item.fullUrl));
+```
+
+## CLI
+
+### Guest upload
+
+```bash
+tmpbox-upload ./video.mp4
+```
+
+### User upload
+
+```bash
+tmpbox-upload ./video.mp4 -u your_username -p your_password
+```
+
+### Upload with token
+
+```bash
+tmpbox-upload ./video.mp4 -t "$TMPBOX_TOKEN"
+```
+
+### Upload multiple files
+
+```bash
+tmpbox-upload ./a.zip ./b.pdf ./c.mp4
+```
+
+### JSON output
+
+```bash
+tmpbox-upload ./video.mp4 --json
+```
+
+### Change chunk concurrency
+
+```bash
+tmpbox-upload ./video.mp4 --chunk-concurrency 4
+```
+
+## Environment variables
+
+The CLI and SDK can read these automatically:
+
+```bash
+TMPBOX_USERNAME=your_username
+TMPBOX_PASSWORD=your_password
+```
+
+or:
+
+```bash
+TMPBOX_TOKEN=your_token
+```
+
+Legacy token environment variables are also supported:
+
+```bash
+FILESTORAGE_TOKEN=your_token
+UPLOAD_TOKEN=your_token
+```
+
+If no account or token is provided, upload runs in guest mode.
+
+## API
+
+### `uploadFile(filePath, options?)`
+
+Uploads one file.
+
+```ts
+uploadFile(filePath: string, options?: UploadOptions): Promise<UploadResult>
+```
+
+### `uploadFiles(filePaths, options?)`
+
+Uploads multiple files one by one.
+
+```ts
+uploadFiles(filePaths: string[], options?: UploadOptions): Promise<UploadResult[]>
+```
+
+### `login(username, password)`
+
+Logs in and returns an auth token.
+
+```ts
+login(username: string, password: string): Promise<LoginResult>
+```
+
+## Options
+
+```ts
+interface UploadOptions {
+  token?: string;
+  username?: string;
+  password?: string;
+  ttl?: string;
+  filename?: string;
+  mimetype?: string;
+  chunkSize?: number;
+  chunkConcurrency?: number;
+  wait?: boolean;
+  timeoutMs?: number;
+  pollIntervalMs?: number;
+  onProgress?: (state: UploadState) => void;
+}
+```
+
+## Limits
+
+| Mode  | Auth required              | Limit          |
+| ----- | -------------------------- | -------------- |
+| Guest | No                         | 100MB per file |
+| User  | Username/password or token | 500MB per file |
+
+## License
+
+MIT

package/bin/tmpbox-upload.cjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+const path = require("path");
+const {
+  login,
+  uploadFile,
+  BASE_URL,
+  DEFAULT_CHUNK_CONCURRENCY,
+  GUEST_MAX_FILE_SIZE,
+  USER_MAX_FILE_SIZE
+} = require("../lib/index.cjs");
+
+function formatMB(bytes) {
+  return `${Math.round(bytes / 1024 / 1024)}MB`;
+}
+
+function usage() {
+  console.log(`Usage:
+  tmpbox <file...> [--ttl 30d]
+  tmpbox <file...> --username <username> --password <password> [--ttl 30d]
+  tmpbox <file...> --token <jwt-token> [--ttl 30d]
+
+Options:
+  --username, -u      TmpBox username. Default: TMPBOX_USERNAME
+  --password, -p      TmpBox password. Default: TMPBOX_PASSWORD
+  --token, -t         Existing JWT token. Default: TMPBOX_TOKEN, FILESTORAGE_TOKEN, or UPLOAD_TOKEN
+  --ttl               TTL sent to backend. Default: 30d
+  --chunk-concurrency Number of chunks uploaded at once. Default: ${DEFAULT_CHUNK_CONCURRENCY}
+  --no-wait           Return after chunks are queued, without waiting for backend completion
+  --json              Print final result as JSON
+  --help, -h          Show help
+
+Limits:
+  Guest upload: ${formatMB(GUEST_MAX_FILE_SIZE)} per file
+  User upload:  ${formatMB(USER_MAX_FILE_SIZE)} per file
+
+Examples:
+  tmpbox ./video.mp4
+  tmpbox ./video.mp4 -u myuser -p mypassword
+  TMPBOX_USERNAME=myuser TMPBOX_PASSWORD=mypassword tmpbox ./a.zip ./b.pdf
+  tmpbox ./video.mp4 -t "$TMPBOX_TOKEN"
+`);
+}
+
+function parseArgs(argv) {
+  const args = { files: [], wait: true, json: false };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") args.help = true;
+    else if (arg === "--username" || arg === "-u") args.username = argv[++i];
+    else if (arg === "--password" || arg === "-p") args.password = argv[++i];
+    else if (arg === "--token" || arg === "-t") args.token = argv[++i];
+    else if (arg === "--ttl") args.ttl = argv[++i];
+    else if (arg === "--chunk-concurrency") args.chunkConcurrency = Number(argv[++i]);
+    else if (arg === "--no-wait") args.wait = false;
+    else if (arg === "--json") args.json = true;
+    else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    else args.files.push(arg);
+  }
+
+  if (args.chunkConcurrency && (!Number.isInteger(args.chunkConcurrency) || args.chunkConcurrency < 1)) {
+    throw new Error("--chunk-concurrency must be a positive integer");
+  }
+
+  return args;
+}
+
+(async () => {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.help || args.files.length === 0) {
+      usage();
+      process.exit(args.help ? 0 : 1);
+    }
+
+    args.username = args.username || process.env.TMPBOX_USERNAME;
+    args.password = args.password || process.env.TMPBOX_PASSWORD;
+    args.token = args.token || process.env.TMPBOX_TOKEN || process.env.FILESTORAGE_TOKEN || process.env.UPLOAD_TOKEN;
+
+    if (!args.token && args.username && args.password) {
+      if (!args.json) console.log(`Logging in as ${args.username}...`);
+      const auth = await login(args.username, args.password);
+      args.token = auth.token;
+      if (!args.json) console.log("Login successful. User limit enabled.");
+    } else if (!args.token && !args.json) {
+      console.log(`Uploading as guest. Limit: ${formatMB(GUEST_MAX_FILE_SIZE)} per file.`);
+    }
+
+    const allResults = [];
+
+    for (const file of args.files) {
+      const fileName = path.basename(file);
+      if (!args.json) console.log(`Uploading ${fileName}...`);
+
+      const result = await uploadFile(file, {
+        token: args.token,
+        username: args.username,
+        password: args.password,
+        ttl: args.ttl,
+        wait: args.wait,
+        chunkConcurrency: args.chunkConcurrency,
+        onProgress: args.json
+          ? undefined
+          : (state) => {
+            const p = state.progress || {};
+            if (state.status === "initialized") {
+              console.log(`  initialized: ${state.id}, mode=${state.mode}, chunks=${p.total}`);
+            } else if (state.status === "queued") {
+              process.stdout.write(`\r  queued chunks: ${p.queued}/${p.total}`);
+            } else {
+              process.stdout.write(`\r  backend: ${state.status} ${p.uploaded || 0}/${p.total || 0}`);
+            }
+          }
+      });
+
+      allResults.push(result);
+      if (!args.json) {
+        process.stdout.write("\n");
+        console.log(`Done: ${result.fullUrl}`);
+      }
+    }
+
+    if (args.json) {
+      console.log(JSON.stringify(allResults.length === 1 ? allResults[0] : allResults, null, 2));
+    }
+  } catch (err) {
+    console.error("Upload failed:", err.message || err);
+    if (err.data) console.error(JSON.stringify(err.data, null, 2));
+    process.exit(1);
+  }
+})();

package/lib/index.cjs

@@ -0,0 +1,286 @@
+const fs = require("fs");
+const path = require("path");
+
+const BASE_URL = "https://api.tmpbox.me";
+const DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+const DEFAULT_CHUNK_CONCURRENCY = 4;
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const GUEST_MAX_FILE_SIZE = 100 * 1024 * 1024;
+const USER_MAX_FILE_SIZE = 500 * 1024 * 1024;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function formatBytes(bytes) {
+  const mb = bytes / 1024 / 1024;
+  return `${mb % 1 === 0 ? mb.toFixed(0) : mb.toFixed(2)}MB`;
+}
+
+function guessMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".zip": "application/zip",
+    ".rar": "application/vnd.rar",
+    ".7z": "application/x-7z-compressed"
+  };
+  return map[ext] || "application/octet-stream";
+}
+
+function authHeader(token) {
+  if (!token) return {};
+  return { Authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}` };
+}
+
+async function parseJsonResponse(res) {
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = { raw: text };
+  }
+
+  if (!res.ok) {
+    const error = new Error(data.msg || data.message || `HTTP ${res.status}`);
+    error.status = res.status;
+    error.data = data;
+    throw error;
+  }
+
+  return data;
+}
+
+async function login(username, password) {
+  if (!username || !password) {
+    throw new Error("username and password are required");
+  }
+
+  const res = await fetch(`${BASE_URL}/auth/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ username, password })
+  });
+
+  return parseJsonResponse(res);
+}
+
+async function resolveToken(options = {}) {
+  if (options.token) return options.token;
+
+  const envToken = process.env.TMPBOX_TOKEN || process.env.FILESTORAGE_TOKEN || process.env.UPLOAD_TOKEN;
+  if (envToken) return envToken;
+
+  const username = options.username || process.env.TMPBOX_USERNAME;
+  const password = options.password || process.env.TMPBOX_PASSWORD;
+
+  if (username && password) {
+    const auth = await login(username, password);
+    return auth.token;
+  }
+
+  return undefined;
+}
+
+async function initUpload({ token, filename, mimetype, size, ttl }) {
+  const res = await fetch(`${BASE_URL}/upload/init`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...authHeader(token)
+    },
+    body: JSON.stringify({ filename, mimetype, size, ttl })
+  });
+
+  return parseJsonResponse(res);
+}
+
+async function uploadChunk({ token, uploadId, index, buffer }) {
+  const form = new FormData();
+  form.append("chunk", new Blob([buffer], { type: "application/octet-stream" }), "chunk.bin");
+
+  const res = await fetch(`${BASE_URL}/upload/chunk/${uploadId}/${index}`, {
+    method: "POST",
+    headers: authHeader(token),
+    body: form
+  });
+
+  return parseJsonResponse(res);
+}
+
+async function checkUpload(uploadId) {
+  const res = await fetch(`${BASE_URL}/check/${uploadId}`);
+  return parseJsonResponse(res);
+}
+
+async function waitForDone(uploadId, options = {}) {
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs || DEFAULT_POLL_INTERVAL_MS;
+  const onProgress = options.onProgress;
+  const startedAt = Date.now();
+  let lastUploaded = -1;
+  let lastStatus = "";
+
+  while (true) {
+    const check = await checkUpload(uploadId);
+    const progress = check.progress || {};
+
+    if (onProgress && (progress.uploaded !== lastUploaded || check.status !== lastStatus)) {
+      lastUploaded = progress.uploaded;
+      lastStatus = check.status;
+      onProgress(check);
+    }
+
+    if (check.status === "done") return check;
+    if (check.status === "failed") {
+      const error = new Error(check.error || "Upload failed on backend");
+      error.data = check;
+      throw error;
+    }
+
+    if (Date.now() - startedAt > timeoutMs) {
+      const error = new Error(`Upload timeout after ${timeoutMs}ms`);
+      error.data = check;
+      throw error;
+    }
+
+    await sleep(pollIntervalMs);
+  }
+}
+
+async function mapLimit(items, limit, task) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+
+  async function worker() {
+    while (nextIndex < items.length) {
+      const currentIndex = nextIndex++;
+      results[currentIndex] = await task(items[currentIndex], currentIndex);
+    }
+  }
+
+  const workers = Array.from(
+    { length: Math.min(Math.max(1, limit), items.length) },
+    () => worker()
+  );
+
+  await Promise.all(workers);
+  return results;
+}
+
+async function uploadFile(filePath, options = {}) {
+  const resolvedPath = path.resolve(filePath);
+  const stat = fs.statSync(resolvedPath);
+  if (!stat.isFile()) throw new Error(`${resolvedPath} is not a file`);
+
+  const token = await resolveToken(options);
+  const isGuest = !token;
+  const maxFileSize = isGuest ? GUEST_MAX_FILE_SIZE : USER_MAX_FILE_SIZE;
+
+  if (stat.size > maxFileSize) {
+    throw new Error(
+      `File is too large for ${isGuest ? "guest" : "user"} upload. ` +
+      `Limit is ${formatBytes(maxFileSize)}, file size is ${formatBytes(stat.size)}.`
+    );
+  }
+
+  const chunkSize = options.chunkSize || DEFAULT_CHUNK_SIZE;
+  const chunkConcurrency = options.chunkConcurrency || DEFAULT_CHUNK_CONCURRENCY;
+  const ttl = options.ttl || "30d";
+  const filename = options.filename || path.basename(resolvedPath);
+  const mimetype = options.mimetype || guessMimeType(resolvedPath);
+  const onProgress = options.onProgress;
+
+  const init = await initUpload({ token, filename, mimetype, size: stat.size, ttl });
+  const totalChunks = init.totalChunks || Math.ceil(stat.size / chunkSize);
+  let queuedChunks = 0;
+
+  if (onProgress) {
+    onProgress({
+      success: true,
+      status: "initialized",
+      id: init.uploadId,
+      url: init.url,
+      mode: isGuest ? "guest" : "user",
+      limit: maxFileSize,
+      progress: { percent: 0, uploaded: 0, queued: 0, failed: 0, total: totalChunks }
+    });
+  }
+
+  const fd = fs.openSync(resolvedPath, "r");
+  try {
+    const indexes = Array.from({ length: totalChunks }, (_, index) => index);
+
+    await mapLimit(indexes, chunkConcurrency, async (index) => {
+      const start = index * chunkSize;
+      const size = Math.min(chunkSize, stat.size - start);
+      const buffer = Buffer.alloc(size);
+      fs.readSync(fd, buffer, 0, size, start);
+
+      await uploadChunk({ token, uploadId: init.uploadId, index, buffer });
+
+      queuedChunks += 1;
+      if (onProgress) {
+        onProgress({
+          success: true,
+          status: "queued",
+          id: init.uploadId,
+          url: init.url,
+          mode: isGuest ? "guest" : "user",
+          limit: maxFileSize,
+          progress: {
+            percent: Math.floor((queuedChunks / totalChunks) * 100),
+            queued: queuedChunks,
+            total: totalChunks
+          }
+        });
+      }
+    });
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  const final = options.wait === false
+    ? await checkUpload(init.uploadId)
+    : await waitForDone(init.uploadId, options);
+
+  return {
+    ...final,
+    id: init.uploadId,
+    url: final.url || init.url,
+    fullUrl: `${BASE_URL}${final.url || init.url}`,
+    mode: isGuest ? "guest" : "user",
+    limit: maxFileSize
+  };
+}
+
+async function uploadFiles(filePaths, options = {}) {
+  const results = [];
+  for (const filePath of filePaths) {
+    results.push(await uploadFile(filePath, options));
+  }
+  return results;
+}
+
+module.exports = {
+  DEFAULT_CHUNK_SIZE,
+  DEFAULT_CHUNK_CONCURRENCY,
+  GUEST_MAX_FILE_SIZE,
+  USER_MAX_FILE_SIZE,
+  login,
+  uploadFile,
+  uploadFiles,
+  checkUpload,
+  waitForDone
+};

package/lib/index.d.ts

@@ -0,0 +1,89 @@
+export const BASE_URL: "https://api.tmpbox.me";
+export const DEFAULT_CHUNK_SIZE: number;
+export const DEFAULT_CHUNK_CONCURRENCY: number;
+export const GUEST_MAX_FILE_SIZE: number;
+export const USER_MAX_FILE_SIZE: number;
+
+export interface TmpBoxUser {
+  username: string;
+  role: string;
+}
+
+export interface LoginResult {
+  success: boolean;
+  token: string;
+  user?: TmpBoxUser;
+  [key: string]: unknown;
+}
+
+export interface UploadProgress {
+  percent?: number;
+  uploaded?: number;
+  queued?: number;
+  failed?: number;
+  total?: number;
+  [key: string]: unknown;
+}
+
+export interface UploadState {
+  success?: boolean;
+  status?: string;
+  id?: string;
+  url?: string;
+  mode?: "guest" | "user";
+  limit?: number;
+  progress?: UploadProgress;
+  [key: string]: unknown;
+}
+
+export interface UploadOptions {
+  token?: string;
+  username?: string;
+  password?: string;
+  ttl?: string;
+  filename?: string;
+  mimetype?: string;
+  chunkSize?: number;
+  chunkConcurrency?: number;
+  wait?: boolean;
+  timeoutMs?: number;
+  pollIntervalMs?: number;
+  onProgress?: (state: UploadState) => void;
+}
+
+export interface UploadResult extends UploadState {
+  id: string;
+  url: string;
+  fullUrl: string;
+  mode: "guest" | "user";
+  limit: number;
+}
+
+export function login(username: string, password: string): Promise<LoginResult>;
+export function uploadFile(
+  filePath: string,
+  options?: UploadOptions,
+): Promise<UploadResult>;
+export function uploadFiles(
+  filePaths: string[],
+  options?: UploadOptions,
+): Promise<UploadResult[]>;
+export function checkUpload(uploadId: string): Promise<UploadState>;
+export function waitForDone(
+  uploadId: string,
+  options?: Pick<UploadOptions, "timeoutMs" | "pollIntervalMs" | "onProgress">,
+): Promise<UploadState>;
+
+declare const _default: {
+  DEFAULT_CHUNK_SIZE: typeof DEFAULT_CHUNK_SIZE;
+  DEFAULT_CHUNK_CONCURRENCY: typeof DEFAULT_CHUNK_CONCURRENCY;
+  GUEST_MAX_FILE_SIZE: typeof GUEST_MAX_FILE_SIZE;
+  USER_MAX_FILE_SIZE: typeof USER_MAX_FILE_SIZE;
+  login: typeof login;
+  uploadFile: typeof uploadFile;
+  uploadFiles: typeof uploadFiles;
+  checkUpload: typeof checkUpload;
+  waitForDone: typeof waitForDone;
+};
+
+export default _default;

package/lib/index.mjs

@@ -0,0 +1,14 @@
+import cjs from "./index.cjs";
+
+export const BASE_URL = cjs.BASE_URL;
+export const DEFAULT_CHUNK_SIZE = cjs.DEFAULT_CHUNK_SIZE;
+export const DEFAULT_CHUNK_CONCURRENCY = cjs.DEFAULT_CHUNK_CONCURRENCY;
+export const GUEST_MAX_FILE_SIZE = cjs.GUEST_MAX_FILE_SIZE;
+export const USER_MAX_FILE_SIZE = cjs.USER_MAX_FILE_SIZE;
+export const login = cjs.login;
+export const uploadFile = cjs.uploadFile;
+export const uploadFiles = cjs.uploadFiles;
+export const checkUpload = cjs.checkUpload;
+export const waitForDone = cjs.waitForDone;
+
+export default cjs;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "tmpbox.me",
+  "author": "bangvn71",
+  "version": "1.0.2",
+  "description": "Official TmpBox.me uploader SDK and CLI for Node.js.",
+  "type": "module",
+  "main": "./lib/index.cjs",
+  "module": "./lib/index.mjs",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.mjs",
+      "require": "./lib/index.cjs"
+    }
+  },
+  "bin": {
+    "tmpbox-upload": "./bin/tmpbox-upload.cjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --check lib/index.cjs && node --check lib/index.mjs && node --check bin/tmpbox.cjs",
+    "pack:local": "npm pack"
+  },
+  "keywords": [
+    "tmpbox.me",
+    "tmpbox",
+    "upload",
+    "file-upload",
+    "storage",
+    "cli"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}