vault-go 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Gutierrez Henrique
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,117 @@
+# 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`.
+
+## Instalação
+
+Execução direta:
+
+```sh
+npx -y vault-go@latest
+```
+
+Instalação global:
+
+```sh
+npm install --global vault-go
+vault-go --version
+```
+
+Configuração MCP genérica:
+
+```json
+{
+  "mcpServers": {
+    "vault-go": {
+      "command": "npx",
+      "args": ["-y", "vault-go@latest"]
+    }
+  }
+}
+```
+
+Para usar outro diretório local:
+
+```json
+{
+  "mcpServers": {
+    "vault-go": {
+      "command": "npx",
+      "args": ["-y", "vault-go@latest"],
+      "env": {
+        "VAULT_GO_HOME": "/caminho/privado/.memvault"
+      }
+    }
+  }
+}
+```
+
+## 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
+
+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:
+
+```sh
+memvault start
+```
+
+## 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.
+
+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.
+
+## Desenvolvimento
+
+```sh
+npm install
+npm run typecheck
+npm test
+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:
+
+- `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.
+
+O repositório precisa do segredo `NPM_TOKEN`; ele não deve ser salvo em arquivo,
+commit ou log.

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+export declare const DEFAULT_API_URL = "https://vault.resolveup.com.br/api";
+export interface VaultConfig {
+    apiUrl: string;
+    email?: string;
+    deviceId?: string;
+    intervalSeconds: number;
+    watchPaths: string[];
+}
+export interface VaultStatus {
+    vaultHome: string;
+    apiUrl: string;
+    configured: boolean;
+    authenticated: boolean;
+    watchPaths: string[];
+    notesPath: 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 getStatus(home?: string): VaultStatus;

package/dist/config.js

@@ -0,0 +1,75 @@
+import { chmodSync, existsSync, mkdirSync, 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';
+const DEFAULT_CONFIG = {
+    apiUrl: DEFAULT_API_URL,
+    intervalSeconds: 60,
+    watchPaths: [],
+};
+export function vaultHome(environment = process.env) {
+    const configured = environment['VAULT_GO_HOME'] ?? environment['MEMVAULT_HOME'];
+    return resolve(configured || join(homedir(), '.memvault'));
+}
+export function configPath(home = vaultHome()) {
+    return join(home, 'config.json');
+}
+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: [] };
+    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,
+        };
+    }
+    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 });
+    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,
+        apiUrl: config.apiUrl,
+        configured: existsSync(configPath(home)),
+        authenticated: existsSync(authPath(home)),
+        watchPaths: config.watchPaths.map((entry) => resolve(entry)),
+        notesPath: notesPath(home),
+    };
+}

package/dist/files.d.ts

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,161 @@
+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;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createVaultGoServer, VERSION } from './server.js';
+const argument = process.argv[2];
+if (argument === '--version' || argument === '-v') {
+    process.stdout.write(`${VERSION}\n`);
+    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.exit(0);
+}
+async function main() {
+    const server = createVaultGoServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`vault-go falhou: ${message}\n`);
+    process.exitCode = 1;
+});

package/dist/server.d.ts

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

package/dist/server.js

@@ -0,0 +1,138 @@
+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';
+function jsonResult(value) {
+    const text = JSON.stringify(value, null, 2);
+    return {
+        content: [{ type: 'text', text }],
+        structuredContent: value,
+    };
+}
+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)];
+}
+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;
+}
+export function createVaultGoServer(home = vaultHome()) {
+    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.',
+        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.',
+        inputSchema: {
+            query: z.string().trim().optional().describe('Filtro opcional aplicado ao caminho relativo.'),
+            limit: z.number().int().min(1).max(200).default(50),
+        },
+        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);
+        }
+    });
+    server.registerTool('vault_go_search', {
+        title: 'Pesquisar no Vault',
+        description: 'Pesquisa texto nos arquivos monitorados e retorna trechos com número da linha.',
+        inputSchema: {
+            query: z.string().trim().min(1).max(500),
+            limit: z.number().int().min(1).max(200).default(50),
+        },
+        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.',
+        inputSchema: {
+            path: z.string().trim().min(1).describe('Caminho absoluto ou relativo a um diretório monitorado.'),
+        },
+        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.',
+        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'),
+        },
+        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.',
+        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);
+        }
+    });
+    server.registerResource('vault-go-status', 'vault-go://status', {
+        title: 'Status do Vault Go',
+        description: 'Resumo sanitizado da configuração local.',
+        mimeType: 'application/json',
+    }, async (uri) => {
+        const status = getStatus(home);
+        return {
+            contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify(status, null, 2) }],
+        };
+    });
+    return server;
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "vault-go",
+  "version": "0.1.0",
+  "description": "Servidor MCP local para pesquisar, ler e registrar conhecimento sincronizado pelo MemVault.",
+  "type": "module",
+  "bin": {
+    "vault-go": "dist/index.js",
+    "vault-go-mcp": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/server.js",
+    "dist/server.d.ts",
+    "dist/config.js",
+    "dist/config.d.ts",
+    "dist/files.js",
+    "dist/files.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",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test dist/*.test.js",
+    "pack:check": "npm pack --dry-run",
+    "release": "semantic-release",
+    "prepublishOnly": "npm test && npm run pack:check"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GutierrezHenrique/vault-go.git"
+  },
+  "bugs": {
+    "url": "https://github.com/GutierrezHenrique/vault-go/issues"
+  },
+  "homepage": "https://vault.resolveup.com.br",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "memory",
+    "vault",
+    "memvault",
+    "knowledge"
+  ],
+  "author": "Gutierrez Henrique",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/github": "12.0.9",
+    "@semantic-release/npm": "13.1.5",
+    "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/node": "^22.15.0",
+    "semantic-release": "25.0.8",
+    "typescript": "^5.9.3"
+  },
+  "overrides": {
+    "@hono/node-server": "2.0.11"
+  }
+}