@seekrit/mcp 0.2.0 → 0.4.0

package/README.md

@@ -18,15 +18,38 @@ it just publishes it as its own binary so no CLI install is required first.
 ## Setup
 
 Add it to any MCP client with a stdio server whose command runs this package via
-`npx`, passing a credential in its environment. For Claude Code:
+`npx`, passing a credential in its environment.
+
+**Fully autonomous agent (recommended).** An agent with no account can
+[sign up](https://seekrit.dev/docs/guides/ai-agents) for **machine credentials**
+(`POST https://mcp.seekrit.dev/signup`) and use the *same* client id + secret for
+everything — the hosted metadata plane and this local crypto plane. Point this
+server at them and it mints its own admin token automatically on first use
+(keyless — the keypair is generated locally), so there is no token to copy:
+
+```json
+{
+  "mcpServers": {
+    "seekrit": {
+      "command": "npx",
+      "args": ["-y", "@seekrit/mcp"],
+      "env": {
+        "SEEKRIT_CLIENT_ID": "<your client id>",
+        "SEEKRIT_CLIENT_SECRET": "<your client secret>"
+      }
+    }
+  }
+}
+```
+
+**With an existing token.** If you already hold a service token, pass it directly.
+For Claude Code:
 
 ```sh
 # An admin token lets the agent provision structure (apps/envs/tokens) too:
 claude mcp add seekrit --env SEEKRIT_TOKEN=skt_… -- npx -y @seekrit/mcp
 ```
 
-Or drop a `.mcp.json` in your project — the whole setup is this snippet:
-
 ```json
 {
   "mcpServers": {
@@ -43,14 +66,44 @@ Or drop a `.mcp.json` in your project — the whole setup is this snippet:
 
 Requires Node ≥ 20. Set `SEEKRIT_API_URL` too if you're not on the hosted API.
 
+## As a container
+
+For a sandbox with no Node toolchain, the same server ships as a multi-arch
+Docker image, [`seekritdev/mcp`](https://hub.docker.com/r/seekritdev/mcp).
+Register a stdio server that runs `docker run -i` — the `-i` is required, since
+stdin is the MCP transport:
+
+```json
+{
+  "mcpServers": {
+    "seekrit": {
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm",
+        "-e", "SEEKRIT_TOKEN",
+        "-v", "${PWD}:/work",
+        "seekritdev/mcp"
+      ]
+    }
+  }
+}
+```
+
+The bare `-e SEEKRIT_TOKEN` forwards the token from the client's environment.
+Mount a workdir at `/work` for the `run_command` tool to operate on (it runs
+*inside* the container). Pin a release (`seekritdev/mcp:0.2.0`) or track `:edge`.
+The container still decrypts locally — nothing plaintext leaves it.
+
 ## Choosing the credential
 
-The server authenticates exactly like the CLI — `SEEKRIT_TOKEN`, or saved
-config at `~/.config/seekrit/config.json`.
+The server authenticates exactly like the CLI — `SEEKRIT_CLIENT_ID` +
+`SEEKRIT_CLIENT_SECRET`, `SEEKRIT_TOKEN`, or saved config at
+`~/.config/seekrit/config.json`.
 
 | Credential | Good for | Notes |
 | --- | --- | --- |
-| **Admin token** (`seekrit token create --admin`) | Provisioning: create apps/groups/envs, compose, grant, mint tokens | Org-scoped; the only headless way to create structure. |
+| **Machine credentials** (`SEEKRIT_CLIENT_ID` + `SEEKRIT_CLIENT_SECRET`) | Fully autonomous agents: one credential for both planes | Auto-mints + caches an admin token on first use. Get them from `POST /signup`. |
+| **Admin token** (`seekrit token create --admin`) | Provisioning: create apps/groups/envs, compose, grant, mint tokens | Org-scoped; a fixed headless credential for structure. |
 | **Runtime token** (bound to an env) | Reading/writing/injecting one environment's secrets | Self-decrypts — no passphrase. Cannot provision. |
 
 Under user auth (no token), tools that decrypt need `SEEKRIT_PASSPHRASE` in the

package/dist/index.js

@@ -3,7 +3,7 @@ import { spawn } from "node:child_process";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, parse } from "node:path";
 import { createInterface } from "node:readline";
@@ -664,7 +664,7 @@ function isServiceToken(value) {
 }
 //#endregion
 //#region ../cli/package.json
-var version$1 = "0.19.0";
+var version$1 = "0.20.0";
 const PROJECT_FILE = "seekrit.json";
 function globalConfigPath() {
 	return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "seekrit", "config.json");
@@ -674,6 +674,26 @@ function readGlobalConfig() {
 	if (!existsSync(path)) return {};
 	return JSON.parse(readFileSync(path, "utf8"));
 }
+function writeGlobalConfig(update) {
+	const path = globalConfigPath();
+	const merged = {
+		...readGlobalConfig(),
+		...update
+	};
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(merged, null, 2)}\n`, { mode: 384 });
+}
+/** The admin token previously auto-minted from these M2M credentials, if any. */
+function readCachedM2mToken(clientId) {
+	return readGlobalConfig().m2mTokens?.[clientId];
+}
+/** Remember an auto-minted admin token so the next run reuses it. */
+function cacheM2mToken(clientId, token) {
+	writeGlobalConfig({ m2mTokens: {
+		...readGlobalConfig().m2mTokens,
+		[clientId]: token
+	} });
+}
 /** Walk up from cwd looking for seekrit.json. */
 function findProjectConfig(startDir = process.cwd()) {
 	let dir = startDir;
@@ -718,7 +738,8 @@ var SeekritClient = class {
 			const token = await this.auth.getToken();
 			if (!token) throw new SeekritApiError(401, "unauthorized", "session expired");
 			headers.authorization = `Bearer ${token}`;
-		} else headers["x-seekrit-dev-user"] = this.auth.email;
+		} else if (this.auth.type === "m2m") headers.authorization = `Basic ${btoa(`${this.auth.clientId}:${this.auth.clientSecret}`)}`;
+		else headers["x-seekrit-dev-user"] = this.auth.email;
 		if (body !== void 0) headers["content-type"] = "application/json";
 		const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
 			method,
