vault-go 0.1.0 → 0.3.0

package/README.md

@@ -1,22 +1,23 @@
 # vault-go
 
-Servidor MCP local para pesquisar, ler e registrar conhecimento sincronizado
-pelo MemVault. Usa transporte `stdio`, roda com Node.js e trabalha somente nos
-caminhos permitidos em `~/.memvault/config.json`.
+Servidor MCP em Bun para pesquisar, contextualizar e registrar memória na
+plataforma Vault. A persistência fica no PostgreSQL do serviço Rust executado
+no EasyPanel; este pacote não cria banco local.
 
-## Instalação
+## Pré-requisito
 
-Execução direta:
+Instale o [Bun](https://bun.sh/) e confirme:
 
 ```sh
-npx -y vault-go@latest
+bun --version
 ```
 
-Instalação global:
+## Instalação MCP
+
+Execução direta:
 
 ```sh
-npm install --global vault-go
-vault-go --version
+bunx --bun vault-go@latest
 ```
 
 Configuração MCP genérica:
@@ -25,21 +26,23 @@ Configuração MCP genérica:
 {
   "mcpServers": {
     "vault-go": {
-      "command": "npx",
-      "args": ["-y", "vault-go@latest"]
+      "command": "bunx",
+      "args": ["--bun", "vault-go@latest"]
     }
   }
 }
 ```
 
-Para usar outro diretório local:
+Por padrão, o MCP reutiliza `~/.memvault/config.json` e
+`~/.memvault/auth.json`, criados pelo comando `memvault login`. Também é
+possível apontar outro diretório:
 
 ```json
 {
   "mcpServers": {
     "vault-go": {
-      "command": "npx",
-      "args": ["-y", "vault-go@latest"],
+      "command": "bunx",
+      "args": ["--bun", "vault-go@latest"],
       "env": {
         "VAULT_GO_HOME": "/caminho/privado/.memvault"
       }
@@ -48,70 +51,69 @@ Para usar outro diretório local:
 }
 ```
 
-## Ferramentas MCP
-
-- `vault_go_status`: configuração sanitizada, autenticação e caminhos.
-- `vault_go_list_files`: lista arquivos textuais monitorados.
-- `vault_go_search`: busca texto e retorna linha/trecho.
-- `vault_go_read_file`: lê até 1 MiB dentro dos caminhos permitidos.
-- `vault_go_write_note`: cria ou acrescenta Markdown em `mcp-notes`.
-- `vault_go_cloud_health`: testa a API pública sem enviar tokens ou conteúdo.
-
-O recurso `vault-go://status` fornece o mesmo resumo sanitizado em formato JSON.
-
-## Integração com a nuvem
+Para ambientes efêmeros, `VAULT_GO_TOKEN` aceita um access token e
+`VAULT_GO_API_URL` troca o endpoint. Prefira o login normal, porque ele permite
+renovação automática da sessão.
 
-O servidor MCP não implementa uma segunda sincronização e não lê chaves do
-cofre. Ao criar a primeira nota, ele adiciona `~/.memvault/mcp-notes` aos
-caminhos monitorados. O agente local existente:
-
-1. detecta a nota;
-2. cifra o conteúdo no dispositivo;
-3. envia somente o blob cifrado para `vault.resolveup.com.br`;
-4. sincroniza o arquivo com os outros dispositivos autorizados.
-
-Mantenha o agente em execução para sincronização contínua:
+## Ferramentas MCP
 
-```sh
-memvault start
+- `vault_go_status`: conexão e autenticação sem expor credenciais.
+- `vault_go_cloud_health`: disponibilidade da plataforma.
+- `vault_go_projects` e `vault_go_project_create`: projetos da conta.
+- `vault_go_session_start` e `vault_go_session_end`: ciclo de sessão.
+- `vault_go_event`: eventos de prompt, ferramenta e resultado.
+- `vault_go_remember`: observações, decisões, descobertas e resumos.
+- `vault_go_search`: busca textual com ranking e trechos.
+- `vault_go_timeline`: contexto anterior e posterior a uma memória.
+- `vault_go_context`: contexto progressivo com limite de caracteres.
+- `vault_go_file_context`: histórico ligado aos arquivos lidos ou modificados.
+- `vault_go_stats`: contagens isoladas da conta.
+- `vault_go_forget`: exclusão explícita de uma memória.
+
+O recurso `vault-go://status` fornece o resumo sanitizado em JSON.
+
+## Fluxo integrado
+
+```text
+Cliente MCP -> vault-go (Bun) -> API autenticada (Bun)
+                              -> engine interno (Rust)
+                              -> PostgreSQL no EasyPanel
 ```
 
+O engine não possui rota pública. A API valida o JWT do usuário, substitui-o
+por uma credencial interna e informa ao engine a conta autenticada. Todas as
+consultas aplicam esse identificador, impedindo leitura entre contas.
+
 ## Segurança
 
-- Nunca retorna access token ou refresh token.
-- Restringe leitura aos caminhos configurados.
-- Resolve caminhos reais e bloqueia travessia/symlinks externos.
-- Ignora diretórios ocultos, `node_modules`, `dist` e `.cache`.
-- Limita leitura e busca por arquivo a 1 MiB.
-- Grava notas somente em `mcp-notes`, com permissões privadas.
-- Usa HTTPS para health remoto; HTTP só é aceito em localhost.
-- Não escreve logs no `stdout`, que é reservado ao protocolo MCP.
+- Não retorna access token nem refresh token em ferramentas ou recursos.
+- Aceita HTTPS; HTTP somente em localhost.
+- Renova o access token usando o refresh token local com permissão privada.
+- Limita tamanhos, listas e janelas nos schemas das ferramentas.
+- Reserva `stdout` exclusivamente para o protocolo MCP.
+- Não persiste memória nem cria banco no dispositivo.
 
-O cliente MCP conectado pode receber o conteúdo dos arquivos que solicitar.
-Instale este servidor apenas em clientes confiáveis e revise as permissões antes
-de autorizar chamadas de leitura ou escrita.
+Instale o MCP apenas em clientes confiáveis: o cliente conectado pode pedir
+busca, gravação e exclusão de memórias dentro da conta autenticada.
 
 ## Desenvolvimento
 
 ```sh
 npm install
-npm run typecheck
-npm test
+bun run typecheck
+bun test src
+bun run build
 npm run pack:check
 ```
 
-Requer Node.js `>= 20`.
-
 ## Publicação automática
 
-O GitHub Actions executa testes em cada pull request e push para `main`. Depois
-da versão inicial, o workflow de release interpreta commits convencionais,
-atualiza a versão, publica no npm e cria a release e a tag no GitHub:
+Pushes em `main` passam por CI. Commits convencionais acionam release
+semântica, publicação no npm, tag e GitHub Release:
 
-- `fix:` publica uma versão patch;
-- `feat:` publica uma versão minor;
-- `feat!:` ou `BREAKING CHANGE:` publica uma versão major;
-- `docs:`, `test:`, `chore:` e `ci:` não publicam uma nova versão.
+- `fix:` gera patch;
+- `feat:` gera minor;
+- `feat!:` ou `BREAKING CHANGE:` gera major.
 
-O repositório precisa do segredo `NPM_TOKEN`; ele não deve ser salvo em arquivo,
-commit ou log.
+O segredo `NPM_TOKEN` existe apenas no GitHub Actions e nunca deve ser salvo no
+repositório ou em logs.

package/dist/cloud.d.ts

@@ -0,0 +1,36 @@
+export interface VaultMemoryApi {
+    health(): Promise<unknown>;
+    projects(): Promise<unknown>;
+    createProject(input: Record<string, unknown>): Promise<unknown>;
+    startSession(input: Record<string, unknown>): Promise<unknown>;
+    endSession(id: string): Promise<unknown>;
+    event(input: Record<string, unknown>): Promise<unknown>;
+    remember(input: Record<string, unknown>): Promise<unknown>;
+    forget(id: string): Promise<unknown>;
+    search(input: Record<string, unknown>): Promise<unknown>;
+    timeline(input: Record<string, unknown>): Promise<unknown>;
+    context(input: Record<string, unknown>): Promise<unknown>;
+    fileContext(input: Record<string, unknown>): Promise<unknown>;
+    stats(): Promise<unknown>;
+}
+export declare class VaultCloudClient implements VaultMemoryApi {
+    private readonly home;
+    private readonly cloudFetch;
+    constructor(home?: string, cloudFetch?: typeof fetch);
+    health(): Promise<unknown>;
+    projects(): Promise<unknown>;
+    createProject(input: Record<string, unknown>): Promise<unknown>;
+    startSession(input: Record<string, unknown>): Promise<unknown>;
+    endSession(id: string): Promise<unknown>;
+    event(input: Record<string, unknown>): Promise<unknown>;
+    remember(input: Record<string, unknown>): Promise<unknown>;
+    forget(id: string): Promise<unknown>;
+    search(input: Record<string, unknown>): Promise<unknown>;
+    timeline(input: Record<string, unknown>): Promise<unknown>;
+    context(input: Record<string, unknown>): Promise<unknown>;
+    fileContext(input: Record<string, unknown>): Promise<unknown>;
+    stats(): Promise<unknown>;
+    private endpoint;
+    private accessToken;
+    private request;
+}

package/dist/cloud.js

@@ -0,0 +1,121 @@
+import { loadConfig, loadTokens, saveTokens, validateApiUrl, vaultHome, } from './config.js';
+export class VaultCloudClient {
+    home;
+    cloudFetch;
+    constructor(home = vaultHome(), cloudFetch = globalThis.fetch) {
+        this.home = home;
+        this.cloudFetch = cloudFetch;
+    }
+    async health() {
+        return this.request('/health', { authenticated: false });
+    }
+    async projects() {
+        return this.request('/memory/projects');
+    }
+    async createProject(input) {
+        return this.request('/memory/projects', { method: 'POST', body: input });
+    }
+    async startSession(input) {
+        return this.request('/memory/sessions/start', { method: 'POST', body: input });
+    }
+    async endSession(id) {
+        return this.request(`/memory/sessions/${encodeURIComponent(id)}/end`, { method: 'POST' });
+    }
+    async event(input) {
+        return this.request('/memory/events', { method: 'POST', body: input });
+    }
+    async remember(input) {
+        return this.request('/memory/memories', { method: 'POST', body: input });
+    }
+    async forget(id) {
+        await this.request(`/memory/memories/${encodeURIComponent(id)}`, { method: 'DELETE' });
+        return { deleted: true, id };
+    }
+    async search(input) {
+        return this.request('/memory/search', { method: 'POST', body: input });
+    }
+    async timeline(input) {
+        return this.request('/memory/timeline', { method: 'POST', body: input });
+    }
+    async context(input) {
+        return this.request('/memory/context', { method: 'POST', body: input });
+    }
+    async fileContext(input) {
+        return this.request('/memory/files/context', { method: 'POST', body: input });
+    }
+    async stats() {
+        return this.request('/memory/stats');
+    }
+    endpoint(path) {
+        const base = validateApiUrl(loadConfig(this.home).apiUrl);
+        const prefix = base.pathname.replace(/\/$/u, '');
+        return new URL(`${prefix}${path}`, base.origin);
+    }
+    async accessToken(forceRefresh = false) {
+        const environmentToken = process.env['VAULT_GO_TOKEN'];
+        if (environmentToken)
+            return environmentToken;
+        const tokens = loadTokens(this.home);
+        if (!tokens) {
+            throw new Error('Vault não autenticado. Execute `memvault login` antes de iniciar o MCP.');
+        }
+        const valid = !forceRefresh &&
+            (!tokens.expiresAt || Date.now() < tokens.expiresAt - 60_000);
+        if (valid)
+            return tokens.accessToken;
+        if (!tokens.refreshToken)
+            throw new Error('Sessão expirada. Execute `memvault login` novamente.');
+        const response = await this.cloudFetch(this.endpoint('/auth/refresh'), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ refreshToken: tokens.refreshToken }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) {
+            throw new Error('Sessão expirada. Execute `memvault login` novamente.');
+        }
+        const refreshed = (await response.json());
+        const stored = {
+            ...refreshed,
+            expiresAt: Date.now() + (refreshed.expiresIn ?? 900) * 1000,
+        };
+        saveTokens(stored, this.home);
+        return stored.accessToken;
+    }
+    async request(path, options = {}) {
+        const headers = new Headers({ accept: 'application/json' });
+        if (options.body)
+            headers.set('content-type', 'application/json');
+        if (options.authenticated !== false) {
+            headers.set('authorization', `Bearer ${await this.accessToken(options.retried)}`);
+        }
+        const request = {
+            method: options.method ?? 'GET',
+            headers,
+            signal: AbortSignal.timeout(15_000),
+        };
+        if (options.body)
+            request.body = JSON.stringify(options.body);
+        const response = await this.cloudFetch(this.endpoint(path), request);
+        if (response.status === 401 && options.authenticated !== false && !options.retried) {
+            return this.request(path, { ...options, retried: true });
+        }
+        const text = await response.text();
+        const payload = text ? safeJson(text) : null;
+        if (!response.ok) {
+            const message = payload && typeof payload === 'object' && 'error' in payload
+                ? String(payload.error)
+                : `Vault respondeu HTTP ${response.status}`;
+            throw new Error(message);
+        }
+        return payload;
+    }
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/dist/config.d.ts

@@ -6,20 +6,23 @@ export interface VaultConfig {
     intervalSeconds: number;
     watchPaths: string[];
 }
+export interface StoredTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn?: number;
+    expiresAt?: number;
+}
 export interface VaultStatus {
-    vaultHome: string;
     apiUrl: string;
     configured: boolean;
     authenticated: boolean;
-    watchPaths: string[];
-    notesPath: string;
+    account?: string;
 }
 export declare function vaultHome(environment?: NodeJS.ProcessEnv): string;
 export declare function configPath(home?: string): string;
 export declare function authPath(home?: string): string;
-export declare function notesPath(home?: string): string;
-export declare function ensurePrivateDirectory(directory: string): void;
 export declare function loadConfig(home?: string): VaultConfig;
-export declare function saveConfig(config: VaultConfig, home?: string): void;
-export declare function ensureNotesPath(home?: string): string;
+export declare function loadTokens(home?: string): StoredTokens | null;
+export declare function saveTokens(tokens: StoredTokens, home?: string): void;
 export declare function getStatus(home?: string): VaultStatus;
+export declare function validateApiUrl(value: string): URL;

package/dist/config.js

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 export const DEFAULT_API_URL = 'https://vault.resolveup.com.br/api';
@@ -8,7 +8,9 @@ const DEFAULT_CONFIG = {
     watchPaths: [],
 };
 export function vaultHome(environment = process.env) {
-    const configured = environment['VAULT_GO_HOME'] ?? environment['MEMVAULT_HOME'];
+    const configured = environment['VAULT_GO_HOME'] ??
+        environment['MEMVAULT_CONFIG_DIR'] ??
+        environment['MEMVAULT_HOME'];
     return resolve(configured || join(homedir(), '.memvault'));
 }
 export function configPath(home = vaultHome()) {
@@ -17,59 +19,61 @@ export function configPath(home = vaultHome()) {
 export function authPath(home = vaultHome()) {
     return join(home, 'auth.json');
 }
-export function notesPath(home = vaultHome()) {
-    return join(home, 'mcp-notes');
-}
-export function ensurePrivateDirectory(directory) {
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    chmodSync(directory, 0o700);
-}
 export function loadConfig(home = vaultHome()) {
     const file = configPath(home);
-    if (!existsSync(file))
-        return { ...DEFAULT_CONFIG, watchPaths: [] };
+    const environmentApiUrl = process.env['VAULT_GO_API_URL'];
+    if (!existsSync(file)) {
+        return {
+            ...DEFAULT_CONFIG,
+            apiUrl: environmentApiUrl || DEFAULT_API_URL,
+            watchPaths: [],
+        };
+    }
     try {
         const parsed = JSON.parse(readFileSync(file, 'utf8'));
-        const watchPaths = Array.isArray(parsed.watchPaths)
-            ? parsed.watchPaths.filter((entry) => typeof entry === 'string')
-            : [];
         return {
             ...DEFAULT_CONFIG,
             ...parsed,
-            apiUrl: parsed.apiUrl || DEFAULT_API_URL,
-            watchPaths,
+            apiUrl: environmentApiUrl || parsed.apiUrl || DEFAULT_API_URL,
+            watchPaths: Array.isArray(parsed.watchPaths) ? parsed.watchPaths : [],
         };
     }
     catch {
         return { ...DEFAULT_CONFIG, watchPaths: [] };
     }
 }
-export function saveConfig(config, home = vaultHome()) {
-    ensurePrivateDirectory(home);
-    const destination = configPath(home);
-    const temporary = join(dirname(destination), `.config.${process.pid}.tmp`);
-    writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+export function loadTokens(home = vaultHome()) {
+    try {
+        const parsed = JSON.parse(readFileSync(authPath(home), 'utf8'));
+        return typeof parsed.accessToken === 'string' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveTokens(tokens, home = vaultHome()) {
+    const destination = authPath(home);
+    const temporary = join(dirname(destination), `.auth.${process.pid}.tmp`);
+    writeFileSync(temporary, `${JSON.stringify(tokens, null, 2)}\n`, { mode: 0o600 });
     renameSync(temporary, destination);
     chmodSync(destination, 0o600);
 }
-export function ensureNotesPath(home = vaultHome()) {
-    const directory = notesPath(home);
-    ensurePrivateDirectory(directory);
-    const config = loadConfig(home);
-    const normalized = new Set(config.watchPaths.map((entry) => resolve(entry)));
-    if (!normalized.has(resolve(directory))) {
-        saveConfig({ ...config, watchPaths: [...config.watchPaths, directory] }, home);
-    }
-    return directory;
-}
 export function getStatus(home = vaultHome()) {
     const config = loadConfig(home);
-    return {
-        vaultHome: home,
+    const status = {
         apiUrl: config.apiUrl,
         configured: existsSync(configPath(home)),
-        authenticated: existsSync(authPath(home)),
-        watchPaths: config.watchPaths.map((entry) => resolve(entry)),
-        notesPath: notesPath(home),
+        authenticated: Boolean(process.env['VAULT_GO_TOKEN']) || loadTokens(home) !== null,
     };
+    if (config.email)
+        status.account = config.email;
+    return status;
+}
+export function validateApiUrl(value) {
+    const url = new URL(value);
+    const local = url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+    if (url.protocol !== 'https:' && !(local && url.protocol === 'http:')) {
+        throw new Error('A API deve usar HTTPS, exceto em localhost.');
+    }
+    return url;
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 export {};

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { createVaultGoServer, VERSION } from './server.js';
 const argument = process.argv[2];
@@ -7,7 +7,7 @@ if (argument === '--version' || argument === '-v') {
     process.exit(0);
 }
 if (argument === '--help' || argument === '-h') {
-    process.stdout.write(`vault-go ${VERSION}\n\nServidor MCP local por stdio.\n\nVariáveis:\n  VAULT_GO_HOME   Diretório local do vault (padrão: ~/.memvault)\n  MEMVAULT_HOME   Alias compatível com o agente local\n`);
+    process.stdout.write(`vault-go ${VERSION}\n\nServidor MCP cloud por stdio, executado com Bun.\n\nVariáveis:\n  VAULT_GO_HOME         Diretório de configuração (padrão: ~/.memvault)\n  MEMVAULT_CONFIG_DIR   Mesmo diretório usado pelo agente\n`);
     process.exit(0);
 }
 async function main() {

package/dist/server.d.ts

@@ -1,3 +1,4 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const VERSION = "0.1.0";
-export declare function createVaultGoServer(home?: string): McpServer;
+import { type VaultMemoryApi } from './cloud.js';
+export declare const VERSION: string;
+export declare function createVaultGoServer(home?: string, cloud?: VaultMemoryApi): McpServer;

package/dist/server.js

@@ -1,137 +1,177 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
-import { ensureNotesPath, getStatus, loadConfig, notesPath, vaultHome, } from './config.js';
-import { listVaultFiles, readVaultFile, searchVaultFiles, writeVaultNote, } from './files.js';
-export const VERSION = '0.1.0';
+import { VaultCloudClient } from './cloud.js';
+import { getStatus, vaultHome } from './config.js';
+import packageJson from '../package.json' with { type: 'json' };
+export const VERSION = packageJson.version;
 function jsonResult(value) {
-    const text = JSON.stringify(value, null, 2);
+    const structuredContent = value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : { value };
     return {
-        content: [{ type: 'text', text }],
-        structuredContent: value,
+        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+        structuredContent,
     };
 }
 function errorResult(error) {
     const message = error instanceof Error ? error.message : 'Erro inesperado.';
-    return {
-        content: [{ type: 'text', text: message }],
-        isError: true,
-    };
-}
-function rootsFor(home) {
-    const config = loadConfig(home);
-    return [...config.watchPaths, notesPath(home)];
+    return { content: [{ type: 'text', text: message }], isError: true };
 }
-function validateApiUrl(value) {
-    const url = new URL(value);
-    const local = url.hostname === 'localhost' || url.hostname === '127.0.0.1';
-    if (url.protocol !== 'https:' && !(local && url.protocol === 'http:')) {
-        throw new Error('A API deve usar HTTPS, exceto em localhost.');
+async function run(operation) {
+    try {
+        return jsonResult(await operation());
+    }
+    catch (error) {
+        return errorResult(error);
     }
-    return url;
 }
-export function createVaultGoServer(home = vaultHome()) {
+const uuid = z.string().uuid();
+export function createVaultGoServer(home = vaultHome(), cloud = new VaultCloudClient(home)) {
     const server = new McpServer({ name: 'vault-go', version: VERSION });
     server.registerTool('vault_go_status', {
         title: 'Status do Vault',
-        description: 'Mostra configuração local, autenticação e caminhos monitorados sem revelar tokens.',
+        description: 'Mostra conexão e autenticação sem revelar credenciais.',
         inputSchema: {},
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
     }, async () => jsonResult(getStatus(home)));
-    server.registerTool('vault_go_list_files', {
-        title: 'Listar arquivos do Vault',
-        description: 'Lista arquivos textuais dentro dos caminhos monitorados.',
+    server.registerTool('vault_go_cloud_health', {
+        title: 'Verificar nuvem do Vault',
+        description: 'Verifica a disponibilidade da plataforma Vault.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async () => run(() => cloud.health()));
+    server.registerTool('vault_go_projects', {
+        title: 'Listar projetos',
+        description: 'Lista os projetos de memória da conta autenticada.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async () => run(() => cloud.projects()));
+    server.registerTool('vault_go_project_create', {
+        title: 'Criar projeto',
+        description: 'Cria um projeto de memória no Vault.',
         inputSchema: {
-            query: z.string().trim().optional().describe('Filtro opcional aplicado ao caminho relativo.'),
-            limit: z.number().int().min(1).max(200).default(50),
+            name: z.string().trim().min(1).max(200),
+            rootPath: z.string().trim().max(2_000).optional(),
         },
-        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-    }, async ({ query, limit }) => {
-        try {
-            const options = query === undefined ? { limit } : { query, limit };
-            return jsonResult({ files: listVaultFiles(rootsFor(home), options) });
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
+        annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (input) => run(() => cloud.createProject(input)));
+    server.registerTool('vault_go_session_start', {
+        title: 'Iniciar sessão',
+        description: 'Inicia ou recupera uma sessão de trabalho no Vault.',
+        inputSchema: {
+            projectId: uuid,
+            externalSessionId: z.string().trim().max(500).optional(),
+            platformSource: z.string().trim().min(1).max(100).default('mcp'),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.startSession(input)));
+    server.registerTool('vault_go_session_end', {
+        title: 'Encerrar sessão',
+        description: 'Marca uma sessão como concluída.',
+        inputSchema: { id: uuid },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async ({ id }) => run(() => cloud.endSession(id)));
+    server.registerTool('vault_go_event', {
+        title: 'Registrar evento',
+        description: 'Registra um evento de prompt, ferramenta ou resultado na sessão.',
+        inputSchema: {
+            projectId: uuid,
+            sessionId: uuid.optional(),
+            sourceAdapter: z.string().trim().min(1).max(100).default('mcp'),
+            sourceEventId: z.string().trim().max(500).optional(),
+            eventType: z.string().trim().min(1).max(100),
+            payload: z.record(z.unknown()).default({}),
+            occurredAtEpoch: z.number().int().positive().optional(),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.event(input)));
+    server.registerTool('vault_go_remember', {
+        title: 'Registrar memória',
+        description: 'Persiste uma observação, decisão, descoberta ou resumo no Vault.',
+        inputSchema: {
+            projectId: uuid,
+            sessionId: uuid.optional(),
+            kind: z.string().trim().min(1).max(100).default('observation'),
+            memoryType: z.string().trim().min(1).max(100).default('discovery'),
+            title: z.string().trim().max(500).optional(),
+            content: z.string().trim().min(1).max(200_000),
+            facts: z.array(z.string().trim().min(1).max(2_000)).max(200).default([]),
+            concepts: z.array(z.string().trim().min(1).max(500)).max(200).default([]),
+            filesRead: z.array(z.string().trim().min(1).max(2_000)).max(500).default([]),
+            filesModified: z.array(z.string().trim().min(1).max(2_000)).max(500).default([]),
+        },
+        annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (input) => run(() => cloud.remember(input)));
+    server.registerTool('vault_go_forget', {
+        title: 'Excluir memória',
+        description: 'Exclui uma memória da conta autenticada.',
+        inputSchema: { id: uuid },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ id }) => run(() => cloud.forget(id)));
     server.registerTool('vault_go_search', {
         title: 'Pesquisar no Vault',
-        description: 'Pesquisa texto nos arquivos monitorados e retorna trechos com número da linha.',
+        description: 'Pesquisa memórias persistidas na plataforma Vault.',
         inputSchema: {
-            query: z.string().trim().min(1).max(500),
-            limit: z.number().int().min(1).max(200).default(50),
+            query: z.string().trim().min(1).max(1_000),
+            projectId: uuid.optional(),
+            kind: z.string().trim().max(100).optional(),
+            memoryType: z.string().trim().max(100).optional(),
+            limit: z.number().int().min(1).max(200).default(20),
         },
-        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-    }, async ({ query, limit }) => {
-        try {
-            return jsonResult({ matches: searchVaultFiles(rootsFor(home), query, limit) });
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
-    server.registerTool('vault_go_read_file', {
-        title: 'Ler arquivo do Vault',
-        description: 'Lê um arquivo textual permitido, limitado a 1 MiB e sem atravessar os caminhos monitorados.',
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.search(input)));
+    server.registerTool('vault_go_timeline', {
+        title: 'Abrir linha do tempo',
+        description: 'Retorna memórias anteriores e posteriores a uma memória âncora.',
         inputSchema: {
-            path: z.string().trim().min(1).describe('Caminho absoluto ou relativo a um diretório monitorado.'),
+            anchorId: uuid,
+            before: z.number().int().min(1).max(100).default(5),
+            after: z.number().int().min(1).max(100).default(5),
         },
-        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-    }, async ({ path }) => {
-        try {
-            return jsonResult(readVaultFile(path, rootsFor(home)));
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
-    server.registerTool('vault_go_write_note', {
-        title: 'Registrar nota no Vault',
-        description: 'Cria ou acrescenta uma nota Markdown em mcp-notes, monitorada pelo agente de sincronização.',
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.timeline(input)));
+    server.registerTool('vault_go_context', {
+        title: 'Montar contexto',
+        description: 'Monta contexto progressivo, limitado e pronto para injeção no cliente.',
         inputSchema: {
-            title: z.string().trim().min(1).max(200),
-            content: z.string().trim().min(1).max(200_000),
-            mode: z.enum(['create', 'append']).default('create'),
+            projectId: uuid,
+            query: z.string().trim().max(1_000).optional(),
+            limit: z.number().int().min(1).max(100).default(20),
+            maxChars: z.number().int().min(1_000).max(100_000).default(24_000),
         },
-        annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: false },
-    }, async ({ title, content, mode }) => {
-        try {
-            const directory = ensureNotesPath(home);
-            return jsonResult({ path: writeVaultNote(directory, title, content, mode), mode });
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
-    server.registerTool('vault_go_cloud_health', {
-        title: 'Verificar nuvem do Vault',
-        description: 'Verifica o health público da API configurada sem enviar arquivos, notas ou tokens.',
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.context(input)));
+    server.registerTool('vault_go_file_context', {
+        title: 'Contexto de arquivos',
+        description: 'Recupera memórias anteriores associadas a um ou mais arquivos do projeto.',
+        inputSchema: {
+            projectId: uuid,
+            paths: z.array(z.string().trim().min(1).max(2_000)).min(1).max(20),
+            limit: z.number().int().min(1).max(100).default(20),
+            maxChars: z.number().int().min(1_000).max(100_000).default(16_000),
+        },
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+    }, async (input) => run(() => cloud.fileContext(input)));
+    server.registerTool('vault_go_stats', {
+        title: 'Estatísticas do Vault',
+        description: 'Mostra contagens da conta autenticada.',
         inputSchema: {},
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
-    }, async () => {
-        try {
-            const status = getStatus(home);
-            const base = validateApiUrl(status.apiUrl);
-            const healthUrl = new URL(`${base.pathname.replace(/\/$/u, '')}/health`, base.origin);
-            const response = await fetch(healthUrl, {
-                headers: { Accept: 'application/json' },
-                signal: AbortSignal.timeout(10_000),
-            });
-            const body = await response.text();
-            return jsonResult({ ok: response.ok, status: response.status, url: healthUrl.href, body });
-        }
-        catch (error) {
-            return errorResult(error);
-        }
-    });
+    }, async () => run(() => cloud.stats()));
     server.registerResource('vault-go-status', 'vault-go://status', {
         title: 'Status do Vault Go',
-        description: 'Resumo sanitizado da configuração local.',
+        description: 'Resumo sanitizado da conexão cloud.',
         mimeType: 'application/json',
     }, async (uri) => {
         const status = getStatus(home);
         return {
-            contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(status, null, 2) }],
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(status, null, 2),
+                },
+            ],
         };
     });
     return server;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vault-go",
-  "version": "0.1.0",
-  "description": "Servidor MCP local para pesquisar, ler e registrar conhecimento sincronizado pelo MemVault.",
+  "version": "0.3.0",
+  "description": "Servidor MCP Bun para pesquisar e registrar memória na plataforma Vault.",
   "type": "module",
   "bin": {
     "vault-go": "dist/index.js",
@@ -26,21 +26,22 @@
     "dist/server.d.ts",
     "dist/config.js",
     "dist/config.d.ts",
-    "dist/files.js",
-    "dist/files.d.ts",
+    "dist/cloud.js",
+    "dist/cloud.d.ts",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
-    "build": "npm run clean && tsc -p tsconfig.json",
+    "clean": "bun -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "bun run clean && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "npm run build && node --test dist/*.test.js",
+    "test": "bun run build && bun test src",
     "pack:check": "npm pack --dry-run",
     "release": "semantic-release",
-    "prepublishOnly": "npm test && npm run pack:check"
+    "prepublishOnly": "bun test src && npm run pack:check"
   },
   "engines": {
+    "bun": ">=1.3.0",
     "node": ">=20"
   },
   "publishConfig": {
@@ -74,6 +75,7 @@
     "@semantic-release/github": "12.0.9",
     "@semantic-release/npm": "13.1.5",
     "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/bun": "^1.3.0",
     "@types/node": "^22.15.0",
     "semantic-release": "25.0.8",
     "typescript": "^5.9.3"

package/dist/files.d.ts

@@ -1,25 +0,0 @@
-export declare const MAX_READ_BYTES = 1048576;
-export interface VaultFile {
-    path: string;
-    root: string;
-    relativePath: string;
-    size: number;
-    modifiedAt: string;
-}
-export interface SearchMatch {
-    path: string;
-    relativePath: string;
-    line: number;
-    snippet: string;
-}
-export declare function resolveAllowedFile(input: string, roots: string[]): string;
-export declare function listVaultFiles(roots: string[], options?: {
-    query?: string;
-    limit?: number;
-}): VaultFile[];
-export declare function readVaultFile(input: string, roots: string[]): {
-    path: string;
-    text: string;
-};
-export declare function searchVaultFiles(roots: string[], query: string, limit?: number): SearchMatch[];
-export declare function writeVaultNote(notesRoot: string, title: string, content: string, mode?: 'create' | 'append'): string;

package/dist/files.js

@@ -1,161 +0,0 @@
-import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync, } from 'node:fs';
-import { basename, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-export const MAX_READ_BYTES = 1_048_576;
-const DEFAULT_LIMIT = 50;
-const MAX_LIMIT = 200;
-const TEXT_EXTENSIONS = new Set([
-    '.md',
-    '.mdx',
-    '.txt',
-    '.json',
-    '.jsonl',
-    '.yaml',
-    '.yml',
-    '.toml',
-    '.csv',
-    '.log',
-]);
-const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', '.cache']);
-function boundedLimit(limit) {
-    if (!limit || !Number.isFinite(limit))
-        return DEFAULT_LIMIT;
-    return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
-}
-function isTextFile(file) {
-    return TEXT_EXTENSIONS.has(extname(file).toLowerCase());
-}
-function normalizedRoots(roots) {
-    return [...new Set(roots.map((root) => resolve(root)))].filter((root) => {
-        try {
-            return statSync(root).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    });
-}
-function isInside(candidate, root) {
-    return candidate === root || candidate.startsWith(`${root}${sep}`);
-}
-export function resolveAllowedFile(input, roots) {
-    const availableRoots = normalizedRoots(roots);
-    const candidates = isAbsolute(input)
-        ? [resolve(input)]
-        : availableRoots.map((root) => resolve(root, input));
-    for (const candidate of candidates) {
-        if (!existsSync(candidate))
-            continue;
-        const actual = realpathSync(candidate);
-        if (!lstatSync(actual).isFile())
-            continue;
-        if (availableRoots.some((root) => isInside(actual, realpathSync(root))))
-            return actual;
-    }
-    throw new Error('Arquivo inexistente ou fora dos caminhos monitorados.');
-}
-export function listVaultFiles(roots, options = {}) {
-    const limit = boundedLimit(options.limit);
-    const query = options.query?.trim().toLocaleLowerCase();
-    const results = [];
-    for (const root of normalizedRoots(roots)) {
-        const stack = [root];
-        while (stack.length > 0 && results.length < limit) {
-            const current = stack.pop();
-            if (!current)
-                break;
-            const entries = readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-            for (const entry of entries) {
-                if (entry.name.startsWith('.'))
-                    continue;
-                const absolute = join(current, entry.name);
-                if (entry.isSymbolicLink())
-                    continue;
-                if (entry.isDirectory()) {
-                    if (!IGNORED_DIRECTORIES.has(entry.name))
-                        stack.push(absolute);
-                    continue;
-                }
-                if (!entry.isFile() || !isTextFile(entry.name))
-                    continue;
-                const relativePath = relative(root, absolute);
-                if (query && !relativePath.toLocaleLowerCase().includes(query))
-                    continue;
-                const stats = statSync(absolute);
-                results.push({
-                    path: absolute,
-                    root,
-                    relativePath,
-                    size: stats.size,
-                    modifiedAt: stats.mtime.toISOString(),
-                });
-                if (results.length >= limit)
-                    break;
-            }
-        }
-        if (results.length >= limit)
-            break;
-    }
-    return results;
-}
-export function readVaultFile(input, roots) {
-    const file = resolveAllowedFile(input, roots);
-    const size = statSync(file).size;
-    if (size > MAX_READ_BYTES) {
-        throw new Error(`Arquivo excede o limite de ${MAX_READ_BYTES} bytes.`);
-    }
-    if (!isTextFile(file))
-        throw new Error('Tipo de arquivo não permitido para leitura textual.');
-    return { path: file, text: readFileSync(file, 'utf8') };
-}
-export function searchVaultFiles(roots, query, limit) {
-    const normalizedQuery = query.trim().toLocaleLowerCase();
-    if (!normalizedQuery)
-        throw new Error('A consulta não pode ser vazia.');
-    const maxResults = boundedLimit(limit);
-    const files = listVaultFiles(roots, { limit: MAX_LIMIT });
-    const matches = [];
-    for (const file of files) {
-        if (file.size > MAX_READ_BYTES)
-            continue;
-        const lines = readFileSync(file.path, 'utf8').split(/\r?\n/u);
-        for (let index = 0; index < lines.length; index += 1) {
-            const line = lines[index] ?? '';
-            if (!line.toLocaleLowerCase().includes(normalizedQuery))
-                continue;
-            matches.push({
-                path: file.path,
-                relativePath: file.relativePath,
-                line: index + 1,
-                snippet: line.trim().slice(0, 500),
-            });
-            if (matches.length >= maxResults)
-                return matches;
-        }
-    }
-    return matches;
-}
-function safeSlug(title) {
-    const slug = title
-        .normalize('NFKD')
-        .replace(/[\u0300-\u036f]/gu, '')
-        .toLocaleLowerCase()
-        .replace(/[^a-z0-9]+/gu, '-')
-        .replace(/^-+|-+$/gu, '')
-        .slice(0, 80);
-    return slug || `note-${Date.now()}`;
-}
-export function writeVaultNote(notesRoot, title, content, mode = 'create') {
-    mkdirSync(notesRoot, { recursive: true, mode: 0o700 });
-    const file = join(notesRoot, `${safeSlug(title)}.md`);
-    const body = `# ${title.trim()}\n\n${content.trim()}\n`;
-    if (mode === 'create' && existsSync(file)) {
-        throw new Error(`A nota ${basename(file)} já existe; use mode=append.`);
-    }
-    if (mode === 'append' && existsSync(file)) {
-        appendFileSync(file, `\n${content.trim()}\n`, { encoding: 'utf8', mode: 0o600 });
-    }
-    else {
-        writeFileSync(file, body, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
-    }
-    return file;
-}