@iksdev/shard-cli 0.1.1

package/README.md

@@ -0,0 +1,46 @@
+# shard-cli
+
+CLI pour synchroniser un dossier local vers ton serveur Shard.
+
+## Installation locale (dev)
+
+Depuis la racine du repo:
+
+```bash
+npm i -g ./shard-cli
+```
+
+Puis verifier:
+
+```bash
+shard --help
+```
+
+## Usage rapide
+
+1. Login
+
+```bash
+shard login --server http://localhost:3000 --username admin --password secret
+```
+
+2. Sync un dossier
+
+```bash
+shard sync ./MonDossier
+```
+
+## Commandes
+
+- `shard login --username <name> --password <pass> [--server <url>]`
+- `shard whoami [--server <url>]`
+- `shard sync <folder> [--server <url>] [--dry-run] [--force]`
+- `shard logout`
+- `shard config show`
+- `shard config set-server <url>`
+
+## Notes
+
+- Le CLI stocke la config dans `~/.shard-cli/config.json`.
+- Le CLI stocke l'etat de sync dans `<ton-dossier>/.shard-sync-state.json`.
+- Les uploads passent par `POST /api/files/upload` avec token `Bearer`.

package/bin/shard.js

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const os = require('os');
+const path = require('path');
+
+const CONFIG_DIR = path.join(os.homedir(), '.shard-cli');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+const STATE_FILE = '.shard-sync-state.json';
+const DEFAULT_SERVER = 'http://localhost:3000';
+const IGNORED_DIRS = new Set(['.git', 'node_modules']);
+
+function printHelp() {
+  console.log(`Shard CLI
+
+Usage:
+  shard login --username <name> --password <pass> [--server <url>]
+  shard whoami [--server <url>]
+  shard sync <folder> [--server <url>] [--dry-run] [--force]
+  shard logout
+  shard config show
+  shard config set-server <url>
+
+Examples:
+  shard login --server http://localhost:3000 --username admin --password secret
+  shard sync ./MonDossier
+  shard sync ./MonDossier --dry-run
+`);
+}
+
+function parseArgs(rawArgs) {
+  const args = [...rawArgs];
+  const command = args.shift();
+  const positionals = [];
+  const flags = {};
+
+  for (let i = 0; i < args.length; i += 1) {
+    const cur = args[i];
+    if (!cur.startsWith('--')) {
+      positionals.push(cur);
+      continue;
+    }
+    const key = cur.slice(2);
+    const next = args[i + 1];
+    if (!next || next.startsWith('--')) {
+      flags[key] = true;
+      continue;
+    }
+    flags[key] = next;
+    i += 1;
+  }
+  return { command, positionals, flags };
+}
+
+function normalizeServer(input) {
+  const raw = String(input || '').trim();
+  if (!raw) return DEFAULT_SERVER;
+  return raw.replace(/\/+$/, '');
+}
+
+async function ensureConfigDir() {
+  await fsp.mkdir(CONFIG_DIR, { recursive: true });
+}
+
+async function readConfig() {
+  try {
+    const raw = await fsp.readFile(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      server: normalizeServer(parsed.server || DEFAULT_SERVER),
+      token: parsed.token || ''
+    };
+  } catch {
+    return { server: DEFAULT_SERVER, token: '' };
+  }
+}
+
+async function writeConfig(config) {
+  await ensureConfigDir();
+  const payload = {
+    server: normalizeServer(config.server || DEFAULT_SERVER),
+    token: config.token || ''
+  };
+  await fsp.writeFile(CONFIG_PATH, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function getServer(flags, config) {
+  return normalizeServer(flags.server || process.env.SHARD_SERVER || config.server || DEFAULT_SERVER);
+}
+
+function getToken(config) {
+  return process.env.SHARD_TOKEN || config.token || '';
+}
+
+async function httpJson(url, options = {}) {
+  const res = await fetch(url, options);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const err = new Error(data.message || data.error || `HTTP ${res.status}`);
+    err.status = res.status;
+    err.data = data;
+    throw err;
+  }
+  return data;
+}
+
+async function login(flags) {
+  const username = flags.username;
+  const password = flags.password;
+  if (!username || !password) {
+    throw new Error('Usage: shard login --username <name> --password <pass> [--server <url>]');
+  }
+
+  const config = await readConfig();
+  const server = getServer(flags, config);
+
+  const data = await httpJson(`${server}/api/auth/login`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ username, password })
+  });
+
+  if (!data.token) {
+    throw new Error('Connexion réussie mais token manquant.');
+  }
+
+  await writeConfig({ server, token: data.token });
+  console.log(`Connecte a ${server}`);
+  if (data.user?.username) {
+    console.log(`Utilisateur: ${data.user.username}`);
+  }
+}
+
+async function whoami(flags) {
+  const config = await readConfig();
+  const server = getServer(flags, config);
+  const token = getToken(config);
+  if (!token) {
+    throw new Error('Non connecte. Lance: shard login --username ... --password ...');
+  }
+
+  const data = await httpJson(`${server}/api/auth/verify`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  const user = data.user || {};
+  console.log(`Server: ${server}`);
+  console.log(`User: ${user.username || user.userId || 'inconnu'}`);
+  if (user.email) console.log(`Email: ${user.email}`);
+}
+
+async function logout() {
+  const config = await readConfig();
+  await writeConfig({ ...config, token: '' });
+  console.log('Token supprime.');
+}
+
+async function showConfig() {
+  const config = await readConfig();
+  console.log(JSON.stringify({
+    server: config.server,
+    hasToken: Boolean(config.token)
+  }, null, 2));
+}
+
+async function setServer(positionals) {
+  const url = positionals[0];
+  if (!url) {
+    throw new Error('Usage: shard config set-server <url>');
+  }
+  const config = await readConfig();
+  await writeConfig({ ...config, server: normalizeServer(url) });
+  console.log(`Server mis a jour: ${normalizeServer(url)}`);
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fsp.access(targetPath, fs.constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listFilesRecursive(rootDir) {
+  const out = [];
+
+  async function walk(currentDir) {
+    const entries = await fsp.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name === STATE_FILE) continue;
+      if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue;
+
+      const abs = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+
+      const rel = path.relative(rootDir, abs).split(path.sep).join('/');
+      const stat = await fsp.stat(abs);
+      out.push({
+        absPath: abs,
+        relPath: rel,
+        size: stat.size,
+        mtimeMs: Math.round(stat.mtimeMs)
+      });
+    }
+  }
+
+  await walk(rootDir);
+  out.sort((a, b) => a.relPath.localeCompare(b.relPath));
+  return out;
+}
+
+async function readState(rootDir) {
+  const filePath = path.join(rootDir, STATE_FILE);
+  try {
+    const raw = await fsp.readFile(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object') return { version: 1, files: {} };
+    return { version: 1, files: parsed.files || {} };
+  } catch {
+    return { version: 1, files: {} };
+  }
+}
+
+async function writeState(rootDir, state) {
+  const filePath = path.join(rootDir, STATE_FILE);
+  const payload = {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    files: state.files || {}
+  };
+  await fsp.writeFile(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function guessMime(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const map = {
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.ts': 'text/plain',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.pdf': 'application/pdf',
+    '.zip': 'application/zip'
+  };
+  return map[ext] || 'application/octet-stream';
+}
+
+async function uploadOneFile(server, token, file) {
+  const blob = await fs.openAsBlob(file.absPath, { type: guessMime(file.absPath) });
+  const form = new FormData();
+  // On force le nom "relatif" pour garder la notion de dossier dans l'UI/DB.
+  form.append('file', blob, file.relPath);
+
+  return httpJson(`${server}/api/files/upload`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` },
+    body: form
+  });
+}
+
+async function syncFolder(positionals, flags) {
+  const target = positionals[0];
+  if (!target) {
+    throw new Error('Usage: shard sync <folder> [--server <url>] [--dry-run] [--force]');
+  }
+
+  const rootDir = path.resolve(process.cwd(), target);
+  if (!(await pathExists(rootDir))) {
+    throw new Error(`Dossier introuvable: ${rootDir}`);
+  }
+  const stat = await fsp.stat(rootDir);
+  if (!stat.isDirectory()) {
+    throw new Error(`Ce n'est pas un dossier: ${rootDir}`);
+  }
+
+  const config = await readConfig();
+  const server = getServer(flags, config);
+  const token = getToken(config);
+  if (!token) {
+    throw new Error('Non connecte. Lance: shard login --username ... --password ...');
+  }
+
+  await httpJson(`${server}/api/auth/verify`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` }
+  });
+
+  const files = await listFilesRecursive(rootDir);
+  const state = await readState(rootDir);
+  const force = Boolean(flags.force);
+  const dryRun = Boolean(flags['dry-run']);
+
+  const changed = files.filter((f) => {
+    if (force) return true;
+    const prev = state.files[f.relPath];
+    if (!prev) return true;
+    return !(prev.size === f.size && prev.mtimeMs === f.mtimeMs);
+  });
+
+  const unchanged = files.length - changed.length;
+  console.log(`Server: ${server}`);
+  console.log(`Dossier: ${rootDir}`);
+  console.log(`Total: ${files.length} fichier(s)`);
+  console.log(`A uploader: ${changed.length}`);
+  console.log(`Inchanges: ${unchanged}`);
+
+  if (dryRun) {
+    for (const f of changed.slice(0, 50)) console.log(`- ${f.relPath}`);
+    if (changed.length > 50) console.log(`... +${changed.length - 50} autres`);
+    return;
+  }
+
+  let success = 0;
+  let failed = 0;
+
+  for (let i = 0; i < changed.length; i += 1) {
+    const file = changed[i];
+    const label = `[${i + 1}/${changed.length}]`;
+    try {
+      const result = await uploadOneFile(server, token, file);
+      success += 1;
+      state.files[file.relPath] = {
+        size: file.size,
+        mtimeMs: file.mtimeMs,
+        uploadedAt: new Date().toISOString(),
+        remoteId: result?.file?.id || null
+      };
+      console.log(`${label} OK ${file.relPath}`);
+    } catch (error) {
+      failed += 1;
+      console.error(`${label} FAIL ${file.relPath} -> ${error.message}`);
+    }
+  }
+
+  for (const relPath of Object.keys(state.files)) {
+    const stillThere = files.some((f) => f.relPath === relPath);
+    if (!stillThere) delete state.files[relPath];
+  }
+  await writeState(rootDir, state);
+
+  console.log(`Termine. Uploades: ${success}, erreurs: ${failed}`);
+  if (failed > 0) process.exitCode = 2;
+}
+
+async function main() {
+  const { command, positionals, flags } = parseArgs(process.argv.slice(2));
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    printHelp();
+    return;
+  }
+
+  if (command === 'login') {
+    await login(flags);
+    return;
+  }
+
+  if (command === 'whoami') {
+    await whoami(flags);
+    return;
+  }
+
+  if (command === 'logout') {
+    await logout();
+    return;
+  }
+
+  if (command === 'sync') {
+    await syncFolder(positionals, flags);
+    return;
+  }
+
+  if (command === 'config') {
+    const sub = positionals[0];
+    if (sub === 'show') {
+      await showConfig();
+      return;
+    }
+    if (sub === 'set-server') {
+      await setServer(positionals.slice(1));
+      return;
+    }
+    throw new Error('Usage: shard config show | shard config set-server <url>');
+  }
+
+  throw new Error(`Commande inconnue: ${command}`);
+}
+
+main().catch((error) => {
+  console.error(`Erreur: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@iksdev/shard-cli",
+  "version": "0.1.1",
+  "description": "CLI pour synchroniser un dossier local avec Shard",
+  "bin": {
+    "shard": "bin/shard.js"
+  },
+  "type": "commonjs",
+  "scripts": {
+    "check": "node --check bin/shard.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "MIT"
+}