shiply-cli 0.2.0 → 0.4.0

package/README.md

@@ -13,12 +13,16 @@ curl -fsSL https://shiply.now/install.sh | bash
 
 ```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 update ./dist --claim-token <token>   # push a new version to an anonymous site
 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).

package/dist/index.js

@@ -4,32 +4,38 @@ 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';
+import { installSkill } from './skill.js';
+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
-  shiply update <dir> --claim-token <token>   Push a new version to an anonymous site
-  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 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})
-  --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.
+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 skill [--project]                    Install the shiply skill for your AI agent
+                                              (global ~/.claude/skills, or ./.claude/skills with --project)
+  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);
@@ -65,6 +71,8 @@ async function main() {
             base: { type: 'string' },
             email: { type: 'string' },
             wait: { type: 'boolean' },
+            'new-site': { type: 'boolean' },
+            project: { type: 'boolean' },
             timeout: { type: 'string' },
             'no-confetti': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
@@ -80,18 +88,34 @@ 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 {
@@ -107,14 +131,14 @@ async function main() {
             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;
@@ -145,6 +169,14 @@ async function main() {
                 await new Promise((r) => setTimeout(r, 5000));
             }
         }
+        case 'skill': {
+            const written = await installSkill(Boolean(values.project));
+            for (const w of written)
+                console.log(`✔ skill installed — ${w}`);
+            console.log('  Your agent now knows how to publish, update (same URL!), check SSL, and more.');
+            console.log('  Restart the agent session to pick it up. Re-run after CLI upgrades.');
+            return;
+        }
         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/skill.js

@@ -0,0 +1,29 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The SKILL.md ships inside the npm package (skill/SKILL.md next to dist/). */
+export async function bundledSkill() {
+    const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/dist
+    return readFile(join(here, '..', 'skill', 'SKILL.md'), 'utf8');
+}
+/** Where agents look for skills. Claude Code is the reference layout
+ *  (~/.claude/skills/<name>/SKILL.md); several other agents read the same
+ *  format from their own folders. */
+export function installTargets(project) {
+    if (project) {
+        return [{ agent: 'this project (Claude Code & compatible)', dir: join(process.cwd(), '.claude', 'skills', 'shiply') }];
+    }
+    return [{ agent: 'Claude Code (all projects)', dir: join(homedir(), '.claude', 'skills', 'shiply') }];
+}
+export async function installSkill(project) {
+    const content = await bundledSkill();
+    const written = [];
+    for (const t of installTargets(project)) {
+        await mkdir(t.dir, { recursive: true });
+        const file = join(t.dir, 'SKILL.md');
+        await writeFile(file, content);
+        written.push(`${t.agent}: ${file}`);
+    }
+    return written;
+}

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/package.json

@@ -1,11 +1,11 @@
 {
   "name": "shiply-cli",
-  "version": "0.2.0",
+  "version": "0.4.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"],
+  "files": ["dist", "skill", "README.md"],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepublishOnly": "pnpm build",

package/skill/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: shiply
+description: Publish static sites to the web instantly with shiply.now and manage them (updates, SSL checks, custom domains, variables). Use when the user asks to publish, host, deploy, share, or update a website/page/demo/report, or wants a live URL for generated files. Triggers - "publish this", "host this", "put this online", "give me a link", "update the site", shiply.
+---
+
+# shiply — instant web hosting for agents
+
+shiply.now puts files on the web in seconds. No account needed to start:
+anonymous sites are live immediately, last 24 hours, and can be claimed into
+an account to keep them. The cardinal rule:
+
+**NEVER create a new site to update an existing one. Always re-publish to the
+same site** — otherwise you litter subdomains and lose the user's URL.
+
+## Pick your interface (best first)
+
+### 1. MCP (native tools)
+If the `shiply` MCP server is connected (https://shiply.now/mcp), use
+`publish_site`. Every result includes a `toUpdate` field telling you the exact
+call for updates — follow it. Other tools: `site_status`, `list_sites`,
+`set_handle`, `set_variable`, `add_domain`, `check_domain`, `get_analytics`,
+`delete_site`, `rollback` via dashboard.
+
+### 2. CLI
+```bash
+npm i -g shiply-cli        # or: curl -fsSL https://shiply.now/install.sh | bash
+shiply publish ./dir       # live URL + confetti
+shiply publish ./dir       # run AGAIN after edits → updates the SAME site
+shiply status <slug> --wait  # SSL + readiness; prints SSL_READY / SITE_READY
+shiply login               # email code → API key → sites become permanent
+```
+The CLI stores each directory's site in `.shiply.json` (slug + update token),
+so repeat publishes reuse the URL automatically. `--new-site` opts out.
+Gitignore `.shiply.json` in public repos. Parse `SITE_READY` / `SSL_READY`
+lines for automation; exit code 0 = ready.
+
+### 3. Raw HTTP (no installs)
+```
+1. POST https://shiply.now/api/v1/publish
+   {"files":[{"path":"index.html","size":<bytes>,"contentType":"text/html","hash":"<sha256, optional>"}]}
+   (+ "Authorization: Bearer shp_…" for permanent owned sites)
+2. PUT each file's bytes to response upload.uploads[].url
+3. POST upload.finalizeUrl with {"versionId":"..."}
+```
+**Updates:** anonymous → include `"claimToken":"..."` (returned ONCE by the
+first publish — save it); owned → include `"slug":"..."`. Hashes make updates
+cheap: unchanged files are skipped server-side.
+
+## The lifecycle to explain to users
+- Anonymous site: live instantly, expires in 24 h. Give the user the
+  `claimUrl` — claiming keeps it forever on a free account.
+- API key (`shiply login` or POST /api/auth/agent/request-code →
+  verify-code): publishes are permanent and manageable.
+- Paid plans add vanity handles (<name>.shiply.now), more custom domains,
+  storage, analytics: https://shiply.now/dashboard/plan
+
+## Power features (Bearer key)
+- **Custom domains**: POST /api/v1/domains {"hostname","slug"} → tell the
+  user to CNAME the hostname to `cname.shiply.now` → cert auto-issues; poll
+  GET /api/v1/domains/{id}/check until `ready:true`.
+- **SSL/readiness checker**: `shiply status <slug-or-domain> --wait` or the
+  check endpoint — confirms certificate + serving before telling the user
+  it's done.
+- **Variables**: encrypted per-user KV for API keys the user's sites need
+  (GET/PUT /api/v1/variables, DELETE /api/v1/variables/{NAME}); Supabase can
+  be connected from the dashboard and lands here as SUPABASE_URL +
+  SUPABASE_ANON_KEY.
+- **Rollback**: POST /api/v1/publish/{slug}/rollback {"versionId"} flips any
+  finalized version live instantly.
+- **SPA**: pass `"spaMode":true` so deep links serve index.html.
+
+## Limits & references
+≤1000 files/site (≤50 inline via MCP), ≤100 MiB/file, 1 GiB total.
+Machine guide: https://shiply.now/llms.txt · OpenAPI:
+https://shiply.now/openapi.json · Docs: https://shiply.now/docs