@piecemaker-legal/piecemaker 1.0.6 → 1.0.8

package/scripts/piecemaker/cli/lib/services.mjs

@@ -6,6 +6,7 @@ import { spawn } from 'node:child_process';
 import { APP, LOG_DIR, PIECEMAKER_HOME, PORTS } from './config.mjs';
 import { waitUntil } from './exec.mjs';
 import { npmPath, runtimeEnv } from './node-runtime.mjs';
+import { freePort } from './ports.mjs';
 
 export const APP_LOG = path.join(LOG_DIR, 'application.log');
 export const APP_PID_FILE = path.join(PIECEMAKER_HOME, 'application.pid');
@@ -32,6 +33,53 @@ export function appClientReachable() {
   return httpReachable(`http://127.0.0.1:${PORTS.appClient}/`);
 }
 
+function anonymizerPort() {
+  try {
+    const port = Number.parseInt(JSON.parse(fs.readFileSync(path.join(PIECEMAKER_HOME, 'config.json'), 'utf8')).mikePiiPort, 10);
+    if (Number.isInteger(port) && port > 0) return port;
+  } catch {
+  }
+  return PORTS.anonymizer;
+}
+
+function stopPid(pid) {
+  if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+  if (process.platform === 'win32') {
+    try { process.kill(pid, 'SIGTERM'); return true; } catch { return false; }
+  }
+  try { process.kill(-pid, 'SIGTERM'); return true; } catch {
+    try { process.kill(pid, 'SIGTERM'); return true; } catch { return false; }
+  }
+}
+
+export async function stopApplication() {
+  const killed = [];
+  const occupied = [];
+  try {
+    const pid = Number.parseInt(fs.readFileSync(APP_PID_FILE, 'utf8'), 10);
+    if (stopPid(pid)) killed.push(pid);
+  } catch {
+  }
+
+  for (const port of [PORTS.appClient, PORTS.appServer, anonymizerPort()]) {
+    const result = await freePort(port);
+    killed.push(...result.killed);
+    if (!result.released) occupied.push(port);
+  }
+
+  try { fs.rmSync(APP_PID_FILE, { force: true }); } catch { }
+  return { killed: [...new Set(killed)], occupied };
+}
+
+function readLogTail(file, maxLines = 40) {
+  try {
+    const lines = fs.readFileSync(file, 'utf8').trimEnd().split(/\n/);
+    return lines.slice(-maxLines).join('\n');
+  } catch {
+    return '';
+  }
+}
+
 export async function startApplication(runtime, report) {
   const alreadyRunning = await appClientReachable() && await appServerReachable();
   if (alreadyRunning) {
@@ -61,11 +109,24 @@ export async function startApplication(runtime, report) {
     fs.closeSync(logHandle);
   }
 
-  child.unref();
   fs.writeFileSync(APP_PID_FILE, String(child.pid), 'utf8');
 
-  const serverUp = await waitUntil(appServerReachable, { timeoutMs: 120_000 });
-  const clientUp = await waitUntil(appClientReachable, { timeoutMs: 120_000 });
+  const death = new Promise((resolve) => {
+    child.once('error', () => resolve('died'));
+    child.once('exit', () => resolve('died'));
+  });
+
+  await Promise.race([
+    waitUntil(appServerReachable, { timeoutMs: 120_000 }),
+    death,
+  ]);
+  const serverUp = await appServerReachable();
+  if (!serverUp) {
+    child.unref();
+    return { started: true, pid: child.pid, serverUp: false, clientUp: false, logTail: readLogTail(APP_LOG) };
+  }
 
-  return { started: true, pid: child.pid, serverUp, clientUp };
+  const clientUp = await waitUntil(appClientReachable, { timeoutMs: 120_000 });
+  child.unref();
+  return { started: true, pid: child.pid, serverUp: true, clientUp, logTail: clientUp ? '' : readLogTail(APP_LOG) };
 }

package/scripts/piecemaker/cli/piecemaker-command.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+
+import { BIN_DIR } from './lib/config.mjs';
+import { piecemakerExecutable } from './install-command.mjs';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+test('the curl bootstrap installs the piecemaker command before launching', () => {
+  const posix = fs.readFileSync(path.join(here, 'piecemaker.sh'), 'utf8');
+  const windows = fs.readFileSync(path.join(here, 'piecemaker.ps1'), 'utf8');
+  assert.match(posix, /install-command\.mjs/);
+  assert.match(windows, /install-command\.mjs/);
+});
+
+test('the desktop launcher binds to the installed piecemaker binary', () => {
+  const executable = piecemakerExecutable();
+  assert.equal(path.basename(executable).startsWith('piecemaker'), true);
+  if (executable !== 'piecemaker') {
+    assert.equal(executable.startsWith(BIN_DIR) || executable.includes(`${path.sep}node${path.sep}` ) || executable.includes('versions/node'), true);
+  }
+});

package/scripts/piecemaker/cli/piecemaker.mjs

@@ -1,50 +1,36 @@
 #!/usr/bin/env node
 
+import { installPiecemakerCommand, piecemakerExecutable } from './install-command.mjs';
 import { APP, APP_URL, PORTS } from './lib/config.mjs';
+import { repairClientProxies } from './lib/piecemaker-anonymizer.mjs';
 import { installComponents } from './lib/composants.mjs';
 import { installPlugins } from './lib/plugins.mjs';
 import { gitAvailable, resolveNodeRuntime } from './lib/node-runtime.mjs';
-import { freePort } from './lib/ports.mjs';
 import { ensureDependencies, ensureRepository, rebuildNativeModules } from './lib/repos.mjs';
-import { APP_LOG, appClientReachable, appServerReachable, startApplication } from './lib/services.mjs';
-import { installApplicationEntry, openApplication, verifyPwaAssets } from './lib/pwa.mjs';
+import { APP_LOG, appClientReachable, appServerReachable, startApplication, stopApplication } from './lib/services.mjs';
+import { applicationWindowIsOpen, installApplicationEntry, openApplication, verifyPwaAssets } from './lib/pwa.mjs';
+import { runApplicationWindow } from './lib/app-window.mjs';
 import { banner, blank, c, detail, fail, ok, step, warn } from './lib/ui.mjs';
 
 const report = { step, ok, warn, detail };
 
-const HELP = `${c.bold('piecemaker')} — installe, met à jour et lance toute la plateforme.
+const HELP = `${c.bold('piecemaker')} — installe, met à jour, répare et lance toute la plateforme.
 
-  piecemaker                 tout faire : ports, dépôts, dépendances, PWA, serveurs
-  piecemaker --launch-only   ne relance que les serveurs manquants
-  piecemaker --no-open       ne pas ouvrir l application à la fin
+  piecemaker                 reset propre, puis installation et lancement
+  piecemaker --launch-only   répare et relance seulement si l'application est arrêtée
+  piecemaker --window        relance si besoin, ouvre la fenêtre et arrête tout à sa fermeture
   piecemaker --help          cette aide
 `;
 
 function parseArguments(argv) {
+  const window = argv.includes('--window');
   return {
     help: argv.includes('--help') || argv.includes('-h'),
-    launchOnly: argv.includes('--launch-only'),
-    open: !argv.includes('--no-open'),
+    launchOnly: argv.includes('--launch-only') || window,
+    window,
   };
 }
 
-async function cleanPorts(launchOnly) {
-  step('Libération des ports');
-  const targets = launchOnly
-    ? [PORTS.appServer, PORTS.appClient]
-    : [PORTS.appClient, PORTS.appServer];
-
-  for (const port of targets) {
-    const result = await freePort(port);
-    if (!result.released) {
-      warn(`port ${port} toujours occupé`);
-      continue;
-    }
-    if (result.killed.length > 0) detail(`port ${port} libéré (${result.killed.join(', ')})`);
-  }
-  ok('Ports disponibles');
-}
-
 async function synchroniseRepositories(runtime) {
   if (!gitAvailable()) {
     throw new Error('git est requis et introuvable.');
@@ -63,32 +49,43 @@ async function synchroniseRepositories(runtime) {
   rebuildNativeModules(APP, runtime, report, ['better-sqlite3', 'node-pty']);
 }
 
-async function launchServices(runtime) {
-  const applicationAlreadyRunning = await appServerReachable() && await appClientReachable();
-
-  if (applicationAlreadyRunning) {
-    ok(`Application déjà active — ${APP_URL}`);
-    detail('socle laissé en l état : le routage des clients IA appartient à l application en cours');
-    return true;
+function printLogTail(logTail) {
+  if (!logTail) {
+    detail(`journal : ${APP_LOG}`);
+    return;
+  }
+  detail(`journal : ${APP_LOG}`);
+  for (const line of logTail.split('\n')) {
+    if (line.trim()) detail(line);
   }
+}
+
+async function applicationIsRunning() {
+  return await appServerReachable() && await appClientReachable();
+}
+
+async function resetAndLaunch(runtime) {
+  step('Reset de l application');
+  const stopped = await stopApplication();
+  if (stopped.killed.length) detail(`arrêtés : ${stopped.killed.join(', ')}`);
+  for (const port of stopped.occupied) warn(`port ${port} toujours occupé`);
+  ok('Processus précédents arrêtés');
 
   const application = await startApplication(runtime, report);
   if (application.alreadyRunning) {
     ok(`Application déjà active — ${APP_URL}`);
     return true;
   }
-
   if (!application.serverUp) {
     fail(`Serveur applicatif injoignable sur le port ${PORTS.appServer}`);
-    detail(`journal : ${APP_LOG}`);
+    printLogTail(application.logTail);
     return false;
   }
   if (!application.clientUp) {
     fail(`Client applicatif injoignable sur le port ${PORTS.appClient}`);
-    detail(`journal : ${APP_LOG}`);
+    printLogTail(application.logTail);
     return false;
   }
-
   ok(`Application active — serveur :${PORTS.appServer}, client ${APP_URL}`);
   return true;
 }
@@ -111,6 +108,7 @@ async function installPwa() {
   for (const location of entry.locations || []) {
     if (location !== entry.location) detail(`également posé : ${location}`);
   }
+  detail(`icône liée à ${piecemakerExecutable()}`);
   if (!entry.standalone) detail('navigateur Chromium absent : ouverture en onglet classique');
   if (!entry.verified) warn('installation incomplète : un emplacement attendu est introuvable après coup');
 }
@@ -127,7 +125,19 @@ async function main() {
   const runtime = resolveNodeRuntime();
   detail(`Node ${runtime.version}`);
 
-  await cleanPorts(options.launchOnly);
+  step('Commande piecemaker');
+  const command = installPiecemakerCommand();
+  if (command.shims.length) ok(`installée : ${command.executable}`);
+  else warn('commande absente du PATH — relancez node scripts/piecemaker/cli/install-command.mjs');
+
+  await repairClientProxies({ appDir: APP.directory, report });
+
+  if (!options.launchOnly || !(await applicationIsRunning())) {
+    const running = await resetAndLaunch(runtime);
+    if (!running) return 1;
+  } else {
+    ok(`Application déjà active — ${APP_URL}`);
+  }
 
   if (!options.launchOnly) {
     await synchroniseRepositories(runtime);
@@ -135,19 +145,24 @@ async function main() {
     await installPlugins(runtime, report);
   }
 
-  const running = await launchServices(runtime);
-  if (!running) return 1;
-
-  if (!options.launchOnly) {
-    await installPwa();
-  }
+  await installPwa();
 
   blank();
   ok(`Application  ${c.bold(APP_URL)}`);
   detail('Configuration du socle : onglet Dossier › Configuration.');
   blank();
 
-  if (options.open) openApplication();
+  if (options.window) {
+    const session = await runApplicationWindow();
+    if (!session.supervised) {
+      warn(`Fenêtre non supervisée : ${session.reason}`);
+      return 0;
+    }
+    ok('Fenêtre fermée — application arrêtée');
+    return 0;
+  }
+
+  if (!options.launchOnly && !applicationWindowIsOpen()) openApplication();
   return 0;
 }
 

package/scripts/piecemaker/cli/piecemaker.ps1

@@ -59,5 +59,13 @@ if (-not (Test-Path $EntryPath)) {
   exit 1
 }
 
+$Installer = Join-Path $AppDir 'scripts\piecemaker\cli\install-command.mjs'
+if (Test-Path $Installer) {
+  & $NodeBin $Installer
+}
+
+$BinDir = Join-Path $HOME '.piecemaker\bin'
+$env:PATH = "$(Split-Path $NodeBin -Parent);$BinDir;$env:PATH"
+
 & $NodeBin $EntryPath @args
 exit $LASTEXITCODE

package/scripts/piecemaker/cli/piecemaker.sh

@@ -54,7 +54,12 @@ if [ ! -f "$APP_DIR/$ENTRY" ]; then
   exit 1
 fi
 
-PATH="$(dirname "$NODE_BIN"):$PATH"
+INSTALLER="$APP_DIR/scripts/piecemaker/cli/install-command.mjs"
+if [ -f "$INSTALLER" ]; then
+  "$NODE_BIN" "$INSTALLER" || true
+fi
+
+PATH="$(dirname "$NODE_BIN"):${HOME}/.piecemaker/bin:${PATH:-}"
 export PATH
 
 exec "$NODE_BIN" "$APP_DIR/$ENTRY" "$@"

package/server/index.ts

@@ -30,7 +30,7 @@ import { commandsRoutes } from './modules/commands/index.js';
 import { settingsRoutes } from './modules/settings/index.js';
 import { createSystemModule } from './modules/system/index.js';
 import { createAgentModule } from './modules/agent/index.js';
-import { createPieceMakerRouter } from './piecemaker/index.js';
+import { createPieceMakerRouter, stopOriginalsJobs } from './piecemaker/index.js';
 import projectModuleRoutes from './modules/projects/projects.routes.js';
 import notificationRoutes from './modules/notifications/notifications.routes.js';
 import { userRoutes } from './modules/user/index.js';
@@ -378,29 +378,58 @@ async function startServer() {
             });
         });
 
-        await closeSessionsWatcher();
-        closeScheduledMessageDispatcher();
-        // Clean up plugin processes on shutdown
-        const shutdownRuntimeServices = async () => {
-            try {
-                await browserUseService.stopAllSessions();
-            } catch (err) {
-                console.error('[Browser] Error stopping sessions during shutdown:', getErrorMessage(err));
-            }
-            try {
-                await stopAllPlugins();
-            } catch (err) {
-                console.error('[Plugins] Error stopping plugins during shutdown:', getErrorMessage(err));
-            }
-            try {
-                await removeLocalServerMarker();
-            } catch (err) {
-                console.error('[Local Server] Error removing server marker during shutdown:', getErrorMessage(err));
-            }
-            process.exit(0);
+        let shutdownPromise: Promise<void> | null = null;
+        const shutdownRuntimeServices = () => {
+            if (shutdownPromise) return shutdownPromise;
+            shutdownPromise = (async () => {
+                // Stop accepting HTTP work first. Existing requests may finish while
+                // the process pipelines and background services are being drained.
+                const serverClosed = new Promise<void>((resolve, reject) => {
+                    server.close((error) => {
+                        if (error && getErrorCode(error) !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+                        else resolve();
+                    });
+                }).catch((err) => {
+                    console.error('[Server] Error closing HTTP server during shutdown:', getErrorMessage(err));
+                });
+
+                try {
+                    await closeSessionsWatcher();
+                } catch (err) {
+                    console.error('[Sessions] Error stopping watchers during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    closeScheduledMessageDispatcher();
+                } catch (err) {
+                    console.error('[Scheduled messages] Error stopping dispatcher during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await stopOriginalsJobs();
+                } catch (err) {
+                    console.error('[PieceMaker] Error stopping pipeline jobs during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await browserUseService.stopAllSessions();
+                } catch (err) {
+                    console.error('[Browser] Error stopping sessions during shutdown:', getErrorMessage(err));
+                }
+                try {
+                    await stopAllPlugins();
+                } catch (err) {
+                    console.error('[Plugins] Error stopping plugins during shutdown:', getErrorMessage(err));
+                }
+                await serverClosed;
+                try {
+                    await removeLocalServerMarker();
+                } catch (err) {
+                    console.error('[Local Server] Error removing server marker during shutdown:', getErrorMessage(err));
+                }
+                process.exit(0);
+            })();
+            return shutdownPromise;
         };
-        process.on('SIGTERM', () => void shutdownRuntimeServices());
-        process.on('SIGINT', () => void shutdownRuntimeServices());
+        process.on('SIGTERM', () => { void shutdownRuntimeServices(); });
+        process.on('SIGINT', () => { void shutdownRuntimeServices(); });
     } catch (error) {
         console.error('[ERROR] Failed to start server:', error);
         process.exit(1);

package/server/modules/cli/desktop-shortcut.ts

@@ -0,0 +1,89 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+type ShortcutOutput = {
+  log(message: string): void;
+};
+
+const SHORTCUT_NAME = 'PieceMaker';
+
+function desktopDirectory(): string {
+  return process.env.PIECEMAKER_DESKTOP_DIR || path.join(os.homedir(), 'Desktop');
+}
+
+function launchCommand(): { executable: string; argument: string } {
+  return { executable: process.execPath, argument: process.argv[1] || '' };
+}
+
+function createMacShortcut(desktop: string): string | null {
+  const { executable, argument } = launchCommand();
+  if (!argument) return null;
+  const bundle = path.join(desktop, `${SHORTCUT_NAME}.app`);
+  if (fs.existsSync(bundle)) return null;
+
+  const macOsDirectory = path.join(bundle, 'Contents', 'MacOS');
+  fs.mkdirSync(macOsDirectory, { recursive: true });
+  fs.writeFileSync(
+    path.join(bundle, 'Contents', 'Info.plist'),
+    `<?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>CFBundleName</key><string>${SHORTCUT_NAME}</string>
+  <key>CFBundleIdentifier</key><string>legal.piecemaker.launcher</string>
+  <key>CFBundleExecutable</key><string>${SHORTCUT_NAME}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>LSUIElement</key><true/>
+</dict>
+</plist>
+`,
+  );
+
+  const launcher = path.join(macOsDirectory, SHORTCUT_NAME);
+  fs.writeFileSync(launcher, `#!/bin/sh\nexec ${JSON.stringify(executable)} ${JSON.stringify(argument)} start\n`);
+  fs.chmodSync(launcher, 0o755);
+  return bundle;
+}
+
+function createWindowsShortcut(desktop: string): string | null {
+  const { executable, argument } = launchCommand();
+  if (!argument) return null;
+  const shortcut = path.join(desktop, `${SHORTCUT_NAME}.lnk`);
+  if (fs.existsSync(shortcut)) return null;
+
+  const script = [
+    '$shell = New-Object -ComObject WScript.Shell',
+    `$shortcut = $shell.CreateShortcut(${JSON.stringify(shortcut)})`,
+    `$shortcut.TargetPath = ${JSON.stringify(executable)}`,
+    `$shortcut.Arguments = ${JSON.stringify(`${JSON.stringify(argument)} start`)}`,
+    `$shortcut.WorkingDirectory = ${JSON.stringify(path.dirname(executable))}`,
+    '$shortcut.WindowStyle = 7',
+    `$shortcut.Description = ${JSON.stringify('Ouvre PieceMaker')}`,
+    '$shortcut.Save()',
+  ].join('; ');
+  execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], { stdio: 'ignore' });
+  return shortcut;
+}
+
+/**
+ * Creates the PieceMaker desktop icon once, right after a fresh install, so the
+ * application can be reopened without a terminal. Existing shortcuts are left
+ * untouched and any failure is reported without interrupting the launch.
+ */
+export function ensureDesktopShortcut(output: ShortcutOutput): void {
+  if (process.platform !== 'darwin' && process.platform !== 'win32') return;
+
+  const desktop = desktopDirectory();
+  if (!fs.existsSync(desktop)) return;
+
+  try {
+    const created = process.platform === 'darwin'
+      ? createMacShortcut(desktop)
+      : createWindowsShortcut(desktop);
+    if (created) output.log(`[OK] PieceMaker desktop icon created at ${created}`);
+  } catch {
+    output.log('[WARN] Could not create the PieceMaker desktop icon.');
+  }
+}

