Merge pull request #3 from Shikakiben/test

install AM si non detecté

Author: Shikakiben

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: ["main", "test"]
+  pull_request:
+    branches: ["main", "test"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Lint
+        run: npm run lint
+
+      - name: Verify main-process modules
+        run: node scripts/verify-main-modules.js
+
+      - name: Verify renderer queue logic
+        run: node scripts/verify-renderer-queue.js

index.html

@@ -133,7 +133,7 @@ <h2 class="panel-heading-sm centered" data-i18n="advanced.title">Mode avancé</h
       <li><code>am translate</code> — <span data-i18n="advanced.cmd.translate">gérer traductions</span></li>
     </ul>
 
-    <p class="note"><em><span data-i18n="advanced.note.appman">Pour la version sans privilèges, remplacez <code>am</code> par <code>appman</code>.</span></em></p>
+    <p class="note"><em><span data-i18n-html="advanced.note.appman">Pour la version sans privilèges, remplacez <code>am</code> par <code>appman</code>.</span></em></p>
 
     <p class="docs-link"><a href="https://github.com/ivan-hc/AM" target="_blank" rel="noopener"><span data-i18n="advanced.docs">Documentation complète & guides →</span> AM (GitHub)</a></p>
       </section>

main.js

@@ -5,6 +5,7 @@ const { exec, spawn } = require('child_process');
 const { registerCategoryHandlers } = require('./src/main/categories');
 const { detectPackageManager, invalidatePackageManagerCache } = require('./src/main/packageManager');
 const { createIconCacheManager } = require('./src/main/iconCache');
+const { installAppManAuto } = require('./src/main/appManAuto');
 
 const iconCacheManager = createIconCacheManager(app);
 registerCategoryHandlers(ipcMain);
@@ -443,6 +444,16 @@ ipcMain.handle('install-send-choice', async (_event, installId, choice) => {
   }
 });
 
