@peume/cli 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# @peume/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Put your app online from Claude Code or your terminal. No account, no GitHub. Free on `yourapp.peume.com`.
+
+## Claude Code
+
+```bash
+claude mcp add peume -- npx -y @peume/cli mcp
+```
+
+Then ask: **“Deploy this on Peume”**. Claude gets your link, and if the build fails it reads the logs and fixes the code.
+
+## Terminal
+
+```bash
+npx @peume/cli deploy            # deploy the current folder and follow the build
+npx @peume/cli status            # URL, state and last build
+npx @peume/cli logs              # runtime logs
+npx @peume/cli env set KEY=value # set variables, then redeploy
+```
+
+- Works with Node, Next.js, React/Vite, Python, plain HTML or a Dockerfile.
+- Your app must listen on the `PORT` environment variable.
+- Variables in `.env` are set on the app, never stored with the code.
+- `node_modules`, `.git` and build caches are not uploaded.
+- A new app stops after 24 h unless you claim it (free) with the link shown after the deploy.
+
+https://cloud.peume.com

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "@peume/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Deploy your app on Peume from Claude Code or your terminal. No account, no GitHub.",
+  "type": "module",
+  "bin": {
+    "peume": "peume.mjs"
+  },
+  "files": [
+    "peume.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "keywords": [
+    "deploy",
+    "hosting",
+    "mcp",
+    "claude-code",
+    "vibe-coding",
+    "paas"
+  ],
+  "homepage": "https://cloud.peume.com"
+}

