feat: replace proxy with local form server + vault MCP tools

- kern serve: local HTTP server with credential capture form
- kern mcp: MCP server with kern_add (URL-mode elicitation),
  kern_list, kern_status, kern_rotate, kern_remove, kern_recipients
- Credential values flow: browser form → kern → vault. Never through LLM.
- Removed proxy (kern_fetch URL-matching approach)
- 16 tests passing

Author: mirkokiefer

bin/kern.ts

@@ -34,8 +34,8 @@ async function main() {
         case "secret":
         case "secrets":  return cmdSecret(sub, args.slice(2));
         case "recipients": return cmdRecipients();
-        case "proxy":
-        case "mcp":      return cmdProxy(sub);
+        case "mcp":      return cmdMcp();
+        case "serve":    return cmdServe();
         default:
             console.error(`unknown command: ${cmd}`);
             help();
@@ -45,7 +45,8 @@ async function main() {
 
 function help() {
     process.stdout.write(`kern v0.2 — the agent credential manager\n\n` +
-`  kern proxy                      start MCP proxy (agents connect via MCP)\n` +
+`  kern mcp                        start MCP server (for Claude Code, Cursor, etc.)\n` +
+`  kern serve                      start local form server only\n\n` +
 `  kern identity init [--save PATH]\n` +
 `  kern identity pubkey\n\n` +
 `  kern secret add NAME\n` +
@@ -58,11 +59,24 @@ function help() {
 `env: KERN_AGE_KEY (private key)  KERN_VAULT_DIR (default ./secrets)\n`);
 }
 
-async function cmdProxy(configPath?: string) {
+async function cmdMcp() {
     const { startMcpServer } = await import("../src/mcp.js");
-    const { loadConfig } = await import("../src/proxy.js");
-    const config = loadConfig(configPath);
-    await startMcpServer(config);
+    await startMcpServer();
+}
+
+async function cmdServe() {
+    const { loadFromHost } = await import("../src/identity.js");
+    const { Vault } = await import("../src/vault.js");
+    const { startLocalServer } = await import("../src/serve.js");
+    const identity = await loadFromHost();
+    const dir = process.env.KERN_VAULT_DIR ?? process.env.KORN_VAULT_DIR;
+    const vault = new Vault({ identity, ...(dir ? { dir } : {}) });
+    const srv = startLocalServer({
+        vault,
+        onAdd: (name) => console.log(`✓ encrypted: ${name}`),
+    });
+    console.log(`kern form server at ${srv.url}`);
+    console.log(`Open ${srv.url}/add?name=YOUR_SECRET to add a credential`);
 }
 
 async function cmdIdentity(sub: string | undefined, rest: string[]) {

package.json

@@ -10,7 +10,7 @@
     ".":          "./src/index.ts",
     "./vault":    "./src/vault.ts",
     "./identity": "./src/identity.ts",
-    "./proxy":    "./src/proxy.ts",
+    "./serve":    "./src/serve.ts",
     "./mcp":      "./src/mcp.ts"
   },
   "bin": {

src/mcp.ts

@@ -1,109 +1,271 @@
-// kern MCP server — stdio transport.
+// kern MCP server — stdio transport + embedded local HTTP server.
 //
-// Started by MCP clients (Claude Code, Cursor, etc.):
-//   { "command": "npx", "args": ["kern", "proxy"] }
+// Tools:
+//   kern_status    — vault health (secret count, recipient count)
+//   kern_list      — list secret names (no values)
+//   kern_add       — add a secret via URL-mode elicitation (browser form)
+//   kern_rotate    — rotate a secret via URL-mode elicitation
+//   kern_remove    — remove a secret
+//   kern_recipients — list recipients (public keys)
 //
-// Implements the MCP JSON-RPC 2.0 protocol over stdin/stdout.
+// Credential capture uses MCP URL-mode elicitation:
+//   1. kern returns a localhost URL
+//   2. MCP client opens the user's browser
+//   3. User pastes credential into kern's local form
+//   4. Value goes vault → encrypted. Never through the LLM.
 
-import { createProxyTools, loadConfig, type ProxyConfig } from "./proxy.js";
+import { loadFromHost } from "./identity.js";
+import { Vault } from "./vault.js";
+import { startLocalServer, type LocalServer } from "./serve.js";
 
-interface JsonRpcRequest {
-  jsonrpc: "2.0";
-  id?: string | number;
-  method: string;
-  params?: any;
+interface Tool {
+  name: string;
+  description: string;
+  inputSchema: object;
+  handler: (args: any, respond: RespondFn) => Promise<void>;
 }
 
-function respond(id: string | number | undefined, result: any) {
-  const msg = JSON.stringify({ jsonrpc: "2.0", id, result });
-  process.stdout.write(msg + "\n");
-}
+type RespondFn = (id: string | number | undefined, result: any) => void;
 
-function respondError(id: string | number | undefined, code: number, message: string) {
-  const msg = JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
-  process.stdout.write(msg + "\n");
-}
+export async function startMcpServer() {
+  const identity = await loadFromHost();
+  const dir = process.env.KERN_VAULT_DIR ?? process.env.KORN_VAULT_DIR;
+  const vault = new Vault({ identity, ...(dir ? { dir } : {}) });
+
+  let server: LocalServer | null = null;
+
+  function ensureServer(): LocalServer {
+    if (!server) {
+      server = startLocalServer({
+        vault,
+        onAdd: (name) => process.stderr.write(`[kern] encrypted: ${name}\n`),
+      });
+      process.stderr.write(`[kern] local server at ${server.url}\n`);
+    }
+    return server;
+  }
 
-export async function startMcpServer(config?: ProxyConfig) {
-  const cfg = config ?? loadConfig();
-  const tools = await createProxyTools(cfg);
+  const tools: Tool[] = [
+    {
+      name: "kern_status",
+      description: "Vault health: how many secrets, how many recipients, vault directory.",
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_args, respond) => {
+        const secrets = vault.list();
+        let recipients: string[] = [];
+        try {
+          const { readFileSync } = await import("fs");
+          const { join } = await import("path");
+          const r = readFileSync(join(vault.dir, ".recipients"), "utf8");
+          recipients = r.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+        } catch {}
+        respond(undefined, {
+          content: [{ type: "text", text: JSON.stringify({
+            secrets: secrets.length,
+            recipients: recipients.length,
+            names: secrets,
+            dir: vault.dir,
+          }, null, 2) }],
+        });
+      },
+    },
+    {
+      name: "kern_list",
+      description: "List all secret names in the vault. Returns names only — never values.",
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_args, respond) => {
+        const secrets = vault.list();
+        respond(undefined, {
+          content: [{ type: "text", text: secrets.length
+            ? `${secrets.length} secrets: ${secrets.join(", ")}`
+            : "Vault is empty. Use kern_add to add secrets." }],
+        });
+      },
+    },
+    {
+      name: "kern_add",
+      description: "Add a secret to the vault. Opens a secure browser form where the user pastes the credential. The value never passes through the LLM.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", description: "Secret name (e.g. github_token, openai_key)" },
+        },
+      },
+      handler: async (args, respond) => {
+        const name = args.name as string;
+        const srv = ensureServer();
+        const url = `${srv.url}/add?name=${encodeURIComponent(name)}`;
+
+        respond(undefined, {
+          content: [{ type: "text", text: `Opening secure form for "${name}". Paste your credential in the browser — it goes directly to the vault, never through this conversation.` }],
+          _meta: {
+            elicitation: {
+              mode: "url",
+              url,
+              message: `Paste your ${name} credential in the browser form.`,
+              elicitationId: `kern-add-${name}-${Date.now()}`,
+            },
+          },
+        });
 
-  const toolDefs = Object.entries(tools).map(([name, def]) => ({
-    name,
-    description: def.description,
-    inputSchema: def.inputSchema,
+        // Wait for the user to submit the form
+        try {
+          await fetch(`${srv.url}/api/wait?name=${encodeURIComponent(name)}`);
+        } catch {}
+      },
+    },
+    {
+      name: "kern_rotate",
+      description: "Rotate a secret — opens browser form for the new value. The old value is replaced.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", description: "Secret name to rotate" },
+        },
+      },
+      handler: async (args, respond) => {
+        const name = args.name as string;
+        const secrets = vault.list();
+        if (!secrets.includes(name)) {
+          respond(undefined, {
+            content: [{ type: "text", text: `Secret "${name}" not found. Available: ${secrets.join(", ")}` }],
+          });
+          return;
+        }
+        const srv = ensureServer();
+        const url = `${srv.url}/add?name=${encodeURIComponent(name)}`;
+
+        respond(undefined, {
+          content: [{ type: "text", text: `Opening secure form to rotate "${name}".` }],
+          _meta: {
+            elicitation: {
+              mode: "url",
+              url,
+              message: `Paste the new value for ${name}.`,
+              elicitationId: `kern-rotate-${name}-${Date.now()}`,
+            },
+          },
+        });
+
+        try {
+          await fetch(`${srv.url}/api/wait?name=${encodeURIComponent(name)}`);
+        } catch {}
+      },
+    },
+    {
+      name: "kern_remove",
+      description: "Remove a secret from the vault.",
+      inputSchema: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", description: "Secret name to remove" },
+        },
+      },
+      handler: async (args, respond) => {
+        const name = args.name as string;
+        try {
+          vault.delete(name);
+          respond(undefined, {
+            content: [{ type: "text", text: `Removed "${name}" from vault.` }],
+          });
+        } catch (e: any) {
+          respond(undefined, {
+            content: [{ type: "text", text: `Error: ${e.message}` }],
+            isError: true,
+          });
+        }
+      },
+    },
+    {
+      name: "kern_recipients",
+      description: "List vault recipients (public keys that can decrypt). No secret values exposed.",
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_args, respond) => {
+        try {
+          const { readFileSync } = await import("fs");
+          const { join } = await import("path");
+          const raw = readFileSync(join(vault.dir, ".recipients"), "utf8");
+          const keys = raw.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+          respond(undefined, {
+            content: [{ type: "text", text: `${keys.length} recipients:\n${keys.map(k => `  ${k}`).join("\n")}` }],
+          });
+        } catch {
+          respond(undefined, {
+            content: [{ type: "text", text: "No .recipients file found." }],
+          });
+        }
+      },
+    },
+  ];
+
+  // MCP stdio transport
+  const toolDefs = tools.map(t => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema,
   }));
 
