@alucard_24/pi-codeindex 1.0.0 → 1.1.1

package/src/project-state.js

@@ -0,0 +1,53 @@
+// Consenso persistente per progetto, separato dal profilo embedding globale.
+// Nessun file viene letto o scritto nel repository del progetto.
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { configPath } from './config.js';
+
+export function projectIdentity(root, platform = process.platform) {
+  const resolved = (platform === 'win32' ? path.win32 : path).resolve(root);
+  return platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+async function location(root, options = {}) {
+  const project = await fs.realpath(path.resolve(root));
+  const identity = projectIdentity(project);
+  const hash = createHash('sha256').update(identity).digest('hex');
+  const file = path.join(path.dirname(configPath(options.env, options.home)), 'projects', `${hash}.json`);
+  return { project, identity, file };
+}
+
+export async function readProjectState(root, options = {}) {
+  const target = await location(root, options);
+  let text;
+  try { text = await fs.readFile(target.file, 'utf8'); }
+  catch (e) {
+    if (e.code === 'ENOENT') return { ...target, enabled: false };
+    throw e;
+  }
+  let value;
+  try { value = JSON.parse(text); }
+  catch { throw new Error(`attivazione progetto non valida: ${target.file}`); }
+  if (!value || value.version !== 1 || typeof value.enabled !== 'boolean'
+      || typeof value.project !== 'string' || !path.isAbsolute(value.project)
+      || projectIdentity(value.project) !== target.identity) {
+    throw new Error(`attivazione progetto non valida: ${target.file}`);
+  }
+  return { ...target, enabled: value.enabled };
+}
+
+export async function writeProjectState(root, enabled, options = {}) {
+  if (typeof enabled !== 'boolean') throw new Error('attivazione progetto: enabled deve essere booleano');
+  const target = await location(root, options);
+  await fs.mkdir(path.dirname(target.file), { recursive: true, mode: 0o700 });
+  const tmp = `${target.file}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(tmp, JSON.stringify({ version: 1, project: target.project, enabled }, null, 2) + '\n',
+      { flag: 'wx', mode: 0o600 });
+    await fs.rename(tmp, target.file);
+  } finally {
+    await fs.rm(tmp, { force: true });
+  }
+  return { ...target, enabled };
+}

package/src/service-client.js

@@ -0,0 +1,130 @@
+// Client leggero: solo JSON e socket loopback. Nessuna pipeline locale.
+import { fork } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import { loadConfig } from './config.js';
+import { assertCompatibleIndex, validateEmbeddings } from './backend.js';
+import { serviceAddress, readServiceRecord, rpc, disconnected, serviceError } from './service-protocol.js';
+import { validateServiceConfig, validateTexts } from './service-policy.js';
+
+export function createEmbeddingClient({ env = process.env, settings = () => loadConfig({ env }),
+  workerFile = new URL('./service-worker.js', import.meta.url), startupTimeoutMs = 10_000, requestTimeoutMs = 15 * 60_000 } = {}) {
+  let config = null, configLoading = null, starting = null, pinned = null;
+  let pending = 0, error = null, remote = null;
+  async function getConfig() {
+    if (config) return config;
+    if (!configLoading) configLoading = Promise.resolve().then(settings).then((loaded) => {
+      config = validateServiceConfig(loaded.config);
+      return config;
+    });
+    try { return await configLoading; } finally { configLoading = null; }
+  }
+  async function probe(address) {
+    const record = await readServiceRecord(address);
+    if (!record) return { record: null };
+    try {
+      const response = await rpc(address, record, { op: 'status' }, { timeoutMs: 2000 });
+      return { record, status: response.result };
+    } catch (e) {
+      if (disconnected(e)) return { record: null };
+      if (e.code === 'SERVICE_STOPPING') return { record, status: { running: false } };
+      throw e;
+    }
+  }
+  async function start(address) {
+    if (starting) return starting;
+    starting = (async () => {
+      let launchError, childRunning = false, launches = 0, lastLaunchAt = 0;
+      const launch = () => {
+        launches++; childRunning = true; lastLaunchAt = Date.now();
+        const child = fork(workerFile instanceof URL ? fileURLToPath(workerFile) : workerFile,
+          [address.directory, String(address.port)], { detached: true, execArgv: [], env,
+            stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
+        child.on('error', (e) => { launchError = e; childRunning = false; });
+        child.on('exit', () => { childRunning = false; });
+        child.on('message', (message) => {
+          if (message?.ready === false && message.code !== 'EADDRINUSE') {
+            const hint = message.code === 'EACCES' && /^listen\b/.test(message.error ?? '')
+              ? ' Porta locale non utilizzabile: potrebbe essere esclusa dal sistema. Scegli una porta libera con /codeindex config set servicePort NUMERO e riavvia pi. Nessun fallback in-process.' : '';
+            launchError = serviceError(message.code ?? 'START_FAILED', `${message.error}${hint}`);
+          }
+        });
+        child.unref(); child.channel?.unref();
+      };
+      const deadline = Date.now() + startupTimeoutMs;
+      while (Date.now() < deadline) {
+        if (launchError) throw launchError;
+        const { record, status } = await probe(address);
+        if (record && status.running) return record;
+        // Il vecchio processo tiene la porta durante dispose. Non tentare
+        // un secondo modello mentre quel processo sta ancora liberando VRAM.
+        if (!record && !childRunning && launches < 3 && Date.now() - lastLaunchAt >= 100) launch();
+        await delay(40);
+      }
+      throw serviceError('START_FAILED', `servizio locale non avviabile su 127.0.0.1:${address.port}: porta occupata o avvio fallito. Controlla service status e servicePort. Nessun fallback in-process.`);
+    })();
+    try { return await starting; } finally { starting = null; }
+  }
+  function remember(info) { if (info) remote = { ...info, lastSeenAt: Date.now() }; }
+  async function call(op, payload = {}) {
+    const active = await getConfig();
+    const address = serviceAddress(active);
+    pending++;
+    error = null;
+    try {
+      let record = await readServiceRecord(address);
+      if (!record) record = await start(address);
+      let response;
+      const request = { op, config: active, expectedProfile: pinned, ...payload };
+      try { response = await rpc(address, record, request, { timeoutMs: requestTimeoutMs }); }
+      catch (e) {
+        // Questi errori provano che l'inferenza non è iniziata. Un crash
+        // dopo l'invio non viene ritentato automaticamente.
+        if (!['ECONNREFUSED', 'SERVICE_STOPPING'].includes(e.code)) throw e;
+        record = await start(address);
+        response = await rpc(address, record, request, { timeoutMs: requestTimeoutMs });
+      }
+      remember(response.info);
+      const profile = response.info?.profile;
+      if (!profile) throw serviceError('BAD_FRAME', 'il servizio non ha restituito il profilo del modello');
+      if (pinned) {
+        try { assertCompatibleIndex(pinned, profile); }
+        catch { throw serviceError('PROFILE_CHANGED', 'profilo del servizio cambiato: riavvia pi e verifica/reindicizza; nessun vettore accettato'); }
+      }
+      pinned ??= Object.freeze({ ...profile });
+      return response.result;
+    } catch (e) {
+      remember(e.info);
+      error = e.message;
+      throw e;
+    } finally { pending--; }
+  }
+  return {
+    getProfile: async () => { await call('profile'); return pinned; },
+    embed: async (texts, { normalize = true } = {}) => {
+      if (Array.isArray(texts) && !texts.length) return [];
+      validateTexts(texts, normalize);
+      const rows = await call('embed', { texts, normalize });
+      return validateEmbeddings(rows, texts.length).map((row) => Float32Array.from(row));
+    },
+    info: () => ({ profile: pinned, config, loading: pending > 0, attempts: (remote?.attempts ?? []).map((a) => ({ ...a })),
+      error, shared: true,
+      warnings: pinned?.device === 'cpu' && config && !['auto', 'cpu'].includes(config.device)
+        ? [`fallback CPU esplicitamente consentito: richiesto ${config.device}, riutilizzato il servizio ${pinned.device}/${pinned.dtype}`] : [],
+      service: remote ? { pid: remote.pid, lastSeenAt: remote.lastSeenAt } : null }),
+    status: async () => {
+      const address = serviceAddress(await getConfig());
+      const record = await readServiceRecord(address);
+      if (!record) return { running: false, shared: true, port: address.port };
+      try { return (await rpc(address, record, { op: 'status' }, { timeoutMs: 2000 })).result; }
+      catch (e) { if (disconnected(e)) return { running: false, shared: true, port: address.port }; throw e; }
+    },
+    stop: async () => {
+      const address = serviceAddress(await getConfig());
+      const record = await readServiceRecord(address);
+      if (!record) return { stopping: false };
+      try { return (await rpc(address, record, { op: 'stop' }, { timeoutMs: 5000 })).result; }
+      catch (e) { if (disconnected(e)) return { stopping: false }; throw e; }
+    },
+  };
+}

package/src/service-policy.js

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { ENV_KEYS, validateConfig } from './config.js';
+import { assertCompatibleIndex, backendPlan, formatProfile, webgpuBackendOf } from './backend.js';
+import { MAX_TEXTS, MAX_TEXT_BYTES, serviceError } from './service-protocol.js';
+
+export function validateServiceConfig(config) {
+  validateConfig(config, 'client del servizio');
+  if (Object.keys(ENV_KEYS).some((key) => !Object.hasOwn(config, key))) throw serviceError('BAD_CONFIG', 'configurazione client incompleta');
+  if (!path.isAbsolute(config.cacheDir) || !path.isAbsolute(config.serviceDir)) throw serviceError('BAD_CONFIG', 'cacheDir e serviceDir devono essere assoluti');
+  return Object.freeze({ ...config });
+}
+
+export function assertServiceCompatible(config, activeConfig, profile, expectedProfile) {
+  const permitted = backendPlan(config, [{ device: profile.device, available: true }]).some((p) =>
+    p.device === profile.device && p.dtype === profile.dtype &&
+    (p.device !== 'webgpu' || config.webgpuBackend === webgpuBackendOf(profile)));
+  const differs = ['cacheDir', 'cpuThreads', 'serviceIdleMs'].filter((key) => config[key] !== activeConfig[key]);
+  if (!permitted || differs.length) {
+    throw serviceError('PROFILE_CONFLICT', `servizio condiviso già configurato per ${formatProfile(profile)}${differs.length ? `; impostazioni diverse: ${differs.join(', ')}` : ''}. Nessun secondo modello avviato. Usa /codeindex service status; per cambiare profilo, service stop quando inattivo e riavvia pi.`);
+  }
+  if (expectedProfile) {
+    try { assertCompatibleIndex(expectedProfile, profile); }
+    catch { throw serviceError('PROFILE_CHANGED', `profilo del servizio cambiato dopo una riconnessione: ${formatProfile(profile)}. Riavvia pi e verifica/reindicizza; nessun vettore è stato accettato.`); }
+  }
+}
+
+export function validateTexts(texts, normalize) {
+  if (!Array.isArray(texts) || !texts.length || texts.length > MAX_TEXTS || texts.some((t) => typeof t !== 'string')) {
+    throw serviceError('BAD_TEXTS', `embedding: attesi da 1 a ${MAX_TEXTS} testi`);
+  }
+  if (typeof normalize !== 'boolean') throw serviceError('BAD_TEXTS', 'normalize deve essere booleano');
+  if (texts.reduce((n, t) => n + Buffer.byteLength(t), 0) > MAX_TEXT_BYTES) throw serviceError('BAD_TEXTS', `batch di embedding troppo grande (massimo ${MAX_TEXT_BYTES} byte)`);
+}

package/src/service-protocol.js

@@ -0,0 +1,122 @@
+// IPC locale autenticato. Nessun provider o modello viene importato qui.
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+
+export const PROTOCOL = 1;
+export const HOST = '127.0.0.1';
+export const MAX_FRAME = 8 * 1024 * 1024;
+export const MAX_TEXT_BYTES = 2 * 1024 * 1024;
+export const MAX_TEXTS = 128;
+
+export function serviceError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+
+export function serviceAddress(config) {
+  const directory = path.resolve(config.serviceDir);
+  const identity = process.platform === 'win32' ? directory.toLowerCase() : directory;
+  const port = config.servicePort || 49152 + createHash('sha256').update(identity).digest().readUInt16BE(0) % 16384;
+  return { directory, host: HOST, port, file: path.join(directory, 'service.json') };
+}
+
+function checkPrivate(stat, target, directory = false) {
+  if (stat.isSymbolicLink() || (directory ? !stat.isDirectory() : !stat.isFile())) {
+    throw serviceError('UNSAFE_SERVICE_PATH', `percorso del servizio non sicuro: ${target}`);
+  }
+  if (process.platform !== 'win32' && (stat.uid !== process.getuid() || (stat.mode & 0o077))) {
+    throw serviceError('UNSAFE_SERVICE_PATH', `il servizio richiede proprietà utente e permessi privati (0700 directory, 0600 file): ${target}`);
+  }
+}
+
+export async function prepareServiceDirectory(address) {
+  await fs.mkdir(address.directory, { recursive: true, mode: 0o700 });
+  checkPrivate(await fs.lstat(address.directory), address.directory, true);
+}
+
+// Status è read-only: non crea directory/file e non avvia il servizio.
+export async function readServiceRecord(address) {
+  try {
+    checkPrivate(await fs.lstat(address.directory), address.directory, true);
+    const stat = await fs.lstat(address.file);
+    checkPrivate(stat, address.file);
+    if (stat.size > 4096) throw serviceError('BAD_SERVICE_RECORD', 'record del servizio troppo grande');
+    const record = JSON.parse(await fs.readFile(address.file, 'utf8'));
+    if (record.port !== address.port || !Number.isInteger(record.pid) || record.pid < 1 ||
+        typeof record.token !== 'string' || !/^[a-f0-9]{64}$/.test(record.token)) {
+      throw serviceError('BAD_SERVICE_RECORD', 'record del servizio locale non valido');
+    }
+    if (record.protocol !== PROTOCOL) throw serviceError('PROTOCOL_MISMATCH', 'servizio locale di versione incompatibile: arrestalo prima di riavviare pi');
+    return record;
+  } catch (e) {
+    if (e.code === 'ENOENT') return null;
+    throw e;
+  }
+}
+
+export async function writeServiceRecord(address, record) {
+  const tmp = `${address.file}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(tmp, JSON.stringify(record) + '\n', { flag: 'wx', mode: 0o600 });
+    await fs.rename(tmp, address.file);
+  } finally { await fs.rm(tmp, { force: true }); }
+}
+
+export function readFrame(socket, { timeoutMs = 30_000 } = {}) {
+  return new Promise((resolve, reject) => {
+    let size = 0;
+    const chunks = [];
+    const finish = (error, value) => {
+      clearTimeout(timer);
+      socket.off('data', data); socket.off('end', end); socket.off('close', end); socket.off('error', fail);
+      if (error) reject(error); else resolve(value);
+    };
+    const fail = (e) => finish(e);
+    const end = () => fail(serviceError('SERVICE_DISCONNECTED', 'servizio locale disconnesso; nessun fallback in-process'));
+    const data = (chunk) => {
+      size += chunk.length;
+      if (size > MAX_FRAME) return fail(serviceError('FRAME_TOO_LARGE', 'messaggio del servizio troppo grande'));
+      chunks.push(chunk);
+      const newline = chunk.indexOf(10);
+      if (newline < 0) return;
+      try {
+        const buffer = Buffer.concat(chunks);
+        const at = buffer.indexOf(10);
+        if (buffer.subarray(at + 1).toString().trim()) throw new Error('attesa una sola richiesta per connessione');
+        finish(null, JSON.parse(buffer.subarray(0, at).toString('utf8')));
+      } catch (e) { fail(serviceError('BAD_FRAME', `messaggio del servizio non valido: ${e.message}`)); }
+    };
+    const timer = setTimeout(() => fail(serviceError('SERVICE_TIMEOUT', 'timeout del servizio locale')), timeoutMs);
+    socket.on('data', data); socket.once('end', end); socket.once('close', end); socket.once('error', fail);
+  });
+}
+
+export function writeFrame(socket, value) {
+  const frame = JSON.stringify(value) + '\n';
+  if (Buffer.byteLength(frame) > MAX_FRAME) throw serviceError('FRAME_TOO_LARGE', 'messaggio del servizio troppo grande');
+  socket.write(frame);
+}
+
+export async function rpc(address, record, request, { timeoutMs = 15 * 60_000, connectTimeoutMs = 1000 } = {}) {
+  const socket = net.createConnection({ host: HOST, port: address.port });
+  socket.on('error', () => {});
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { socket.destroy(); reject(serviceError('CONNECT_TIMEOUT', 'timeout connessione al servizio locale')); }, connectTimeoutMs);
+      socket.once('connect', () => { clearTimeout(timer); resolve(); });
+      socket.once('error', (e) => { clearTimeout(timer); reject(e); });
+    });
+    const response = readFrame(socket, { timeoutMs });
+    try { writeFrame(socket, { protocol: PROTOCOL, token: record.token, ...request }); }
+    catch (e) { socket.destroy(); await response.catch(() => {}); throw e; }
+    const message = await response;
+    if (!message || message.protocol !== PROTOCOL || typeof message.ok !== 'boolean') throw serviceError('BAD_FRAME', 'risposta del servizio non valida');
+    if (!message.ok) throw Object.assign(serviceError(message.code ?? 'SERVICE_ERROR', message.error ?? 'errore del servizio locale'), { info: message.info });
+    return message;
+  } finally { socket.destroy(); }
+}
+
+export function disconnected(error) {
+  return ['ECONNREFUSED', 'ECONNRESET', 'EPIPE', 'CONNECT_TIMEOUT', 'SERVICE_DISCONNECTED'].includes(error.code);
+}

