@piecemaker-legal/piecemaker 1.1.1 → 2.0.1

package/server/piecemaker/vendor/installer/bin/piecemaker.mjs

@@ -8,9 +8,6 @@
  *
  * Usage:
  *   piecemaker                 menu interactif
- *   piecemaker open            démarre le serveur et ouvre l'interface web
- *   piecemaker start|stop|restart gère le serveur local
- *   piecemaker status|logs     affiche l'état ou les journaux
  *   piecemaker chronology      affiche la chronologie du dossier courant
  *   piecemaker chronology write --path <pièce> --correction-json <json>
  *                              crée une correction de chronologie pour une pièce
@@ -35,21 +32,12 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { banner, title, log, write, blank, summary, spinner, badge, c } from '../lib/ui.mjs';
 import { select, confirm, multiSelect, pause, nonInteractive } from '../lib/prompt.mjs';
-import { HOME_DIR, REPO_ROOT, commandExists, findPython, venvPaths } from '../lib/platform.mjs';
+import { GIT_REPO_ROOT, HOME_DIR, REPO_ROOT, commandExists, findPython } from '../lib/platform.mjs';
 import { COMMANDS, CHRONOLOGY_ACTIONS } from '../lib/commandes.mjs';
 import { loadConfig, readEnv, markStep, loadState, CONFIG_FILE } from '../lib/state.mjs';
 import { scheduleStepResume, selectStepsToResume } from '../lib/resume-steps.mjs';
-import {
-  getServerStatus,
-  openAdmin,
-  readLogs,
-  restartTelegramDaemon,
-  startServer,
-  stopServer,
-  checkForUpdate,
-  updateRepository,
-  depositRootClaudeMd,
-} from '../lib/service.mjs';
+import { appServerPort, readLocalScanJob, startLocalScan } from '../lib/conversion-client.mjs';
+import { restartTelegramDaemon, checkForUpdate, updateRepository } from '../lib/service.mjs';
 
 const require = createRequire(import.meta.url);
 const CLAUDE_ASSETS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/claude-assets.cjs');
