shary-artifacts 0.1.0

package/bin/shary-artifacts.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import { realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { runCli } from '../src/cli.js';
+
+const isMain = pathToFileURL(realpathSync(process.argv[1])).href === import.meta.url;
+
+if (isMain) {
+  runCli(process.argv).catch((error) => {
+    console.error(error?.message ?? String(error));
+    process.exit(1);
+  });
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "shary-artifacts",
+  "version": "0.1.0",
+  "description": "CLI for publishing self-contained artifacts to Shary.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "shary-artifacts": "bin/shary-artifacts.js"
+  },
+  "main": "src/cli.js",
+  "files": [
+    "bin",
+    "src"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.1.4",
+    "vitest": "^2.1.4"
+  }
+}

package/src/cli.js

@@ -0,0 +1,113 @@
+import { Command, Option } from 'commander';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { inlineHtml } from './inline.js';
+import { publishArtifact, upgradeArtifact } from './publish.js';
+import { checkForUpdates } from './update-check.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+
+function applyGlobalOptions(command) {
+  command.option('--server <url>', 'Shary server URL', 'https://shary.cc');
+  command.addOption(
+    new Option('--api-key <key>', 'Shary API key').env('SHARY_API_KEY')
+  );
+}
+
+export async function runCli(argv) {
+  await checkForUpdates(pkg.version);
+
+  const program = new Command();
+  program
+    .name('shary')
+    .description('CLI for publishing self-contained artifacts to Shary.')
+    .version(pkg.version)
+    .exitOverride();
+
+  applyGlobalOptions(program);
+
+  program
+    .command('inline <input>')
+    .description('Inline local assets into a self-contained HTML file.')
+    .requiredOption('-o, --output <path>', 'Output file path')
+    .action(async (input, options, command) => {
+      const inlined = await inlineHtml(input, options.output);
+      const size = Buffer.byteLength(inlined, 'utf8');
+      console.log(`Wrote ${options.output} (${size} bytes)`);
+    });
+
+  program
+    .command('publish <input>')
+    .description('Inline assets and publish the file to Shary.')
+    .requiredOption('-t, --title <title>', 'Artifact title')
+    .action(async (input, options, command) => {
+      const apiKey = getApiKey(command);
+      const server = command.optsWithGlobals().server;
+      const tmpFile = await inlineToTemp(input);
+      try {
+        const result = await publishArtifact(server, apiKey, tmpFile, options.title);
+        console.log(result.url);
+      } finally {
+        await cleanup(tmpFile);
+      }
+    });
+
+  program
+    .command('upgrade <slug> <input>')
+    .description('Inline assets and upgrade an existing artifact.')
+    .option('-t, --title <title>', 'New artifact title')
+    .action(async (slug, input, options, command) => {
+      const apiKey = getApiKey(command);
+      const server = command.optsWithGlobals().server;
+      const tmpFile = await inlineToTemp(input);
+      try {
+        const result = await upgradeArtifact(server, apiKey, slug, tmpFile, options.title);
+        console.log(result.url);
+      } finally {
+        await cleanup(tmpFile);
+      }
+    });
+
+  program.commands.forEach(applyGlobalOptions);
+
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    if (error?.name === 'CommanderError') {
+      if (error.code === 'commander.help' || error.code === 'commander.helpDisplayed' || error.code === 'commander.version') {
+        return 0;
+      }
+      return error.exitCode ?? 1;
+    }
+    throw error;
+  }
+
+  return 0;
+}
+
+function getApiKey(command) {
+  const apiKey = command.optsWithGlobals().apiKey;
+  if (!apiKey) {
+    throw new Error('API key is required. Set SHARY_API_KEY or use --api-key.');
+  }
+  return apiKey;
+}
+
+async function inlineToTemp(input) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'shary-'));
+  const tmpFile = path.join(tmpDir, 'artifact.html');
+  await inlineHtml(input, tmpFile);
+  return tmpFile;
+}
+
+async function cleanup(tmpFile) {
+  try {
+    await fs.rm(path.dirname(tmpFile), { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup.
+  }
+}

package/src/inline.js

@@ -0,0 +1,306 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const SIXTEEN_MIB = 16 * 1024 * 1024;
+
+const MIME_TYPES = {
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.html': 'text/html',
+  '.md': 'text/markdown',
+};
+
+const FONT_EXTENSIONS = new Set(['.woff', '.woff2', '.ttf', '.otf', '.eot']);
+
+export async function inlineHtml(inputPath, outputPath) {
+  const absInput = path.resolve(inputPath);
+  const html = await fs.readFile(absInput, 'utf8');
+  const baseDir = path.dirname(absInput);
+  const inlined = await inlineHtmlString(html, baseDir);
+
+  if (outputPath) {
+    await fs.writeFile(path.resolve(outputPath), inlined, 'utf8');
+  }
+
+  return inlined;
+}
+
+export async function inlineHtmlString(html, baseDir) {
+  const externalRefs = new Set();
+  let result = html;
+
+  result = await inlineStylesheets(result, baseDir, externalRefs);
+  result = await inlineScripts(result, baseDir, externalRefs);
+  result = await inlineImages(result, baseDir);
+  result = await inlineFontLinks(result, baseDir);
+  result = await inlineStyleBlocks(result, baseDir);
+
+  findExternalUrls(result).forEach((url) => externalRefs.add(url));
+  warnRemainingExternal(externalRefs);
+  warnIfOversized(result);
+
+  return result;
+}
+
+async function inlineStylesheets(html, baseDir, externalRefs) {
+  const linkRegex = /<link\b[^>]*?>/gi;
+  const matches = [...html.matchAll(linkRegex)];
+  if (!matches.length) return html;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const tag = match[0];
+      const attrs = parseAttributes(tag);
+      if (!/stylesheet/i.test(attrs.rel ?? '')) return tag;
+      const href = attrs.href;
+      if (!href) return tag;
+
+      const cssPath = resolveLocalPath(href, baseDir);
+      if (!cssPath) return tag;
+
+      let css;
+      try {
+        css = await fs.readFile(cssPath, 'utf8');
+      } catch (error) {
+        warn(`Could not read stylesheet ${href}: ${error.message}`);
+        return tag;
+      }
+
+      const cssDir = path.dirname(cssPath);
+      const inlinedCss = await inlineUrlsInCss(css, cssDir);
+      findExternalUrls(inlinedCss).forEach((url) => externalRefs.add(url));
+      const dataUri = await contentToDataUri(inlinedCss, cssPath);
+      return replaceAttribute(tag, 'href', dataUri);
+    })
+  );
+
+  let index = 0;
+  return html.replace(linkRegex, () => replacements[index++]);
+}
+
+async function inlineScripts(html, baseDir, externalRefs) {
+  const scriptRegex = /<script\b[^>]*?>(?:[\s\S]*?)<\/script>/gi;
+  const matches = [...html.matchAll(scriptRegex)];
+  if (!matches.length) return html;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const tag = match[0];
+      const attrs = parseAttributes(tag);
+      const src = attrs.src;
+      if (!src) return tag;
+
+      const scriptPath = resolveLocalPath(src, baseDir);
+      if (!scriptPath) return tag;
+
+      let content;
+      try {
+        content = await fs.readFile(scriptPath, 'utf8');
+      } catch (error) {
+        warn(`Could not read script ${src}: ${error.message}`);
+        return tag;
+      }
+
+      findExternalUrls(content).forEach((url) => externalRefs.add(url));
+      const dataUri = await contentToDataUri(content, scriptPath);
+      return replaceAttribute(tag, 'src', dataUri);
+    })
+  );
+
+  let index = 0;
+  return html.replace(scriptRegex, () => replacements[index++]);
+}
+
+async function inlineImages(html, baseDir) {
+  const imgRegex = /<img\b[^>]*?>/gi;
+  const matches = [...html.matchAll(imgRegex)];
+  if (!matches.length) return html;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const tag = match[0];
+      const attrs = parseAttributes(tag);
+      const src = attrs.src;
+      if (!src) return tag;
+
+      const dataUri = await assetToDataUri(src, baseDir);
+      if (!dataUri) return tag;
+
+      return replaceAttribute(tag, 'src', dataUri);
+    })
+  );
+
+  let index = 0;
+  return html.replace(imgRegex, () => replacements[index++]);
+}
+
+async function inlineFontLinks(html, baseDir) {
+  const linkRegex = /<link\b[^>]*?>/gi;
+  const matches = [...html.matchAll(linkRegex)];
+  if (!matches.length) return html;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const tag = match[0];
+      const attrs = parseAttributes(tag);
+      const href = attrs.href;
+      if (!href) return tag;
+
+      const ext = path.extname(stripQueryAndHash(href)).toLowerCase();
+      if (!FONT_EXTENSIONS.has(ext)) return tag;
+
+      const dataUri = await assetToDataUri(href, baseDir);
+      if (!dataUri) return tag;
+
+      return replaceAttribute(tag, 'href', dataUri);
+    })
+  );
+
+  let index = 0;
+  return html.replace(linkRegex, () => replacements[index++]);
+}
+
+async function inlineStyleBlocks(html, baseDir) {
+  const styleRegex = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+  const matches = [...html.matchAll(styleRegex)];
+  if (!matches.length) return html;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const fullTag = match[0];
+      const css = match[1];
+      const inlinedCss = await inlineUrlsInCss(css, baseDir);
+      return fullTag.replace(css, inlinedCss);
+    })
+  );
+
+  let index = 0;
+  return html.replace(styleRegex, () => replacements[index++]);
+}
+
+async function inlineUrlsInCss(css, baseDir) {
+  const urlRegex = /url\(\s*(['"]?)([^'"\n)]+)\1\s*\)/g;
+  const matches = [...css.matchAll(urlRegex)];
+  if (!matches.length) return css;
+
+  const replacements = await Promise.all(
+    matches.map(async (match) => {
+      const url = match[2];
+      const dataUri = await assetToDataUri(url, baseDir);
+      if (!dataUri) return match[0];
+      return `url("${dataUri}")`;
+    })
+  );
+
+  let index = 0;
+  return css.replace(urlRegex, () => replacements[index++]);
+}
+
+async function assetToDataUri(url, baseDir) {
+  if (isExternal(url)) return null;
+
+  const assetPath = resolveLocalPath(url, baseDir);
+  if (!assetPath) return null;
+
+  let buffer;
+  try {
+    buffer = await fs.readFile(assetPath);
+  } catch (error) {
+    warn(`Could not read asset ${url}: ${error.message}`);
+    return null;
+  }
+
+  const mime = mimeTypeFor(assetPath);
+  const base64 = buffer.toString('base64');
+  return `data:${mime};base64,${base64}`;
+}
+
+function resolveLocalPath(url, baseDir) {
+  const clean = stripQueryAndHash(url);
+  if (!clean || clean.startsWith('/') || /^[a-z][a-z0-9+.-]*:/i.test(clean)) {
+    return null;
+  }
+  return path.resolve(baseDir, clean);
+}
+
+function isExternal(url) {
+  return /^https?:\/\//i.test(url) || /^\/\//i.test(url);
+}
+
+function stripQueryAndHash(url) {
+  return url.split('#')[0].split('?')[0];
+}
+
+function mimeTypeFor(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] ?? 'application/octet-stream';
+}
+
+function parseAttributes(tag) {
+  const attrs = {};
+  const regex = /(\w[-\w]*)=["']([^"']*)["']/g;
+  let match;
+  while ((match = regex.exec(tag)) !== null) {
+    attrs[match[1].toLowerCase()] = match[2];
+  }
+  return attrs;
+}
+
+function replaceAttribute(tag, name, value) {
+  const regex = new RegExp(`(${escapeRegExp(name)}=)["'][^"']*["']`, 'i');
+  return tag.replace(regex, `$1"${value}"`);
+}
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function findExternalUrls(text) {
+  const regex = /https?:\/\/[^\s"')>]+/g;
+  const refs = new Set();
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    refs.add(match[0]);
+  }
+  return refs;
+}
+
+async function contentToDataUri(content, filePath) {
+  const mime = mimeTypeFor(filePath);
+  const base64 = Buffer.from(content, 'utf8').toString('base64');
+  return `data:${mime};base64,${base64}`;
+}
+
+function warnRemainingExternal(refs) {
+  if (refs.size > 0) {
+    warn(
+      `Warning: ${refs.size} external HTTP(S) reference(s) remain after inlining: ${[...refs].join(', ')}`
+    );
+  }
+}
+
+function warnIfOversized(html) {
+  const bytes = Buffer.byteLength(html, 'utf8');
+  if (bytes > SIXTEEN_MIB) {
+    warn(
+      `Warning: output is ${bytes} bytes, which exceeds the 16 MiB limit enforced by the Shary server.`
+    );
+  }
+}
+
+function warn(message) {
+  console.error(message);
+}

package/src/publish.js

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function publishArtifact(serverUrl, apiKey, filePath, title) {
+  const url = new URL('/api/artifacts', serverUrl).toString();
+  return upload(url, apiKey, filePath, { title });
+}
+
+export async function upgradeArtifact(serverUrl, apiKey, slug, filePath, title) {
+  const url = new URL(`/api/artifacts/${encodeURIComponent(slug)}`, serverUrl).toString();
+  const fields = {};
+  if (title !== undefined && title !== null && title !== '') {
+    fields.title = title;
+  }
+  return upload(url, apiKey, filePath, fields);
+}
+
+async function upload(url, apiKey, filePath, fields) {
+  const buffer = await fs.readFile(filePath);
+  const form = new FormData();
+  form.append('file', new Blob([buffer]), path.basename(filePath));
+  for (const [key, value] of Object.entries(fields)) {
+    form.append(key, value);
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: form,
+  });
+
+  const text = await response.text();
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    body = { message: text };
+  }
+
+  if (!response.ok) {
+    const message = formatError(body, text, response.status);
+    throw new Error(message);
+  }
+
+  if (!body.url) {
+    throw new Error('Upload succeeded but the response did not contain a URL.');
+  }
+
+  return body;
+}
+
+function formatError(body, rawText, status) {
+  const message = body?.message || rawText || `HTTP ${status}`;
+  const issues = body?.issues;
+
+  if (!Array.isArray(issues) || issues.length === 0) {
+    return `Upload failed: ${message}`;
+  }
+
+  const lines = [message];
+  for (const issue of issues) {
+    lines.push(`- ${issue.message}`);
+    if (issue.fix) {
+      lines.push(`  Fix: ${issue.fix}`);
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/update-check.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const REGISTRY_URL = 'https://registry.npmjs.org/shary-artifacts/latest';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+export async function checkForUpdates(currentVersion) {
+  if (!currentVersion) return;
+
+  const configDir = getConfigDir();
+  const cacheFile = path.join(configDir, 'version-check.json');
+
+  let cached;
+  try {
+    cached = JSON.parse(await fs.readFile(cacheFile, 'utf8'));
+  } catch {
+    cached = null;
+  }
+
+  if (cached?.checkedAt && cached?.latest && Date.now() - cached.checkedAt < CACHE_TTL_MS) {
+    warnIfOutdated(currentVersion, cached.latest);
+    return;
+  }
+
+  try {
+    const response = await fetch(REGISTRY_URL, {
+      headers: { accept: 'application/json' },
+    });
+    if (!response.ok) return;
+
+    const data = await response.json();
+    const latest = data.version;
+    if (!latest) return;
+
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      cacheFile,
+      JSON.stringify({ checkedAt: Date.now(), latest }),
+      'utf8'
+    );
+
+    warnIfOutdated(currentVersion, latest);
+  } catch {
+    // Network or registry errors are intentionally ignored so the CLI keeps working offline.
+  }
+}
+
+function getConfigDir() {
+  const base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+  return path.join(base, 'shary-artifacts');
+}
+
+function warnIfOutdated(current, latest) {
+  if (isNewer(latest, current)) {
+    console.error(
+      `A new version of shary-artifacts is available: ${latest} (you have ${current}). Run with npx shary-artifacts@latest to update.`
+    );
+  }
+}
+
+function isNewer(latest, current) {
+  const parse = (version) =>
+    version
+      .replace(/^v/, '')
+      .split('.')
+      .map((part) => parseInt(part, 10) || 0);
+
+  const l = parse(latest);
+  const c = parse(current);
+
+  for (let i = 0; i < 3; i++) {
+    const li = l[i] ?? 0;
+    const ci = c[i] ?? 0;
+    if (li > ci) return true;
+    if (li < ci) return false;
+  }
+
+  return false;
+}