@victframework/server 0.1.0

package/dist/app-remote.d.ts

@@ -0,0 +1,36 @@
+import type { ServerActorContext } from './auth.js';
+/**
+ * Stage 06B — the remote Application data/action adapter.
+ *
+ * Wraps the Stage 05 verified Application data port with the SAME server
+ * authorization boundary (APP-010, API-006):
+ *
+ * - resource queries and mutations preserve the declared resource ID,
+ *   revision, and release binding — never re-derived or widened;
+ * - VICT actions use the same authorization boundary (scopes below the UI);
+ * - LOCAL actions are client-local by definition and are REFUSED remotely;
+ * - cross-actor and stale-release access fails;
+ * - hostile query/filter containers produce structured non-echoing errors.
+ */
+export interface RemoteApplicationDataOptions {
+    /** The verified Stage 05 application-data port (composed). */
+    readonly data: ApplicationDataPortLike;
+    /** The actor→resource ownership policy: resource records carry actorId. */
+    readonly ownsResource?: (actor: ServerActorContext, resource: {
+        readonly actorId?: unknown;
+    }) => boolean;
+    /** The expected release binding (stale-release denial). */
+    readonly expectedReleaseVersion?: string;
+}
+/** The neutral application-data port surface used by the server. */
+export interface ApplicationDataPortLike {
+    query(request: Record<string, unknown>): Promise<unknown>;
+    mutate(request: Record<string, unknown>): Promise<unknown>;
+}
+/** Hostile-container containment: any throw from a filter object is a stable error. */
+/** The remote resource query boundary. */
+export declare function remoteQuery(actor: ServerActorContext, options: RemoteApplicationDataOptions, input: Record<string, unknown>): Promise<unknown>;
+/** The remote resource mutation boundary. */
+export declare function remoteMutate(actor: ServerActorContext, options: RemoteApplicationDataOptions, input: Record<string, unknown>): Promise<unknown>;
+/** The VICT-action boundary (governed Vict actions through the same server authorization). */
+export declare function remoteAction(actor: ServerActorContext, options: RemoteApplicationDataOptions, input: Record<string, unknown>): Promise<unknown>;

package/dist/app-remote.js