@@ -58,6 +46,7 @@ const CENTRAL_MAPPING_MODULE = path.resolve(path.dirname(fileURLToPath(import.me
 const DOCUMENT_INDEX_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/document-index.cjs');
 const CASE_INSTRUCTIONS_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/case-instructions.cjs');
 const ORIGINALS_PIPELINE_MODULE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../websocket-server/originals-pipeline.cjs');
+const APP_CLI_LIB = path.join(GIT_REPO_ROOT, 'scripts', 'piecemaker', 'cli', 'lib');
 
 /**
  * The bootstrap/update command is also distributed as an installer-only
@@ -87,17 +76,17 @@ function loadCentralMappingIntegration() {
 function reconcileCentralMapping() {
   let hooksRemoved = false;
   const claude = loadClaudeIntegrations();
-  if (typeof claude?.removeDeprecatedMappingHooks === 'function') {
-    const cleanup = claude.removeDeprecatedMappingHooks(os.homedir());
+  if (typeof claude?.removeDeprecatedHooks === 'function') {
+    const cleanup = claude.removeDeprecatedHooks(os.homedir());
     hooksRemoved = Boolean(cleanup.changed);
-    if (!cleanup.ok) log.warn(`Anciens hooks de mapping non nettoyés (${cleanup.reason}).`);
-    else if (cleanup.changed) log.ok('Anciens hooks de mapping Claude Code retirés.');
+    if (!cleanup.ok) log.warn(`Hooks hérités non nettoyés (${cleanup.reason}).`);
+    else if (cleanup.changed) log.ok('Hooks hérités Claude Code retirés.');
   }
 
   const integration = loadCentralMappingIntegration();
   const central = integration?.syncCentralMapping(loadConfig());
   if (central) log.ok(`Mapping central du proxy reconstruit (${central.entities || 0} entité(s)).`);
-  else log.warn('Mapping central du proxy non reconstruit ; relancez « piecemaker start ».');
+  else log.warn('Mapping central du proxy non reconstruit ; relancez « piecemaker ».');
   return hooksRemoved;
 }
 
@@ -118,28 +107,6 @@ function reconcileCaseInstructions() {
   }
 }
 
-/** Rejoue la partie non interactive de l'étape 15 après une mise à jour, mais
- * seulement pour une application Bureau déjà installée. Le chargement reste
- * dynamique : il intervient après le reset Git et utilise donc la nouvelle
- * version de l'étape qui vient d'être téléchargée. */
-async function refreshDesktopApplicationAfterUpdate() {
-  const stepPath = path.join(STEPS_DIR, '15-pwa-desktop.mjs');
-  if (!fs.existsSync(stepPath)) return false;
-  try {
-    const step = await import(`${pathToFileURL(stepPath).href}?update=${Date.now()}`);
-    if (typeof step.refreshInstalledDesktopApplication !== 'function') return false;
-    const result = await step.refreshInstalledDesktopApplication();
-    if (result.status !== 'skipped') markStep('15-pwa-desktop', result.status, result.note || '');
-    if (result.status === 'done') log.ok('Application PieceMaker sur le Bureau mise à jour.');
-    else if (result.status === 'partial') log.warn(`Application Bureau partiellement mise à jour : ${result.note}`);
-    else if (result.status === 'failed') log.warn(`Application Bureau non mise à jour : ${result.note}`);
-    return result.status === 'done';
-  } catch (error) {
-    log.warn(`Application Bureau non mise à jour (${error.message}).`);
-    return false;
-  }
-}
-
 /**
  * Reprend en tâche de fond les étapes d'installation restées incomplètes.
  *
@@ -381,12 +348,6 @@ async function runCheck(steps, ctx) {
 function printHelp() {
   write(`  ${c.bold('piecemaker')} — PieceMaker local`);
   blank();
-  write('  open            démarre le serveur et ouvre l’interface web');
-  write('  start           démarre le serveur local en arrière-plan');
-  write('  stop            arrête le serveur local');
-  write('  restart         redémarre le serveur local');
-  write('  status          affiche l’état du serveur');
-  write('  logs            affiche les dernières lignes du journal');
   write('  chronology [read]        affiche la chronologie pseudonymisée du dossier courant');
   write('  chronology write --path <pièce> --correction-json <json>  crée une correction de chronologie');
   write('  chronology edit --path <pièce> --correction-json <json>   modifie une correction existante');
@@ -449,17 +410,6 @@ async function installerMenu(steps, ctx, { allowBack = false } = {}) {
   }
 }
 
-function printServerStatus(status) {
-  title('État local');
-  const rows = [
-    ['Serveur HTTPS', status.running ? badge.done : badge.todo, status.running ? `PID ${status.pid || 'externe'}` : 'arrêté'],
-    ['Interface web', status.running ? badge.done : badge.todo, status.url],
-    ['Journal', badge.todo, status.logFile],
-  ];
-  summary(rows);
-  blank();
-}
-
 function formatChronologyText(chronology) {
   const lines = [];
   lines.push(`Chronologie : ${chronology.stats.documents} pièce(s), ${chronology.stats.dated} datée(s), ${chronology.stats.entities} entité(s).`);
@@ -626,139 +576,99 @@ function publicConversionResult(job) {
   return {
     id: job?.id || null,
     state: job?.state || 'error',
+    phase: job?.phase || null,
     processed: Number(job?.processed) || 0,
     total: Number(job?.total) || 0,
-    skipped: Number(job?.skipped) || 0,
     result: {
-      converted: Number(result.converted) || 0,
-      scanned: Number(result.scanned) || 0,
-      ...(Number.isFinite(result.mappingAdded) ? { mappingAdded: result.mappingAdded } : {}),
-      ...(Number.isFinite(result.mappingTotal) ? { mappingTotal: result.mappingTotal } : {}),
-      ...(result.upToDate ? { upToDate: true } : {}),
-      ...(result.commit ? {
-        commitCreated: Boolean(result.commit.created),
-        commit: result.commit.hash || null,
-      } : {}),
+      documents: Number(result.documents) || 0,
+      ...(Number.isFinite(result.nodes) ? { nodes: result.nodes } : {}),
+      ...(Number.isFinite(result.edges) ? { edges: result.edges } : {}),
     },
   };
 }
 
-async function waitForConversionJob(initialJob, getJob, { json = false } = {}) {
-  let job = initialJob;
-  let reportedState = '';
+async function waitForConversionJob({ folder, id }, { json = false } = {}) {
+  let job = null;
   let reportedPercent = -10;
-  while (job && ['queued', 'running'].includes(job.state)) {
-    if (!json && (job.state !== reportedState || job.percent >= reportedPercent + 10)) {
-      if (job.state === 'queued') log.info('Conversion en attente d’une place dans la file de traitement.');
-      else log.info(`Conversion et analyse PII : ${job.percent || 0} % (${job.processed || 0}/${job.total || 0})`);
-      reportedState = job.state;
+  do {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    ({ job } = await readLocalScanJob({ folder, id }));
+    if (!json && job && job.percent >= reportedPercent + 10) {
+      log.info(`Conversion et analyse PII : ${job.percent || 0} % (${job.processed || 0}/${job.total || 0})`);
       reportedPercent = job.percent || 0;
     }
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    job = getJob(job.id);
-  }
+  } while (job && job.state === 'running');
   if (!job) throw new Error('Le travail de conversion a expiré avant sa fin.');
   if (job.state === 'error') throw new Error(job.error || 'La conversion a échoué.');
+  if (job.state === 'cancelled') throw new Error('La conversion a été annulée.');
   return job;
 }
 
+async function ensureServerForConversion({ json = false } = {}) {
+  const servicesModule = path.join(APP_CLI_LIB, 'services.mjs');
+  if (!fs.existsSync(servicesModule)) {
+    throw new Error(`Le serveur applicatif doit être démarré par la commande « piecemaker » avant la conversion (port ${appServerPort()}).`);
+  }
+  const { appServerReachable, startApplication } = await import(pathToFileURL(servicesModule).href);
+  if (await appServerReachable()) return;
+  if (!json) log.info(`Serveur applicatif arrêté : démarrage sur le port ${appServerPort()} avant conversion.`);
+  const { resolveNodeRuntime } = await import(pathToFileURL(path.join(APP_CLI_LIB, 'node-runtime.mjs')).href);
+  const outcome = await startApplication(resolveNodeRuntime(), {
+    step: (text) => { if (!json) log.info(text); },
+  });
+  if (outcome.serverUp === false) {
+    throw new Error(`Le serveur applicatif n'a pas démarré.${outcome.logTail ? `\n${outcome.logTail}` : ''}`);
+  }
+}
+
 async function runConversionCommand(flags) {
   if (!fs.existsSync(ORIGINALS_PIPELINE_MODULE)) {
     throw new Error('Le module de conversion PieceMaker est introuvable.');
   }
-  const config = loadConfig();
   const { locateConfiguredCase } = require('../../piecemaker-plugin/scripts/lib/case-folders.cjs');
-  const located = locateConfiguredCase(config, flags.caseTarget || process.cwd());
+  const located = locateConfiguredCase(loadConfig(), flags.caseTarget || process.cwd());
   if (!located) {
     throw new Error('Lancez la commande depuis un dossier juridique enregistré ou passez --case <chemin>.');
   }
 
-  // Le serveur choisit habituellement l’interpréteur au démarrage. La commande
-  // autonome reproduit ce choix sans exiger que le serveur PieceMaker tourne.
-  const configuredVenv = venvPaths(config.venvPath);
-  const python = process.env.PYTHON_PATH
-    || readEnv().PYTHON_PATH
-    || config.pythonPath
-    || (configuredVenv.exists ? configuredVenv.python : null)
-    || findPython()?.command;
-  if (!python) throw new Error('Aucun interpréteur Python 3.10+ n’est disponible pour la conversion.');
-  process.env.PYTHON_PATH = python;
-
-  const { getJob, listOriginals, startOriginalsJob } = require(ORIGINALS_PIPELINE_MODULE);
+  const { listOriginals } = require(ORIGINALS_PIPELINE_MODULE);
   const originals = await listOriginals(located.caseRoot);
-  const requestedFiles = resolveConversionFiles(
+  const selected = resolveConversionFiles(
     originals,
     flags.conversionDocuments || [],
     located.caseRoot,
   );
+  const requestedFiles = selected.length || !flags.force
+    ? selected
+    : originals.map((original) => original.path);
   if (!flags.json) {
     log.info(requestedFiles.length
       ? `Conversion et pseudonymisation de ${requestedFiles.length} pièce(s) sélectionnée(s).`
       : 'Conversion et pseudonymisation des pièces qui ne sont pas encore prêtes.');
   }
-  const initialJob = await startOriginalsJob({
-    casesRoot: located.casesRoot,
-    caseName: located.caseName,
-    homeDir: HOME_DIR,
-    action: 'anonymize',
-    files: requestedFiles,
-    options: { force: flags.force },
-  });
-  const job = await waitForConversionJob(initialJob, getJob, { json: flags.json });
+
+  await ensureServerForConversion({ json: flags.json });
+  const started = await startLocalScan({ folder: located.caseRoot, files: requestedFiles });
+  const job = await waitForConversionJob(
+    { folder: located.caseRoot, id: started.job?.id },
+    { json: flags.json },
+  );
   const result = publicConversionResult(job);
   if (flags.json) process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-  else if (result.result.upToDate) log.ok('Toutes les pièces sont déjà converties et pseudonymisées.');
-  else log.ok(`Conversion et pseudonymisation terminées : ${result.result.scanned} pièce(s).`);
+  else log.ok(`Conversion et pseudonymisation terminées : ${result.result.documents} pièce(s).`);
   return 0;
 }
 
 async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
   if (command === 'chronology') return runChronologyCommand(flags);
   if (command === 'conversion') return runConversionCommand(flags);
-  if (command === 'open') {
-    const status = await openAdmin();
-    log.ok(`Interface ouverte : ${status.url}`);
-    return 0;
-  }
-  if (command === 'start') {
-    const status = await startServer();
-    log.ok(status.started ? `Serveur démarré : ${status.url}` : `Serveur déjà actif : ${status.url}`);
-    return 0;
-  }
-  if (command === 'stop') {
-    const status = await stopServer();
-    if (status.alreadyStopped) log.info('Le serveur est déjà arrêté.');
-    else log.ok('Serveur arrêté.');
-    return 0;
-  }
-  if (command === 'restart') {
-    await stopServer();
-    const status = await startServer();
-    log.ok(`Serveur redémarré : ${status.url}`);
-    return 0;
-  }
-  if (command === 'status') {
-    const status = await getServerStatus();
-    printServerStatus(status);
-    return 0;
-  }
-  if (command === 'logs') {
-    title('Journal du serveur HTTPS');
-    const content = readLogs();
-    write(content || '  Aucun journal disponible.');
-    blank();
-    return 0;
-  }
   if (command === 'update') {
-    // Look before stopping anything: an up-to-date install must not lose its
-    // server for the duration of a no-op npm install.
     const pending = knownUpdate ?? checkForUpdate();
     if (!pending.available) {
       log.ok(`PieceMaker est déjà à jour (${pending.ref}, ${pending.current.slice(0, 7)}).`);
       reconcileCaseInstructions();
-      await refreshDesktopApplicationAfterUpdate();
       if (reconcileCentralMapping()) {
-        log.info('Rouvrez les sessions Claude Code actives pour oublier les anciens hooks de mapping.');
+        log.info('Rouvrez les sessions Claude Code actives pour oublier les hooks hérités.');
       }
       // « update » reste le geste de remise à niveau : même sans nouveau commit,
       // une étape d'installation restée incomplète repart en tâche de fond.
@@ -771,24 +681,10 @@ async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
       log.info(`Restauration de l’installation depuis le dépôt distant (${pending.localChanges} fichier(s) localement modifié(s)).`);
     }
 
-    // A live server on the port is a PieceMaker server (the health probe
-    // answered 200), whether we started it or not — e.g. one launched by hand
-    // from the dev clone, so with no PID file it comes back unmanaged. We adopt
-    // it: stop whatever holds the port and bring a managed server back below,
-    // rather than leaving the user to restart it themselves.
-    const previous = await getServerStatus();
-    if (previous.running) await stopServer();
     try {
       const result = updateRepository(pending);
       log.ok(`PieceMaker mis à jour (${result.ref}, ${result.target.slice(0, 7)}).`);
 
-      // CLAUDE.md racine est gitignoré : « git reset --hard » ci-dessus le
-      // supprime dès qu'un clone récupère le commit qui l'a dé-versionné. On
-      // redépose donc la persona utilisateur depuis le gabarit (absent → écrit,
-      // présent → intact), même source que l'étape d'installation 09.
-      if (depositRootClaudeMd().status === 'deposited') {
-        log.ok('CLAUDE.md (persona utilisateur) redéposé depuis le gabarit.');
-      }
       reconcileCaseInstructions();
 
       if (result.pythonChanged) {
@@ -813,13 +709,8 @@ async function runOperationalCommand(command, knownUpdate = null, flags = {}) {
       }
 
       reconcileCentralMapping();
-      await refreshDesktopApplicationAfterUpdate();
       log.info('Rouvrez les sessions Claude Code/Codex actives pour charger les hooks et le MCP mis à jour.');
     } finally {
-      if (previous.running) {
-        const restarted = await startServer();
-        log.ok(`Serveur redémarré : ${restarted.url}`);
-      }
       const daemon = restartTelegramDaemon();
       if (daemon.restarted) log.ok('Moniteur Telegram redémarré.');
       else if (daemon.reason && daemon.reason !== 'absent' && daemon.reason !== 'unsupported') {
@@ -859,49 +750,14 @@ function checkForUpdateOnOpen() {
   }
 }
 
-/**
- * Bare `piecemaker` should land on a live server. Start it if it is down, but
- * never block the menu on failure: a missing certificate or a boot error is
- * reported and the interactive installer below stays reachable to fix it.
- * The browser is left closed on purpose — the menu's "Ouvrir l'interface"
- * entry is how the admin pane gets opened.
- */
-async function ensureServerRunning() {
-  let status;
-  try {
-    status = await getServerStatus();
-  } catch {
-    return;
-  }
-  if (status.running) return;
-
-  const spin = spinner('Démarrage du serveur local...');
-  try {
-    const started = await startServer();
-    spin.stop();
-    log.ok(`Serveur démarré : ${started.url}`);
-  } catch (error) {
-    spin.stop();
-    log.warn(`Serveur non démarré : ${error.message}`);
-    log.detail('Réparez-le via « Installer ou réparer des composants » ci-dessous.');
-  }
-  blank();
-}
-
 async function mainMenu(steps, ctx, knownUpdate = null) {
   for (;;) {
-    const status = await getServerStatus();
-    printServerStatus(status);
     const choice = await select('Que voulez-vous faire ?', [
-      { value: 'open', label: 'Ouvrir l’interface graphique', hint: 'paramètres, skills et agents' },
-      { value: status.running ? 'stop' : 'start', label: status.running ? 'Arrêter le serveur local' : 'Démarrer le serveur local' },
-      { value: 'status', label: 'Actualiser l’état' },
       { value: 'install', label: 'Installer ou réparer des composants' },
       {
         value: 'update',
         label: knownUpdate?.remoteAvailable ? 'Mettre à jour PieceMaker — MAJ disponible' : 'Mettre à jour PieceMaker',
       },
-      { value: 'logs', label: 'Afficher les journaux' },
       { value: 'quit', label: 'Quitter' },
     ]);
 
@@ -918,7 +774,6 @@ async function mainMenu(steps, ctx, knownUpdate = null) {
     } catch (error) {
       log.error(error.message);
     }
-    if (choice === 'open') return;
     await pause();
   }
 }
@@ -978,9 +833,7 @@ async function main() {
     return runOperationalCommand(flags.command, null, flags);
   }
 
-  // `update` arrête puis relance lui-même le serveur et le proxy : il passe
-  // avant ensureServerRunning() plus bas, pour ne pas démarrer un serveur juste
-  // avant de le couper. Il enchaîne aussi sur la reprise des étapes.
+  // `update` enchaîne sur la reprise des étapes : il passe avant le menu.
   let autoUpdated = false;
   if (opensInteractiveInstaller && knownUpdate?.available) {
     try {
@@ -1050,10 +903,7 @@ async function main() {
   }
 
   if (flags.command === 'install') await installerMenu(steps, ctx);
-  else {
-    await ensureServerRunning();
-    await mainMenu(steps, ctx, knownUpdate);
-  }
+  else await mainMenu(steps, ctx, knownUpdate);
   return 0;
 }
 

package/server/piecemaker/vendor/installer/lib/commandes.mjs

@@ -4,10 +4,8 @@
  * Isolée dans son propre module parce que `installer/bin/piecemaker.mjs`
  * lance `main()` dès son import : rien ne peut l'importer sans ouvrir le menu
  * interactif et donc toucher aux services réels de la machine. Ce module-ci
- * est importable sans effet de bord, ce qui permet au test anti-dérive
- * (`test/commandes-templates.test.mjs`) de confronter cette surface aux
- * outils MCP et aux commandes citées dans les templates.
+ * est importable sans effet de bord.
  */
 
-export const COMMANDS = new Set(['open', 'start', 'stop', 'restart', 'status', 'logs', 'chronology', 'conversion', 'install', 'doctor', 'check', 'update']);
+export const COMMANDS = new Set(['chronology', 'conversion', 'install', 'doctor', 'check', 'update']);
 export const CHRONOLOGY_ACTIONS = new Set(['read', 'write', 'edit']);

package/server/piecemaker/vendor/installer/lib/conversion-client.mjs

@@ -0,0 +1,74 @@
+/**
+ * Client HTTP de la conversion PieceMaker.
+ *
+ * La conversion et l'analyse PII n'ont qu'un seul point d'entrée : la route
+ * `knowledge/scan` du serveur applicatif. Le CLI en est un client, sur la
+ * boucle locale, via le montage `/api/piecemaker/local` placé avant
+ * l'authentification. Le serveur applicatif écoute en clair sur le port du
+ * CLI (`PIECEMAKER_APP_PORT`, 3003 par défaut) : aucun certificat n'entre en
+ * jeu et la requête ne sort jamais de 127.0.0.1.
+ */
+
+import http from 'node:http';
+
+const LOCAL_BASE = '/api/piecemaker/local';
+
+export function appServerPort() {
+  const parsed = Number.parseInt(process.env.PIECEMAKER_APP_PORT || '', 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : 3003;
+}
+
+function requestJson({ method, path, body }) {
+  const payload = body === undefined ? null : Buffer.from(JSON.stringify(body));
+  return new Promise((resolve, reject) => {
+    const request = http.request(
+      {
+        hostname: '127.0.0.1',
+        port: appServerPort(),
+        path,
+        method,
+        timeout: 30_000,
+        headers: {
+          Accept: 'application/json',
+          ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': payload.length } : {}),
+        },
+      },
+      (response) => {
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => {
+          const raw = Buffer.concat(chunks).toString('utf8');
+          let parsed = null;
+          try {
+            parsed = raw ? JSON.parse(raw) : null;
+          } catch {
+            reject(new Error(`Réponse illisible du serveur PieceMaker (${response.statusCode}).`));
+            return;
+          }
+          if (response.statusCode >= 400) {
+            reject(new Error(parsed?.error || `Le serveur PieceMaker a répondu ${response.statusCode}.`));
+            return;
+          }
+          resolve(parsed);
+        });
+      }
+    );
+    request.on('timeout', () => request.destroy(new Error('Le serveur PieceMaker n’a pas répondu à temps.')));
+    request.on('error', reject);
+    if (payload) request.write(payload);
+    request.end();
+  });
+}
+
+export function startLocalScan({ folder, files }) {
+  return requestJson({
+    method: 'POST',
+    path: `${LOCAL_BASE}/scan`,
+    body: { folder, ...(files?.length ? { files } : {}) },
+  });
+}
+
+export function readLocalScanJob({ folder, id }) {
+  const query = new URLSearchParams({ folder, ...(id ? { id } : {}) });
+  return requestJson({ method: 'GET', path: `${LOCAL_BASE}/scan/job?${query}` });
+}