-  let buffer = "";
+  function respond(id: string | number | undefined, result: any) {
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
+  }
+
+  function respondError(id: string | number | undefined, code: number, message: string) {
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } }) + "\n");
+  }
 
+  let buffer = "";
   process.stdin.setEncoding("utf8");
   process.stdin.on("data", (chunk: string) => {
     buffer += chunk;
-    let newlineIdx: number;
-    while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
-      const line = buffer.slice(0, newlineIdx).trim();
-      buffer = buffer.slice(newlineIdx + 1);
+    let idx: number;
+    while ((idx = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
       if (line) handleMessage(line);
     }
   });
 
   function handleMessage(line: string) {
-    let req: JsonRpcRequest;
-    try {
-      req = JSON.parse(line);
-    } catch {
-      respondError(undefined, -32700, "Parse error");
-      return;
-    }
+    let req: { jsonrpc: string; id?: string | number; method: string; params?: any };
+    try { req = JSON.parse(line); } catch { respondError(undefined, -32700, "Parse error"); return; }
 
     switch (req.method) {
       case "initialize":
         respond(req.id, {
           protocolVersion: "2024-11-05",
-          capabilities: { tools: {} },
-          serverInfo: { name: "kern", version: "0.1.0" },
+          capabilities: { tools: {}, elicitation: { url: {} } },
+          serverInfo: { name: "kern", version: "0.2.0" },
         });
         break;
-
       case "notifications/initialized":
       case "notifications/cancelled":
         break;
-
       case "ping":
         respond(req.id, {});
         break;
-
       case "tools/list":
         respond(req.id, { tools: toolDefs });
         break;
-
       case "tools/call": {
         const name = req.params?.name;
         const args = req.params?.arguments ?? {};
-        const tool = tools[name as keyof typeof tools];
-        if (!tool) {
-          respondError(req.id, -32602, `Unknown tool: ${name}`);
-          return;
-        }
-        (tool.handler as any)(args)
-          .then((result: any) => {
-            respond(req.id, {
-              content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-            });
-          })
-          .catch((err: any) => {
-            respond(req.id, {
-              content: [{ type: "text", text: `Error: ${err.message}` }],
-              isError: true,
-            });
-          });
+        const tool = tools.find(t => t.name === name);
+        if (!tool) { respondError(req.id, -32602, `Unknown tool: ${name}`); return; }
+        tool.handler(args, (_, result) => respond(req.id, result))
+          .catch((err: any) => respond(req.id, {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+          }));
         break;
       }
-
       default:
         respondError(req.id, -32601, `Method not found: ${req.method}`);
     }
   }
 
-  process.stderr.write("[kern] MCP proxy ready\n");
+  process.on("exit", () => server?.close());
+  process.stderr.write("[kern] MCP server ready\n");
 }