@@ -0,0 +1,108 @@
+import { VictControlError } from '@victframework/runtime';
+/** Bounded string fields on the remote boundary (closed schemas). */
+function bounded(value, field, max = 128) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > max) {
+        throw new VictControlError('VICT_APPDATA_FIELD_INVALID', `${field} must be a bounded string.`);
+    }
+    return value;
+}
+/** Hostile-container containment: any throw from a filter object is a stable error. */
+/** The remote resource query boundary. */
+export async function remoteQuery(actor, options, input) {
+    const resourceId = bounded(input.resourceId, 'resourceId');
+    const releaseVersion = bounded(input.releaseVersion, 'releaseVersion');
+    if (options.expectedReleaseVersion !== undefined &&
+        releaseVersion !== options.expectedReleaseVersion) {
+        throw new VictControlError('VICT_APPDATA_RELEASE_STALE', 'The declared release binding does not match the currently selected release.');
+    }
+    // The authenticated actor owns the read; hostile filter containers are
+    // contained BEFORE they reach the adapter.
+    let filters;
+    if (input.filters !== undefined) {
+        if (typeof input.filters !== 'object' ||
+            input.filters === null ||
+            Array.isArray(input.filters)) {
+            throw new VictControlError('VICT_APPDATA_FILTER_INVALID', 'The filter container must be a plain object.');
+        }
+        filters = input.filters;
+        // Hostile getters/proxies are contained: enumeration failures collapse
+        // to the stable structured error without echoing the hostile value.
+        try {
+            for (const key of Object.keys(filters)) {
+                bounded(key, 'filterKey');
+            }
+        }
+        catch (error) {
+            if (error instanceof VictControlError) {
+                throw error;
+            }
+            throw new VictControlError('VICT_APPDATA_FILTER_INVALID', 'The filter container could not be read safely.');
+        }
+    }
+    // Hostile containers (throwing getters/proxies) are contained at this
+    // boundary: any downstream throw collapses to the stable structured
+    // error — raw hostile content never echoes.
+    try {
+        return await options.data.query({
+            kind: 'query',
+            resourceId,
+            releaseVersion,
+            actorId: actor.actorId,
+            ...(filters !== undefined ? { filters } : {}),
+        });
+    }
+    catch (error) {
+        if (error instanceof VictControlError) {
+            throw error;
+        }
+        throw new VictControlError('VICT_APPDATA_FILTER_INVALID', 'The query could not be processed safely.');
+    }
+}
+/** The remote resource mutation boundary. */
+export async function remoteMutate(actor, options, input) {
+    const resourceId = bounded(input.resourceId, 'resourceId');
+    const releaseVersion = bounded(input.releaseVersion, 'releaseVersion');
+    const expectedRevision = bounded(input.expectedRevision ?? '0', 'expectedRevision');
+    if (options.expectedReleaseVersion !== undefined &&
+        releaseVersion !== options.expectedReleaseVersion) {
+        throw new VictControlError('VICT_APPDATA_RELEASE_STALE', 'The declared release binding does not match the currently selected release.');
+    }
+    const actionKind = bounded(input.actionKind ?? 'mutation', 'actionKind', 32);
+    if (actionKind === 'local') {
+        // Local/view actions are CLIENT-LOCAL by definition and can never be
+        // dispatched through the server boundary.
+        throw new VictControlError('VICT_APPDATA_LOCAL_ACTION_DENIED', 'Local view actions are client-local and cannot be dispatched remotely.');
+    }
+    try {
+        return await options.data.mutate({
+            kind: 'mutate',
+            resourceId,
+            releaseVersion,
+            actorId: actor.actorId,
+            expectedRevision,
+            actionKind,
+        });
+    }
+    catch (error) {
+        if (error instanceof VictControlError) {
+            throw error;
+        }
+        throw new VictControlError('VICT_APPDATA_FILTER_INVALID', 'The mutation could not be processed safely.');
+    }
+}
+/** The VICT-action boundary (governed Vict actions through the same server authorization). */
+export async function remoteAction(actor, options, input) {
+    const actionKind = bounded(input.actionKind, 'actionKind', 32);
+    if (actionKind === 'local') {
+        throw new VictControlError('VICT_APPDATA_LOCAL_ACTION_DENIED', 'Local view actions are client-local and cannot be dispatched remotely.');
+    }
+    if (actionKind === 'query' || actionKind === 'mutation') {
+        return actionKind === 'query'
+            ? remoteQuery(actor, options, input)
+            : remoteMutate(actor, options, input);
+    }
+    // capability / signal / navigation actions must reference their exact
+    // declared identities; the composition supplies the authorized handler.
+    throw new VictControlError('VICT_APPDATA_ACTION_UNAVAILABLE', 'The declared action kind is not composed in this deployment.');
+}
+//# sourceMappingURL=app-remote.js.map

package/dist/app-remote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-remote.js","sourceRoot":"","sources":["../src/app-remote.ts"],"names":[],"mappings":"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"}

package/dist/auth.d.ts

@@ -0,0 +1,53 @@
+import { type ActorDirectory, type AuthenticatedActorContext } from '@victframework/runtime';
+/**
+ * Stage 06B — the authenticated actor boundary (SEC-001, MSTR-007).
+ *
+ * Authentication and authorization remain DISTINCT: the authenticator only
+ * establishes WHO the caller is; scope checks happen below the transport in
+ * `@victframework/control` and every command handler. Client-supplied actor ids,
+ * roles, scopes, and the Mastra memory identity are NEVER authoritative —
+ * the authoritative context is derived ONLY from the server-side actor
+ * directory.
+ *
+ * A deterministic local test authenticator is provided; no production
+ * identity-provider integration is claimed.
+ */
+/** Stable, non-echoing authentication failure codes. */
+export type AuthErrorCode = 'VICT_AUTH_TOKEN_MISSING' | 'VICT_AUTH_TOKEN_UNKNOWN' | 'VICT_AUTH_MALFORMED';
+/** Structured authentication failure (never echoes the presented token). */
+export declare class AuthenticationError extends Error {
+    readonly code: AuthErrorCode;
+    constructor(code: AuthErrorCode);
+}
+/**
+ * The server-side actor context: the ONLY authoritative identity surface.
+ * The Mastra memory identity is derived exclusively from the authenticated
+ * VICT actor (`vict-actor-<actorId>`; MSTR-007).
+ */
+export interface ServerActorContext extends AuthenticatedActorContext {
+    /** Bounded presentation token of the authenticated session (not a secret). */
+    readonly presentedTokenKind: 'local-test';
+}
+/**
+ * The neutral server-side authentication port. Implementations resolve a
+ * transport credential to ONE actor id; the directory supplies the record
+ * and the context derivation fails closed on unknown, disabled, malformed,
+ * or mismatched actors.
+ */
+export interface Authenticator {
+    /** Authenticate the transport credential; returns the actor id. */
+    authenticate(token: string | undefined): Promise<string>;
+}
+/**
+ * Deterministic local test authenticator: fixed token → actorId mapping
+ * supplied by operator test configuration. NOT a production identity
+ * provider; the composition boundary is identical to a real one.
+ */
+export declare function createLocalTestAuthenticator(mapping: Readonly<Record<string, string>>): Authenticator;
+/** Compose the authenticator with the authoritative actor directory. */
+export declare function createServerAuthenticator(options: {
+    readonly authenticator: Authenticator;
+    readonly directory: ActorDirectory;
+}): {
+    resolve(token: string | undefined): Promise<ServerActorContext>;
+};

