shiply-cli 0.1.0 → 0.3.0

package/README.md

@@ -1,38 +1,47 @@
-# 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
+# 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          # run it AGAIN → updates the SAME site (no new subdomain)
+shiply publish ./dist --spa    # single-page app mode
+shiply login                   # email a 6-digit code, mint + save an API key
+shiply status <slug-or-domain> [--wait]      # SSL + readiness check — confetti when live 🎉
+```
+
+shiply remembers each directory's site in `.shiply.json` (slug + update token),
+so repeat publishes always hit the same URL. Use `--new-site` to start fresh;
+gitignore `.shiply.json` in public repos.
+
+`shiply status` prints stable `SSL_READY` / `SITE_READY` markers for agents and
+exits 0 only when the certificate is valid and the site serves. `--wait` polls
+until ready (great while a custom domain's certificate issues).
+
+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/confetti.js

@@ -0,0 +1,28 @@
+const GLYPHS = ['✦', '✧', '★', '☆', '●', '◆', '▲', '■', '♥', '✶', '*', 'o', '°'];
+const COLORS = [196, 202, 208, 220, 226, 118, 46, 51, 45, 39, 99, 201, 207, 213];
+const ESC = '\x1b';
+/** Full-width ANSI confetti burst — sites going live deserve a party. */
+export function confetti(message = '🎉  SITE IS LIVE  🎉') {
+    const cols = Math.min(process.stdout.columns ?? 80, 100);
+    const rows = Math.min(Math.max((process.stdout.rows ?? 24) - 6, 8), 18);
+    let out = '\n';
+    for (let r = 0; r < rows; r++) {
+        let line = '';
+        for (let c = 0; c < cols; c++) {
+            if (Math.random() < 0.12) {
+                const g = GLYPHS[Math.floor(Math.random() * GLYPHS.length)];
+                const color = COLORS[Math.floor(Math.random() * COLORS.length)];
+                line += `${ESC}[38;5;${color}m${g}${ESC}[0m`;
+            }
+            else {
+                line += ' ';
+            }
+        }
+        out += `${line}\n`;
+        if (r === Math.floor(rows / 2)) {
+            const pad = Math.max(Math.floor((cols - message.length) / 2), 0);
+            out += `${' '.repeat(pad)}${ESC}[1m${message}${ESC}[0m\n`;
+        }
+    }
+    return out;
+}

package/dist/index.js

@@ -1,27 +1,62 @@
 #!/usr/bin/env node
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
+import { confetti } from './confetti.js';
 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.
+import { readState, writeState } from './state.js';
+import { checkReadiness, targetToHostname } from './status.js';
+const HELP = `shiply — instant static hosting for agents (https://shiply.now)
+
+Usage:
+  shiply publish <dir> [options]              Publish a directory, print the live URL.
+                                              Re-running UPDATES the same site (state in .shiply.json)
+  shiply update <dir>                         Same as publish when .shiply.json exists
+  shiply status <slug-or-domain> [--wait]     SSL + readiness check (agent-friendly output)
+  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 a specific anonymous site (overrides .shiply.json)
+  --new-site             Ignore .shiply.json and create a fresh site
+  --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})
+  --wait                 (status) poll until the site is ready
+  --timeout <seconds>    (status --wait) give up after this long (default 300)
+  --no-confetti          Celebrate quietly
+
+\`shiply status\` prints stable machine-readable markers for agents:
+SSL_READY and SITE_READY on success (exit 0); ✖ lines and exit 1 otherwise.
+
+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 reportReadiness(host, celebrate) {
+    const r = await checkReadiness(host);
+    if (r.tls.valid) {
+        const detail = [r.tls.issuer, r.tls.daysLeft !== undefined ? `expires in ${r.tls.daysLeft} days` : '']
+            .filter(Boolean)
+            .join(', ');
+        console.log(`✔ ssl: valid${detail ? ` — ${detail}` : ''}`);
+        console.log(`SSL_READY host=${host}${r.tls.daysLeft !== undefined ? ` days_left=${r.tls.daysLeft}` : ''}`);
+    }
+    else {
+        console.log(`✖ ssl: not ready${r.tls.error ? ` — ${r.tls.error}` : ''}`);
+    }
+    if (r.http.ok) {
+        console.log(`✔ site: ready (HTTP ${r.http.status})`);
+        console.log(`SITE_READY url=https://${host}/ status=${r.http.status}`);
+    }
+    else {
+        console.log(`✖ site: not ready${r.http.status ? ` (HTTP ${r.http.status})` : r.http.error ? ` — ${r.http.error}` : ''}`);
+    }
+    if (r.ready && celebrate)
+        console.log(confetti());
+    return r.ready;
+}
 async function main() {
     const { values, positionals } = parseArgs({
         allowPositionals: true,
@@ -32,6 +67,10 @@ async function main() {
             anonymous: { type: 'boolean' },
             base: { type: 'string' },
             email: { type: 'string' },
+            wait: { type: 'boolean' },
+            'new-site': { type: 'boolean' },
+            timeout: { type: 'string' },
+            'no-confetti': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
     });
@@ -45,31 +84,87 @@ async function main() {
         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()));
+            // same command, same URL: reuse this directory's site automatically
+            const state = await readState(dir);
+            let claimToken = values['claim-token'] ?? state?.claimToken;
+            let slug = state?.owned && apiKey ? state.slug : undefined;
+            if (values['new-site']) {
+                claimToken = values['claim-token'];
+                slug = undefined;
+            }
+            if (cmd === 'update' && !claimToken && !slug) {
+                throw new Error('nothing to update here — publish first (shiply remembers the site in .shiply.json), or pass --claim-token');
+            }
+            const updating = Boolean(claimToken || slug);
             const res = await publish(dir, {
                 apiKey,
                 base: values.base,
                 spaMode: values.spa,
-                claimToken: values['claim-token'],
+                claimToken,
+                slug,
+            });
+            await writeState(dir, {
+                slug: res.slug,
+                siteUrl: res.siteUrl,
+                ...(res.claimToken ? { claimToken: res.claimToken } : state?.claimToken && updating ? { claimToken: state.claimToken } : {}),
+                owned: !res.anonymous,
             });
             const skipped = res.skipped > 0 ? ` (${res.skipped} unchanged, skipped)` : '';
-            console.log(`✔ published ${res.uploaded} file${res.uploaded === 1 ? '' : 's'}${skipped}`);
+            console.log(`✔ ${updating ? `updated ${res.slug} in place` : 'published'} — ${res.uploaded} file${res.uploaded === 1 ? '' : 's'}${skipped}`);
             console.log(`\n  ${res.siteUrl}\n`);
+            // confirm the site actually serves, then celebrate
+            try {
+                const host = new URL(res.siteUrl).hostname;
+                const live = await fetch(res.siteUrl, { method: 'GET', redirect: 'follow' });
+                void live.body?.cancel();
+                if (live.status < 400) {
+                    console.log(`SITE_READY url=${res.siteUrl} status=${live.status}`);
+                    if (!values['no-confetti'])
+                        console.log(confetti(`🎉  ${host} IS LIVE  🎉`));
+                }
+            }
+            catch {
+                /* serving check is best-effort */
+            }
+            if (!updating) {
+                console.log(`  saved .shiply.json — run \`shiply publish ${dir}\` again to UPDATE this same site`);
+                console.log(`  (gitignore .shiply.json if this folder is public — it can update the site)`);
+            }
             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(`  claim it to KEEP it (free account): ${res.claimUrl}`);
                 console.log(`  tip: run \`shiply login\` first to publish permanent sites`);
             }
             return;
         }
