@wardby/cli 0.1.0

package/dist/mcp/auth/self-hosted/cli.d.ts

@@ -0,0 +1,2 @@
+import type { PrismaClient } from "@prisma/client";
+export declare function authCommand(args: string[], db: PrismaClient, hashKey: string, output?: (value: string) => void): Promise<void>;

package/dist/mcp/auth/self-hosted/cli.js

@@ -0,0 +1,39 @@
+import { parseArgs } from "node:util";
+import { IdentityService } from "./credentials.js";
+export async function authCommand(args, db, hashKey, output = console.log) {
+    const [kind, action, ...rest] = args;
+    const service = new IdentityService(db, hashKey);
+    if (hashKey.toLowerCase() === process.env.SECRET_APP_KEY?.toLowerCase() ||
+        hashKey.toLowerCase() === process.env.AUTH_SIGNING_KEY?.toLowerCase())
+        throw new Error("Authentication keys must be independent.");
+    if (kind === "key" && action === "revoke" && rest.length === 1) {
+        await service.revokeKey(rest[0]);
+        output("Key, sessions, and grants revoked.");
+        return;
+    }
+    const { values } = parseArgs({ args: rest, options: { subject: { type: "string" } } });
+    if (kind === "user" && action === "list") {
+        output(JSON.stringify(await service.listUsers(), null, 2));
+        return;
+    }
+    if (!values.subject)
+        throw new Error("auth requires --subject (except user list and key revoke <key-id>).");
+    if (kind === "user" && action === "create") {
+        output(JSON.stringify(await service.createUser(values.subject)));
+        return;
+    }
+    if (kind === "user" && action === "disable") {
+        await service.disableUser(values.subject);
+        output("User disabled; credentials, sessions, and grants revoked.");
+        return;
+    }
+    if (kind === "key" && action === "create") {
+        output(await service.createKey(values.subject));
+        return;
+    }
+    if (kind === "key" && action === "list") {
+        output(JSON.stringify(await service.listKeys(values.subject), null, 2));
+        return;
+    }
+    throw new Error("Use auth user create|list|disable or auth key create|list|revoke.");
+}

package/dist/mcp/auth/self-hosted/credentials.d.ts

@@ -0,0 +1,58 @@
+import type { Prisma, PrismaClient } from "@prisma/client";
+export type AuthDb = Prisma.TransactionClient;
+export declare const DAY = 86400000;
+export declare function decodeKey(value: string, name: string): Buffer;
+export declare class Credentials {
+    private readonly key;
+    constructor(value: string);
+    hash(value: string): string;
+    create(prefix: string): {
+        id: `${string}-${string}-${string}-${string}-${string}`;
+        token: string;
+        hash: string;
+    };
+    id(token: string, prefix: string): string | undefined;
+    matches(token: string, hash: string | undefined): boolean;
+}
+export declare function lockUser(tx: AuthDb, id: string): Promise<{
+    principal: {
+        id: string;
+        createdAt: Date;
+        subject: string;
+    };
+} & {
+    status: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    principalId: string;
+    displayName: string | null;
+}>;
+export declare class IdentityService {
+    readonly db: PrismaClient;
+    readonly credentials: Credentials;
+    constructor(db: PrismaClient, hashKey: string);
+    createUser(subject: string): Promise<{
+        userId: string;
+        subject: string;
+        loginKey: string;
+    }>;
+    createKey(subject: string): Promise<string>;
+    disableUser(subject: string): Promise<void>;
+    revokeKey(keyId: string): Promise<void>;
+    listUsers(): Prisma.PrismaPromise<{
+        status: string;
+        principal: {
+            subject: string;
+        };
+        id: string;
+        displayName: string | null;
+    }[]>;
+    listKeys(subject: string): Prisma.PrismaPromise<{
+        createdAt: Date;
+        keyId: string;
+        lastUsedAt: Date | null;
+        expiresAt: Date;
+        revokedAt: Date | null;
+    }[]>;
+}