@@ -1296,6 +1317,77 @@ async function kmsRecoverMaterial(ctx, orgId, keyId, version) {
 	};
 }
 //#endregion
+//#region ../cli/src/m2m.ts
+/**
+* Resolve M2M client credentials from (in order) the process environment, a
+* `.env` overlay (for `seekrit run`), then saved config. Both halves must come
+* through for the credential to be usable.
+*/
+function readM2mCreds(dotenvVars = {}) {
+	const config = readGlobalConfig();
+	const fromEnv = (key) => process.env[key] ?? dotenvVars[key];
+	const clientId = fromEnv("SEEKRIT_CLIENT_ID") ?? config.clientId;
+	const clientSecret = fromEnv("SEEKRIT_CLIENT_SECRET") ?? config.clientSecret;
+	if (!clientId || !clientSecret) return null;
+	return {
+		clientId,
+		clientSecret
+	};
+}
+/** True when a service/dev credential is already configured explicitly. */
+function hasExplicitCredential(dotenvVars) {
+	const fromEnv = (key) => process.env[key] ?? dotenvVars[key];
+	if (fromEnv("SEEKRIT_TOKEN") || fromEnv("SEEKRIT_DEV_USER")) return true;
+	const config = readGlobalConfig();
+	return Boolean(config.token || config.devUser);
+}
+/** Mint a fresh org-scoped admin token using M2M credentials (keyless). */
+async function mintAdminToken(apiUrl, creds) {
+	const client = new SeekritClient({
+		baseUrl: apiUrl,
+		auth: {
+			type: "m2m",
+			clientId: creds.clientId,
+			clientSecret: creds.clientSecret
+		}
+	});
+	const { orgs } = await client.listOrgs();
+	const org = orgs[0];
+	if (!org) throw new Error("machine client has no organization — sign up first (POST /signup)");
+	const created = await createServiceToken();
+	await client.createToken(org.id, {
+		name: "agent-admin (auto)",
+		tokenId: created.tokenId,
+		tokenHash: created.tokenHash,
+		publicKeyJwk: created.publicKeyJwk,
+		role: "admin",
+		environmentId: null
+	});
+	return created.token;
+}
+/**
+* If M2M credentials are configured (and no explicit token/dev-user is), ensure
+* an admin token exists for them — minting and caching one on first use — and
+* expose it as `SEEKRIT_TOKEN` so the normal credential resolution
+* ({@link tryBuildContext}) picks it up. A no-op (returns null) when there is
+* nothing to bootstrap. Throws only when credentials ARE present but minting
+* fails, so the reason surfaces instead of a later opaque "no credentials".
+*/
+async function ensureM2mAdminToken(dotenvVars = {}) {
+	if (hasExplicitCredential(dotenvVars)) return null;
+	const creds = readM2mCreds(dotenvVars);
+	if (!creds) return null;
+	const cached = readCachedM2mToken(creds.clientId);
+	if (cached) {
+		process.env.SEEKRIT_TOKEN = cached;
+		return cached;
+	}
+	const token = await mintAdminToken(process.env.SEEKRIT_API_URL ?? dotenvVars.SEEKRIT_API_URL ?? readGlobalConfig().apiUrl ?? "https://api.seekrit.dev", creds);
+	cacheM2mToken(creds.clientId, token);
+	process.env.SEEKRIT_TOKEN = token;
+	return token;
+}
+//#endregion
 //#region ../cli/src/dotenv.ts
 /**
 * Minimal `.env` parser: `KEY=VALUE`, `#` comments, an optional `export`
@@ -1416,7 +1508,7 @@ function errText(err) {
 /** Build the client context or throw a friendly, agent-readable error. */
 function getCtx() {
 	const ctx = tryBuildContext();
-	if (!ctx) throw new Error("no credentials — set SEEKRIT_TOKEN (a skt_… token) or SEEKRIT_DEV_USER in the MCP server env, or run `seekrit login` first");
+	if (!ctx) throw new Error("no credentials — set SEEKRIT_CLIENT_ID + SEEKRIT_CLIENT_SECRET (machine credentials from POST /signup) or SEEKRIT_TOKEN (a skt_… token) in the MCP server env, or run `seekrit login` first");
 	return ctx;
 }
 /**
@@ -1504,6 +1596,7 @@ async function resolveTargetEnv(ctx, o) {
 }
 async function runMcpServer(options = {}) {
 	setFailThrows(true);
+	await ensureM2mAdminToken();
 	const server = new McpServer({
 		name: "seekrit",
 		version: options.version ?? version$1
@@ -2221,7 +2314,7 @@ async function runMcpServer(options = {}) {
 * `seekrit mcp`. tsdown bundles the shared server source in at build time, so the
 * published package is self-contained and needs no `@seekrit/cli` install.
 */
-runMcpServer({ version: "0.2.0" }).catch((err) => {
+runMcpServer({ version: "0.4.0" }).catch((err) => {
 	const message = err instanceof Error ? err.message : String(err);
 	process.stderr.write(`seekrit-mcp: fatal: ${message}\n`);
 	process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seekrit/mcp",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "npx-able MCP server for seekrit — let Claude Code and other MCP clients provision, manage, and inject end-to-end encrypted secrets.",
   "type": "module",
   "publishConfig": {
@@ -22,7 +22,7 @@
   "devDependencies": {
     "@types/node": "^26.1.0",
     "tsdown": "^0.22.3",
-    "@seekrit/cli": "0.19.0"
+    "@seekrit/cli": "0.20.0"
   },
   "scripts": {
     "build": "tsdown",