package/dist/auth.js

@@ -0,0 +1,44 @@
+import { authenticatedActorContext, assertControlId, } from '@victframework/runtime';
+/** Structured authentication failure (never echoes the presented token). */
+export class AuthenticationError extends Error {
+    code;
+    constructor(code) {
+        super(`Authentication failed (${code}).`);
+        this.name = 'AuthenticationError';
+        this.code = code;
+    }
+}
+/**
+ * Deterministic local test authenticator: fixed token → actorId mapping
+ * supplied by operator test configuration. NOT a production identity
+ * provider; the composition boundary is identical to a real one.
+ */
+export function createLocalTestAuthenticator(mapping) {
+    // Tokens must be bounded plain strings; hostile inputs fail closed as
+    // unknown tokens (never echoed).
+    return {
+        async authenticate(token) {
+            if (typeof token !== 'string' || token.length === 0 || token.length > 256) {
+                throw new AuthenticationError('VICT_AUTH_TOKEN_MISSING');
+            }
+            const actorId = mapping[token];
+            if (actorId === undefined || typeof actorId !== 'string') {
+                throw new AuthenticationError('VICT_AUTH_TOKEN_UNKNOWN');
+            }
+            return actorId;
+        },
+    };
+}
+/** Compose the authenticator with the authoritative actor directory. */
+export function createServerAuthenticator(options) {
+    return {
+        async resolve(token) {
+            const actorId = await options.authenticator.authenticate(token);
+            assertControlId(actorId, 'actorId');
+            const actor = await options.directory.get(actorId);
+            const context = authenticatedActorContext(actor, actorId);
+            return { ...context, presentedTokenKind: 'local-test' };
+        },
+    };
+}
+//# sourceMappingURL=auth.js.map

package/dist/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,eAAe,GAIhB,MAAM,wBAAwB,CAAC;AAoBhC,4EAA4E;AAC5E,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnC,IAAI,CAAgB;IAC7B,YAAY,IAAmB;QAC7B,KAAK,CAAC,0BAA0B,IAAI,IAAI,CAAC,CAAC;QAC1C,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAuBD;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAC1C,OAAyC;IAEzC,sEAAsE;IACtE,iCAAiC;IACjC,OAAO;QACL,KAAK,CAAC,YAAY,CAAC,KAAK;YACtB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;gBAC1E,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;YAC3D,CAAC;YACD,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;YAC/B,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;gBACzD,MAAM,IAAI,mBAAmB,CAAC,yBAAyB,CAAC,CAAC;YAC3D,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,yBAAyB,CAAC,OAGzC;IACC,OAAO;QACL,KAAK,CAAC,OAAO,CAAC,KAAyB;YACrC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAChE,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;YACpC,MAAM,KAAK,GAA4B,MAAM,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAC5E,MAAM,OAAO,GAAG,yBAAyB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC1D,OAAO,EAAE,GAAG,OAAO,EAAE,kBAAkB,EAAE,YAAqB,EAAE,CAAC;QACnE,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/commands.d.ts