+ipcMain.handle('install-appman-auto', async () => {
+  try {
+    const result = await installAppManAuto();
+    invalidatePackageManagerCache();
+    return { ok: true, result };
+  } catch (error) {
+    return { ok: false, error: error?.message || 'Installation AppMan échouée.' };
+  }
+});
+
 
 // Liste détaillée: distingue installées vs catalogue
 ipcMain.handle('list-apps-detailed', async () => {

preload.js

@@ -19,6 +19,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   installCancel: (id) => ipcRenderer.invoke('install-cancel', id, id),
   installSendChoice: (id, choice) => ipcRenderer.invoke('install-send-choice', id, choice),
   onInstallProgress: (cb) => ipcRenderer.on('install-progress', (e, msg) => cb && cb(msg)),
+  installAppManAuto: () => ipcRenderer.invoke('install-appman-auto'),
   purgeIconsCache: () => ipcRenderer.invoke('purge-icons-cache'),
   getGpuPref: () => ipcRenderer.invoke('get-gpu-pref'),
   setGpuPref: (val) => ipcRenderer.invoke('set-gpu-pref', val),

scripts/verify-main-modules.js

@@ -2,10 +2,13 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const childProcess = require('child_process');
+const undici = require('undici');
 
 const originalExec = childProcess.exec;
+const originalFetch = undici.fetch;
 let tempDir = null;
 let success = false;
+let categoriesBackup = null;
 
 (async () => {
   let execInvocations = 0;
@@ -30,7 +33,54 @@ let success = false;
     });
   };
 
+  const repoRoot = path.resolve(__dirname, '..');
+  const categoriesCachePath = path.join(repoRoot, 'categories-cache.json');
+  const categoriesMetaPath = path.join(repoRoot, 'categories-cache.meta.json');
+
+  function snapshotCategoriesFiles() {
+    return {
+      cache: fs.existsSync(categoriesCachePath) ? fs.readFileSync(categoriesCachePath) : null,
+      meta: fs.existsSync(categoriesMetaPath) ? fs.readFileSync(categoriesMetaPath) : null
+    };
+  }
+
+  function restoreCategoriesFiles(snapshot) {
+    if (!snapshot) return;
+    if (snapshot.cache) fs.writeFileSync(categoriesCachePath, snapshot.cache);
+    else if (fs.existsSync(categoriesCachePath)) fs.rmSync(categoriesCachePath);
+    if (snapshot.meta) fs.writeFileSync(categoriesMetaPath, snapshot.meta);
+    else if (fs.existsSync(categoriesMetaPath)) fs.rmSync(categoriesMetaPath);
+  }
+
+  function createHeadersProxy(headers = {}) {
+    const normalized = Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [String(k).toLowerCase(), v])
+    );
+    return {
+      get(name) {
+        return normalized[String(name).toLowerCase()] || null;
+      }
+    };
+  }
+
+  function createResponse({ status = 200, ok = true, jsonData = null, textData = '', headers = {} }) {
+    return {
+      status,
+      ok,
+      async json() {
+        if (jsonData === null) throw new Error('JSON payload missing');
+        return jsonData;
+      },
+      async text() {
+        return textData;
+      },
+      headers: createHeadersProxy(headers)
+    };
+  }
+
   try {
+    categoriesBackup = snapshotCategoriesFiles();
+
     const { detectPackageManager, invalidatePackageManagerCache } = require('../src/main/packageManager');
     const { createIconCacheManager } = require('../src/main/iconCache');
 
@@ -82,6 +132,71 @@ let success = false;
     if (!purgeResult || purgeResult.removed < 1) throw new Error('Purge cache did not report removed files');
     if (fs.existsSync(fakeIconPath)) throw new Error('Purge cache did not delete dummy icon');
 
+    const fileEtags = new Map();
+    const markdownByFile = {
+      'games.md': `| App | Desc |\n| --- | --- |\n| ***alpha*** | great app |`,
+      'tools.md': `| App | Desc |\n| --- | --- |\n| ***beta*** | tool desc |`
+    };
+
+    undici.fetch = async (url, options = {}) => {
+      const headers = options.headers || {};
+      if (url.endsWith('/contents')) {
+        return createResponse({
+          jsonData: [
+            { name: 'games.md' },
+            { name: 'tools.md' },
+            { name: 'README.md' }
+          ]
+        });
+      }
+      const fileName = path.basename(url);
+      if (!markdownByFile[fileName]) {
+        return createResponse({ status: 404, ok: false, textData: 'missing' });
+      }
+      const previousEtag = fileEtags.get(fileName);
+      if (headers['If-None-Match'] && previousEtag && headers['If-None-Match'] === previousEtag) {
+        return createResponse({ status: 304, ok: false });
+      }
+      const nextEtag = `W/"etag-${fileName}-${Date.now()}"`;
+      fileEtags.set(fileName, nextEtag);
+      return createResponse({
+        textData: markdownByFile[fileName],
+        headers: { etag: nextEtag, 'last-modified': new Date().toUTCString() }
+      });
+    };
+
+    const { registerCategoryHandlers } = require('../src/main/categories');
+    const ipcHandlers = new Map();
+    const ipcMain = {
+      handle(channel, handler) {
+        ipcHandlers.set(channel, handler);
+      }
+    };
+
+    registerCategoryHandlers(ipcMain);
+    if (!ipcHandlers.has('fetch-all-categories')) throw new Error('fetch-all-categories handler missing');
+
+    const firstFetch = await ipcHandlers.get('fetch-all-categories')();
+    if (!firstFetch.ok) throw new Error(`fetch-all-categories failed: ${firstFetch.error}`);
+    if (!Array.isArray(firstFetch.categories) || firstFetch.categories.length !== 2) {
+      throw new Error('Unexpected categories payload on first fetch');
+    }
+    if (!firstFetch.categories[0].apps.includes('alpha')) throw new Error('Category parsing failed');
+
+    const cached = await ipcHandlers.get('get-categories-cache')();
+    if (!cached.ok || cached.categories.length !== 2) throw new Error('get-categories-cache returned invalid data');
+
+    const secondFetch = await ipcHandlers.get('fetch-all-categories')();
+    if (!secondFetch.ok) throw new Error('Second fetch should still be ok (even with 304)');
+    if (secondFetch.categories.length !== firstFetch.categories.length) {
+      throw new Error('Second fetch should reuse cached categories when not modified');
+    }
+
+    const deleteResult = await ipcHandlers.get('delete-categories-cache')();
+    if (!deleteResult.ok) throw new Error('delete-categories-cache failed');
+    if (fs.existsSync(categoriesCachePath)) throw new Error('Cache file still present after deletion');
+    if (fs.existsSync(categoriesMetaPath)) throw new Error('Cache meta file still present after deletion');
+
     success = true;
     console.log('✔ Main-process modules verified successfully.');
   } catch (err) {
@@ -96,6 +211,8 @@ let success = false;
       console.warn('Warning: failed to clean temporary directory:', cleanupErr.message);
     }
     childProcess.exec = originalExec;
+    undici.fetch = originalFetch;
+    restoreCategoriesFiles(categoriesBackup);
     if (success) {
       process.exitCode = 0;
     }

scripts/verify-renderer-queue.js

