filesharing-onl 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,12 @@
-# Temporary Holding Version
+# Filesharing
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Upload files to ShareIt.onl and receive a shareable link.
+
+```sh
+npm install --global filesharing-onl
+filesharing report.pdf
+filesharing photo.jpg notes.txt --expiry 7d
+filesharing archive.zip --password
+```
+
+The hidden password prompt keeps share passwords out of shell history. Anonymous limits and retention rules are the same as on <https://shareit.onl>.

package/bin/filesharing.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const pkg = require('../package.json');
+
+const base = (process.env.FILESHARING_URL || 'https://shareit.onl').replace(/\/$/, '');
+const client = 'shareit-browser-extension-v1';
+
+function help() {
+  return `Filesharing ${pkg.version}
+
+Usage:
+  filesharing <file...> [--expiry 1h|1d|7d|30d] [--password] [--one-time]
+
+Options:
+  --password   Prompt for a share password without echo
+  --one-time   Expire after the first successful download
+  --expiry     Retention selection
+  --json       Print JSON`;
+}
+
+function parse(argv) {
+  const args = [...argv];
+  if (!args.length || args.includes('--help') || args.includes('-h')) return { help: true };
+  if (args.includes('--version') || args.includes('-v')) return { version: true };
+  const takeBoolean = (name) => { const found = args.includes(name); if (found) args.splice(args.indexOf(name), 1); return found; };
+  const take = (name, fallback) => { const index = args.indexOf(name); if (index < 0) return fallback; const value = args[index + 1]; if (!value) throw new Error(`${name} requires a value.`); args.splice(index, 2); return value; };
+  return { files: args, password: takeBoolean('--password'), oneTime: takeBoolean('--one-time'), json: takeBoolean('--json'), expiry: take('--expiry', '7d') };
+}
+
+function secret(label) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || !process.stdin.setRawMode) throw new Error('Password prompting requires a terminal.');
+  return new Promise((resolve, reject) => {
+    let value = '';
+    process.stdout.write(label); process.stdin.setRawMode(true); process.stdin.resume(); process.stdin.setEncoding('utf8');
+    const done = (error) => { process.stdin.setRawMode(false); process.stdin.pause(); process.stdin.off('data', input); process.stdout.write('\n'); error ? reject(error) : resolve(value); };
+    const input = (key) => { if (key === '\u0003') return done(new Error('Cancelled.')); if (key === '\r' || key === '\n') return done(); if (key === '\u007f' || key === '\b') value = value.slice(0, -1); else if (key >= ' ') value += key; };
+    process.stdin.on('data', input);
+  });
+}
+
+class Session {
+  constructor() { this.cookie = ''; this.csrf = ''; }
+  capture(response) {
+    const values = response.headers.getSetCookie?.() || [response.headers.get('set-cookie')].filter(Boolean);
+    if (values.length) this.cookie = values.map((value) => value.split(';', 1)[0]).join('; ');
+  }
+  headers(extra = {}) { return { Cookie: this.cookie, 'X-CSRFToken': this.csrf, 'X-ShareIt-Client': client, 'User-Agent': `filesharing/${pkg.version}`, ...extra }; }
+  async start() {
+    const response = await fetch(`${base}/api/extension/session`, { headers: { 'User-Agent': `filesharing/${pkg.version}` } });
+    this.capture(response); const data = await response.json().catch(() => ({}));
+    if (!response.ok || !data.csrf) throw new Error(data.error || `ShareIt.onl session failed with HTTP ${response.status}.`);
+    this.csrf = data.csrf; this.limits = data;
+  }
+  async json(endpoint, method, body) {
+    const response = await fetch(`${base}${endpoint}`, { method, headers: this.headers({ 'Content-Type': 'application/json' }), body: body ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(120_000) });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data.error || `ShareIt.onl returned HTTP ${response.status}.`);
+    return data;
+  }
+}
+
+async function main() {
+  const options = parse(process.argv.slice(2));
+  if (options.help) return process.stdout.write(`${help()}\n`);
+  if (options.version) return process.stdout.write(`${pkg.version}\n`);
+  const files = options.files.map((item) => {
+    const filename = path.resolve(item);
+    if (!fs.existsSync(filename) || !fs.statSync(filename).isFile()) throw new Error(`File not found: ${item}`);
+    return { path: filename, name: path.basename(filename), size: fs.statSync(filename).size };
+  });
+  if (!files.length) throw new Error('Add at least one file.');
+  const password = options.password ? await secret('Share password: ') : '';
+  if (password && password.length < 8) throw new Error('Share passwords must contain at least 8 characters.');
+  const session = new Session(); await session.start();
+  const total = files.reduce((sum, file) => sum + file.size, 0);
+  if (files.length > session.limits.max_files) throw new Error(`This session accepts at most ${session.limits.max_files} files.`);
+  if (total > session.limits.max_bytes) throw new Error(`The selected files exceed the ${session.limits.max_label} limit.`);
+  const upload = await session.json('/api/upload/init', 'POST', { files: files.map(({ name, size }) => ({ name, size })), expiry: options.expiry, password, one_time: options.oneTime });
+  const completion = [];
+  for (const remote of upload.files) {
+    const local = files[remote.idx];
+    const handle = await fs.promises.open(local.path, 'r');
+    const parts = [];
+    try {
+      for (let number = 1; number <= remote.parts; number += 1) {
+        const start = (number - 1) * upload.part_size;
+        const length = Math.min(upload.part_size, local.size - start);
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, start);
+        process.stderr.write(`Uploading ${local.name}: part ${number}/${remote.parts}\r`);
+        const response = await fetch(`${base}/api/upload/part/${upload.token}/${remote.idx}/${number}`, {
+          method: 'POST', headers: session.headers({ 'Content-Type': 'application/octet-stream', 'Content-Length': String(length) }), body: buffer, signal: AbortSignal.timeout(180_000),
+        });
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok || !data.etag) throw new Error(data.error || `Part ${number} failed with HTTP ${response.status}.`);
+        parts.push({ n: number, etag: data.etag });
+      }
+    } finally { await handle.close(); }
+    completion.push({ idx: remote.idx, parts });
+  }
+  if (process.stderr.isTTY) process.stderr.write('\n');
+  const result = await session.json(`/api/upload/complete/${upload.token}`, 'POST', { files: completion, expiry: options.expiry, password, one_time: options.oneTime });
+  process.stdout.write(options.json ? `${JSON.stringify(result, null, 2)}\n` : `${result.url}\n`);
+}
+
+if (require.main === module) main().catch((error) => { process.stderr.write(`filesharing: ${error.message}\n`); process.exitCode = 1; });
+
+module.exports = { parse };

package/package.json

@@ -1,6 +1,14 @@
 {
   "name": "filesharing-onl",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Upload files and create shareable Filesharing links from your terminal.",
+  "bin": { "filesharing": "bin/filesharing.js" },
+  "files": ["bin", "README.md"],
+  "scripts": { "test": "node --check bin/filesharing.js && node bin/filesharing.js --version", "prepublishOnly": "npm test" },
+  "engines": { "node": ">=20" },
+  "keywords": ["file-sharing", "upload", "share-files", "transfer", "cli", "shareit"],
+  "homepage": "https://shareit.onl",
+  "license": "UNLICENSED",
+  "author": "ShareIt.onl",
+  "publishConfig": { "access": "public" }
+}