shiply-cli 0.6.0 → 0.7.1

package/dist/drive.js

@@ -0,0 +1,77 @@
+import { createHash } from 'node:crypto';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { api, resolveBase } from './publish.js';
+const sha256 = (b) => createHash('sha256').update(b).digest('hex');
+const headers = (apiKey) => ({ 'content-type': 'application/json', authorization: `Bearer ${apiKey}` });
+async function defaultDrive(ctx) {
+    const base = resolveBase(ctx.base);
+    const d = await api(`${base}/api/v1/drives/default`, { headers: headers(ctx.apiKey) });
+    return d.publicId;
+}
+export async function driveLs(ctx, prefix = '') {
+    const base = resolveBase(ctx.base);
+    const id = await defaultDrive(ctx);
+    const out = await api(`${base}/api/v1/drives/${id}/files?prefix=${encodeURIComponent(prefix)}&limit=200`, { headers: headers(ctx.apiKey) });
+    if (out.files.length === 0) {
+        console.log('  (empty)');
+        return;
+    }
+    for (const f of out.files)
+        console.log(`  ${f.path}  ${Math.ceil(f.size / 1024)}KB`);
+}
+export async function drivePut(ctx, file, asPath) {
+    const base = resolveBase(ctx.base);
+    const id = await defaultDrive(ctx);
+    const body = await readFile(file);
+    const path = asPath ?? basename(file);
+    const hash = sha256(body);
+    const meta = { path, size: body.length, contentType: 'application/octet-stream', hash };
+    const stage = await api(`${base}/api/v1/drives/${id}/files/uploads`, { method: 'POST', headers: headers(ctx.apiKey), body: JSON.stringify({ files: [meta] }) });
+    for (const u of stage.uploads) {
+        const res = await fetch(u.url, { method: 'PUT', body: new Uint8Array(body) });
+        if (!res.ok)
+            throw new Error(`upload failed for ${u.path}`);
+    }
+    await api(`${base}/api/v1/drives/${id}/files/finalize`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ files: [meta] }),
+    });
+    console.log(`✔ put ${path}`);
+}
+export async function driveGet(ctx, path, out) {
+    const base = resolveBase(ctx.base);
+    const id = await defaultDrive(ctx);
+    const { url } = await api(`${base}/api/v1/drives/${id}/files/${path.split('/').map(encodeURIComponent).join('/')}`, { headers: headers(ctx.apiKey) });
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`download failed (${res.status})`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (out) {
+        await writeFile(out, buf);
+        console.log(`✔ saved ${out}`);
+    }
+    else {
+        process.stdout.write(buf);
+    }
+}
+export async function driveRm(ctx, path) {
+    const base = resolveBase(ctx.base);
+    const id = await defaultDrive(ctx);
+    await api(`${base}/api/v1/drives/${id}/files/${path.split('/').map(encodeURIComponent).join('/')}`, {
+        method: 'DELETE',
+        headers: headers(ctx.apiKey),
+    });
+    console.log(`✔ removed ${path}`);
+}
+export async function drivePublish(ctx, prefix) {
+    const base = resolveBase(ctx.base);
+    const id = await defaultDrive(ctx);
+    const out = await api(`${base}/api/v1/publish/from-drive`, {
+        method: 'POST',
+        headers: headers(ctx.apiKey),
+        body: JSON.stringify({ driveId: id, ...(prefix ? { prefix } : {}) }),
+    });
+    console.log(`✔ published drive (${out.filesCount} files)\n\n  ${out.siteUrl}\n`);
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { parseArgs } from 'node:util';
 import { confetti } from './confetti.js';
 import { detectFramework, findBuildOutput } from './framework.js';
+import { driveGet, driveLs, drivePublish, drivePut, driveRm } from './drive.js';
 import { loadApiKey, saveApiKey } from './config.js';
 import { api, DEFAULT_BASE, publish, resolveBase } from './publish.js';
 import { installSkill } from './skill.js';
@@ -17,6 +18,7 @@ Usage:
   shiply update <dir>                         Same as publish when .shiply.json exists
   shiply status <slug-or-domain> [--wait]     SSL + readiness check (agent-friendly output)
   shiply duplicate <slug>                     Server-side copy of an owned site → new URL
+  shiply drive <ls|put|get|rm|publish>        Private cloud storage (drive publish → live site)
   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
@@ -77,6 +79,7 @@ async function main() {
             'new-site': { type: 'boolean' },
             project: { type: 'boolean' },
             timeout: { type: 'string' },
+            out: { type: 'string', short: 'o' },
             'no-confetti': { type: 'boolean' },
             help: { type: 'boolean', short: 'h' },
         },
@@ -209,6 +212,40 @@ async function main() {
             console.log(`\n  ${out.siteUrl}\n`);
             return;
         }
+        case 'drive': {
+            const apiKey = values.key ?? (await loadApiKey());
+            if (!apiKey)
+                throw new Error('drive commands need an API key — run `shiply login` first');
+            const dctx = { base: values.base, apiKey };
+            const sub = dir; // positionals[1]
+            const arg = positionals[2];
+            const arg2 = positionals[3];
+            switch (sub) {
+                case 'ls':
+                    await driveLs(dctx, arg);
+                    return;
+                case 'put':
+                    if (!arg)
+                        throw new Error('usage: shiply drive put <file> [as-path]');
+                    await drivePut(dctx, arg, arg2);
+                    return;
+                case 'get':
+                    if (!arg)
+                        throw new Error('usage: shiply drive get <path> [out-file]  (omit out-file to print to stdout)');
+                    await driveGet(dctx, arg, values.out ?? arg2);
+                    return;
+                case 'rm':
+                    if (!arg)
+                        throw new Error('usage: shiply drive rm <path>');
+                    await driveRm(dctx, arg);
+                    return;
+                case 'publish':
+                    await drivePublish(dctx, arg);
+                    return;
+                default:
+                    throw new Error('usage: shiply drive <ls|put|get|rm|publish>');
+            }
+        }
         case 'skill': {
             const written = await installSkill(Boolean(values.project));
             for (const w of written)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shiply-cli",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Publish static sites to shiply.now from the command line — instant web hosting for agents.",
   "license": "MIT",
   "type": "module",

package/skill/SKILL.md

@@ -17,9 +17,23 @@ same site** — otherwise you litter subdomains and lose the user's URL.
 ### 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.
+call for updates — follow it, and a `shareSuggestion` you can relay to the user.
+Other tools: `site_status`, `list_sites`, `get_site`, `set_handle`,
+`duplicate_site`, `set_variable`, `add_domain`/`list_domains`/`check_domain`/
+`remove_domain`, `get_analytics`, `delete_site`.
+
+Newer capabilities (use when relevant):
+- `set_site_access` — password / invite-only protect a site (paid).
+- `set_link` — mount another owned **public** site at a path on a host
+  (host/docs → target).
+- `set_profile` / `feature_site` — stand up the user's public portfolio at
+  <handle>.shiply.now and feature a public site on shiply.now/explore.
+- **Drives** (private cloud storage for files/notes/context): `list_drives`,
+  `create_drive`, `drive_put_file` (driveId "default", utf8/base64, ≤2 MB),
+  `drive_list_files`, `drive_delete_file`, `publish_from_drive` (snapshot a
+  drive into a live site). Great for agent memory and assets you don't want on
+  a public site.
+- `export_account` — JSON bundle of the user's data (no secrets).
 
 ### 2. CLI
 ```bash