@@ -0,0 +1,192 @@
+import type { AgentControlStores, ControlAuditEvent } from '@victframework/runtime';
+import type { ServerActorContext } from './auth.js';
+/**
+ * Stage 06B — the transport-free, versioned command service (API-002).
+ *
+ * The HTTP transport and the CLI consume the SAME typed dispatcher; no
+ * caller bypasses governance. Properties enforced HERE (below the
+ * transport, fail closed):
+ *
+ * - ONE command registry: authorization scope, closed payload field set,
+ *   and the mutation/idempotency policy are declared TOGETHER per command,
+ *   so the command list, the scope matrix, and the mutation list cannot
+ *   silently diverge;
+ * - AUTHORIZATION MATRIX: every command's required scope is asserted from
+ *   the closed scope vocabulary BEFORE any store access;
+ * - CLOSED PAYLOAD SCHEMAS: unknown fields and non-object payloads are
+ *   rejected (never silently converted to `{}`); payloads are canonicalized
+ *   ONCE into plain data (own enumerable properties only — accessors,
+ *   proxies that throw, and enumeration traps fail with a stable,
+ *   non-echoing error) and that SAME canonical form is used for the
+ *   request digest and for execution;
+ * - DURABLE COMMAND IDEMPOTENCY: every state-changing command requires a
+ *   bounded `Idempotency-Key`; receipts are NAMESPACED by (authenticated
+ *   actor, command, key) and bind the canonical request digest. A pending
+ *   receipt carries a durable LEASE (owner + expiry): concurrent
+ *   duplicates answer `IN_PROGRESS`, a crashed claim's expired lease is
+ *   taken over on retry (fenced re-execution through the domain's own
+ *   idempotency), deterministic failures settle `failed` and replay, and
+ *   retryable infrastructure failures RELEASE the claim instead of being
+ *   permanently confused with command failure;
+ * - SAFE RECEIPT RETENTION: receipts store a per-command SAFE replay
+ *   projection (stable codes, identifiers, content references) — never the
+ *   full command response, rationale, application rows, model content, or
+ *   tool data. An authorized replay result is reconstructed from its
+ *   authoritative domain when necessary;
+ * - stable, structured, non-echoing errors.
+ */
+/** The versioned command envelope marker. */
+export declare const VICT_COMMAND_SCHEMA = "vict.command@1";
+/** Closed command names (version 1). */
+export declare const VICT_COMMANDS: readonly ["health.inspect", "compatibility.inspect", "actor.whoami", "changeset.propose", "changeset.revise", "changeset.execute-check", "changeset.attach-evidence", "changeset.decide", "changeset.commit", "changeset.get", "changeset.list", "release.publish", "release.select", "release.rollback", "release.get-selected", "activation.select", "run.cancel", "agent.turn.start", "agent.turn.cancel", "agent.turn.get", "agent.tool.approve", "agent.tool.decline", "stream.inspect", "app.data.query", "app.data.mutate", "app.data.action"];
+export type VictCommandName = (typeof VICT_COMMANDS)[number];
+/**
+ * True when the command mutates durable state (idempotency-governed).
+ * Derived from the ONE registry — the mutation policy can never silently
+ * diverge from the command list.
+ */
+export declare function isMutationCommand(command: string): boolean;
+/** A closed, versioned command request. */
+export interface VictCommandRequest {
+    readonly command: VictCommandName;
+    /** Bounded, command-specific payload (validated per command below). */
+    readonly payload: Record<string, unknown>;
+    /**
+     * Durable mutation idempotency key (REQUIRED for state-changing
+     * commands; validated against the closed bounded format).
+     */
+    readonly idempotencyKey?: string;
+}
+/** A safe command result. */
+export interface VictCommandResult {
+    readonly ok: true;
+    readonly data: Record<string, unknown>;
+}
+/** A structured command error (safe, non-echoing). */
+export interface VictCommandError {
+    readonly ok: false;
+    readonly code: string;
+}
+export type VictCommandOutcome = VictCommandResult | VictCommandError;
+export interface VictCommandServiceOptions {
+    readonly stores: AgentControlStores;
+    /** The composed control-plane service (ChangeSets/releases/audit). */
+    readonly controlPlane: ControlPlanePort;
+    /** The composed agent-turn service (optional in governance-only deployments). */
+    readonly turnService?: TurnServiceLike;
+    readonly clock?: () => number;
+    /** The remote Application data/action boundary. */
+    readonly appData?: AppDataPort;
+    /**
+     * Durable lease duration for pending idempotency claims (default
+     * 60_000 ms). A crashed claimer's lease expires and the key becomes
+     * recoverable.
+     */
+    readonly idempotencyLeaseMs?: number;
+    /** The lease owner token (defaults to a per-service instance token). */
+    readonly idempotencyOwner?: string;
+}
+/** The subset of AgentTurnService the dispatcher uses. */
+export interface TurnServicePort {
+    startTurn(actor: ServerActorContext, input: {
+        threadId: string;
+        input: string;
+    }): Promise<unknown>;
+    cancelTurn(actor: ServerActorContext, input: {
+        turnId: string;
+        reasonCode?: string;
+    }): Promise<unknown>;
+    getTurn(actor: ServerActorContext, turnId: string): Promise<unknown>;
+    decideToolApproval(actor: ServerActorContext, input: {
+        approvalId: string;
+        decision: 'approved' | 'declined';
+        reason?: string;
+    }): Promise<unknown>;
+    reconcileAfterRestart(): Promise<{
+        cancelled: number;
+        failed: number;
+        pendingApprovals: number;
+    }>;
+}
+type TurnServiceLike = TurnServicePort;
+/**
+ * The remote Application data/action port (Stage 05 adapter semantics
+ * preserved: typed resource queries and mutations across the SAME server
+ * authorization boundary). Implemented in `app-remote.ts`.
+ */
+export interface AppDataPort {
+    query(actor: ServerActorContext, input: Record<string, unknown>): Promise<unknown>;
+    mutate(actor: ServerActorContext, input: Record<string, unknown>): Promise<unknown>;
+}
+/**
+ * The versioned command dispatcher: transport-free and shared by HTTP and
+ * the CLI. Every command re-derives its authorization from the
+ * authenticated server context (never from the payload) and mutates only
+ * through the durable idempotency policy.
+ */
+export declare class VictCommandService {
+    #private;
+    constructor(options: VictCommandServiceOptions);
+    /** Dispatch one command (closed schemas; durable idempotency; safe errors). */
+    dispatch(actor: ServerActorContext, request: VictCommandRequest): Promise<VictCommandOutcome>;
+}
+/** The ControlPlanePort: the control-plane surface the server composes. */
+export interface ControlPlanePort {
+    propose(actor: ServerActorContext, input: {
+        changesetId: string;
+        base: {
+            kind: 'activation' | 'release';
+            subjectId: string;
+            expectedVersion: string;
+        };
+        operations: readonly unknown[];
+        rationale: string;
+        riskClass: 'low' | 'medium' | 'high';
+        requiredApproverCount: number;
+        expiresAt: number;
+    }): Promise<unknown>;
+    revise(actor: ServerActorContext, input: Record<string, unknown>): Promise<unknown>;
+    executeChangeSetCheck(actor: ServerActorContext, input: {
+        changesetId: string;
+        kind: 'validation' | 'simulation';
+    }): Promise<unknown>;
+    attachValidationEvidence(actor: ServerActorContext, input: {
+        changesetId: string;
+        runId: string;
+    }): Promise<unknown>;
+    attachSimulationEvidence(actor: ServerActorContext, input: {
+        changesetId: string;
+        runId: string;
+    }): Promise<unknown>;
+    decide(actor: ServerActorContext, input: {
+        changesetId: string;
+        decision: 'approved' | 'declined';
+    }): Promise<unknown>;
+    commit(actor: ServerActorContext, input: {
+        changesetId: string;
+    }): Promise<unknown>;
+    decline(actor: ServerActorContext, input: {
+        changesetId: string;
+    }): Promise<unknown>;
+    get(actor: ServerActorContext, changesetId: string): Promise<unknown>;
+    list(actor: ServerActorContext): Promise<unknown>;
+    publishRelease(actor: ServerActorContext, content: Record<string, unknown>): Promise<unknown>;
+    selectRelease(actor: ServerActorContext, input: Record<string, unknown>): Promise<unknown>;
+    rollbackRelease(actor: ServerActorContext, input: Record<string, unknown>): Promise<unknown>;
+    getSelectedRelease(actor: ServerActorContext, applicationId: string): Promise<unknown>;
+    auditTrail(subject: {
+        subjectType?: string;
+        subjectId?: string;
+    }): Promise<readonly ControlAuditEvent[]>;
+    selectActivation(actor: ServerActorContext, input: {
+        graphId: string;
+        activationVersion: string;
+    }): Promise<unknown>;
+    cancelRun?(input: {
+        runId: string;
+        actorId: string;
+        requestId: string;
+        reasonCode: string;
+    }): Promise<unknown>;
+}
+export {};