shiply-cli 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# shiply-cli
+
+Publish static sites to [shiply.now](https://shiply.now) from the command line —
+instant web hosting built for agents.
+
+```bash
+npm install -g shiply-cli
+# or
+curl -fsSL https://shiply.now/install.sh | bash
+```
+
+## Usage
+
+```bash
+shiply publish ./dist          # publish a directory, print the live URL
+shiply publish ./dist --spa    # single-page app mode
+shiply login                   # email a 6-digit code, mint + save an API key
+shiply update ./dist --claim-token <token>   # push a new version to an anonymous site
+```
+
+Without an API key, sites are anonymous: live immediately at
+`https://<slug>.shiply.now/`, expire after 24 hours, and print a one-time
+`claimToken`/`claimUrl` so they can be updated or claimed into an account.
+
+With an API key (`shiply login`, `$SHIPLY_API_KEY`, or `--key`), sites are
+permanent and owned by your account.
+
+Unchanged files are hash-skipped on updates — only diffs are uploaded.
+
+## For agents
+
+- Machine guide: <https://shiply.now/llms.txt>
+- OpenAPI spec: <https://shiply.now/openapi.json>
+- Docs: <https://shiply.now/docs>
+
+## License
+
+MIT

package/dist/config.js

@@ -0,0 +1,25 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const credsDir = () => join(homedir(), '.shiply');
+export const credentialsPath = () => join(credsDir(), 'credentials');
+/** SHIPLY_API_KEY env wins; otherwise ~/.shiply/credentials (JSON { apiKey }). */
+export async function loadApiKey() {
+    const env = process.env.SHIPLY_API_KEY?.trim();
+    if (env)
+        return env;
+    try {
+        const raw = await readFile(credentialsPath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.apiKey?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function saveApiKey(apiKey) {
+    await mkdir(credsDir(), { recursive: true });
+    const path = credentialsPath();
+    await writeFile(path, `${JSON.stringify({ apiKey }, null, 2)}\n`, { mode: 0o600 });
+    return path;
+}

package/dist/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { parseArgs } from 'node:util';
+import { loadApiKey, saveApiKey } from './config.js';
+import { api, DEFAULT_BASE, publish, resolveBase } from './publish.js';
+const HELP = `shiply — instant static hosting for agents (https://shiply.now)
+
+Usage:
+  shiply publish <dir> [options]              Publish a directory, print the live URL
+  shiply update <dir> --claim-token <token>   Push a new version to an anonymous site
+  shiply login [--email <address>]            Email a 6-digit code, mint + save an API key
+  shiply help
+
+Options:
+  --spa                  Single-page app mode (unknown paths fall back to index.html)
+  --claim-token <tok>    Update the anonymous site this token belongs to
+  --key <key>            API key (default: $SHIPLY_API_KEY, then ~/.shiply/credentials)
+  --anonymous            Publish without an API key even if one is saved
+  --base <url>           API origin (default: ${DEFAULT_BASE})
+
+With an API key the site is permanent and owned by your account. Without one
+it expires in 24 hours — save the printed claimToken/claimUrl to update or
+claim it later.
+`;
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            spa: { type: 'boolean' },
+            'claim-token': { type: 'string' },
+            key: { type: 'string' },
+            anonymous: { type: 'boolean' },
+            base: { type: 'string' },
+            email: { type: 'string' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    const [cmd, dir] = positionals;
+    if (values.help || !cmd || cmd === 'help') {
+        process.stdout.write(HELP);
+        return;
+    }
+    switch (cmd) {
+        case 'publish':
+        case 'update': {
+            if (!dir)
+                throw new Error(`usage: shiply ${cmd} <dir>`);
+            if (cmd === 'update' && !values['claim-token']) {
+                throw new Error('shiply update needs --claim-token <token> (printed by the original publish)');
+            }
+            const apiKey = values.anonymous ? undefined : (values.key ?? (await loadApiKey()));
+            const res = await publish(dir, {
+                apiKey,
+                base: values.base,
+                spaMode: values.spa,
+                claimToken: values['claim-token'],
+            });
+            const skipped = res.skipped > 0 ? ` (${res.skipped} unchanged, skipped)` : '';
+            console.log(`✔ published ${res.uploaded} file${res.uploaded === 1 ? '' : 's'}${skipped}`);
+            console.log(`\n  ${res.siteUrl}\n`);
+            if (res.anonymous) {
+                console.log(`  anonymous site — expires ${res.expiresAt ?? 'in 24h'}`);
+                if (res.claimUrl)
+                    console.log(`  claim it (make permanent): ${res.claimUrl}`);
+                if (res.claimToken) {
+                    console.log(`  claimToken (SAVE THIS — shown once): ${res.claimToken}`);
+                    console.log(`  update later: shiply update <dir> --claim-token ${res.claimToken}`);
+                }
+                console.log(`  tip: run \`shiply login\` first to publish permanent sites`);
+            }
+            return;
+        }
+        case 'login': {
+            const base = resolveBase(values.base);
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            try {
+                const email = values.email ?? (await rl.question('Email address: '));
+                await api(`${base}/api/auth/agent/request-code`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ email: email.trim() }),
+                });
+                const code = await rl.question(`6-digit code sent to ${email.trim()}: `);
+                const out = await api(`${base}/api/auth/agent/verify-code`, {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ email: email.trim(), code: code.trim() }),
+                });
+                const path = await saveApiKey(out.apiKey);
+                console.log(`✔ logged in as ${out.email} — key saved to ${path}`);
+                console.log('  publishes are now permanent and owned by your account');
+            }
+            finally {
+                rl.close();
+            }
+            return;
+        }
+        default:
+            throw new Error(`unknown command: ${cmd} (try \`shiply help\`)`);
+    }
+}
+main().catch((e) => {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`✖ ${msg}`);
+    process.exit(1);
+});