package/src/service-worker.js

@@ -0,0 +1,3 @@
+// Worker autonomo: non deve mai importare il client embed.js.
+import { runServiceWorker } from './service.js';
+await runServiceWorker();

package/src/service.js

@@ -0,0 +1,172 @@
+// Un listener esclusivo per directory/utente, un modello, una coda seriale.
+import net from 'node:net';
+import fs from 'node:fs/promises';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { PROTOCOL, HOST, prepareServiceDirectory, readServiceRecord, writeServiceRecord, readFrame, writeFrame, serviceAddress, serviceError } from './service-protocol.js';
+import { validateServiceConfig, assertServiceCompatible, validateTexts } from './service-policy.js';
+
+export async function startEmbeddingService({ directory, port, maxQueue = 16, createRuntime = async (config) => {
+  const { createLocalEmbedder } = await import('./local-embed.js');
+  return createLocalEmbedder(config);
+} }) {
+  const address = serviceAddress({ serviceDir: directory, servicePort: port });
+  await prepareServiceDirectory(address);
+  const token = randomBytes(32).toString('hex');
+  const record = { protocol: PROTOCOL, pid: process.pid, port: address.port, token };
+  const sockets = new Set();
+  const startedAt = Date.now();
+  let lastUsedAt = startedAt;
+  let idleMs = 300_000;
+  let timer, runtime = null, activeConfig = null;
+  let pending = 0, initializing = false, stopping = false, shutdownStarted = false, tail = Promise.resolve();
+  let resolveStopped;
+  const stopped = new Promise((resolve) => { resolveStopped = resolve; });
+
+  function info() {
+    return { running: !stopping, stopping, shared: true, pid: process.pid, protocol: PROTOCOL, port: address.port,
+      pending, initializing, startedAt, lastUsedAt, idleMs, rssBytes: process.memoryUsage().rss,
+      ...(runtime?.info() ?? { profile: null, attempts: [], error: null }) };
+  }
+  function reply(socket, value) {
+    if (socket.destroyed) return;
+    try { writeFrame(socket, { protocol: PROTOCOL, ...value }); socket.end(); }
+    catch { socket.destroy(); }
+  }
+  function armIdle() {
+    clearTimeout(timer);
+    if (!stopping && pending === 0) timer = setTimeout(() => { void stop(); }, Math.max(1, idleMs - (Date.now() - lastUsedAt)));
+  }
+  async function stop() {
+    if (shutdownStarted) return stopped;
+    shutdownStarted = true;
+    stopping = true;
+    clearTimeout(timer);
+    // L'inferenza attiva termina; quelle in coda ricevono un errore esplicito.
+    await tail;
+    for (const socket of sockets) socket.destroy();
+    if (runtime) {
+      let timeout;
+      try { await Promise.race([runtime.dispose(), new Promise((resolve) => { timeout = setTimeout(resolve, 3000); })]); }
+      catch { /* l'uscita del processo libera comunque le risorse native */ }
+      finally { clearTimeout(timeout); }
+    }
+    try {
+      const current = await readServiceRecord(address);
+      if (current?.token === token) await fs.rm(address.file, { force: true });
+    } catch { /* non cancellare record sostituiti/non sicuri */ }
+    // Chiudi anche connessioni arrivate durante dispose, prima di rilasciare
+    // la porta: nessun client incompleto deve trattenere il worker nativo.
+    for (const socket of sockets) socket.destroy();
+    await new Promise((resolve) => server.close(resolve));
+    resolveStopped();
+  }
+  async function modelFor(config, expectedProfile) {
+    if (!runtime) {
+      activeConfig = config;
+      idleMs = config.serviceIdleMs;
+      initializing = true;
+      try {
+        runtime = await createRuntime(config);
+        await runtime.getProfile();
+      } catch (e) {
+        // Dopo un'inizializzazione fallita si esce: nessuna risorsa nativa
+        // residua viene riusata per avviare un altro profilo.
+        e.initializationFailed = true;
+        throw e;
+      } finally { initializing = false; }
+    }
+    const profile = await runtime.getProfile();
+    assertServiceCompatible(config, activeConfig, profile, expectedProfile);
+    return { runtime, profile };
+  }
+
+  const server = net.createServer((socket) => {
+    socket.on('error', () => {});
+    sockets.add(socket);
+    socket.once('close', () => sockets.delete(socket));
+    if (sockets.size > maxQueue + 16) { socket.destroy(); return; }
+    void (async () => {
+      let authenticated = false;
+      try {
+        const request = await readFrame(socket, { timeoutMs: 3000 });
+        if (typeof request?.token !== 'string' || !/^[a-f0-9]{64}$/.test(request.token) ||
+            !timingSafeEqual(Buffer.from(request.token), Buffer.from(token))) throw serviceError('UNAUTHORIZED', 'autenticazione del servizio locale fallita');
+        authenticated = true;
+        if (request.protocol !== PROTOCOL) throw serviceError('PROTOCOL_MISMATCH', 'protocollo del servizio incompatibile; arresta il servizio e riavvia pi');
+        if (request.op === 'status') { reply(socket, { ok: true, result: info() }); return; }
+        if (request.op === 'stop') {
+          if (stopping) { reply(socket, { ok: true, result: { stopping: true, pid: process.pid } }); return; }
+          if (pending) throw serviceError('SERVICE_BUSY', `servizio occupato (${pending} richieste): stop rifiutato per non interrompere altre sessioni`);
+          reply(socket, { ok: true, result: { stopping: true, pid: process.pid } });
+          // Blocca subito nuove operazioni, poi lascia uscire la risposta.
+          stopping = true;
+          setImmediate(() => { void stop(); });
+          return;
+        }
+        if (stopping) throw serviceError('SERVICE_STOPPING', 'servizio locale in arresto; riprova tra poco');
+        if (!['profile', 'embed'].includes(request.op)) throw serviceError('BAD_OPERATION', 'operazione del servizio sconosciuta');
+        const config = validateServiceConfig(request.config);
+        const requestedAddress = serviceAddress(config);
+        if (requestedAddress.directory !== address.directory || requestedAddress.port !== address.port) throw serviceError('BAD_CONFIG', 'endpoint client diverso da quello del servizio');
+        if (request.op === 'embed') validateTexts(request.texts, request.normalize);
+        if (pending >= maxQueue) throw serviceError('QUEUE_FULL', `coda del servizio piena (massimo ${maxQueue}); riprova senza avviare altri modelli`);
+        pending++;
+        clearTimeout(timer);
+        const task = tail.then(async () => {
+          try {
+            if (socket.destroyed) return;
+            if (stopping) throw serviceError('SERVICE_STOPPING', 'servizio locale in arresto');
+            const { runtime: model, profile } = await modelFor(config, request.expectedProfile);
+            const result = request.op === 'embed' ? await model.embed(request.texts, { normalize: request.normalize }) : profile;
+            reply(socket, { ok: true, result, info: info() });
+          } catch (e) {
+            reply(socket, { ok: false, code: e.code ?? 'INFERENCE_FAILED', error: String(e.message ?? e).slice(0, 4000), info: info() });
+            if (e.initializationFailed) {
+              stopping = true;
+              setImmediate(() => { void stop(); });
+            }
+          } finally {
+            pending--;
+            lastUsedAt = Date.now();
+            armIdle();
+          }
+        });
+        // La coda non viene avvelenata da richieste fallite/disconnesse.
+        tail = task.catch(() => {});
+      } catch (e) {
+        reply(socket, { ok: false, code: e.code ?? 'BAD_REQUEST', error: String(e.message ?? e).slice(0, 4000), ...(authenticated ? { info: info() } : {}) });
+      }
+    })();
+  });
+  server.on('error', () => {});
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen({ host: HOST, port: address.port, exclusive: true }, () => { server.off('error', reject); resolve(); });
+  });
+  try { await writeServiceRecord(address, record); }
+  catch (e) { server.close(); throw e; }
+  armIdle();
+  return { info, stop, stopped };
+}
+
+// Entry point condiviso dal worker reale e da fixture senza modello.
+export async function runServiceWorker(options = {}) {
+  let service;
+  try {
+    const directory = process.argv[2];
+    const port = Number(process.argv[3]);
+    if (!directory || !Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('argomenti interni del servizio non validi');
+    service = await startEmbeddingService({ ...options, directory, port });
+    process.once('SIGTERM', () => { void service.stop(); });
+    process.once('SIGINT', () => { void service.stop(); });
+    if (process.connected) process.send({ ready: true, pid: process.pid }, () => { if (process.connected) process.disconnect(); });
+    await service.stopped;
+    // Necessario anche se ORT/Dawn trattiene handle dopo dispose: l'OS libera
+    // l'intero processo. Non si scarica/ricarica un modello nello stesso worker.
+    process.exit(0);
+  } catch (e) {
+    const exit = () => process.exit(e.code === 'EADDRINUSE' ? 0 : 1);
+    if (process.connected) process.send({ ready: false, code: e.code, error: e.message }, exit);
+    else exit();
+  }
+}

package/src/sync.js

@@ -19,8 +19,12 @@ const extOf = (p) => {
   return m ? m[0].toLowerCase() : '';
 };
 
-/** Path relativo al repo -> normalizzato con '/', o null se non è indicizzabile. */
-export function watchablePath(rel, root) {
+/**
+ * Path relativo -> normalizzato con '/', o null se fuori scope.
+ * Su rename, includeDirectories accetta anche directory/nomi senza estensione
+ * supportata: un evento sulla directory può rappresentare molti file rimossi.
+ */
+export function watchablePath(rel, root, { includeDirectories = false } = {}) {
   if (!rel) return null;
   let p = String(rel).replace(/\\/g, '/');
   if (path.isAbsolute(p)) {
@@ -33,15 +37,15 @@ export function watchablePath(rel, root) {
   if (segments.length === 0 || segments[0] === '..') return null;
   p = segments.join('/');
   if (segments.some((s) => IGNORED_DIRS.has(s))) return null;
-  if (!(extOf(p) in LANG_BY_EXT)) return null;
+  if (!includeDirectories && !(extOf(p) in LANG_BY_EXT)) return null;
   return segments.join('/');
 }
 
 /** Filtra e deduplica una lista di path (watcher, hook dei tool, git status). */
-export function filterDirty(paths, root) {
+export function filterDirty(paths, root, options) {
   const out = new Set();
   for (const p of paths ?? []) {
-    const w = watchablePath(p, root);
+    const w = watchablePath(p, root, options);
     if (w) out.add(w);
   }
   return out;

package/src/workspace.js

@@ -0,0 +1,26 @@
+// Radice del progetto: Git quando disponibile, altrimenti la cartella corrente.
+// Nessuna configurazione di progetto viene letta e nessun repository viene creato.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { repoRoot } from './util.js';
+
+function canonicalPath(value) {
+  let result = path.resolve(value);
+  try { result = fs.realpathSync.native(result); } catch { /* directory non accessibile */ }
+  return process.platform === 'win32' ? result.toLowerCase() : result;
+}
+
+export function resolveWorkspace(cwd = process.cwd(), {
+  findRepoRoot = repoRoot,
+  home = os.homedir(),
+} = {}) {
+  const gitRoot = findRepoRoot(cwd);
+  const root = path.resolve(gitRoot ?? cwd);
+  const mode = gitRoot ? 'git' : 'folder';
+  // Un avvio dalla home o dalla radice del disco non deve scandire l'intera
+  // macchina per errore. /codeindex enable resta un consenso esplicito.
+  const canonicalRoot = canonicalPath(root);
+  const broadFolder = canonicalRoot === path.parse(canonicalRoot).root || canonicalRoot === canonicalPath(home);
+  return { root, mode, autoIndex: mode === 'git' || !broadFolder };
+}