package/peume.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+// Peume CLI et serveur MCP (même fichier) : envoie le dossier courant sur Peume, suit le build, rend l'adresse de l'app.
+//   peume deploy [dossier]        peume status   peume logs   peume env set CLE=valeur…   peume mcp (pour Claude Code)
+// Le nom de l'app est gardé dans <dossier>/.peume ; le jeton qui permet de la redéployer reste sur la machine (~/.peume/jetons.json).
+import { spawn } from 'node:child_process';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join, resolve, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { createInterface } from 'node:readline';
+
+const PEUME = (process.env.PEUME_URL || 'https://cloud.peume.com').replace(/\/$/, '');
+const JETONS = join(homedir(), '.peume', 'jetons.json');
+const EXCLUS = ['node_modules', '.git', '.next', '.nuxt', '.svelte-kit', '.vercel', '.turbo', '.cache', '.DS_Store', '.peume', '__pycache__', '.venv', 'venv', '.idea', '.vscode', '*.log'];
+const VERSION = '0.1.0';
+
+const lireJSON = async (f, d) => { try { return JSON.parse(await readFile(f, 'utf8')); } catch { return d; } };
+async function lien(dossier) {
+  const app = (await lireJSON(join(dossier, '.peume'), {})).app;
+  return { app, jeton: app ? (await lireJSON(JETONS, {}))[app] : undefined };
+}
+async function retenir(dossier, app, jeton) {
+  await writeFile(join(dossier, '.peume'), JSON.stringify({ app }, null, 2) + '\n');
+  if (jeton) {
+    const j = await lireJSON(JETONS, {}); j[app] = jeton;
+    await mkdir(join(homedir(), '.peume'), { recursive: true });
+    await writeFile(JETONS, JSON.stringify(j, null, 2), { mode: 0o600 });
+  }
+}
+
+// dossier → .tar.gz en mémoire (tar est présent sur macOS, Linux et Windows 10+)
+function empaqueter(dossier) {
+  return new Promise((ok, ko) => {
+    const p = spawn('tar', ['-czf', '-', ...EXCLUS.map(e => `--exclude=${e}`), '-C', dossier, '.'], { env: { ...process.env, COPYFILE_DISABLE: '1' } });
+    const d = [], err = [];
+    p.stdout.on('data', x => d.push(x)); p.stderr.on('data', x => err.push(x));
+    p.on('error', e => ko(new Error(`tar is needed to pack the folder: ${e.message}`)));
+    p.on('close', c => c === 0 ? ok(Buffer.concat(d)) : ko(new Error(`Could not pack the folder: ${Buffer.concat(err).toString().slice(0, 300)}`)));
+  });
+}
+
+async function appel(chemin, { methode = 'GET', corps, entetes = {}, delai = 30000 } = {}) {
+  let r;
+  try { r = await fetch(`${PEUME}${chemin}`, { method: methode, body: corps, headers: { 'user-agent': `peume-cli/${VERSION}`, ...entetes }, signal: AbortSignal.timeout(delai) }); }
+  catch (e) { throw new Error(e.name === 'TimeoutError' ? 'Peume did not answer in time. Try again.' : `Could not reach Peume (${e.message}).`); }
+  const j = await r.json().catch(() => ({}));
+  if (!r.ok) throw new Error(j.error || `Peume answered ${r.status}.`);
+  return j;
+}
+const auth = jeton => (jeton ? { 'x-peume-jeton': jeton } : {});
+
+// envoie le dossier puis suit le build (10 min max) ; surLigne reçoit chaque nouvelle ligne de log
+export async function deployer(dossier, { nom, surLigne = () => {}, surEtape = () => {} } = {}) {
+  dossier = resolve(dossier);
+  const { app, jeton } = await lien(dossier);
+  surEtape('Packing the folder…');
+  const archive = await empaqueter(dossier);
+  if (archive.length > 50e6) throw new Error(`The folder is ${Math.round(archive.length / 1e6)} MB once packed (50 MB max). Move big files out of it.`);
+  surEtape(`Uploading ${Math.max(1, Math.round(archive.length / 1e3))} KB…`);
+  const r = await appel('/api/deploy', { methode: 'POST', corps: archive, delai: 180000, entetes: {
+    'content-type': 'application/gzip', 'x-peume-nom': nom || basename(dossier), ...(app ? { 'x-peume-app': app } : {}), ...auth(jeton) } });
+  await retenir(dossier, r.id, r.jeton);
+  surEtape(`Building ${r.url}…`);
+  let vus = 0, e = r;
+  const fin = Date.now() + 10 * 60e3;
+  while (Date.now() < fin) {
+    await new Promise(t => setTimeout(t, 2000));
+    try { e = await appel(`/api/apps/${r.id}`, { entetes: auth(r.jeton || jeton) }); } catch { continue; }
+    const logs = e.deploiement?.logs || [];
+    for (const l of logs.slice(vus)) surLigne(l);
+    vus = logs.length;
+    if (['live', 'failed', 'cancelled'].includes(e.deploiement?.statut)) break;
+  }
+  return e;
+}
+
+const resume = e => {
+  const ok = e.deploiement?.statut === 'live';
+  const l = [ok ? `Live: ${e.url}` : e.deploiement?.statut === 'failed' ? `Build failed for ${e.url}.` : `Still building: ${e.url} (check again with "npx @peume/cli status").`];
+  if (!ok && e.deploiement?.logs?.length) l.push('', 'Last build lines:', ...e.deploiement.logs.slice(-40));
+  if (!e.reclamee && e.lienClaim) l.push('', `This app stops in 24 h unless you claim it (free): ${e.lienClaim}`);
+  return l.join('\n');
+};
+
+async function etat(dossier) {
+  const { app, jeton } = await lien(resolve(dossier));
+  if (!app) throw new Error('This folder is not deployed yet. Run "npx @peume/cli deploy" first.');
+  return { app, jeton, e: await appel(`/api/apps/${app}`, { entetes: auth(jeton) }) };
+}
+async function logs(dossier) {
+  const { app, jeton } = await lien(resolve(dossier));
+  if (!app) throw new Error('This folder is not deployed yet.');
+  return (await appel(`/api/apps/${app}/logs`, { entetes: auth(jeton) })).logs;
+}
+async function variables(dossier, paires) {
+  const { app, jeton } = await lien(resolve(dossier));
+  if (!app) throw new Error('This folder is not deployed yet.');
+  const vars = Object.entries(paires).map(([key, value]) => ({ key, value: String(value) }));
+  await appel(`/api/apps/${app}/env`, { methode: 'PUT', corps: JSON.stringify({ vars, fusion: true }), entetes: { 'content-type': 'application/json', ...auth(jeton) } });
+  return appel(`/api/apps/${app}/redeploy`, { methode: 'POST', entetes: auth(jeton) });
+}
+
+// ——— serveur MCP (stdio) pour Claude Code : claude mcp add peume -- npx -y @peume/cli mcp
+const OUTILS = [
+  { name: 'deploy', description: 'Deploy a project folder on Peume (free, no account needed) and wait for the build. Returns the live URL (name.peume.com), or the build logs if it failed so you can fix the code and deploy again. The app must listen on the PORT environment variable. Variables in .env are set on the app, never uploaded as files.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the project folder.' }, name: { type: 'string', description: 'Wanted app name for the first deploy (becomes name.peume.com). Defaults to the folder name.' } }, required: ['path'] } },
+  { name: 'status', description: 'Status of the Peume app deployed from this folder: URL, state and the latest build logs.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the project folder.' } }, required: ['path'] } },
+  { name: 'logs', description: 'Runtime logs of the running Peume app deployed from this folder.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the project folder.' } }, required: ['path'] } },
+  { name: 'set_env', description: 'Set environment variables on the Peume app deployed from this folder, then redeploy it.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the project folder.' }, vars: { type: 'object', additionalProperties: { type: 'string' }, description: 'Variables to set, e.g. {"API_KEY": "…"}.' } }, required: ['path', 'vars'] } },
+];
+async function outil(nom, args = {}) {
+  if (!args.path) throw new Error('path is required.');
+  if (nom === 'deploy') return resume(await deployer(args.path, { nom: args.name }));
+  if (nom === 'status') { const { e } = await etat(args.path); return `${e.url} — ${e.statut}${e.deploiement ? ` (last build: ${e.deploiement.statut}, ${e.deploiement.commit})` : ''}\n${resume(e)}`; }
+  if (nom === 'logs') return (await logs(args.path)).join('\n') || 'No logs yet.';
+  if (nom === 'set_env') { const e = await variables(args.path, args.vars || {}); return `Variables set (${Object.keys(args.vars || {}).join(', ')}). Redeploying ${e.url}.`; }
+  throw new Error(`Unknown tool ${nom}.`);
+}
+function mcp() {
+  const envoyer = m => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...m }) + '\n');
+  createInterface({ input: process.stdin }).on('line', async l => {
+    let m; try { m = JSON.parse(l); } catch { return; }
+    if (m.id === undefined) return; // notifications
+    try {
+      if (m.method === 'initialize') return envoyer({ id: m.id, result: { protocolVersion: m.params?.protocolVersion || '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: 'peume', version: VERSION } } });
+      if (m.method === 'ping') return envoyer({ id: m.id, result: {} });
+      if (m.method === 'tools/list') return envoyer({ id: m.id, result: { tools: OUTILS } });
+      if (m.method === 'tools/call') {
+        try { return envoyer({ id: m.id, result: { content: [{ type: 'text', text: await outil(m.params?.name, m.params?.arguments) }] } }); }
+        catch (e) { return envoyer({ id: m.id, result: { content: [{ type: 'text', text: e.message }], isError: true } }); }
+      }
+      envoyer({ id: m.id, error: { code: -32601, message: `Unknown method ${m.method}` } });
+    } catch (e) { envoyer({ id: m.id, error: { code: -32603, message: e.message } }); }
+  });
+}
+
+// ——— ligne de commande
+const AIDE = `Peume — deploy your app, no account, no GitHub.
+
+  npx @peume/cli deploy [folder]       deploy the folder (default: current) and follow the build
+  npx @peume/cli status                URL, state and last build
+  npx @peume/cli logs                  runtime logs
+  npx @peume/cli env set KEY=value…    set variables, then redeploy
+  npx @peume/cli mcp                   MCP server for Claude Code:
+                                       claude mcp add peume -- npx -y @peume/cli mcp
+`;
+const gris = s => process.stdout.isTTY ? `\x1b[2m${s}\x1b[0m` : s;
+async function principal([cmd = 'help', ...args]) {
+  if (cmd === 'mcp') return mcp();
+  try {
+    if (cmd === 'deploy') {
+      const e = await deployer(args.find(a => !a.startsWith('-')) || '.', { surEtape: s => console.log(s), surLigne: l => console.log(gris(`  ${l}`)) });
+      console.log('\n' + resume({ ...e, deploiement: e.deploiement && { ...e.deploiement, logs: e.deploiement.statut === 'live' ? [] : e.deploiement.logs } }));
+      process.exitCode = e.deploiement?.statut === 'live' ? 0 : 1;
+    } else if (cmd === 'status') console.log(await outil('status', { path: '.' }));
+    else if (cmd === 'logs') console.log(await outil('logs', { path: '.' }));
+    else if (cmd === 'env' && args[0] === 'set') {
+      const vars = Object.fromEntries(args.slice(1).map(a => { const i = a.indexOf('='); return i > 0 ? [a.slice(0, i), a.slice(i + 1)] : null; }).filter(Boolean));
+      if (!Object.keys(vars).length) throw new Error('Usage: npx @peume/cli env set KEY=value');
+      console.log(await outil('set_env', { path: '.', vars }));
+    } else if (cmd === '--version' || cmd === '-v') console.log(VERSION);
+    else console.log(AIDE);
+  } catch (e) { console.error(e.message); process.exitCode = 1; }
+}
+principal(process.argv.slice(2));