@piecemaker-legal/piecemaker 1.1.1 → 2.0.2

package/server/piecemaker/vendor/installer/lib/desktop-launcher.mjs

@@ -1,305 +0,0 @@
-/**
- * Raccourci Bureau et gestionnaire du protocole local `piecemaker:`.
- *
- * Le raccourci lance `piecemaker open` : le serveur est donc démarré avant
- * l'ouverture de l'administration. Le gestionnaire de protocole, lui, lance
- * seulement `piecemaker start`; la page PWA hors ligne peut ainsi redémarrer
- * le serveur sans ouvrir une seconde fenêtre.
- */
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-import { HOME_DIR, REPO_ROOT, runCapture } from './platform.mjs';
-
-const MAC_REGISTER = '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister';
-const DEFAULT_ICNS = path.join(REPO_ROOT, 'installer', 'assets', 'piecemaker.icns');
-const DEFAULT_ICO = path.join(REPO_ROOT, 'installer', 'assets', 'piecemaker.ico');
-const DEFAULT_PNG = path.join(REPO_ROOT, 'admin', 'icons', 'icon-512.png');
-const SWIFT_SOURCE = path.join(REPO_ROOT, 'installer', 'assets', 'PieceMakerApp.swift');
-
-function shellQuote(value) {
-  return `'${String(value).replaceAll("'", `'"'"'`)}'`;
-}
-
-function powershellQuote(value) {
-  return `'${String(value).replaceAll("'", "''")}'`;
-}
-
-function desktopEntryQuote(value) {
-  return `"${String(value).replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('$', '\\$').replaceAll('`', '\\`')}"`;
-}
-
-function commandSucceeded(result) {
-  return !result?.error && result?.code === 0;
-}
-
-function writeFile(file, content, mode = 0o644) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, content, { encoding: 'utf8', mode });
-  fs.chmodSync(file, mode);
-}
-
-function desktopDirectoryForLinux(homeDir) {
-  const config = path.join(homeDir, '.config', 'user-dirs.dirs');
-  try {
-    const match = fs.readFileSync(config, 'utf8').match(/^XDG_DESKTOP_DIR="([^"]+)"/m);
-    if (match) return match[1].replace('$HOME', homeDir);
-  } catch {}
-  return path.join(homeDir, 'Desktop');
-}
-
-function resolveDesktopDirectory({ platform, homeDir, desktopDir, commandRunner }) {
-  if (desktopDir) return desktopDir;
-  if (platform === 'win32') {
-    const result = commandRunner('powershell.exe', [
-      '-NoProfile',
-      '-NonInteractive',
-      '-Command',
-      '[Environment]::GetFolderPath("Desktop")',
-    ]);
-    if (commandSucceeded(result) && result.stdout) return result.stdout.trim();
-  }
-  if (platform === 'linux') return desktopDirectoryForLinux(homeDir);
-  return path.join(homeDir, 'Desktop');
-}
-
-export function desktopLauncherPaths({
-  platform = process.platform,
-  homeDir = os.homedir(),
-  runtimeDir = HOME_DIR,
-  desktopDir,
-  commandRunner = runCapture,
-} = {}) {
-  const desktop = resolveDesktopDirectory({ platform, homeDir, desktopDir, commandRunner });
-  if (platform === 'darwin') {
-    return {
-      shortcut: path.join(desktop, 'PieceMaker.app'),
-      protocol: path.join(runtimeDir, 'launcher', 'PieceMaker Protocol.app'),
-    };
-  }
-  if (platform === 'win32') {
-    return {
-      shortcut: path.join(desktop, 'PieceMaker.lnk'),
-      protocol: 'HKCU\\Software\\Classes\\piecemaker',
-    };
-  }
-  return {
-    shortcut: path.join(desktop, 'PieceMaker.desktop'),
-    protocol: path.join(homeDir, '.local', 'share', 'applications', 'piecemaker-protocol.desktop'),
-  };
-}
-
-function macPlist({ executable, identifier, protocol = false, nativeApp = false }) {
-  const protocolBlock = protocol ? `
-  <key>CFBundleURLTypes</key>
-  <array>
-    <dict>
-      <key>CFBundleURLName</key><string>PieceMaker</string>
-      <key>CFBundleURLSchemes</key><array><string>piecemaker</string></array>
-    </dict>
-  </array>` : '';
-  const uiElement = nativeApp ? '' : '\n  <key>LSUIElement</key><true/>';
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>CFBundleDisplayName</key><string>PieceMaker</string>
-  <key>CFBundleExecutable</key><string>${executable}</string>
-  <key>CFBundleIconFile</key><string>piecemaker.icns</string>
-  <key>CFBundleIdentifier</key><string>${identifier}</string>
-  <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
-  <key>CFBundlePackageType</key><string>APPL</string>
-  <key>CFBundleShortVersionString</key><string>1.0</string>
-  <key>CFBundleVersion</key><string>1</string>${uiElement}${protocolBlock}
-</dict>
-</plist>
-`;
-}
-
-function createMacShellApplication(target, {
-  verb,
-  identifier,
-  protocol = false,
-  nodePath,
-  cliPath,
-  runtimeDir,
-  iconPath,
-}) {
-  const executable = 'PieceMaker';
-  const contents = path.join(target, 'Contents');
-  const executablePath = path.join(contents, 'MacOS', executable);
-  const logPath = path.join(runtimeDir, 'desktop-launcher.log');
-  const script = `#!/bin/sh\n${shellQuote(nodePath)} ${shellQuote(cliPath)} ${verb} >>${shellQuote(logPath)} 2>&1 &\nexit 0\n`;
-  writeFile(executablePath, script, 0o755);
-  writeFile(path.join(contents, 'Info.plist'), macPlist({ executable, identifier, protocol }));
-  fs.mkdirSync(path.join(contents, 'Resources'), { recursive: true });
-  fs.copyFileSync(iconPath, path.join(contents, 'Resources', 'piecemaker.icns'));
-}
-
-function createMacNativeApplication(target, { identifier, nodePath, cliPath, iconPath, commandRunner }) {
-  const executable = 'PieceMaker';
-  const contents = path.join(target, 'Contents');
-  const executablePath = path.join(contents, 'MacOS', executable);
-  fs.mkdirSync(path.dirname(executablePath), { recursive: true });
-  const compile = commandRunner('swiftc', [
-    '-o', executablePath,
-    '-framework', 'Cocoa',
-    '-framework', 'WebKit',
-    '-suppress-warnings',
-    SWIFT_SOURCE,
-  ]);
-  if (!commandSucceeded(compile)) {
-    throw new Error(`Compilation Swift impossible : ${compile.stderr || compile.error?.message || `code ${compile.code}`}`);
-  }
-  fs.chmodSync(executablePath, 0o755);
-  const plist = macPlist({ executable, identifier, nativeApp: true });
-  writeFile(path.join(contents, 'Info.plist'), plist);
-  fs.mkdirSync(path.join(contents, 'Resources'), { recursive: true });
-  fs.copyFileSync(iconPath, path.join(contents, 'Resources', 'piecemaker.icns'));
-  const envPlist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>PIECEMAKER_NODE</key><string>${nodePath}</string>
-  <key>PIECEMAKER_CLI</key><string>${cliPath}</string>
-</dict>
-</plist>
-`;
-  writeFile(path.join(contents, 'Resources', 'environment.plist'), envPlist);
-}
-
-function installMac({ paths, nodePath, cliPath, runtimeDir, iconPath, commandRunner }) {
-  const swiftAvailable = commandSucceeded(commandRunner('which', ['swiftc']));
-  if (swiftAvailable) {
-    createMacNativeApplication(paths.shortcut, {
-      identifier: 'com.piecemaker.desktop',
-      nodePath,
-      cliPath,
-      iconPath,
-      commandRunner,
-    });
-  } else {
-    createMacShellApplication(paths.shortcut, {
-      verb: 'open',
-      identifier: 'com.piecemaker.desktop',
-      nodePath,
-      cliPath,
-      runtimeDir,
-      iconPath,
-    });
-  }
-  createMacShellApplication(paths.protocol, {
-    verb: 'start',
-    identifier: 'com.piecemaker.protocol',
-    protocol: true,
-    nodePath,
-    cliPath,
-    runtimeDir,
-    iconPath,
-  });
-  const registration = commandRunner(MAC_REGISTER, ['-f', paths.protocol]);
-  return {
-    native: swiftAvailable,
-    protocolReady: commandSucceeded(registration),
-    protocolError: registration.stderr || registration.error?.message || '',
-  };
-}
-
-function installWindows({ paths, nodePath, cliPath, repoRoot, iconPath, commandRunner }) {
-  fs.mkdirSync(path.dirname(paths.shortcut), { recursive: true });
-  const script = [
-    '$shell = New-Object -ComObject WScript.Shell',
-    `$shortcut = $shell.CreateShortcut(${powershellQuote(paths.shortcut)})`,
-    `$shortcut.TargetPath = ${powershellQuote(nodePath)}`,
-    `$shortcut.Arguments = ${powershellQuote(`"${cliPath}" open`)}`,
-    `$shortcut.WorkingDirectory = ${powershellQuote(repoRoot)}`,
-    `$shortcut.IconLocation = ${powershellQuote(`${iconPath},0`)}`,
-    "$shortcut.Description = 'Démarrer et ouvrir PieceMaker'",
-    '$shortcut.Save()',
-  ].join('; ');
-  const shortcut = commandRunner('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script]);
-  if (!commandSucceeded(shortcut)) {
-    throw new Error(shortcut.stderr || shortcut.error?.message || 'Création du raccourci Windows impossible.');
-  }
-
-  const key = 'HKCU\\Software\\Classes\\piecemaker';
-  const protocolCommand = `"${nodePath}" "${cliPath}" start`;
-  const commands = [
-    [key, '/ve', '/d', 'URL:PieceMaker'],
-    [key, '/v', 'URL Protocol', '/d', ''],
-    [`${key}\\DefaultIcon`, '/ve', '/d', `"${iconPath}",0`],
-    [`${key}\\shell\\open\\command`, '/ve', '/d', protocolCommand],
-  ];
-  const results = commands.map((args) => commandRunner('reg.exe', ['add', ...args, '/f']));
-  const failure = results.find((result) => !commandSucceeded(result));
-  return { protocolReady: !failure, protocolError: failure?.stderr || failure?.error?.message || '' };
-}
-
-function linuxDesktopEntry({ name, comment, nodePath, cliPath, verb, iconPath, protocol = false }) {
-  return `[Desktop Entry]
-Type=Application
-Name=${name}
-Comment=${comment}
-Exec=${desktopEntryQuote(nodePath)} ${desktopEntryQuote(cliPath)} ${verb}
-Icon=${iconPath}
-Terminal=false
-Categories=Office;Utility;
-${protocol ? 'NoDisplay=true\nMimeType=x-scheme-handler/piecemaker;\n' : ''}`;
-}
-
-function installLinux({ paths, nodePath, cliPath, iconPath, commandRunner }) {
-  writeFile(paths.shortcut, linuxDesktopEntry({
-    name: 'PieceMaker',
-    comment: 'Démarrer et ouvrir PieceMaker',
-    nodePath,
-    cliPath,
-    verb: 'open',
-    iconPath,
-  }), 0o755);
-  writeFile(paths.protocol, linuxDesktopEntry({
-    name: 'PieceMaker Protocol',
-    comment: 'Démarrer le serveur local PieceMaker',
-    nodePath,
-    cliPath,
-    verb: 'start',
-    iconPath,
-    protocol: true,
-  }), 0o755);
-  const registration = commandRunner('xdg-mime', ['default', path.basename(paths.protocol), 'x-scheme-handler/piecemaker']);
-  return { protocolReady: commandSucceeded(registration), protocolError: registration.stderr || registration.error?.message || '' };
-}
-
-export function installDesktopLauncher({
-  platform = process.platform,
-  homeDir = os.homedir(),
-  runtimeDir = HOME_DIR,
-  repoRoot = REPO_ROOT,
-  desktopDir,
-  nodePath = process.execPath,
-  commandRunner = runCapture,
-  iconPath,
-} = {}) {
-  const paths = desktopLauncherPaths({ platform, homeDir, runtimeDir, desktopDir, commandRunner });
-  const cliPath = path.join(repoRoot, 'installer', 'bin', 'piecemaker.mjs');
-  let result;
-  if (platform === 'darwin') {
-    result = installMac({ paths, nodePath, cliPath, runtimeDir, iconPath: iconPath || DEFAULT_ICNS, commandRunner });
-  } else if (platform === 'win32') {
-    result = installWindows({ paths, nodePath, cliPath, repoRoot, iconPath: iconPath || DEFAULT_ICO, commandRunner });
-  } else {
-    result = installLinux({ paths, nodePath, cliPath, iconPath: iconPath || DEFAULT_PNG, commandRunner });
-  }
-  return { ...paths, ...result };
-}
-
-export function desktopLauncherStatus(options = {}) {
-  const paths = desktopLauncherPaths(options);
-  const shortcutReady = fs.existsSync(paths.shortcut);
-  const platform = options.platform || process.platform;
-  const protocolReady = platform === 'win32'
-    ? commandSucceeded((options.commandRunner || runCapture)('reg.exe', ['query', paths.protocol, '/v', 'URL Protocol']))
-    : fs.existsSync(paths.protocol);
-  return { ...paths, shortcutReady, protocolReady };
-}

package/server/piecemaker/vendor/installer/steps/05-certificats.mjs

@@ -1,171 +0,0 @@
-/**
- * Step 05 — HTTPS certificates for the local server.
- *
- * The certificate the local server needs — a CA + a localhost server cert,
- * read directly by server.cjs at
- * websocket-server/localhost.{crt,key} — is produced by
- * websocket-server/generate-ca-certificates.cjs. That is what this step
- * drives; verify-certificates.cjs's checks are reproduced inline via openssl
- * so we get a structured result instead of parsing console output.
- */
-
-import { createRequire } from 'node:module';
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import { log, spinner } from '../lib/ui.mjs';
-import { confirm, nonInteractive } from '../lib/prompt.mjs';
-import { commandExists, runCapture, IS_WINDOWS, IS_MAC, REPO_ROOT } from '../lib/platform.mjs';
-
-export const meta = {
-  id: '05-certificats',
-  label: 'Certificats HTTPS',
-  description: 'Génère le certificat local requis pour servir l\'administration et l\'API en HTTPS',
-};
-
-const CERT_DIR = path.join(REPO_ROOT, 'websocket-server');
-const CERT_PATH = path.join(CERT_DIR, 'localhost.crt');
-const KEY_PATH = path.join(CERT_DIR, 'localhost.key');
-const GEN_SCRIPT = path.join(CERT_DIR, 'generate-ca-certificates.cjs');
-
-// Certs valid for less than this many seconds are treated as "needs renewal".
-const EXPIRY_MARGIN_SECONDS = 30 * 24 * 60 * 60; // 30 days
-
-const require = createRequire(import.meta.url);
-
-/**
- * Read-only validity probe. Returns 'missing', 'expiring' (or unreadable), or 'valid'.
- * When openssl is unavailable the expiry check is skipped gracefully — presence
- * of both files is then treated as good enough.
- */
-function probeCert() {
-  const filesExist = fs.existsSync(CERT_PATH) && fs.existsSync(KEY_PATH);
-  if (!filesExist) return { state: 'missing' };
-
-  if (!commandExists('openssl', ['version'])) {
-    return { state: 'valid', opensslMissing: true };
-  }
-
-  const checkend = runCapture('openssl', ['x509', '-checkend', String(EXPIRY_MARGIN_SECONDS), '-noout', '-in', CERT_PATH]);
-  if (checkend.code === 0) return { state: 'valid' };
-
-  const enddate = runCapture('openssl', ['x509', '-enddate', '-noout', '-in', CERT_PATH]);
-  return { state: 'expiring', enddate: enddate.stdout.replace(/^notAfter=/, '') };
-}
-
-function installCATrust(caCertPath) {
-  if (IS_MAC) {
-    // Requires an admin password entered interactively — stdio must be
-    // inherited so the user can type it in the real terminal.
-    const result = spawnSync(
-      'sudo',
-      ['security', 'add-trusted-cert', '-d', '-r', 'trustRoot', '-k', '/Library/Keychains/System.keychain', caCertPath],
-      { stdio: 'inherit' }
-    );
-    return result.status === 0;
-  }
-  if (IS_WINDOWS) {
-    const result = spawnSync('certutil', ['-addstore', '-user', 'Root', caCertPath], { stdio: 'inherit' });
-    return result.status === 0;
-  }
-  return false;
-}
-
-export async function install(ctx) {
-  const probe = probeCert();
-
-  if (probe.state === 'valid') {
-    log.ok(`Certificat déjà valide : ${CERT_PATH}`);
-    if (probe.opensslMissing) log.detail('openssl absent — expiration non vérifiée, présence des fichiers seulement.');
-    return { status: 'done', note: '' };
-  }
-
-  if (ctx.dryRun) {
-    log.info(`[simulation] Génération du certificat CA + serveur dans ${CERT_DIR}`);
-    return { status: 'skipped', note: 'Mode simulation — aucune modification effectuée.' };
-  }
-
-  if (!commandExists('openssl', ['version'])) {
-    return {
-      status: 'failed',
-      note: 'OpenSSL introuvable — installez-le (brew install openssl / choco install openssl) puis relancez cette étape.',
-    };
-  }
-
-  const filesExist = fs.existsSync(CERT_PATH) && fs.existsSync(KEY_PATH);
-  if (filesExist && probe.state === 'expiring') {
-    const regenerate = await confirm(
-      `Le certificat existant expire bientôt (${probe.enddate || 'date inconnue'}). Le régénérer ?`,
-      true
-    );
-    if (!regenerate) {
-      return { status: 'partial', note: 'Certificat existant conservé malgré son expiration prochaine.' };
-    }
-  }
-
-  if (!fs.existsSync(GEN_SCRIPT)) {
-    return { status: 'failed', note: `Script de génération introuvable : ${GEN_SCRIPT}` };
-  }
-
-  const { generateCACertificates, verifyCertificate } = require(GEN_SCRIPT);
-
-  const spin = spinner('Génération du certificat CA et du certificat serveur (localhost)...');
-  let result;
-  try {
-    result = await generateCACertificates(CERT_DIR);
-  } catch (error) {
-    spin.fail('Échec de la génération des certificats');
-    return { status: 'failed', note: `${error.message} — vérifiez qu'openssl fonctionne (openssl version).` };
-  }
-  spin.succeed(`Certificats générés : ${path.basename(CERT_PATH)} / ${path.basename(KEY_PATH)}`);
-
-  try {
-    await verifyCertificate(result.serverCert, result.caCert);
-  } catch {
-    log.warn('La vérification du certificat serveur a échoué — les fichiers sont générés mais non validés.');
-  }
-
-  // Trust the CA at the OS level so browsers accept the connection without
-  // a security warning. Requires admin rights — ask first.
-  if (nonInteractive || !process.stdout.isTTY) {
-    return {
-      status: 'partial',
-      note: `Certificats générés mais CA non ajoutée au magasin de confiance (mode non interactif). Exécutez manuellement : node "${GEN_SCRIPT}"`,
-    };
-  }
-
-  const wantTrust = await confirm(
-    'Ajouter ce certificat aux autorités de confiance du système ? Nécessaire pour que les navigateurs se connectent sans avertissement (mot de passe administrateur requis).',
-    true
-  );
-
-  if (!wantTrust) {
-    return {
-      status: 'partial',
-      note: 'CA non ajoutée au magasin de confiance — les navigateurs peuvent afficher un avertissement de sécurité.',
-    };
-  }
-
-  log.step('Ajout du certificat CA au magasin de confiance du système...');
-  const trusted = installCATrust(result.caCert);
-  if (!trusted) {
-    return {
-      status: 'partial',
-      note: 'Échec de l\'ajout au magasin de confiance (droits administrateur ?). Certificats générés mais non approuvés.',
-    };
-  }
-  log.ok('Certificat CA approuvé par le système');
-
-  return { status: 'done', note: '' };
-}
-
-export async function check(ctx) {
-  const probe = probeCert();
-  if (probe.state === 'valid') {
-    return { status: 'done', note: probe.opensslMissing ? 'Présence vérifiée (openssl absent, expiration non testée).' : '' };
-  }
-  if (probe.state === 'expiring') {
-    return { status: 'partial', note: `Certificat expire bientôt (${probe.enddate || 'date inconnue'}).` };
-  }
-  return { status: 'failed', note: `Certificat manquant : ${CERT_PATH}` };
-}