package/dist/mcp/auth/self-hosted/credentials.js

@@ -0,0 +1,106 @@
+import { createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { requireSubject } from "../../../providers/auth/subject.js";
+export const DAY = 86_400_000;
+export function decodeKey(value, name) {
+    if (!/^[a-f\d]{64}$/i.test(value))
+        throw new Error(`${name} must be 32 random bytes encoded as 64 hex characters.`);
+    return Buffer.from(value, "hex");
+}
+export class Credentials {
+    key;
+    constructor(value) {
+        this.key = decodeKey(value, "AUTH_CREDENTIAL_HASH_KEY");
+    }
+    hash(value) {
+        return createHmac("sha256", this.key).update(value).digest("hex");
+    }
+    create(prefix) {
+        const id = randomUUID();
+        const token = `${prefix}_${id}.${randomBytes(32).toString("base64url")}`;
+        return { id, token, hash: this.hash(token) };
+    }
+    id(token, prefix) {
+        const match = new RegExp(`^${prefix}_([a-f0-9-]{36})\\.([A-Za-z0-9_-]{43})$`).exec(token);
+        return match?.[1];
+    }
+    matches(token, hash) {
+        const expected = hash && /^[a-f\d]{64}$/i.test(hash) ? Buffer.from(hash, "hex") : Buffer.alloc(32);
+        return timingSafeEqual(Buffer.from(this.hash(token), "hex"), expected) && !!hash;
+    }
+}
+export async function lockUser(tx, id) {
+    await tx.$queryRaw `SELECT "id" FROM "AuthUser" WHERE "id" = ${id} FOR UPDATE`;
+    const user = await tx.authUser.findUnique({ where: { id }, include: { principal: true } });
+    if (!user || user.status !== "enabled")
+        throw new Error("Invalid credentials.");
+    requireSubject(user.principal.subject);
+    return user;
+}
+export class IdentityService {
+    db;
+    credentials;
+    constructor(db, hashKey) {
+        this.db = db;
+        this.credentials = new Credentials(hashKey);
+    }
+    async createUser(subject) {
+        requireSubject(subject);
+        return this.db.$transaction(async (tx) => {
+            const principal = await tx.principal.upsert({ where: { subject }, create: { subject }, update: {} });
+            const user = await tx.authUser.create({ data: { principalId: principal.id } });
+            const key = this.credentials.create("rvk");
+            await tx.authLoginKey.create({
+                data: { keyId: key.id, userId: user.id, secretHash: key.hash, expiresAt: new Date(Date.now() + 365 * DAY) },
+            });
+            return { userId: user.id, subject, loginKey: key.token };
+        });
+    }
+    async createKey(subject) {
+        const user = await this.db.authUser.findFirst({ where: { principal: { subject: requireSubject(subject) } } });
+        if (!user)
+            throw new Error("Unknown user.");
+        return this.db.$transaction(async (tx) => {
+            await lockUser(tx, user.id);
+            const key = this.credentials.create("rvk");
+            await tx.authLoginKey.create({
+                data: { keyId: key.id, userId: user.id, secretHash: key.hash, expiresAt: new Date(Date.now() + 365 * DAY) },
+            });
+            return key.token;
+        });
+    }
+    async disableUser(subject) {
+        const user = await this.db.authUser.findFirst({ where: { principal: { subject: requireSubject(subject) } } });
+        if (!user)
+            throw new Error("Unknown user.");
+        await this.db.$transaction(async (tx) => {
+            await tx.$queryRaw `SELECT "id" FROM "AuthUser" WHERE "id" = ${user.id} FOR UPDATE`;
+            const now = new Date();
+            await tx.authUser.update({ where: { id: user.id }, data: { status: "disabled" } });
+            await tx.authLoginKey.updateMany({ where: { userId: user.id }, data: { revokedAt: now } });
+            await tx.authSession.updateMany({ where: { userId: user.id }, data: { revokedAt: now } });
+            await tx.oAuthFamily.updateMany({ where: { userId: user.id }, data: { revokedAt: now } });
+        });
+    }
+    async revokeKey(keyId) {
+        const key = await this.db.authLoginKey.findUnique({ where: { keyId } });
+        if (!key)
+            return;
+        await this.db.$transaction(async (tx) => {
+            await tx.$queryRaw `SELECT "id" FROM "AuthUser" WHERE "id" = ${key.userId} FOR UPDATE`;
+            await tx.authLoginKey.update({ where: { keyId }, data: { revokedAt: new Date() } });
+            await tx.authSession.updateMany({ where: { userId: key.userId }, data: { revokedAt: new Date() } });
+            await tx.oAuthFamily.updateMany({ where: { userId: key.userId }, data: { revokedAt: new Date() } });
+        });
+    }
+    listUsers() {
+        return this.db.authUser.findMany({
+            select: { id: true, status: true, displayName: true, principal: { select: { subject: true } } },
+        });
+    }
+    listKeys(subject) {
+        return this.db.authLoginKey.findMany({
+            where: { user: { principal: { subject: requireSubject(subject) } } },
+            select: { keyId: true, createdAt: true, expiresAt: true, lastUsedAt: true, revokedAt: true },
+        });
+    }
+}

package/dist/mcp/auth/self-hosted/rate-limit.d.ts

@@ -0,0 +1,13 @@
+import type { PrismaClient } from "@prisma/client";
+import type { Credentials } from "./credentials.js";
+export interface RateLimiter {
+    check(bucket: string, identity: string, limit: number): Promise<void>;
+}
+export declare class RateLimitError extends Error {
+}
+export declare class PostgresRateLimiter implements RateLimiter {
+    private db;
+    private credentials;
+    constructor(db: PrismaClient, credentials: Credentials);
+    check(bucket: string, identity: string, limit: number): Promise<void>;
+}

package/dist/mcp/auth/self-hosted/rate-limit.js

@@ -0,0 +1,20 @@
+export class RateLimitError extends Error {
+}
+export class PostgresRateLimiter {
+    db;
+    credentials;
+    constructor(db, credentials) {
+        this.db = db;
+        this.credentials = credentials;
+    }
+    async check(bucket, identity, limit) {
+        const window = Math.floor(Date.now() / 60_000);
+        const key = this.credentials.hash(`${bucket}:${identity}:${window}`);
+        const expires = new Date((window + 2) * 60_000);
+        const rows = await this.db.$queryRaw `
+      INSERT INTO "AuthRateLimit" ("key", "hits", "expiresAt") VALUES (${key}, 1, ${expires})
+      ON CONFLICT ("key") DO UPDATE SET "hits" = "AuthRateLimit"."hits" + 1 RETURNING "hits"`;
+        if (rows[0].hits > limit)
+            throw new RateLimitError("Rate limited.");
+    }
+}

package/dist/mcp/auth/self-hosted/session.d.ts

@@ -0,0 +1,36 @@
+import type { PrismaClient } from "@prisma/client";
+import type { Credentials } from "./credentials.js";
+import { type AuthDb } from "./credentials.js";
+export declare class Sessions {
+    readonly db: PrismaClient;
+    readonly credentials: Credentials;
+    constructor(db: PrismaClient, credentials: Credentials);
+    challenge(purpose: "login" | "consent" | "logout", sessionId: string | null, binding: string): Promise<string>;
+    consumeChallenge(tx: AuthDb, token: string, purpose: string, sessionId: string | null, binding: string): Promise<void>;
+    login(loginKey: string, challenge: string, binding: string, previousSession?: string): Promise<string>;
+    get(token: string, tx?: AuthDb): Promise<{
+        user: {
+            principal: {
+                id: string;
+                createdAt: Date;
+                subject: string;
+            };
+        } & {
+            status: string;
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            principalId: string;
+            displayName: string | null;
+        };
+    } & {
+        createdAt: Date;
+        userId: string;
+        secretHash: string;
+        expiresAt: Date;
+        revokedAt: Date | null;
+        sessionId: string;
+        lastSeenAt: Date;
+    }>;
+    logout(token: string, challenge: string): Promise<void>;
+}

package/dist/mcp/auth/self-hosted/session.js

@@ -0,0 +1,110 @@
+import { DAY, lockUser } from "./credentials.js";
+export class Sessions {
+    db;
+    credentials;
+    constructor(db, credentials) {
+        this.db = db;
+        this.credentials = credentials;
+    }
+    async challenge(purpose, sessionId, binding) {
+        const challenge = this.credentials.create("rvc");
+        await this.db.authFormChallenge.create({
+            data: {
+                challengeId: challenge.id,
+                sessionId,
+                purpose,
+                binding: this.credentials.hash(binding),
+                secretHash: challenge.hash,
+                expiresAt: new Date(Date.now() + 600_000),
+            },
+        });
+        return challenge.token;
+    }
+    async consumeChallenge(tx, token, purpose, sessionId, binding) {
+        const id = this.credentials.id(token, "rvc");
+        if (!id)
+            throw new Error("Invalid form challenge.");
+        const row = await tx.authFormChallenge.findUnique({ where: { challengeId: id } });
+        if (!this.credentials.matches(token, row?.secretHash))
+            throw new Error("Invalid form challenge.");
+        const result = await tx.authFormChallenge.updateMany({
+            where: {
+                challengeId: id,
+                purpose,
+                sessionId,
+                binding: this.credentials.hash(binding),
+                consumedAt: null,
+                expiresAt: { gt: new Date() },
+            },
+            data: { consumedAt: new Date() },
+        });
+        if (result.count !== 1)
+            throw new Error("Invalid form challenge.");
+    }
+    async login(loginKey, challenge, binding, previousSession) {
+        // A failed credential attempt still consumes its challenge.
+        await this.consumeChallenge(this.db, challenge, "login", null, binding);
+        const keyId = this.credentials.id(loginKey, "rvk");
+        const key = keyId ? await this.db.authLoginKey.findUnique({ where: { keyId } }) : null;
+        if (!this.credentials.matches(loginKey, key?.secretHash) || !key)
+            throw new Error("Invalid credentials.");
+        return this.db.$transaction(async (tx) => {
+            await lockUser(tx, key.userId);
+            const valid = await tx.authLoginKey.updateMany({
+                where: { keyId: key.keyId, revokedAt: null, expiresAt: { gt: new Date() } },
+                data: { lastUsedAt: new Date() },
+            });
+            if (valid.count !== 1)
+                throw new Error("Invalid credentials.");
+            if (previousSession) {
+                const previousId = this.credentials.id(previousSession, "rvs");
+                if (previousId)
+                    await tx.authSession.updateMany({
+                        where: { sessionId: previousId, secretHash: this.credentials.hash(previousSession) },
+                        data: { revokedAt: new Date() },
+                    });
+            }
+            const session = this.credentials.create("rvs");
+            await tx.authSession.create({
+                data: {
+                    sessionId: session.id,
+                    userId: key.userId,
+                    secretHash: session.hash,
+                    expiresAt: new Date(Date.now() + 30 * DAY),
+                },
+            });
+            return session.token;
+        });
+    }
+    async get(token, tx = this.db) {
+        const sessionId = this.credentials.id(token, "rvs");
+        if (!sessionId)
+            throw new Error("Invalid session.");
+        const session = await tx.authSession.findUnique({
+            where: { sessionId },
+            include: { user: { include: { principal: true } } },
+        });
+        if (!session || !this.credentials.matches(token, session.secretHash) || session.user.status !== "enabled")
+            throw new Error("Invalid session.");
+        const now = new Date();
+        const live = await tx.authSession.updateMany({
+            where: {
+                sessionId,
+                revokedAt: null,
+                expiresAt: { gt: now },
+                lastSeenAt: { gt: new Date(now.getTime() - DAY / 2) },
+            },
+            data: { lastSeenAt: now },
+        });
+        if (live.count !== 1)
+            throw new Error("Invalid session.");
+        return session;
+    }
+    async logout(token, challenge) {
+        await this.db.$transaction(async (tx) => {
+            const session = await this.get(token, tx);
+            await this.consumeChallenge(tx, challenge, "logout", session.sessionId, "logout");
+            await tx.authSession.update({ where: { sessionId: session.sessionId }, data: { revokedAt: new Date() } });
+        });
+    }
+}

package/dist/mcp/capabilities.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tasks extension identity + per-request client-capability inspection.
+ * `io.modelcontextprotocol/tasks` capabilities have no settings of their
+ * own (an empty object means "supported"), per the extension's own spec.
+ */
+export declare const TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
+export interface ClientCapabilitiesLike {
+    extensions?: Record<string, unknown>;
+}
+/** Whether a request's declared client capabilities include the Tasks extension. */
+export declare function clientSupportsTasks(clientCapabilities: ClientCapabilitiesLike | undefined): boolean;

package/dist/mcp/capabilities.js

@@ -0,0 +1,10 @@
+/**
+ * Tasks extension identity + per-request client-capability inspection.
+ * `io.modelcontextprotocol/tasks` capabilities have no settings of their
+ * own (an empty object means "supported"), per the extension's own spec.
+ */
+export const TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
+/** Whether a request's declared client capabilities include the Tasks extension. */
+export function clientSupportsTasks(clientCapabilities) {
+    return Boolean(clientCapabilities?.extensions?.[TASKS_EXTENSION_ID]);
+}

package/dist/mcp/context.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Per-request context every MCP tool handler receives: who's calling
+ * (principal + granted scopes) and what they can call into. Narrowed to
+ * the seams Phase 4's tool modules actually touch (llm/engine/datastore/
+ * secrets/executor/memory) — same `Pick<ProviderRegistry, ...>` narrowing
+ * this codebase already uses for `executeRun`/`RunnerDb`, since the full
+ * registry also carries jobs/email/auth/storage seams no Phase 4 tool
+ * needs and this plan never builds real adapters for.
+ */
+import type { Principal, PrismaClient } from "@prisma/client";
+import type { RequestStateAccessor } from "@modelcontextprotocol/server";
+import type { ProviderRegistry } from "../providers/index.js";
+export type McpProviders = Pick<ProviderRegistry, "llm" | "engine" | "datastore" | "secrets" | "executor" | "memory">;
+export interface McpRequestContext {
+    principal: Principal;
+    scopes: Set<string>;
+    /**
+     * The server's resource identifier, for tool handlers that need a
+     * field-level scope step-up beyond the tool's own declared scope (e.g.
+     * requiring agents:admin only when a mutation touches workerImageRef).
+     * Passed to requireScope the same way WardbyMcpServer does centrally.
+     */
+    canonicalUri: string;
+    providers: McpProviders;
+    db: PrismaClient;
+    /**
+     * The current call's multi-round-trip data (protocol revision 2026-07-28)
+     * — present on every call so a tool can tell an initial call from a
+     * retried one. `inputResponses` is only populated on a retry;
+     * `requestState()` returns the verified payload minted by
+     * `WardbyMcpServer.mintRequestState` on a prior round, or `undefined` on
+     * an initial call. See src/mcp/tools/secrets.ts for the one current user.
+     */
+    mcpReq: {
+        inputResponses?: Record<string, unknown>;
+        requestState: RequestStateAccessor;
+    };
+    /**
+     * Whether THIS call's client declared the Tasks extension
+     * (io.modelcontextprotocol/tasks) — read from the modern-era per-request
+     * `_meta` envelope (`ctx.mcpReq.envelope.clientCapabilities`). A legacy
+     * (2025-era) client carries no envelope at all and is therefore always
+     * `false` here — Tasks is a 2026-07-28-only concept.
+     */
+    clientSupportsTasks: boolean;
+}

