wendkeep 0.70.0 → 0.71.1

package/src/observer-publish.mjs

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { buildProjectSnapshot } from './observer-snapshot.mjs';
+import { publishObserverMemory } from './observer-memory-publish.mjs';
 
 const OUTBOX_REL = join('.brain', 'observer-outbox');
 const REQUEST_TIMEOUT_MS = 500;
@@ -45,14 +46,13 @@ function removeOutbox(vaultBase, eventId) {
   if (existsSync(path)) unlinkSync(path);
 }
 
-async function postSnapshot(url, token, event) {
+async function postSnapshot(url, event) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
   try {
     const response = await fetch(`${String(url).replace(/\/$/, '')}/v1/projects/${encodeURIComponent(event.project_id)}/snapshot`, {
       method: 'POST',
       headers: {
-        authorization: `Bearer ${token}`,
         'content-type': 'application/json',
       },
       body: JSON.stringify(event),
@@ -70,14 +70,14 @@ async function postSnapshot(url, token, event) {
   }
 }
 
-export async function retryObserverOutbox({ vaultBase, url, token } = {}) {
-  if (!url || !token) return { attempted: 0, confirmed: 0, pending: listOutbox(vaultBase).length };
+export async function retryObserverOutbox({ vaultBase, url } = {}) {
+  if (!url) return { attempted: 0, confirmed: 0, pending: listOutbox(vaultBase).length };
   let attempted = 0;
   let confirmed = 0;
   for (const event of listOutbox(vaultBase)) {
     attempted += 1;
     try {
-      await postSnapshot(url, token, event);
+      await postSnapshot(url, event);
       removeOutbox(vaultBase, event.event_id);
       confirmed += 1;
     } catch { /* preserve the event for a later retry */ }
@@ -89,22 +89,33 @@ export async function publishObserverSnapshot({
   vaultBase,
   projectRoot,
   url = process.env.WENDKEEP_OBSERVER_URL || '',
-  token = process.env.WENDKEEP_OBSERVER_TOKEN || '',
   now = new Date(),
 } = {}) {
   try {
     const event = buildProjectSnapshot({ vaultBase, projectRoot, now });
     if (!url) return { ok: true, skipped: true, queued: false, hookExitCode: 0, event_id: event.event_id };
 
-    await retryObserverOutbox({ vaultBase, url, token });
+    await retryObserverOutbox({ vaultBase, url });
+    let memory;
     try {
-      const response = await postSnapshot(url, token, event);
+      memory = await publishObserverMemory({
+        vaultBase,
+        projectId: event.project_id,
+        url,
+        now,
+      });
+    } catch (error) {
+      memory = { ok: false, queued: false, error: error.message };
+    }
+    try {
+      const response = await postSnapshot(url, event);
       return {
         ok: true,
         queued: false,
         hookExitCode: 0,
         event_id: event.event_id,
         duplicate: response.duplicate === true,
+        memory,
       };
     } catch (error) {
       queueOutbox(vaultBase, event);
@@ -114,6 +125,7 @@ export async function publishObserverSnapshot({
         hookExitCode: 0,
         event_id: event.event_id,
         error: error.message,
+        memory,
       };
     }
   } catch (error) {

package/src/observer-server.mjs

@@ -1,9 +1,35 @@
 import { createServer } from 'node:http';
-import { appendObserverEvent, getObserverProject, readObserverIndex, registerObserverProject } from './observer-store.mjs';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import {
+  appendObserverEvent,
+  getObserverProject,
+  listRegisteredObserverProjects,
+  readObserverIndex,
+  registerObserverProject,
+} from './observer-store.mjs';
 import { MAX_SNAPSHOT_BYTES, validateObserverSnapshot } from './observer-snapshot.mjs';
+import {
+  applyMemoryEvent,
+  exportMemoryBundle,
+  readMemoryDocument,
+  readMemorySync,
+  readMemoryTree,
+  setMemoryMode,
+  searchMemory,
+  validateMemoryEvent,
+} from './observer-memory.mjs';
 
 const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
 const MAX_BODY_BYTES = MAX_SNAPSHOT_BYTES + 4096;
+const MAX_MEMORY_BODY_BYTES = 8 * 1024 * 1024;
+const STATIC_ROOT = fileURLToPath(new URL('../web/observer/', import.meta.url));
+const STATIC_ASSETS = new Map([
+  ['/index.html', { file: 'index.html', type: 'text/html; charset=utf-8' }],
+  ['/styles.css', { file: 'styles.css', type: 'text/css; charset=utf-8' }],
+  ['/app.mjs', { file: 'app.mjs', type: 'text/javascript; charset=utf-8' }],
+  ['/favicon.svg', { file: 'favicon.svg', type: 'image/svg+xml' }],
+]);
 
 function loopbackOnly(host) {
   return LOOPBACK_HOSTS.has(String(host || '').toLowerCase());
@@ -23,7 +49,25 @@ function errorResponse(res, status, code, message) {
   json(res, status, { error: { code, message } });
 }
 
-function readBody(req) {
+function serveStatic(res, pathname) {
+  const asset = STATIC_ASSETS.get(pathname === '/' ? '/index.html' : pathname);
+  if (!asset) return false;
+  try {
+    const body = readFileSync(new URL(asset.file, `file://${STATIC_ROOT.replace(/\\/g, '/')}/`));
+    res.writeHead(200, {
+      'content-type': asset.type,
+      'cache-control': 'no-store',
+      'x-content-type-options': 'nosniff',
+      'content-length': body.byteLength,
+    });
+    res.end(body);
+  } catch {
+    errorResponse(res, 500, 'dashboard_asset_error', 'asset do dashboard indisponível.');
+  }
+  return true;
+}
+
+function readBody(req, maxBytes = MAX_BODY_BYTES) {
   return new Promise((resolve, reject) => {
     let size = 0;
     let tooLarge = false;
@@ -31,7 +75,7 @@ function readBody(req) {
     req.on('data', (chunk) => {
       if (tooLarge) return;
       size += chunk.length;
-      if (size > MAX_BODY_BYTES) {
+      if (size > maxBytes) {
         tooLarge = true;
         const error = new Error('corpo acima do limite.');
         error.code = 'payload_too_large';
@@ -56,13 +100,6 @@ function parseJson(text) {
   }
 }
 
-function authorized(req, token) {
-  if (!token) return false;
-  const header = String(req.headers.authorization || '');
-  return header === `Bearer ${token}`
-    || req.headers['x-wendkeep-observer-token'] === token;
-}
-
 function pathParts(url) {
   return new URL(url, 'http://127.0.0.1').pathname.split('/').filter(Boolean).map((part) => decodeURIComponent(part));
 }
@@ -71,11 +108,17 @@ function projectIdFrom(parts) {
   return parts[0] === 'v1' && parts[1] === 'projects' && parts[2] ? parts[2] : '';
 }
 
+function projectKnown(dataDir, projectId) {
+  return Boolean(
+    getObserverProject(dataDir, projectId)
+    || listRegisteredObserverProjects(dataDir).some((item) => item.projectId === projectId),
+  );
+}
+
 export async function startObserverServer({
   host = '127.0.0.1',
   port = 8787,
   dataDir,
-  token = process.env.WENDKEEP_OBSERVER_TOKEN || '',
   allowNonLoopback = false,
 } = {}) {
   if (!loopbackOnly(host) && !allowNonLoopback) {
@@ -84,15 +127,20 @@ export async function startObserverServer({
   if (!dataDir) throw new Error('dataDir é obrigatório.');
   const server = createServer(async (req, res) => {
     try {
-      const parts = pathParts(req.url || '/');
-      if (req.method === 'GET' && parts.length === 1 && parts[0] === 'healthz') {
+      const pathname = new URL(req.url || '/', 'http://127.0.0.1').pathname;
+      if (req.method === 'GET' && pathname === '/healthz') {
         json(res, 200, { ok: true, service: 'wendkeep-observer', schema_version: 1 });
         return;
       }
-      if (!authorized(req, token)) {
-        errorResponse(res, 401, 'unauthorized', 'token local ausente ou inválido.');
+      if (req.method === 'GET' && (pathname === '/' || STATIC_ASSETS.has(pathname))) {
+        serveStatic(res, pathname);
+        return;
+      }
+      if (req.method === 'GET' && !pathname.startsWith('/v1/')) {
+        errorResponse(res, 404, 'not_found', 'rota não encontrada.');
         return;
       }
+      const parts = pathParts(req.url || '/');
       if (parts[0] !== 'v1' || parts[1] !== 'projects') {
         errorResponse(res, 404, 'not_found', 'rota não encontrada.');
         return;
@@ -113,6 +161,88 @@ export async function startObserverServer({
         return;
       }
 
+      if (parts.length === 4 && parts[3] === 'sync' && req.method === 'GET') {
+        if (!projectKnown(dataDir, projectId)) {
+          errorResponse(res, 404, 'project_not_found', 'projeto não encontrado: ' + projectId);
+          return;
+        }
+        json(res, 200, readMemorySync(dataDir, projectId));
+        return;
+      }
+
+      if (parts.length === 4 && parts[3] === 'sync' && req.method === 'PUT') {
+        if (!projectKnown(dataDir, projectId)) {
+          errorResponse(res, 404, 'project_not_found', 'projeto não encontrado: ' + projectId);
+          return;
+        }
+        const body = parseJson(await readBody(req));
+        try {
+          json(res, 200, setMemoryMode(dataDir, projectId, body.mode));
+        } catch (error) {
+          errorResponse(res, 400, error?.code || 'invalid_memory_mode', error?.message || 'modo inválido.');
+        }
+        return;
+      }
+
+      if (parts.length >= 4 && parts[3] === 'memory') {
+        if (!projectKnown(dataDir, projectId)) {
+          errorResponse(res, 404, 'project_not_found', 'projeto não encontrado: ' + projectId);
+          return;
+        }
+        const memoryAction = parts[4] || '';
+        if (memoryAction === 'tree' && req.method === 'GET') {
+          const query = new URL(req.url || '/', 'http://127.0.0.1').searchParams;
+          json(res, 200, readMemoryTree(dataDir, projectId, query.get('prefix') || ''));
+          return;
+        }
+        if (memoryAction === 'document' && req.method === 'GET') {
+          const query = new URL(req.url || '/', 'http://127.0.0.1').searchParams;
+          try {
+            json(res, 200, readMemoryDocument(dataDir, projectId, query.get('path') || ''));
+          } catch (error) {
+            const status = error?.code === 'memory_not_found' ? 404 : 400;
+            errorResponse(res, status, error?.code || 'invalid_memory_path', error?.message || 'documento inválido.');
+          }
+          return;
+        }
+        if (memoryAction === 'search' && req.method === 'GET') {
+          const query = new URL(req.url || '/', 'http://127.0.0.1').searchParams;
+          json(res, 200, { project_id: projectId, query: query.get('q') || '', results: searchMemory(dataDir, projectId, query.get('q') || '') });
+          return;
+        }
+        if (memoryAction === 'export' && req.method === 'GET') {
+          json(res, 200, exportMemoryBundle(dataDir, projectId));
+          return;
+        }
+        if (memoryAction === 'events' && req.method === 'POST') {
+          const body = parseJson(await readBody(req, MAX_MEMORY_BODY_BYTES));
+          const events = Array.isArray(body.events) ? body.events : [];
+          if (events.length === 0) {
+            errorResponse(res, 400, 'invalid_memory_batch', 'events deve conter pelo menos um evento.');
+            return;
+          }
+          const results = [];
+          for (const event of events) {
+            if (event?.project_id !== projectId) {
+              results.push({ accepted: false, errors: ['project_id do evento não corresponde à rota.'] });
+              continue;
+            }
+            const validation = validateMemoryEvent(event);
+            results.push(validation.ok ? applyMemoryEvent(dataDir, event) : { accepted: false, errors: validation.errors });
+          }
+          const accepted = results.filter((item) => item.accepted).length;
+          const duplicates = results.filter((item) => item.duplicate).length;
+          const conflicts = results.filter((item) => item.conflict).length;
+          const rejected = results.length - accepted - duplicates - conflicts;
+          if (conflicts > 0 || rejected > 0) {
+            json(res, conflicts > 0 ? 409 : 400, { accepted, duplicates, conflicts, rejected, results });
+            return;
+          }
+          json(res, accepted > 0 ? 201 : 200, { accepted, duplicates, conflicts, rejected, results });
+          return;
+        }
+      }
+
       if (parts.length === 3 && req.method === 'GET') {
         const project = getObserverProject(dataDir, projectId);
         if (!project) {

package/src/observer.mjs

@@ -2,20 +2,22 @@ import { homedir } from 'node:os';
 import { isAbsolute, resolve } from 'node:path';
 import { appendObserverEvent, readObserverIndex, registerObserverProject } from './observer-store.mjs';
 import { buildProjectSnapshot } from './observer-snapshot.mjs';
+import { compareMemoryParity, publishObserverMemory } from './observer-memory-publish.mjs';
 import { startObserverServer } from './observer-server.mjs';
 import { resolveProjectVault } from '../packages/vault/src/project-vault.mjs';
 
 export const OBSERVER_HELP = `wendkeep observer — Observer local multi-projeto
 
 Uso:
-  wendkeep observer serve [--data-dir P] [--host 127.0.0.1] [--port 8787] [--token T]
+  wendkeep observer serve [--data-dir P] [--host 127.0.0.1] [--port 8787]
                           [--allow-non-loopback]
   wendkeep observer register --project P [--vault V] [--data-dir D] [--json]
   wendkeep observer publish --project P [--vault V] [--data-dir D] [--json]
+  wendkeep observer memory import --project P [--vault V] [--url U] [--json]
   wendkeep observer status [--data-dir D] [--json]
 
-O vault continua local e é a fonte oficial. O Observer armazena apenas snapshots sanitizados
-e um índice reconstruível; o container não monta nem copia vaults de projetos.
+O Observer local pode manter snapshots operacionais e uma cópia completa da memória em volume
+Docker. O comando memory import faz a primeira migração de um vault para o container.
 `;
 
 function optionValue(argv, name) {
@@ -41,8 +43,8 @@ function vaultBase(argv, root) {
   return resolveProjectVault({ startDir: root }).base;
 }
 
-function print(value, asJson) {
-  process.stdout.write(`${asJson ? JSON.stringify(value, null, 2) : String(value)}\n`);
+function print(value, asJson, write = (chunk) => process.stdout.write(chunk)) {
+  write((asJson ? JSON.stringify(value, null, 2) : String(value)) + '\n');
 }
 
 function summary(index) {
@@ -52,7 +54,7 @@ function summary(index) {
   };
 }
 
-export async function runObserver(argv = []) {
+export async function runObserver(argv = [], { write = (chunk) => process.stdout.write(chunk) } = {}) {
   const [sub] = argv;
   const asJson = argv.includes('--json');
   if (!sub || sub === 'help') {
@@ -62,30 +64,66 @@ export async function runObserver(argv = []) {
   const dir = dataDir(argv);
 
   if (sub === 'status') {
-    print(summary(readObserverIndex(dir)), asJson);
+    print(summary(readObserverIndex(dir)), asJson, write);
     return 0;
   }
 
   if (sub === 'serve') {
-    const token = optionValue(argv, '--token') || process.env.WENDKEEP_OBSERVER_TOKEN || '';
     const host = optionValue(argv, '--host') || '127.0.0.1';
     const server = await startObserverServer({
       dataDir: dir,
       host,
       port: Number(optionValue(argv, '--port') || 8787),
-      token,
       allowNonLoopback: argv.includes('--allow-non-loopback'),
     });
-    if (!token) {
-      await server.close();
-      throw new Error('Observer exige --token ou WENDKEEP_OBSERVER_TOKEN.');
-    }
     const address = server.address();
     process.stdout.write(`wendkeep observer listening: http://${address.address}:${address.port}\n`);
     return 0;
   }
 
-  if (!['register', 'publish'].includes(sub)) throw new Error(`observer: subcomando desconhecido: ${sub}`);
+  if (sub === 'memory') {
+    const action = argv[1] || '';
+    if (action !== 'import') throw new Error('observer memory: use memory import.');
+    const root = projectRoot(argv);
+    const vault = vaultBase(argv, root);
+    const snapshot = buildProjectSnapshot({ vaultBase: vault, projectRoot: root });
+    const url = optionValue(argv, '--url') || process.env.WENDKEEP_OBSERVER_URL || '';
+    if (!url) throw new Error('observer memory import: --url ou WENDKEEP_OBSERVER_URL é obrigatório.');
+    const headers = { 'content-type': 'application/json', accept: 'application/json' };
+    const registration = await fetch(
+      String(url).replace(/\/$/, '') + '/v1/projects/' + encodeURIComponent(snapshot.project_id),
+      {
+        method: 'PUT',
+        headers,
+        body: JSON.stringify({
+          project_id: snapshot.project_id,
+          project_name: snapshot.project_name,
+          wendkeep_version: snapshot.wendkeep_version,
+        }),
+      },
+    );
+    if (!registration.ok) throw new Error('Observer não registrou o projeto: HTTP ' + registration.status + '.');
+    const memory = await publishObserverMemory({
+      vaultBase: vault,
+      projectId: snapshot.project_id,
+      url,
+    });
+    const parity = await compareMemoryParity({
+      vaultBase: vault,
+      projectId: snapshot.project_id,
+      url,
+    });
+    const result = {
+      ok: memory.ok && parity.missing === 0 && parity.mismatched === 0,
+      project_id: snapshot.project_id,
+      memory,
+      parity,
+    };
+    print(result, asJson, write);
+    return result.ok ? 0 : 1;
+  }
+
+  if (!['register', 'publish'].includes(sub)) throw new Error('observer: subcomando desconhecido: ' + sub);
   const root = projectRoot(argv);
   const vault = vaultBase(argv, root);
   const snapshot = buildProjectSnapshot({ vaultBase: vault, projectRoot: root });
@@ -97,12 +135,12 @@ export async function runObserver(argv = []) {
       wendkeepVersion: snapshot.wendkeep_version,
     });
     if (!result.registered) throw new Error(result.errors.join(' '));
-    print(result, asJson);
+    print(result, asJson, write);
     return 0;
   }
 
   const result = appendObserverEvent(dir, snapshot);
   if (!result.accepted && !result.duplicate) throw new Error(result.errors.join(' '));
-  print({ ok: true, ...result }, asJson);
+  print({ ok: true, ...result }, asJson, write);
   return 0;
 }