+        case 'status': {
+            if (!dir)
+                throw new Error('usage: shiply status <slug-or-domain> [--wait]');
+            const host = targetToHostname(dir);
+            const celebrate = !values['no-confetti'];
+            console.log(`checking https://${host}/ …`);
+            if (!values.wait) {
+                const ready = await reportReadiness(host, celebrate);
+                process.exitCode = ready ? 0 : 1;
+                return;
+            }
+            const timeoutMs = Number(values.timeout ?? 300) * 1000;
+            const deadline = Date.now() + timeoutMs;
+            for (;;) {
+                const ready = await reportReadiness(host, celebrate);
+                if (ready)
+                    return;
+                if (Date.now() > deadline) {
+                    console.error(`✖ timed out after ${Math.round(timeoutMs / 1000)}s — still not ready`);
+                    process.exitCode = 1;
+                    return;
+                }
+                console.log('  …waiting 5s (Ctrl-C to stop)');
+                await new Promise((r) => setTimeout(r, 5000));
+            }
+        }
         case 'login': {
             const base = resolveBase(values.base);
             const rl = createInterface({ input: process.stdin, output: process.stdout });

package/dist/publish.js

@@ -39,6 +39,7 @@ export async function publish(dir, opts = {}) {
             files,
             ...(opts.spaMode ? { spaMode: true } : {}),
             ...(opts.claimToken ? { claimToken: opts.claimToken } : {}),
+            ...(opts.slug ? { slug: opts.slug } : {}),
         }),
     });
     await uploadAll(dir, created.upload.uploads);

package/dist/state.js

@@ -0,0 +1,16 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export const stateFile = (dir) => join(dir, '.shiply.json');
+export async function readState(dir) {
+    try {
+        const raw = await readFile(stateFile(dir), 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.slug ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeState(dir, state) {
+    await writeFile(stateFile(dir), `${JSON.stringify(state, null, 2)}\n`);
+}

package/dist/status.js

@@ -0,0 +1,47 @@
+import { connect } from 'node:tls';
+/** Normalize a CLI target (slug, hostname, or URL) to a bare hostname. */
+export function targetToHostname(target) {
+    const t = target
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '');
+    return t.includes('.') ? t : `${t}.shiply.now`;
+}
+/** TLS handshake + peer certificate inspection (the "ssl checker"). */
+export function checkTls(host, timeoutMs = 10_000) {
+    return new Promise((resolve) => {
+        const sock = connect({ host, port: 443, servername: host, timeout: timeoutMs }, () => {
+            const cert = sock.getPeerCertificate();
+            const validTo = cert?.valid_to ? new Date(cert.valid_to) : undefined;
+            const daysLeft = validTo
+                ? Math.round((validTo.getTime() - Date.now()) / 86_400_000)
+                : undefined;
+            const issuer = cert?.issuer?.O ??
+                cert?.issuer?.CN;
+            const valid = sock.authorized;
+            const error = valid ? undefined : String(sock.authorizationError ?? 'not authorized');
+            sock.end();
+            resolve({ valid, issuer, daysLeft, error });
+        });
+        sock.on('error', (e) => resolve({ valid: false, error: e.message }));
+        sock.on('timeout', () => {
+            sock.destroy();
+            resolve({ valid: false, error: 'TLS handshake timed out' });
+        });
+    });
+}
+export async function checkHttp(host) {
+    try {
+        const res = await fetch(`https://${host}/`, { method: 'GET', redirect: 'follow' });
+        void res.body?.cancel();
+        return { ok: res.status < 400, status: res.status };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}
+export async function checkReadiness(host) {
+    const [tls, http] = await Promise.all([checkTls(host), checkHttp(host)]);
+    return { host, tls, http, ready: tls.valid && http.ok };
+}

package/package.json

@@ -1,23 +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"
-  }
-}
+{
+  "name": "shiply-cli",
+  "version": "0.3.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"
+  }
+}