wendkeep 0.70.0 → 0.72.0

package/src/observer.mjs

@@ -2,20 +2,24 @@ 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 } from './observer-memory-publish.mjs';
+import { publishObserverSql } from './observer-sql-publish.mjs';
 import { startObserverServer } from './observer-server.mjs';
+import { ensureObserverDatabase, migrateObserverDatabase, listSqlProjects, OBSERVER_SQL_FILE, OBSERVER_SQL_SCHEMA_VERSION } from './observer-sql-store.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 +45,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 +56,22 @@ function summary(index) {
   };
 }
 
-export async function runObserver(argv = []) {
+function databaseSummary(dir) {
+  const db = ensureObserverDatabase(dir);
+  try {
+    const migrations = migrateObserverDatabase(db);
+    return {
+      engine: 'sqlite',
+      file: OBSERVER_SQL_FILE,
+      schema_version: OBSERVER_SQL_SCHEMA_VERSION,
+      migrations: migrations.applied.length,
+      projects: listSqlProjects(db).length,
+      ready: true,
+    };
+  } finally { db.close(); }
+}
+
+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 +81,67 @@ export async function runObserver(argv = []) {
   const dir = dataDir(argv);
 
   if (sub === 'status') {
-    print(summary(readObserverIndex(dir)), asJson);
+    print({ ...summary(readObserverIndex(dir)), database: databaseSummary(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 sql = await publishObserverSql({
+      vaultBase: vault,
+      projectId: snapshot.project_id,
+      url,
+    });
+    const parity = await compareMemoryParity({
+      vaultBase: vault,
+      projectId: snapshot.project_id,
+      url,
+    });
+    const result = {
+      ok: sql.ok && parity.missing === 0 && parity.mismatched === 0,
+      project_id: snapshot.project_id,
+      sql,
+      memory: { ...sql, authority: 'sqlite' },
+      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 +153,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;
 }