package/dist/manifest.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+const MIME = {
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.mjs': 'text/javascript',
+    '.cjs': 'text/javascript',
+    '.json': 'application/json',
+    '.map': 'application/json',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.xml': 'application/xml',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.wasm': 'application/wasm',
+    '.pdf': 'application/pdf',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+};
+export const contentTypeFor = (path) => MIME[extname(path).toLowerCase()] ?? 'application/octet-stream';
+const SKIP_DIRS = new Set(['node_modules']);
+/** Walk a directory into the publish manifest: posix-relative paths, byte
+ *  sizes, sha256 hex hashes (server hash-skips unchanged files on update).
+ *  Dot entries and node_modules are never published. */
+export async function buildManifest(dir) {
+    const out = [];
+    await walk(dir, '', out);
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function walk(abs, rel, out) {
+    const entries = await readdir(abs, { withFileTypes: true });
+    for (const e of entries) {
+        if (e.name.startsWith('.') || SKIP_DIRS.has(e.name))
+            continue;
+        const childAbs = join(abs, e.name);
+        const childRel = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) {
+            await walk(childAbs, childRel, out);
+        }
+        else if (e.isFile()) {
+            const buf = await readFile(childAbs);
+            out.push({
+                path: childRel,
+                size: buf.length,
+                contentType: contentTypeFor(e.name),
+                hash: createHash('sha256').update(buf).digest('hex'),
+            });
+        }
+    }
+}

package/dist/publish.js

@@ -0,0 +1,74 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildManifest } from './manifest.js';
+export const DEFAULT_BASE = 'https://shiply.now';
+export class ApiError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+export async function api(url, init) {
+    const res = await fetch(url, init);
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+        const err = body.error;
+        throw new ApiError(err?.code ?? 'http_error', err?.message ?? `HTTP ${res.status}`, res.status);
+    }
+    return body;
+}
+export const resolveBase = (base) => (base ?? process.env.SHIPLY_BASE_URL ?? DEFAULT_BASE).replace(/\/+$/, '');
+/** The full publish flow: create → PUT uploads (hash-skipped ones excluded
+ *  server-side) → finalize. Returns the live URL + claim info when anonymous. */
+export async function publish(dir, opts = {}) {
+    const base = resolveBase(opts.base);
+    const files = await buildManifest(dir);
+    if (files.length === 0)
+        throw new Error(`no publishable files found in ${dir}`);
+    const headers = { 'content-type': 'application/json' };
+    if (opts.apiKey)
+        headers.authorization = `Bearer ${opts.apiKey}`;
+    const created = await api(`${base}/api/v1/publish`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            files,
+            ...(opts.spaMode ? { spaMode: true } : {}),
+            ...(opts.claimToken ? { claimToken: opts.claimToken } : {}),
+        }),
+    });
+    await uploadAll(dir, created.upload.uploads);
+    await api(created.upload.finalizeUrl, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ versionId: created.upload.versionId }),
+    });
+    return {
+        slug: created.slug,
+        siteUrl: created.siteUrl,
+        claimToken: created.claimToken,
+        claimUrl: created.claimUrl,
+        expiresAt: created.expiresAt,
+        anonymous: created.anonymous,
+        uploaded: created.upload.uploads.length,
+        skipped: created.upload.skipped.length,
+    };
+}
+const CONCURRENCY = 8;
+async function uploadAll(dir, targets) {
+    let next = 0;
+    const worker = async () => {
+        while (next < targets.length) {
+            const t = targets[next++];
+            const body = await readFile(join(dir, t.path));
+            const res = await fetch(t.url, { method: t.method, headers: t.headers, body });
+            if (!res.ok)
+                throw new Error(`upload failed for ${t.path}: HTTP ${res.status}`);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, targets.length) }, worker));
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "shiply-cli",
+  "version": "0.1.0",
+  "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
+  "license": "MIT",
+  "type": "module",
+  "bin": { "shiply": "dist/index.js" },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": { "node": ">=18" },
+  "keywords": ["shiply", "hosting", "static", "deploy", "agents", "publish"],
+  "homepage": "https://shiply.now",
+  "devDependencies": {
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0",
+    "@types/node": "^22.15.0"
+  }
+}