Use the local daemon

python -m pip install https://docs.soterias.io/downloads/api-preview/soterias_local-0.1.0rc5%2Bapi2-cp311-abi3-win_amd64.whl

npm install https://docs.soterias.io/downloads/api-preview/soterias-core-0.1.0-rc.5-api.2.tgz
npm install --save-dev typescript@5.8.3 @types/node@24

import asyncio
import json
import os
from soterias import security

import { security } from '@soterias/core';

# %% Connect with an execution credential
# The operator runs and configures the daemon. Never reuse its approval credential.
client = security.Daemon(os.environ["SOTERIAS_DAEMON_URL"],
                         os.environ["SOTERIAS_DAEMON_TOKEN"].encode())


async def inspect():
    async with client:

// %% Connect with an execution credential
// The operator runs and configures the daemon. Never reuse its approval credential.
const client = new security.Daemon({ url: process.env.SOTERIAS_DAEMON_URL!,
  bearer: Buffer.from(process.env.SOTERIAS_DAEMON_TOKEN!) });
try {

        # %% Read current snapshots without executing an effect
        # These snapshots describe state; they grant no new authority.
        metrics = json.loads((await client.metrics_async()).canonical_bytes())
        authority = json.loads((await client.authority_graph_async()).canonical_bytes())
        warrants = json.loads((await client.warrants_async()).canonical_bytes())
        print(json.dumps({"status": "PASS", "snapshots": 3,
                          "metrics_version": metrics["version"],
                          "authority_version": authority["version"],
                          "warrants_version": warrants["version"]}))

  // %% Read current snapshots without executing an effect
  // These snapshots describe state; they grant no new authority.
  const metrics = JSON.parse((await client.metricsAsync()).canonicalBytes().toString());
  const authority = JSON.parse((await client.authorityGraphAsync()).canonicalBytes().toString());
  const warrants = JSON.parse((await client.warrantsAsync()).canonicalBytes().toString());
  console.log(JSON.stringify({ status: 'PASS', snapshots: 3,
    metrics_version: metrics.version, authority_version: authority.version,
    warrants_version: warrants.version }));
} finally {

# %% Close the caller-owned client after pending reads
# For local IPC use security.Daemon.connect_ipc(root, name, bearer) instead.
asyncio.run(inspect())

  // %% Close the caller-owned client after pending reads
  // For local IPC use the daemon's ipc option instead of url.
  client.close();
}

import { security, Soterias, observe, canonicalize, Metrics, audit, HistoricalPolicyInputs } from '@soterias/core';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { McpServer } from '@modelcontextprotocol/server';
import { serveStdio } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';

// Trusted startup: paths, trust and credentials are fixed by the host.
const client = new security.Daemon({url: process.env.SOTERIAS_DAEMON_URL, bearer: Buffer.from(process.env.SOTERIAS_DAEMON_TOKEN)});

// Agent input is bounded data. It cannot replace host configuration or trust.
const handle = serveStdio(() => {
  const server = new McpServer({name: 'soterias-daemon', version: '1.0.0'});
  server.registerTool('daemon_metrics', {
    description: 'Use daemon through the host-selected native SDK.',
    inputSchema: z.object({}).strict(),
  }, async input => {
    try {
      const result = await (async () => {
        return JSON.parse((await client.metricsAsync()).canonicalBytes().toString());
      })();
      return {content: [{type: 'text', text: JSON.stringify(result, (_key, value) => typeof value === 'bigint' ? value.toString() : value)}]};
    } catch {

      return {isError: true, content: [{type: 'text', text: 'feature_request_refused'}]};
    }
  });
  return server;
}, {maxSubscriptions: 0});
process.stdin.once('end', () => {
  void (async () => { await handle.close(); client.close(); })();
});

import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
import { fileURLToPath } from 'node:url';

const client = new Client({name: 'feature-example', version: '1.0.0'});
try {
  await client.connect(new StdioClientTransport({
    command: process.execPath,
    args: [fileURLToPath(new URL('./mcp.mjs', import.meta.url))],
    env: Object.fromEntries(Object.entries(process.env).filter(([, value]) => value !== undefined)),
  }));
  const result = await client.callTool({name: 'daemon_metrics', arguments: {}});
  if (result.isError) throw new Error('Feature request refused');
  console.log(JSON.stringify(result));
} finally { await client.close(); }