@i4ctime/q-ring 0.15.0 → 0.16.1

package/dist/index.js

@@ -38,13 +38,14 @@ import {
   removeHook,
   revokeApproval,
   serviceForScope,
+  setAuditAgentLabel,
   setSecret,
   tunnelCreate,
   tunnelDestroy,
   tunnelList,
   tunnelRead,
   verifyAuditChain
-} from "./chunk-MLBJCPX2.js";
+} from "./chunk-5LFKBZ3Q.js";
 
 // src/cli/commands.ts
 import { Command, Help } from "commander";
@@ -2587,7 +2588,7 @@ function registerToolingCommands(program2) {
     }
   });
   program2.command("status").description("Launch the quantum status dashboard in your browser").option("--port <port>", "Port to serve on", "9876").option("--no-open", "Don't auto-open the browser").action(async (cmd) => {
-    const { startDashboardServer } = await import("./dashboard-T2UG23KI.js");
+    const { startDashboardServer } = await import("./dashboard-A3GJQCJX.js");
     const { exec } = await import("child_process");
     const { platform } = await import("os");
     const port = Number(cmd.port);
@@ -4030,6 +4031,285 @@ ${SYMBOLS.check} ${prefix}${c.bold(verb)}: ${c.cyan(result.configPath)} ${c.dim(
   });
 }
 
+// src/core/canary.ts
+var ALPHA_UPPER_NUM = () => generateSecret({ format: "alphanumeric", length: 16 }).toUpperCase();
+var CANARY_FORMATS = {
+  aws: {
+    name: "aws",
+    description: "AWS access key id (AKIA\u2026)",
+    generate: () => `AKIA${ALPHA_UPPER_NUM()}`
+  },
+  github: {
+    name: "github",
+    description: "GitHub personal access token (ghp_\u2026)",
+    generate: () => generateSecret({ format: "api-key", prefix: "ghp_", length: 36 })
+  },
+  openai: {
+    name: "openai",
+    description: "OpenAI API key (sk-\u2026)",
+    generate: () => generateSecret({ format: "api-key", prefix: "sk-", length: 48 })
+  },
+  anthropic: {
+    name: "anthropic",
+    description: "Anthropic API key (sk-ant-\u2026)",
+    generate: () => generateSecret({ format: "api-key", prefix: "sk-ant-api03-", length: 80 })
+  },
+  stripe: {
+    name: "stripe",
+    description: "Stripe live secret key (sk_live_\u2026)",
+    generate: () => generateSecret({ format: "api-key", prefix: "sk_live_", length: 24 })
+  },
+  generic: {
+    name: "generic",
+    description: "Generic high-entropy API key",
+    generate: () => generateSecret({ format: "api-key", prefix: "qk_", length: 40 })
+  }
+};
+var DEFAULT_CANARY_FORMAT = "generic";
+function plantCanary(key, opts = {}) {
+  const formatName = opts.format ?? DEFAULT_CANARY_FORMAT;
+  const format = CANARY_FORMATS[formatName];
+  if (!format) {
+    throw new Error(
+      `Unknown canary format "${formatName}". Available: ${Object.keys(CANARY_FORMATS).join(", ")}`
+    );
+  }
+  const value = opts.value ?? format.generate();
+  const scope = opts.scope ?? "global";
+  setSecret(key, value, {
+    ...opts,
+    scope,
+    canary: true,
+    canaryFormat: formatName,
+    description: opts.value ? "Canary honeytoken (custom value)" : `Canary honeytoken (${format.description})`
+  });
+  return { key, value, format: formatName, scope };
+}
+function listCanaries(opts = {}) {
+  const out = [];
+  for (const entry of listSecrets({ ...opts, silent: true })) {
+    const meta = entry.envelope?.meta;
+    if (!meta?.canary) continue;
+    out.push({
+      key: entry.key,
+      scope: entry.scope,
+      format: meta.canaryFormat,
+      plantedAt: meta.createdAt,
+      tripCount: meta.accessCount,
+      lastTrippedAt: meta.lastAccessedAt
+    });
+  }
+  return out;
+}
+
+// src/cli/commands/canary.ts
+function registerCanaryCommands(program2) {
+  const canary = program2.command("canary").description("Honeytokens \u2014 fake credentials that raise the alarm on read");
+  canary.command("plant <key>").description("Plant a fake credential; any read fires a loud alert").option(
+    "-f, --format <format>",
+    `Token shape to imitate (${Object.keys(CANARY_FORMATS).join(", ")})`,
+    DEFAULT_CANARY_FORMAT
+  ).option("--value <value>", "Plant this exact value instead of generating one").option("--force", "Overwrite an existing non-canary secret at this key").option("-g, --global", "Global scope (default)").option("-p, --project", "Project scope").option("--team <id>", "Team scope").option("--org <id>", "Org scope").option("--project-path <path>", "Project path (defaults to cwd)").action((key, cmd) => {
+    const opts = buildOpts(cmd);
+    const existing = getEnvelope(key, opts);
+    if (existing && !existing.envelope.meta.canary && !cmd.force) {
+      console.error(
+        c.red(
+          `${SYMBOLS.cross} "${key}" already holds a real secret in ${existing.scope} scope. Use --force to replace it with a canary.`
+        )
+      );
+      process.exit(1);
+    }
+    const result = plantCanary(key, { ...opts, format: cmd.format, value: cmd.value });
+    console.log(
+      `${SYMBOLS.sparkle} ${c.yellow("canary planted")} ${c.bold(result.key)} ${c.dim(`(${result.format}, ${result.scope} scope)`)}`
+    );
+    console.log(c.dim(`  value: ${result.value}`));
+    console.log(
+      c.dim(
+        "  Reads return this fake value and fire a desktop alert + a 'canary' audit event."
+      )
+    );
+    console.log(
+      c.dim("  Watch trips with: qring canary list \xB7 qring audit --action canary")
+    );
+  });
+  canary.command("list").alias("ls").description("List planted canaries and their trip counts").option("--json", "Output as JSON").option("-g, --global", "Global scope only").option("-p, --project", "Project scope only").option("--team <id>", "Team scope").option("--org <id>", "Org scope").option("--project-path <path>", "Project path (defaults to cwd)").action((cmd) => {
+    const canaries = listCanaries(buildOpts(cmd));
+    if (emitJson(program2, cmd, { canaries })) return;
+    if (canaries.length === 0) {
+      console.log(c.dim("No canaries planted. Plant one: qring canary plant AWS_SECRET_ACCESS_KEY --format aws"));
+      return;
+    }
+    console.log(c.bold(`
+  ${SYMBOLS.eye} Canaries (${canaries.length})
+`));
+    for (const entry of canaries) {
+      const parts = [c.bold(entry.key)];
+      parts.push(c.dim(`${entry.format ?? "generic"} \xB7 ${entry.scope}`));
+      if (entry.tripCount > 0) {
+        parts.push(c.red(`trips: ${entry.tripCount}`));
+        if (entry.lastTrippedAt) {
+          parts.push(c.red(`last: ${entry.lastTrippedAt}`));
+        }
+      } else {
+        parts.push(c.green("no trips"));
+      }
+      console.log(`  ${SYMBOLS.eye} ${parts.join("  ")}`);
+    }
+    console.log();
+  });
+}
+
+// src/core/wrap.ts
+import { randomUUID } from "crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function createAirlockServer(downstream, session) {
+  const downstreamInfo = downstream.getServerVersion();
+  const name = downstreamInfo ? `${downstreamInfo.name} (q-ring airlock)` : "q-ring-airlock";
+  const proxy = new Server(
+    { name, version: PACKAGE_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  proxy.oninitialized = () => {
+    const info = proxy.getClientVersion();
+    if (info) setAuditAgentLabel(`${info.name}@${info.version}`);
+  };
+  proxy.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    return downstream.listTools(request.params);
+  });
+  proxy.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    const toolName = request.params.name;
+    logAudit({
+      action: "wrap",
+      source: "mcp",
+      detail: `tool call "${toolName}" \u2192 ${session.label}`,
+      correlationId: session.correlationId
+    });
+    try {
+      return await downstream.callTool(request.params, void 0, {
+        signal: extra.signal
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logAudit({
+        action: "wrap",
+        source: "mcp",
+        detail: `tool call "${toolName}" failed: ${message}`,
+        correlationId: session.correlationId
+      });
+      return {
+        content: [
+          { type: "text", text: `airlock: downstream error: ${message}` }
+        ],
+        isError: true
+      };
+    }
+  });
+  return proxy;
+}
+async function connectDownstream(opts) {
+  const client = new Client({
+    name: "q-ring-airlock",
+    version: PACKAGE_VERSION
+  });
+  const env = opts.inheritEnv ? Object.fromEntries(
+    Object.entries(process.env).filter(([, v]) => v !== void 0)
+  ) : void 0;
+  const transport = new StdioClientTransport({
+    command: opts.command,
+    args: opts.args ?? [],
+    env,
+    stderr: "inherit"
+  });
+  await client.connect(transport);
+  return client;
+}
+async function runWrap(opts) {
+  const label = opts.label ?? [opts.command, ...opts.args ?? []].join(" ");
+  const session = { label, correlationId: randomUUID() };
+  const downstream = await connectDownstream(opts);
+  const downstreamInfo = downstream.getServerVersion();
+  logAudit({
+    action: "wrap",
+    source: "cli",
+    detail: `airlock session started: ${label}${opts.inheritEnv ? " (env inherited)" : " (env stripped)"}`,
+    correlationId: session.correlationId
+  });
+  console.error(
+    `q-ring airlock: wrapping ${downstreamInfo?.name ?? label} \u2014 env ${opts.inheritEnv ? "inherited" : "stripped"}, tool calls audited (session ${session.correlationId.slice(0, 8)})`
+  );
+  const proxy = createAirlockServer(downstream, session);
+  const transport = new StdioServerTransport();
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (code, reason) => {
+      if (settled) return;
+      settled = true;
+      logAudit({
+        action: "wrap",
+        source: "cli",
+        detail: `airlock session ended: ${reason}`,
+        correlationId: session.correlationId
+      });
+      void proxy.close().catch(() => {
+      });
+      void downstream.close().catch(() => {
+      });
+      resolve(code);
+    };
+    downstream.onclose = () => finish(1, "wrapped server exited");
+    transport.onclose = () => finish(0, "host disconnected");
+    transport.onerror = (err) => finish(1, `transport error: ${err.message}`);
+    process.stdin.on("end", () => finish(0, "host disconnected"));
+    process.stdout.on("error", (err) => {
+      if (err.code === "EPIPE") finish(0, "host disconnected");
+      else finish(1, `stdout error: ${err.message}`);
+    });
+    proxy.connect(transport).catch((err) => {
+      console.error(
+        `q-ring airlock: failed to start: ${err instanceof Error ? err.message : String(err)}`
+      );
+      finish(1, "startup failure");
+    });
+  });
+}
+
+// src/cli/commands/mcp.ts
+function registerMcpCommands(program2) {
+  const mcp = program2.command("mcp").description("MCP airlock \u2014 run third-party MCP servers behind q-ring");
+  mcp.command("wrap <command...>").description(
+    "Proxy an MCP server through the airlock: spawned with a stripped env, every tool call audited. Use -- before the server command: qring mcp wrap -- npx some-server"
+  ).option(
+    "--inherit-env",
+    "Pass the full parent environment to the wrapped server (default: minimal safe env)"
+  ).option("--label <label>", "Session label for audit events (default: the command line)").action(async (commandArgs, cmd) => {
+    try {
+      const code = await runWrap({
+        command: commandArgs[0],
+        args: commandArgs.slice(1),
+        inheritEnv: cmd.inheritEnv === true,
+        label: cmd.label
+      });
+      process.exit(code);
+    } catch (err) {
+      console.error(
+        c.red(
+          `${SYMBOLS.cross} Airlock failed: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli/commands/doctor.ts
 import { existsSync as existsSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync6, rmSync } from "fs";
 import { join as join5, delimiter } from "path";
@@ -4400,7 +4680,7 @@ var COMMAND_GROUPS = [
   {
     name: "Security & Governance",
     symbol: SYMBOLS.lock,
-    commands: ["approve", "approvals", "policy"]
+    commands: ["approve", "approvals", "policy", "canary", "mcp"]
   }
 ];
 var GroupedHelp = class extends Help {
@@ -4518,6 +4798,8 @@ function createProgram() {
   registerAgentCommands(program2);
   registerSecurityCommands(program2);
   registerBridgeCommands(program2);
+  registerCanaryCommands(program2);
+  registerMcpCommands(program2);
   registerDoctorCommand(program2);
   registerCompletionCommand(program2);
   return program2;