@decionis/mcp 0.1.0

package/dist/agent/AgentIndex.d.ts

@@ -0,0 +1,226 @@
+import { Readable, Writable } from 'node:stream';
+
+type AgentHost = "codex" | "copilot" | "claude";
+type AgentGateVerdict = "allow" | "block" | "review" | "escalate" | "error";
+type AgentGateSource = "local" | "remote";
+interface AgentToolCall {
+    host: AgentHost;
+    sessionId: string;
+    toolUseId: string | null;
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    cwd: string;
+    model: string | null;
+    permissionMode: string | null;
+}
+interface AgentGateDecision {
+    verdict: AgentGateVerdict;
+    reason: string;
+    source: AgentGateSource;
+    outcome: string | null;
+    policyVersion: string | null;
+    matchedRule: string | null;
+    reasonCodes: string[];
+}
+interface AgentGateEvaluator {
+    readonly source: AgentGateSource;
+    evaluate(toolCall: AgentToolCall): Promise<AgentGateDecision>;
+    close?(): Promise<void>;
+}
+interface AgentHostAdapter {
+    readonly host: AgentHost;
+    parse(input: unknown): AgentToolCall;
+    format(decision: AgentGateDecision, input?: unknown): Record<string, unknown>;
+}
+declare class AgentHookInputError extends Error {
+    constructor(message: string);
+}
+declare class AgentGateConfigurationError extends Error {
+    constructor(message: string);
+}
+
+declare class AgentDecisionMapper {
+    static fromProtocol(body: Record<string, unknown>, source: AgentGateSource, fallbackPolicyVersion?: string | null): AgentGateDecision;
+    static error(message: string, source: AgentGateSource): AgentGateDecision;
+    private static toVerdict;
+    private static reason;
+}
+
+declare class AgentGateFactory {
+    static create(env?: NodeJS.ProcessEnv): AgentGateEvaluator;
+}
+
+interface AgentHookCommandOptions {
+    input?: Readable;
+    output?: Writable;
+    errorOutput?: Writable;
+    env?: NodeJS.ProcessEnv;
+}
+declare class AgentHookCommand {
+    static run(args: string[], options?: AgentHookCommandOptions): Promise<number>;
+    private static hostArgument;
+    private static readInput;
+}
+
+declare class AgentHookRunner {
+    private readonly adapter;
+    private readonly evaluator;
+    constructor(adapter: AgentHostAdapter, evaluator: AgentGateEvaluator);
+    run(input: unknown): Promise<Record<string, unknown>>;
+    close(): Promise<void>;
+    static shouldBlock(decision: AgentGateDecision): boolean;
+}
+
+declare class AgentHostRegistry {
+    static resolve(host: string): AgentHostAdapter;
+}
+
+declare class AgentPolicyPayload {
+    static build(toolCall: AgentToolCall): Record<string, unknown>;
+}
+
+interface BundleRule {
+    rule_id: string;
+    name: string;
+    decision_domain: string;
+    when: Record<string, unknown>;
+    then: {
+        action: string;
+    };
+    priority: number;
+    enabled: boolean;
+    rationale?: string;
+}
+interface CompileResult {
+    rules: BundleRule[];
+    errors: string[];
+}
+
+/**
+ * Local Decionis gateway: boots the REAL protocol service (@decionis/protocol)
+ * with an in-memory store and evaluates decisions through fastify's inject()
+ * — the genuine platform evaluator, with zero network, zero database, and
+ * zero credentials. The repo's DECIONIS_POLICY.md is compiled and published
+ * through the protocol's own bundle-ingestion route (schema-validated), so a
+ * policy that misbehaves locally would misbehave identically in production.
+ */
+
+type PublishResult = {
+    ok: true;
+    version: string;
+    sha256: string;
+    ruleCount: number;
+    republished: boolean;
+} | {
+    ok: false;
+    reason: "no_rules_block" | "compile_error" | "bundle_rejected";
+    errors: string[];
+};
+interface EvaluateResult {
+    status: number;
+    body: Record<string, unknown>;
+}
+declare class LocalDecionisGateway {
+    private app;
+    private publishedVersion;
+    private ready;
+    close(): Promise<void>;
+    /** Compile the policy source; does not publish. */
+    compile(source: string, opts?: {
+        workflowKey?: string | null;
+    }): CompileResult | null;
+    /**
+     * Compile + publish the policy as the active local bundle. Idempotent by
+     * content hash — republished only when the file content changes.
+     */
+    publishPolicy(source: string, opts?: {
+        workflowKey?: string | null;
+    }): Promise<PublishResult>;
+    /**
+     * Evaluate a candidate action through POST /v1/protocol/evaluate-decision,
+     * applying the same request normalization the public API performs
+     * (apps/api/src/services/protocolAdapter/normalizeEvaluateBody.ts): the
+     * payload becomes `context`, and decision_type derives from the action
+     * label, then the workflow key, then a stable fallback.
+     */
+    evaluate(input: {
+        payload: Record<string, unknown>;
+        workflowKey?: string | null;
+        mode?: "shadow" | "enforce";
+    }): Promise<EvaluateResult>;
+}
+
+type PolicyFileResult = {
+    ok: true;
+    path: string;
+    content: string;
+} | {
+    ok: false;
+    path: string;
+    message: string;
+};
+declare class PolicyFileRepository {
+    private readonly env;
+    constructor(env?: NodeJS.ProcessEnv);
+    resolvePath(pathOverride: unknown, cwd?: string): string;
+    read(pathOverride: unknown, cwd?: string): Promise<PolicyFileResult>;
+}
+
+interface LocalAgentGateOptions {
+    gateway?: LocalDecionisGateway;
+    policyFiles?: PolicyFileRepository;
+    workflowKey?: string;
+}
+declare class LocalAgentGate implements AgentGateEvaluator {
+    readonly source: "local";
+    private readonly gateway;
+    private readonly policyFiles;
+    private readonly workflowKey;
+    constructor(options?: LocalAgentGateOptions);
+    evaluate(toolCall: AgentToolCall): Promise<AgentGateDecision>;
+    close(): Promise<void>;
+}
+
+type FetchLike = typeof fetch;
+interface RemoteAgentGateOptions {
+    endpoint: string;
+    apiKey: string;
+    orgId: string;
+    fetchImpl?: FetchLike;
+    timeoutMs?: number;
+    workflowKey?: string;
+}
+declare class RemoteAgentGate implements AgentGateEvaluator {
+    private readonly options;
+    readonly source: "remote";
+    private readonly endpoint;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    private readonly workflowKey;
+    constructor(options: RemoteAgentGateOptions);
+    evaluate(toolCall: AgentToolCall): Promise<AgentGateDecision>;
+    private idempotencyKey;
+}
+
+declare abstract class SnakeCaseHookAdapter implements AgentHostAdapter {
+    abstract readonly host: AgentHost;
+    parse(input: unknown): AgentToolCall;
+    format(decision: AgentGateDecision, _input?: unknown): Record<string, unknown>;
+    protected reason(decision: AgentGateDecision): string;
+}
+
+declare class ClaudeHookAdapter extends SnakeCaseHookAdapter {
+    readonly host: "claude";
+}
+
+declare class CodexHookAdapter extends SnakeCaseHookAdapter {
+    readonly host: "codex";
+}
+
+declare class CopilotHookAdapter implements AgentHostAdapter {
+    readonly host: "copilot";
+    parse(input: unknown): AgentToolCall;
+    format(decision: AgentGateDecision, input?: unknown): Record<string, unknown>;
+}
+
+export { AgentDecisionMapper, AgentGateConfigurationError, type AgentGateDecision, type AgentGateEvaluator, AgentGateFactory, type AgentGateSource, type AgentGateVerdict, AgentHookCommand, type AgentHookCommandOptions, AgentHookInputError, AgentHookRunner, type AgentHost, type AgentHostAdapter, AgentHostRegistry, AgentPolicyPayload, type AgentToolCall, ClaudeHookAdapter, CodexHookAdapter, CopilotHookAdapter, LocalAgentGate, type LocalAgentGateOptions, PolicyFileRepository, type PolicyFileResult, RemoteAgentGate, type RemoteAgentGateOptions };

package/dist/agent/AgentIndex.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  AgentDecisionMapper,
+  AgentGateConfigurationError,
+  AgentGateFactory,
+  AgentHookCommand,
+  AgentHookInputError,
+  AgentHookRunner,
+  AgentHostRegistry,
+  AgentPolicyPayload,
+  ClaudeHookAdapter,
+  CodexHookAdapter,
+  CopilotHookAdapter,
+  LocalAgentGate,
+  RemoteAgentGate
+} from "../chunk-UN67W5FH.js";
+import {
+  PolicyFileRepository
+} from "../chunk-QSCP7MRQ.js";
+export {
+  AgentDecisionMapper,
+  AgentGateConfigurationError,
+  AgentGateFactory,
+  AgentHookCommand,
+  AgentHookInputError,
+  AgentHookRunner,
+  AgentHostRegistry,
+  AgentPolicyPayload,
+  ClaudeHookAdapter,
+  CodexHookAdapter,
+  CopilotHookAdapter,
+  LocalAgentGate,
+  PolicyFileRepository,
+  RemoteAgentGate
+};
+//# sourceMappingURL=AgentIndex.js.map

package/dist/agent/AgentIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}