@piecemaker-legal/piecemaker 1.1.1 → 2.0.1

package/server/piecemaker/index.ts

@@ -11,7 +11,7 @@ import { startRequiredAnonymizer } from './anonymizer/lifecycle.js';
 import { createCitationStore } from './harness/citation-store.js';
 import { installChatCitationHarness } from './harness/chat-harness.js';
 import { createCitationsRouter } from './harness/citations.routes.js';
-import { startLibraryBackend, installLibraryRuntime } from './library/index.js';
+import { openLibrary, installLibraryRuntime } from './library/index.js';
 import { createKnowledgeBackend } from './knowledge/index.js';
 import { createTimesheetBackend } from './timesheet/index.js';
 import { createCompanySearchRouter } from './company-search.js';
@@ -49,17 +49,22 @@ const anonymizer = createAnonymizerService({ homeDir: piecemakerHome(), required
 const ensureProxy = await startRequiredAnonymizer(anonymizer);
 const citations = createCitationStore(piecemakerHome());
 installChatCitationHarness({ runtime: providerRuntimeService, sessions: sessionsService, store: citations, ensureProxy });
-const library = await startLibraryBackend(piecemakerHome(), applicationRoot);
-installLibraryRuntime(providerRuntimeService, sessionsService, library);
+const library = await openLibrary(piecemakerHome(), applicationRoot);
+installLibraryRuntime(providerRuntimeService, sessionsService, library.store);
 const timesheet = createTimesheetBackend(piecemakerHome());
 const knowledge = createKnowledgeBackend(applicationRoot);
 
+export function createPieceMakerLocalRouter() {
+  return knowledge.localRouter;
+}
+
 export function createPieceMakerRouter(options: { getRuntimeStatus?: () => PieceMakerRuntimeStatus } = {}) {
   const router = vendor.createPieceMakerRouter({ ...options, anonymizer });
   router.use(createCitationsRouter(citations, (id) => {
     try { sessionsService.getSessionDetailsById(id); return true; } catch { return false; }
   }));
   router.use(timesheet);
+  router.use('/library', library.router);
   router.use(knowledge.router);
   router.use(createCompanySearchRouter());
   router.use(createBodaccSearchRouter());

package/server/piecemaker/knowledge/index.ts

@@ -4,24 +4,32 @@ import { getConnection, projectsDb } from '@/modules/database/index.js';
 
 import { KnowledgeStore } from '../../../plugins/piecemaker-dossier/src/knowledge.js';
 
+import { createKnowledgeLocalRouter } from './local-routes.js';
 import { createKnowledgePipeline } from './pipeline.js';
 import { createKnowledgeRouter } from './routes.js';
 import { createKnowledgeService } from './service.js';
 
 export function createKnowledgeBackend(applicationRoot: string) {
-  const router = express.Router();
-  let knowledgeRouter: express.Router | null = null;
   let store: KnowledgeStore | null = null;
+  let service: ReturnType<typeof createKnowledgeService> | null = null;
   const getStore = () => {
     if (!store) store = new KnowledgeStore(getConnection());
     return store;
   };
-  router.use((request, response, next) => {
-    if (!knowledgeRouter) {
+  const getService = () => {
+    if (!service) {
       const pipeline = createKnowledgePipeline({ applicationRoot, projects: projectsDb, store: getStore() });
-      knowledgeRouter = createKnowledgeRouter(createKnowledgeService(getStore(), projectsDb, pipeline));
+      service = createKnowledgeService(getStore(), projectsDb, pipeline);
     }
+    return service;
+  };
+
+  const router = express.Router();
+  let knowledgeRouter: express.Router | null = null;
+  router.use((request, response, next) => {
+    if (!knowledgeRouter) knowledgeRouter = createKnowledgeRouter(getService());
     knowledgeRouter(request, response, next);
   });
-  return { router };
+
+  return { router, localRouter: createKnowledgeLocalRouter(getService, projectsDb) };
 }

package/server/piecemaker/knowledge/local-routes.ts

@@ -0,0 +1,72 @@
+import express from 'express';
+
+import type { createKnowledgeService } from './service.js';
+
+type KnowledgeService = ReturnType<typeof createKnowledgeService>;
+
+type ProjectPathLookup = {
+  getProjectPath(projectPath: string): { project_id: string; project_path: string } | null;
+};
+
+const LOOPBACK_ADDRESSES = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+
+function isLoopback(request: express.Request): boolean {
+  return LOOPBACK_ADDRESSES.has(request.socket.remoteAddress || '');
+}
+
+function statusFor(error: unknown): number {
+  if (error instanceof TypeError) return 400;
+  if (error instanceof Error && error.message === 'Project not found.') return 404;
+  return 500;
+}
+
+export function createKnowledgeLocalRouter(
+  getService: () => KnowledgeService,
+  projects: ProjectPathLookup,
+) {
+  const router = express.Router();
+
+  router.use((request, response, next) => {
+    if (!isLoopback(request)) {
+      response.status(403).json({ error: 'Local scan is restricted to loopback callers.' });
+      return;
+    }
+    next();
+  });
+
+  const resolveProjectId = (body: unknown): string => {
+    const source = (body ?? {}) as { projectId?: unknown; folder?: unknown };
+    if (typeof source.projectId === 'string' && source.projectId.trim()) return source.projectId.trim();
+    if (typeof source.folder !== 'string' || !source.folder.trim()) {
+      throw new TypeError('folder or projectId is required.');
+    }
+    const project = projects.getProjectPath(source.folder.trim());
+    if (!project) throw new Error('Project not found.');
+    return project.project_id;
+  };
+
+  const respond = (operation: () => unknown | Promise<unknown>, response: express.Response) => {
+    Promise.resolve().then(operation).then((result) => response.json(result)).catch((error: unknown) => {
+      response.status(statusFor(error)).json({ error: error instanceof Error ? error.message : 'Local scan failed.' });
+    });
+  };
+
+  router.post('/scan', (request, response) => respond(() => {
+    const id = resolveProjectId(request.body);
+    return { projectId: id, ...getService().scan(id, request.body?.files) };
+  }, response));
+
+  router.get('/scan/job', (request, response) => respond(() => {
+    const id = typeof request.query.projectId === 'string' && request.query.projectId.trim()
+      ? request.query.projectId.trim()
+      : resolveProjectId({ folder: request.query.folder });
+    return { projectId: id, ...getService().scanJob(request.query.id, id) };
+  }, response));
+
+  router.post('/scan/cancel', (request, response) => respond(() => {
+    const id = resolveProjectId(request.body);
+    return { projectId: id, ...getService().cancelScan(request.body?.id, id) };
+  }, response));
+
+  return router;
+}

package/server/piecemaker/knowledge/scan-jobs.ts

@@ -20,6 +20,7 @@ export type KnowledgeScanJob = {
   processed: number;
   total: number;
   error: string | null;
+  result: unknown;
   startedAt: string;
   finishedAt: string | null;
 };
@@ -63,6 +64,7 @@ export function createKnowledgeScanJobs() {
         processed: 0,
         total: 0,
         error: null,
+        result: null,
         startedAt: new Date().toISOString(),
         finishedAt: null,
       };
@@ -76,11 +78,12 @@ export function createKnowledgeScanJobs() {
       };
       const controller = new AbortController();
       controllers.set(job.id, controller);
-      run(report, controller.signal).then(() => {
+      run(report, controller.signal).then((result: unknown) => {
         if (job.state !== 'running') return;
         job.state = 'done';
         job.phase = 'commit';
         job.percent = 100;
+        job.result = result ?? null;
       }, (error: unknown) => {
         if (job.state !== 'running') return;
         job.state = 'error';

package/server/piecemaker/library/index.ts

@@ -1,8 +1,6 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { createRequire } from 'node:module';
 
 import express from 'express';
 
@@ -15,44 +13,26 @@ import { scanAndPersistLibraryProviderSkills } from './provider-skills.js';
 
 export { installLibraryRuntime } from './runtime.js';
 
-export async function startLibraryBackend(home: string, applicationRoot: string) {
+const LIBRARY_BODY_LIMIT = 1024 * 1024;
+
+export async function openLibrary(home: string, applicationRoot: string) {
   const store = createLibraryStore(home);
   try { await scanAndPersistLibraryProviderSkills(store, undefined, undefined, os.homedir()); } catch {}
   try { scanAndPersistLibraryProviderAgents(store, os.homedir()); } catch {}
   try { scanAndPersistLibraryProviderConnectors(store, os.homedir()); } catch {}
   try { scanInstalledLibraryCollections(store, os.homedir()); } catch {}
-  const require = createRequire(import.meta.url);
-  const { createActivationRouter } = require(path.join(applicationRoot, 'server/piecemaker/activation/index.cjs'));
-  const options = { repoRoot: path.join(applicationRoot, 'server/piecemaker/vendor'), piecemakerHome: home, homeDir: home, userHome: os.homedir(), isOriginAllowed: () => true };
-  const token = randomBytes(32).toString('hex');
-  const app = express();
-  app.use((req, res, next) => {
-    if (req.headers.authorization !== `Bearer ${token}`) { res.sendStatus(401); return; }
+  try { fs.unlinkSync(path.join(store.directory, 'connection.json')); } catch {}
+  const router = express.Router();
+  router.use((req, res, next) => {
+    const length = Number(req.headers['content-length'] || 0);
+    if (Number.isFinite(length) && length > LIBRARY_BODY_LIMIT) {
+      res.status(413).json({ error: 'Requête trop volumineuse.' });
+      return;
+    }
     res.setHeader('Cache-Control', 'no-store');
     next();
   });
-  app.use(express.json({ limit: '1mb' }));
-  app.use(createLibraryRouter(store));
-  app.use(createLibraryMarketplaceRouter(store, applicationRoot, os.homedir()));
-  app.use((req, res, next) => {
-    if ((req.method === 'GET' && req.path === '/activation')
-      || (req.method === 'POST' && req.path === '/activation/toggle')) { next(); return; }
-    res.sendStatus(404);
-  });
-  app.use(createActivationRouter(options));
-  const server = app.listen(0, '127.0.0.1');
-  await new Promise<void>((resolve, reject) => { server.once('listening', resolve); server.once('error', reject); });
-  const address = server.address();
-  if (!address || typeof address === 'string') throw new Error('Bibliothèque indisponible.');
-  const connection = path.join(store.directory, 'connection.json');
-  const temporary = `${connection}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, JSON.stringify({ port: address.port, token }), { mode: 0o600 });
-  fs.renameSync(temporary, connection);
-  server.unref();
-  process.once('exit', () => {
-    try {
-      if (JSON.parse(fs.readFileSync(connection, 'utf8')).token === token) fs.unlinkSync(connection);
-    } catch {}
-  });
-  return store;
+  router.use(createLibraryRouter(store));
+  router.use(createLibraryMarketplaceRouter(store, applicationRoot, os.homedir()));
+  return { store, router };
 }

package/server/piecemaker/library/store.ts

@@ -7,7 +7,7 @@ import Database from 'better-sqlite3';
 import { parseFrontMatter } from '@/shared/frontmatter.js';
 
 import { parseConnectorConfig, prepareConnectorInstallation, type LibraryConnectorConfig } from './connector-installation.js';
-import { prepareWorkspaceInstallation } from './workspace-installation.js';
+import { componentFolderName, prepareWorkspaceInstallation } from './workspace-installation.js';
 
 type StoredLibraryEntry = {
   id: string;
@@ -64,6 +64,11 @@ function decodeEditableFile(bytes: Buffer) {
   return decodeUtf8File(bytes);
 }
 
+function installationFolder(content: string, fallback = '') {
+  const { data } = parseFrontMatter(content);
+  return componentFolderName(String(data.name || data.metadata?.title || fallback));
+}
+
 function collectionMainPath(entry: LibraryEntry, rootPath: string) {
   return entry.kind === 'skill' && !rootPath.toLowerCase().endsWith('.md') ? `${rootPath}/SKILL.md` : rootPath;
 }
@@ -219,6 +224,10 @@ export function createLibraryStore(home: string) {
     return db.transaction(() => {
       const entry = document(id);
       if (entry.content !== previousContent) throw new Error('Le document a été modifié ailleurs. Rouvrez-le avant d’enregistrer.');
+      const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
+      if (entry.kind !== 'connector' && installationFolder(content) !== installationFolder(entry.content)) {
+        for (const { workspace: selected } of active) setEnabled(selected, id, false);
+      }
       if (entry.kind === 'connector') {
         const config = parseConnectorConfig(content);
         const description = config.url || config.command || entry.name;
@@ -229,7 +238,6 @@ export function createLibraryStore(home: string) {
         const description = typeof data.description === 'string' ? data.description : '';
         db.prepare('UPDATE entries SET name = ?, description = ?, content = ? WHERE id = ?').run(name, description, content, id);
       }
-      const active = db.prepare('SELECT workspace FROM activation WHERE entry_id = ?').all(id) as Array<{ workspace: string }>;
       for (const { workspace: selected } of active) setEnabled(selected, id, true);
       return document(id);
     })();
@@ -465,7 +473,7 @@ export function createLibraryStore(home: string) {
       return { ok: true, enabled };
     }
     const packageRoot = path.join(directory, 'active', createHash('sha256').update(selected).digest('hex'), id);
-    const install = prepareWorkspaceInstallation(selected, id, packageRoot, entry.kind, enabled);
+    const install = prepareWorkspaceInstallation(selected, id, installationFolder(entry.content, entry.name), packageRoot, entry.kind, enabled);
     if (enabled) {
       fs.mkdirSync(path.dirname(packageRoot), { recursive: true, mode: 0o700 });
       if (!fs.realpathSync(path.dirname(packageRoot)).startsWith(fs.realpathSync(directory) + path.sep)) throw new Error('Répertoire d’activation non autorisé.');

package/server/piecemaker/library/workspace-installation.ts

@@ -10,6 +10,12 @@ const AGENT_TARGETS = [
   { provider: '.grok', folder: 'agents', extension: '.md', sourceFile: 'agent.md' },
 ] as const;
 
+export function componentFolderName(name: string) {
+  const slug = String(name).normalize('NFKD').replace(/[^\p{Letter}\p{Number}._-]+/gu, '-').replace(/^[-._]+|[-._]+$/g, '');
+  if (!slug) throw new Error(`Nom de composant inutilisable : ${name}`);
+  return slug;
+}
+
 function assertWorkspaceDirectory(workspace: string, directory: string, enabled: boolean) {
   if (!fs.existsSync(directory)) {
     if (enabled) fs.mkdirSync(directory);
@@ -20,14 +26,16 @@ function assertWorkspaceDirectory(workspace: string, directory: string, enabled:
   }
 }
 
-export function prepareWorkspaceInstallation(workspace: string, id: string, packageRoot: string, kind: 'skill' | 'agent', enabled: boolean) {
+export function prepareWorkspaceInstallation(workspace: string, id: string, name: string, packageRoot: string, kind: 'skill' | 'agent', enabled: boolean) {
+  const slug = componentFolderName(name);
   const targets = kind === 'skill'
     ? SKILL_PROVIDERS.map((provider) => {
       const parent = path.join(workspace, provider, 'skills');
       for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
       return {
         parent,
-        target: path.join(parent, `piecemaker-${id}`),
+        target: path.join(parent, slug),
+        legacy: path.join(parent, `piecemaker-${id}`),
         source: packageRoot,
         kind: 'skill' as const,
       };
@@ -37,7 +45,8 @@ export function prepareWorkspaceInstallation(workspace: string, id: string, pack
       for (const directory of [path.dirname(parent), parent]) assertWorkspaceDirectory(workspace, directory, enabled);
       return {
         parent,
-        target: path.join(parent, `piecemaker-${id}${entry.extension}`),
+        target: path.join(parent, `${slug}${entry.extension}`),
+        legacy: path.join(parent, `piecemaker-${id}${entry.extension}`),
         source: path.join(packageRoot, entry.sourceFile),
         kind: 'agent' as const,
       };
@@ -82,5 +91,13 @@ export function prepareWorkspaceInstallation(workspace: string, id: string, pack
       }
       throw error;
     }
+    for (const { legacy, source, kind: targetKind } of prepared) {
+      let existing: fs.Stats;
+      try { existing = fs.lstatSync(legacy); } catch { continue; }
+      const owned = targetKind === 'skill'
+        ? existing.isSymbolicLink() && fs.existsSync(source) && fs.realpathSync(legacy) === fs.realpathSync(source)
+        : existing.isFile() && fs.existsSync(source) && fs.readFileSync(legacy).equals(fs.readFileSync(source));
+      if (owned) fs.unlinkSync(legacy);
+    }
   };
 }

package/server/piecemaker/timesheet/service.ts

@@ -36,7 +36,7 @@ type SessionRecord = ReturnType<typeof sessionsDb.getAllSessions>[number];
 type TimesheetStore = {
   upsert(entry: TimesheetEntry): void;
   findBySessionId(sessionId: string): TimesheetEntry | null;
-  list(projectId?: string): TimesheetEntry[];
+  list(projectPath?: string): TimesheetEntry[];
 };
 
 type TimesheetDependencies = {
@@ -154,10 +154,13 @@ export function createTimesheetService(
     return project;
   }
 
+  function projectPathFor(query: TimesheetQuery): string | undefined {
+    if (query.scope !== 'project') return undefined;
+    return resolveProject(query.projectId as string).project_path;
+  }
+
   function sessionsFor(query: TimesheetQuery): SessionRecord[] {
-    const projectPath = query.scope === 'project'
-      ? resolveProject(query.projectId as string).project_path
-      : null;
+    const projectPath = projectPathFor(query) ?? null;
     const activeSessions = projectPath
       ? dependencies.sessions.getSessionsByProjectPath(projectPath)
       : dependencies.sessions.getAllSessions();
@@ -197,7 +200,7 @@ export function createTimesheetService(
     }
 
     return {
-      entries: store.list(query.scope === 'project' ? query.projectId : undefined).map(toPublicEntry),
+      entries: store.list(projectPathFor(query)).map(toPublicEntry),
       refreshedAt: new Date().toISOString(),
       refreshedCount,
       skippedCount,
@@ -221,8 +224,7 @@ export function createTimesheetService(
 
   return {
     list(query: TimesheetQuery): TimesheetPublicEntry[] {
-      if (query.scope === 'project') resolveProject(query.projectId as string);
-      return store.list(query.scope === 'project' ? query.projectId : undefined).map(toPublicEntry);
+      return store.list(projectPathFor(query)).map(toPublicEntry);
     },
     refresh,
   };

package/server/piecemaker/timesheet/store.ts

@@ -60,6 +60,8 @@ function createSchema(database: TimesheetDatabase): void {
     );
     CREATE INDEX IF NOT EXISTS timesheet_project_date
       ON timesheet_sessions(project_id, started_at);
+    CREATE INDEX IF NOT EXISTS timesheet_project_path_date
+      ON timesheet_sessions(project_path, started_at);
     CREATE INDEX IF NOT EXISTS timesheet_date
       ON timesheet_sessions(started_at);
   `);
@@ -144,7 +146,7 @@ export function createTimesheetStore(homeDir: string) {
   `);
   const findBySessionId = database.prepare('SELECT * FROM timesheet_sessions WHERE session_id = ?');
   const listAll = database.prepare('SELECT * FROM timesheet_sessions ORDER BY datetime(started_at) DESC, session_id DESC');
-  const listByProject = database.prepare('SELECT * FROM timesheet_sessions WHERE project_id = ? ORDER BY datetime(started_at) DESC, session_id DESC');
+  const listByProjectPath = database.prepare('SELECT * FROM timesheet_sessions WHERE project_path = ? ORDER BY datetime(started_at) DESC, session_id DESC');
 
   return {
     databasePath,
@@ -156,8 +158,8 @@ export function createTimesheetStore(homeDir: string) {
       const row = findBySessionId.get(sessionId) as TimesheetEntryRow | undefined;
       return row ? toEntry(row) : null;
     },
-    list(projectId?: string): TimesheetEntry[] {
-      const rows = (projectId ? listByProject.all(projectId) : listAll.all()) as TimesheetEntryRow[];
+    list(projectPath?: string): TimesheetEntry[] {
+      const rows = (projectPath ? listByProjectPath.all(projectPath) : listAll.all()) as TimesheetEntryRow[];
       return rows.map(toEntry);
     },
     close(): void {

package/server/piecemaker/vendor/installer/assets/claude-hooks/piecemaker-guard-secrets.mjs

@@ -42,7 +42,6 @@ const CONFIG_FILE = path.join(os.homedir(), '.claude', 'piecemaker-secret-paths.
 /** Never empty: at minimum, the general PieceMaker runtime .env. */
 const DEFAULT_BLOCKLIST = [
   path.join(os.homedir(), 'PieceMaker', '.env'),
-  path.join(os.homedir(), 'Sites', 'PieceMaker-Installer', '.env'),
 ];
 
 const PATH_TOOLS = new Set(['Read', 'Grep', 'Glob', 'Edit', 'Write', 'NotebookEdit', 'MultiEdit']);