package/server/modules/cli/pwa-launcher.ts

@@ -4,6 +4,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
+import { ensureDesktopShortcut } from './desktop-shortcut.js';
+
 type PwaOutput = {
   log(message: string): void;
 };
@@ -102,7 +104,22 @@ async function waitForServer(url: string): Promise<boolean> {
   return false;
 }
 
-/** Starts PieceMaker in an isolated Chromium app window after its backend is ready. */
+const SHUTDOWN_GRACE_MS = 10_000;
+const DELEGATED_LAUNCH_MS = 3_000;
+
+function shutdownAfterWindowClosed(output: PwaOutput): void {
+  output.log('[OK] PieceMaker window closed; stopping the local server.');
+  const forced = setTimeout(() => process.exit(0), SHUTDOWN_GRACE_MS);
+  forced.unref();
+  if (process.listenerCount('SIGTERM') > 0) process.emit('SIGTERM', 'SIGTERM');
+  else process.exit(0);
+}
+
+/**
+ * Starts PieceMaker in an isolated Chromium app window after its backend is
+ * ready, and ties the server's lifetime to that window: closing it shuts the
+ * local server down through the same graceful path as SIGTERM.
+ */
 export async function launchPwa(output: PwaOutput = DEFAULT_OUTPUT): Promise<void> {
   const url = pwaUrl();
   if (!(await waitForServer(url))) {
@@ -116,16 +133,24 @@ export async function launchPwa(output: PwaOutput = DEFAULT_OUTPUT): Promise<voi
     return;
   }
 
+  ensureDesktopShortcut(output);
+
   const profileDirectory = pwaProfileDirectory();
   fs.mkdirSync(profileDirectory, { recursive: true });
+  const openedAt = Date.now();
   const child = spawn(browser, [`--app=${url}`, `--user-data-dir=${profileDirectory}`], {
-    detached: true,
     stdio: 'ignore',
     windowsHide: true,
   });
   child.on('error', () => {
     output.log(`[WARN] Could not open the PieceMaker PWA; open ${url} manually.`);
   });
-  child.unref();
-  output.log(`[OK] PieceMaker PWA opened at ${url}`);
+  child.on('exit', () => {
+    if (Date.now() - openedAt < DELEGATED_LAUNCH_MS) {
+      output.log(`[WARN] The PieceMaker window is owned by another browser process; the server keeps running.`);
+      return;
+    }
+    shutdownAfterWindowClosed(output);
+  });
+  output.log(`[OK] PieceMaker PWA opened at ${url} — closing the window stops the server.`);
 }