@@ -0,0 +1,117 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+
+function extractQueueSnippet(fullSource) {
+  const startMarker = 'let activeInstallSession = {';
+  const endMarker = 'let syncBtn = null;';
+  const start = fullSource.indexOf(startMarker);
+  const end = fullSource.indexOf(endMarker);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error('Unable to locate install queue section in renderer.js');
+  }
+  return fullSource.slice(start, end);
+}
+
+function createDocumentStub() {
+  const emptyArray = [];
+  return {
+    body: { classList: { toggle() {}, add() {}, remove() {} } },
+    querySelectorAll() { return emptyArray; },
+    querySelector() { return null; }
+  };
+}
+
+function createButtonStub(name) {
+  const attrs = { 'data-name': name };
+  return {
+    hidden: false,
+    disabled: false,
+    textContent: '',
+    classList: { add() {}, remove() {} },
+    setAttribute(key, value) { attrs[key] = value; },
+    getAttribute(key) { return attrs[key]; }
+  };
+}
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+(async () => {
+  const rendererPath = path.join(__dirname, '..', 'src', 'renderer', 'renderer.js');
+  const rendererSource = fs.readFileSync(rendererPath, 'utf8');
+  const queueSnippet = extractQueueSnippet(rendererSource);
+  const instrumentedSnippet = `${queueSnippet}\n globalThis.__queueTest = { installQueue, enqueueInstall, removeFromQueue, processNextInstall, activeInstallSession };`;
+
+  const toastMessages = [];
+  const queueIndicatorsUpdates = [];
+  const startStreamingCalls = [];
+
+  const context = {
+    console,
+    setTimeout,
+    clearTimeout,
+    CSS: { escape: (value) => value },
+    Node: { TEXT_NODE: 3 },
+    window: {
+      electronAPI: {
+        amAction: () => Promise.resolve()
+      }
+    },
+    document: createDocumentStub(),
+    detailsInstallBtn: createButtonStub('alpha'),
+    state: { viewMode: 'grid', installed: new Set(), filtered: [] },
+    showToast(msg) { toastMessages.push(msg); },
+    t(key, vars) {
+      if (!vars) return key;
+      return `${key}:${JSON.stringify(vars)}`;
+    },
+    startStreamingInstall(name) {
+      startStreamingCalls.push(name);
+      return Promise.resolve();
+    },
+    loadApps: () => Promise.resolve(),
+    applySearch: () => {},
+    refreshAllInstallButtons: () => {},
+    refreshTileBadges: () => {},
+    updateQueueIndicators: () => queueIndicatorsUpdates.push(Date.now())
+  };
+
+  vm.createContext(context);
+  vm.runInContext(instrumentedSnippet, context);
+
+  const { installQueue, enqueueInstall, removeFromQueue, processNextInstall, activeInstallSession } = context.__queueTest || {};
+
+  assert(Array.isArray(installQueue), 'installQueue array not exposed');
+
+  activeInstallSession.id = null;
+  activeInstallSession.done = true;
+  enqueueInstall('alpha');
+  assert(startStreamingCalls.includes('alpha'), 'Immediate install should start streaming');
+  assert(installQueue.length === 0, 'Queue should be empty after starting install');
+
+  activeInstallSession.id = 'session-1';
+  activeInstallSession.name = 'alpha';
+  activeInstallSession.done = false;
+  enqueueInstall('beta');
+  assert(installQueue.length === 1, 'Item should be queued while install active');
+
+  const removed = removeFromQueue('beta');
+  assert(removed === true, 'removeFromQueue should return true when entry existed');
+  assert(installQueue.length === 0, 'Queue should be empty after removal');
+
+  enqueueInstall('gamma');
+  assert(installQueue.length === 1, 'Queue should contain gamma before processing');
+
+  activeInstallSession.id = null;
+  activeInstallSession.done = true;
+  processNextInstall();
+  assert(startStreamingCalls.includes('gamma'), 'processNextInstall should start gamma streaming');
+  assert(queueIndicatorsUpdates.length >= 1, 'Queue indicators should update when queue changes');
+
+  console.log('✔ Renderer queue logic verified successfully.');
+})().catch((err) => {
+  console.error('✖ Renderer queue verification failed:', err);
+  process.exitCode = 1;
+});

src/main/appManAuto.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { fetch } = require('undici');
+
+const APPMAN_URL = 'https://raw.githubusercontent.com/ivan-hc/AM/main/APP-MANAGER';
+const USER_AGENT = 'AM-GUI';
+
+async function installAppManAuto() {
+  const home = os.homedir();
+  const bindir = process.env.XDG_BIN_HOME || path.join(home, '.local', 'bin');
+  fs.mkdirSync(bindir, { recursive: true });
+  const res = await fetch(APPMAN_URL, { headers: { 'User-Agent': USER_AGENT } });
+  if (!res.ok) {
+    throw new Error(`Téléchargement échoué (HTTP ${res.status})`);
+  }
+  const buffer = Buffer.from(await res.arrayBuffer());
+  const target = path.join(bindir, 'appman');
+  fs.writeFileSync(target, buffer, { mode: 0o755 });
+  const configDir = path.join(home, '.config', 'appman');
+  fs.mkdirSync(configDir, { recursive: true });
+  const configPath = path.join(configDir, 'appman-config');
+  if (!fs.existsSync(configPath)) {
+    const defaultDir = path.join(home, 'Applications');
+    fs.mkdirSync(defaultDir, { recursive: true });
+    fs.writeFileSync(configPath, defaultDir);
+  }
+  return { target, bindir };
+}
+
+module.exports = { installAppManAuto };