@peume/cli 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,36 @@
-# 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.
+
+## Built in
+
+Every app gets `PEUME_KEY` and `PEUME_API`:
+
+- **Peume Data**: hundreds of data tools (scraping, search, maps, social…).
+- **Peume Routing**: every AI model through the OpenAI SDK, no other account.
+- **Payments**: get paid in your app, money goes to your own Stripe account.
+
+Docs: https://cloud.peume.com/docs

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.2.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,196 @@
+#!/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.2.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;
+}
+// Peume Data (outils de données via Peume, payés en crédits Peume) avec l'identité de l'app du dossier
+async function data(dossier, chemin, corps) {
+  const { app, jeton } = await lien(resolve(dossier));
+  if (!app) throw new Error('Deploy this folder on Peume first (deploy tool), then claim the app to use Peume Data.');
+  return appel(`/api/v1/data${chemin}`, { methode: corps ? 'POST' : 'GET', corps: corps && JSON.stringify(corps), entetes: { 'content-type': 'application/json', 'x-peume-app': app, ...auth(jeton) }, delai: 60000 });
+}
+async function lancerData(dossier, args) {
+  let r = await data(dossier, '/run', { provider: args.provider, endpoint: args.endpoint, input: args.input || {} });
+  const fin = Date.now() + 120e3;
+  while (!['COMPLETED', 'FAILED', 'BLOCKED', 'STOPPED', 'TIMED_OUT'].includes(r.status) && Date.now() < fin) {
+    await new Promise(t => setTimeout(t, 5000));
+    r = await data(dossier, `/runs/${r.runId}`);
+  }
+  const sortie = JSON.stringify(r.output ?? r.error ?? null, null, 2);
+  return `Run ${r.runId}: ${r.status}${r.cost ? ` · $${r.cost.value.toFixed(4)}` : ''}\n${sortie.length > 20000 ? `${sortie.slice(0, 20000)}\n… (truncated)` : sortie}`;
+}
+
+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. The app also gets PEUME_KEY and PEUME_API for Peume Data and payments (see the services tool).',
+    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: 'services', description: 'How the deployed app can use Peume services from its server code: Peume Data (hundreds of data tools: scraping, search, maps, social, companies), Peume Routing (every AI model through the OpenAI SDK, no other API key) and payments (Stripe checkout, money goes to the owner). Every Peume app gets PEUME_KEY and PEUME_API environment variables. Read this before adding data or payments to an app deployed on Peume.',
+    inputSchema: { type: 'object', properties: {} } },
+  { name: 'data_search', description: 'Search Peume Data tools for a need (e.g. "google maps reviews", "linkedin profiles"). Free. Returns provider, endpoint, description and price per call.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the deployed project folder.' }, query: { type: 'string' } }, required: ['path', 'query'] } },
+  { name: 'data_inspect', description: 'Get the exact input schema (body, queryParams, pathParams) and price of a Peume Data tool. Free. Always inspect before running.',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the deployed project folder.' }, provider: { type: 'string' }, endpoint: { type: 'string' } }, required: ['path', 'provider', 'endpoint'] } },
+  { name: 'data_run', description: 'Run a Peume Data tool once (to test it while building the app) and wait up to 2 minutes for the result. Paid from the app owner\'s Peume credits: keep limits small (maxItems 5-10, one query).',
+    inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'Absolute path of the deployed project folder.' }, provider: { type: 'string' }, endpoint: { type: 'string' }, input: { type: 'object', description: '{ body?, queryParams?, pathParams? } as given by data_inspect.' } }, required: ['path', 'provider', 'endpoint'] } },
+  { 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 (nom === 'services') { const r = await fetch(`${PEUME}/docs.md`, { signal: AbortSignal.timeout(15000) }); return r.ok ? r.text() : 'Docs: https://cloud.peume.com/docs'; }
+  if (!args.path) throw new Error('path is required.');
+  if (nom === 'data_search') return JSON.stringify(await data(args.path, '/search', { query: args.query, limit: 10 }), null, 2);
+  if (nom === 'data_inspect') return JSON.stringify(await data(args.path, '/inspect', { provider: args.provider, endpoint: args.endpoint }), null, 2);
+  if (nom === 'data_run') return lancerData(args.path, args);
+  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));