package/server/modules/database/repositories/projects.db.ts

@@ -15,6 +15,22 @@ function normalizeProjectDisplayName(projectPath: string, customProjectName: str
     return directoryName || projectPath;
 }
 
+function ensureAnonymizationStatusTable(db: ReturnType<typeof getConnection>): void {
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS piecemaker_anonymization_status (
+            project_id TEXT PRIMARY KEY NOT NULL,
+            completed_at TEXT NOT NULL,
+            FOREIGN KEY (project_id) REFERENCES projects(project_id) ON DELETE CASCADE
+        )
+    `);
+    const mappingsExist = db.prepare(`SELECT 1 AS ok FROM sqlite_master WHERE type='table' AND name='piecemaker_mappings'`).get() as { ok: number } | undefined;
+    if (!mappingsExist) return;
+    db.prepare(`
+        INSERT OR IGNORE INTO piecemaker_anonymization_status(project_id, completed_at)
+        SELECT DISTINCT project_id, ? FROM piecemaker_mappings
+    `).run(new Date().toISOString());
+}
+
 export const projectsDb = {
     createProjectPath(projectPath: string, customProjectName: string | null = null): CreateProjectPathResult {
         const db = getConnection();
@@ -88,10 +104,13 @@ export const projectsDb = {
 
     getProjectPaths(): ProjectRepositoryRow[] {
         const db = getConnection();
+        ensureAnonymizationStatusTable(db);
         return db.prepare(`
-            SELECT project_id, project_path, custom_project_name, isStarred, isArchived
-            FROM projects
-            WHERE isArchived = 0
+            SELECT p.project_id, p.project_path, p.custom_project_name, p.isStarred, p.isArchived,
+                   CASE WHEN s.project_id IS NULL THEN 0 ELSE 1 END AS anonymization_complete
+            FROM projects p
+            LEFT JOIN piecemaker_anonymization_status s ON s.project_id = p.project_id
+            WHERE p.isArchived = 0
         `).all() as ProjectRepositoryRow[];
     },
 
@@ -101,10 +120,13 @@ export const projectsDb = {
      */
     getArchivedProjectPaths(): ProjectRepositoryRow[] {
         const db = getConnection();
+        ensureAnonymizationStatusTable(db);
         return db.prepare(`
-            SELECT project_id, project_path, custom_project_name, isStarred, isArchived
-            FROM projects
-            WHERE isArchived = 1
+            SELECT p.project_id, p.project_path, p.custom_project_name, p.isStarred, p.isArchived,
+                   CASE WHEN s.project_id IS NULL THEN 0 ELSE 1 END AS anonymization_complete
+            FROM projects p
+            LEFT JOIN piecemaker_anonymization_status s ON s.project_id = p.project_id
+            WHERE p.isArchived = 1
         `).all() as ProjectRepositoryRow[];
     },