package/dist/mcp/context.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP-layer errors that carry an HTTP status + WWW-Authenticate challenge —
+ * the transport (Task 7) maps these to the actual HTTP response; JSON-RPC
+ * dispatch (Task 6) maps them to a JSON-RPC error object. One error type
+ * for both call sites avoids two parallel error hierarchies.
+ */
+export declare class McpError extends Error {
+    readonly httpStatus: number;
+    readonly wwwAuthenticate?: string;
+    constructor(httpStatus: number, message: string, wwwAuthenticate?: string);
+}
+export declare function unauthorized(message: string, resourceMetadataUrl: string): McpError;
+export declare function insufficientScope(scopes: string[], resourceMetadataUrl: string): McpError;

package/dist/mcp/errors.js

@@ -0,0 +1,22 @@
+/**
+ * MCP-layer errors that carry an HTTP status + WWW-Authenticate challenge —
+ * the transport (Task 7) maps these to the actual HTTP response; JSON-RPC
+ * dispatch (Task 6) maps them to a JSON-RPC error object. One error type
+ * for both call sites avoids two parallel error hierarchies.
+ */
+export class McpError extends Error {
+    httpStatus;
+    wwwAuthenticate;
+    constructor(httpStatus, message, wwwAuthenticate) {
+        super(message);
+        this.name = "McpError";
+        this.httpStatus = httpStatus;
+        this.wwwAuthenticate = wwwAuthenticate;
+    }
+}
+export function unauthorized(message, resourceMetadataUrl) {
+    return new McpError(401, message, `Bearer resource_metadata="${resourceMetadataUrl}"`);
+}
+export function insufficientScope(scopes, resourceMetadataUrl) {
+    return new McpError(403, `Insufficient scope; this operation requires: ${scopes.join(" ")}`, `Bearer resource_metadata="${resourceMetadataUrl}", scope="${scopes.join(" ")}"`);
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,32 @@
+import { type WardbyMcpServer } from "./server.js";
+import type { McpProviders } from "./context.js";
+import { type SecretElicitationUrlBuilder } from "./tools/secrets.js";
+/** Registers the full Phase 4 tool surface — every module, in one place. */
+export declare function registerAllTools(mcp: WardbyMcpServer, opts: {
+    secretElicitationUrl: SecretElicitationUrlBuilder;
+    secretElicitationProtocol: boolean;
+}): void;
+export interface McpProviderComposition {
+    providers: McpProviders;
+}
+/** Builds the real provider set (LLM/engine/datastore/secrets/executor) — shared by both transports. */
+export declare function buildMcpProviders(): McpProviderComposition;
+/** Handle returned by `startMcp()` — closes the running transport, then the executor. */
+export interface McpServerHandle {
+    close(): Promise<void>;
+}
+export interface StartMcpOptions {
+    /**
+     * A pre-built provider set. `wardby serve` builds one and shares it, because
+     * DbosExecutor is a per-process singleton and two executors cannot coexist
+     * (dbos.ts launch()). Built internally when omitted.
+     */
+    providers?: McpProviders;
+    /**
+     * Set by a composition root that also runs the scheduler, so startup does
+     * not warn that enabled schedules will never fire.
+     */
+    schedulerAttached?: boolean;
+}
+/** The real CLI entry point: `wardby mcp`. Reads config from the environment, starts stdio or HTTP per MCP_TRANSPORT. */
+export declare function startMcp(options?: StartMcpOptions): Promise<McpServerHandle>;