@remit/mcp-server 0.0.0-stage → 0.1.1

package/dist/auth/scopes.d.ts

@@ -0,0 +1,6 @@
+import type { McpPermission } from "@remit/ui/mcp-pages";
+export declare const MCP_READ_SCOPE = "mail:read";
+export declare const MCP_RULES_SCOPE = "mail:rules";
+export declare const OFFLINE_ACCESS_SCOPE = "offline_access";
+export declare const MCP_SCOPES: readonly ["mail:read", "mail:rules"];
+export declare const describeScopes: (scopes: readonly string[]) => McpPermission[];

package/dist/auth/scopes.js

@@ -0,0 +1,13 @@
+export const MCP_READ_SCOPE = "mail:read";
+export const MCP_RULES_SCOPE = "mail:rules";
+export const OFFLINE_ACCESS_SCOPE = "offline_access";
+export const MCP_SCOPES = [MCP_READ_SCOPE, MCP_RULES_SCOPE];
+const SCOPE_DESCRIPTIONS = {
+    [MCP_READ_SCOPE]: "Read your mail",
+    [MCP_RULES_SCOPE]: "Create and change folders and filters",
+    [OFFLINE_ACCESS_SCOPE]: "Stay connected until you disconnect it",
+};
+export const describeScopes = (scopes) => scopes.map((scope) => ({
+    scope,
+    description: SCOPE_DESCRIPTIONS[scope] ?? `Use the "${scope}" permission`,
+}));

package/dist/auth/token-verifier.d.ts

@@ -0,0 +1,11 @@
+import type { McpPrincipal } from "../server.js";
+export type TokenVerification = {
+    ok: true;
+    principal: McpPrincipal;
+} | {
+    ok: false;
+    reason: string;
+};
+export interface TokenVerifier {
+    verify(bearer: string): Promise<TokenVerification>;
+}

package/dist/auth/token-verifier.js

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

package/dist/cli/device-login.d.ts

@@ -0,0 +1,16 @@
+export interface DeviceLoginIo {
+    fetch: typeof fetch;
+    print: (line: string) => void;
+    sleep: (ms: number) => Promise<void>;
+}
+export type DeviceLoginResult = {
+    ok: true;
+    accessToken: string;
+    command: string;
+} | {
+    ok: false;
+    error: string;
+    description: string;
+};
+export declare const claudeMcpAddCommand: (origin: string, accessToken: string) => string;
+export declare const deviceLogin: (origin: string, io: DeviceLoginIo) => Promise<DeviceLoginResult>;

package/dist/cli/device-login.js

@@ -0,0 +1,111 @@
+import { DEVICE_CODE_GRANT_TYPE } from "@better-auth/oauth-provider";
+import { z } from "zod";
+import { MCP_SCOPES } from "../auth/scopes.js";
+const CLIENT_NAME = "remit mcp login";
+const SLOW_DOWN_STEP_SECONDS = 5;
+const metadataSchema = z.object({
+    registration_endpoint: z.string(),
+    device_authorization_endpoint: z.string(),
+    token_endpoint: z.string(),
+});
+const registrationSchema = z.object({ client_id: z.string() });
+const deviceAuthorizationSchema = z.object({
+    device_code: z.string(),
+    user_code: z.string(),
+    verification_uri: z.string(),
+    verification_uri_complete: z.string(),
+    expires_in: z.number(),
+    interval: z.number(),
+});
+const tokenSchema = z.object({ access_token: z.string() });
+const errorSchema = z.object({
+    error: z.string(),
+    error_description: z.string().default(""),
+});
+const read = async (response, schema, step) => {
+    const body = await response.json();
+    if (response.ok) {
+        const parsed = schema.safeParse(body);
+        if (parsed.success)
+            return { ok: true, value: parsed.data };
+        return {
+            ok: false,
+            error: "invalid_response",
+            description: `${step} answered with an unexpected body`,
+        };
+    }
+    const failure = errorSchema.safeParse(body);
+    return failure.success
+        ? {
+            ok: false,
+            error: failure.data.error,
+            description: failure.data.error_description,
+        }
+        : {
+            ok: false,
+            error: "http_error",
+            description: `${step} answered ${response.status}`,
+        };
+};
+export const claudeMcpAddCommand = (origin, accessToken) => `claude mcp add --transport http --header "Authorization: Bearer ${accessToken}" remit ${origin}/mcp`;
+export const deviceLogin = async (origin, io) => {
+    const metadata = await read(await io.fetch(`${origin}/.well-known/oauth-authorization-server`), metadataSchema, "The authorization server metadata");
+    if (!metadata.ok)
+        return metadata;
+    const registration = await read(await io.fetch(metadata.value.registration_endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            client_name: CLIENT_NAME,
+            grant_types: [DEVICE_CODE_GRANT_TYPE],
+            token_endpoint_auth_method: "none",
+        }),
+    }), registrationSchema, "Client registration");
+    if (!registration.ok)
+        return registration;
+    const clientId = registration.value.client_id;
+    const resource = `${origin}/mcp`;
+    const authorization = await read(await io.fetch(metadata.value.device_authorization_endpoint, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            client_id: clientId,
+            scope: MCP_SCOPES.join(" "),
+            resource,
+        }),
+    }), deviceAuthorizationSchema, "The device authorization request");
+    if (!authorization.ok)
+        return authorization;
+    const grant = authorization.value;
+    io.print(`Open ${grant.verification_uri} and enter the code ${grant.user_code}`);
+    io.print(`or go straight to ${grant.verification_uri_complete}`);
+    io.print(`The code expires in ${Math.round(grant.expires_in / 60)} minutes.`);
+    let intervalSeconds = grant.interval;
+    for (;;) {
+        await io.sleep(intervalSeconds * 1000);
+        const polled = await read(await io.fetch(metadata.value.token_endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: DEVICE_CODE_GRANT_TYPE,
+                device_code: grant.device_code,
+                client_id: clientId,
+                resource,
+            }),
+        }), tokenSchema, "The token endpoint");
+        if (polled.ok) {
+            return {
+                ok: true,
+                accessToken: polled.value.access_token,
+                command: claudeMcpAddCommand(origin, polled.value.access_token),
+            };
+        }
+        if (polled.error === "authorization_pending")
+            continue;
+        if (polled.error === "slow_down") {
+            intervalSeconds += SLOW_DOWN_STEP_SECONDS;
+            continue;
+        }
+        return polled;
+    }
+};

package/dist/cli/mcp-login.d.ts

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

package/dist/cli/mcp-login.js

@@ -0,0 +1,21 @@
+import { setTimeout } from "node:timers/promises";
+import { deviceLogin } from "./device-login.js";
+const origin = process.env.MCP_PUBLIC_ORIGIN;
+if (!origin) {
+    process.stderr.write("Missing required env var: MCP_PUBLIC_ORIGIN\n");
+    process.exit(2);
+}
+const result = await deviceLogin(new URL(origin).origin, {
+    fetch,
+    print: (line) => process.stdout.write(`${line}\n`),
+    sleep: (ms) => setTimeout(ms),
+});
+if (!result.ok) {
+    const reasons = {
+        access_denied: "The request was denied on the approval page.",
+        expired_token: "The code expired before it was approved. Run this again.",
+    };
+    process.stderr.write(`Signing in failed: ${reasons[result.error] ?? `${result.error} ${result.description}`}\n`);
+    process.exit(1);
+}
+process.stdout.write(`\nSigned in. Add remit to Claude Code with:\n\n${result.command}\n`);

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+import { type SqliteDatabasePaths } from "@remit/drizzle-service";
+export interface McpServerConfig {
+    origin: string;
+    secret: string;
+    databases: SqliteDatabasePaths;
+    port: number;
+    pageAssetsDir: string;
+}
+export declare const resolveMcpServerConfig: () => McpServerConfig;

package/dist/config.js

@@ -0,0 +1,41 @@
+import { sqliteDatabasePathsFromEnv, } from "@remit/drizzle-service";
+const MIN_SECRET_LENGTH = 32;
+const DEFAULT_PORT = 8790;
+const required = (name) => {
+    const value = process.env[name];
+    if (!value)
+        throw new Error(`Missing required MCP server env var: ${name}`);
+    return value;
+};
+const parseOrigin = (raw) => {
+    if (!URL.canParse(raw)) {
+        throw new Error(`MCP_PUBLIC_ORIGIN is not a URL: ${raw}`);
+    }
+    const url = new URL(raw);
+    if (url.origin !== raw.replace(/\/$/, "")) {
+        throw new Error(`MCP_PUBLIC_ORIGIN must be a bare origin such as https://mcp.example.com, got ${raw}`);
+    }
+    return url.origin;
+};
+const parsePort = (raw) => {
+    if (!raw)
+        return DEFAULT_PORT;
+    const port = Number(raw);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+        throw new Error(`MCP_PORT is not a port number: ${raw}`);
+    }
+    return port;
+};
+export const resolveMcpServerConfig = () => {
+    const secret = required("MCP_AUTH_SECRET");
+    if (secret.length < MIN_SECRET_LENGTH) {
+        throw new Error(`MCP_AUTH_SECRET must be at least ${MIN_SECRET_LENGTH} characters`);
+    }
+    return {
+        origin: parseOrigin(required("MCP_PUBLIC_ORIGIN")),
+        secret,
+        databases: sqliteDatabasePathsFromEnv(),
+        port: parsePort(process.env.MCP_PORT),
+        pageAssetsDir: required("MCP_PAGE_ASSETS_DIR"),
+    };
+};

package/dist/deps.d.ts

@@ -0,0 +1,33 @@
+import type { RemitClient } from "@remit/backend/client";
+import type { IAccountRepository, IFilterRepository, IMailboxRepository, IMessageRepository, IOrganizeJobRequestRepository, IThreadMessageRepository, OrganizeJobEvent, QueueProducer } from "@remit/data-ports";
+import type { BodyPartMaterializer, BodySyncCue, MailboxQueueService, MaterializeLogger, OrganizeJobLogger } from "@remit/mailbox-service";
+import type { StorageService } from "@remit/storage-service";
+export interface FolderToolDeps {
+    mailboxQueue: Pick<MailboxQueueService, "createMailbox" | "renameMailbox" | "dismissMailboxIntent">;
+    settleTimeoutMs: number;
+    pollIntervalMs: number;
+    sleep: (ms: number) => Promise<void>;
+}
+export interface FilterToolDeps {
+    organizeQueue: QueueProducer<OrganizeJobEvent>;
+    logger: OrganizeJobLogger;
+}
+export interface McpDeps {
+    account: Pick<IAccountRepository, "get" | "listAllByAccountConfig">;
+    mailbox: Pick<IMailboxRepository, "get" | "listAllByAccount" | "findByPath" | "resolveAccountId">;
+    message: Pick<IMessageRepository, "get" | "describe">;
+    threadMessage: Pick<IThreadMessageRepository, "listByMailbox" | "listByThread" | "searchByDate">;
+    filter: Pick<IFilterRepository, "listPageByAccountConfig" | "refreshExpiry" | "create" | "get" | "update">;
+    organizeJobRequest: Pick<IOrganizeJobRequestRepository, "create">;
+    storage: Pick<StorageService, "retrieveBodyPart">;
+    bodySync: BodyPartMaterializer;
+    bodySyncQueue: BodySyncCue;
+    logger: MaterializeLogger;
+    folders: FolderToolDeps;
+    filters: FilterToolDeps;
+}
+export interface McpDepsExtras {
+    logger: MaterializeLogger & OrganizeJobLogger;
+    settle: Omit<FolderToolDeps, "mailboxQueue">;
+}
+export declare const mcpDepsOf: (client: RemitClient, { logger, settle }: McpDepsExtras) => McpDeps;

package/dist/deps.js

@@ -0,0 +1,14 @@
+export const mcpDepsOf = (client, { logger, settle }) => ({
+    account: client.account,
+    mailbox: client.mailbox,
+    message: client.message,
+    threadMessage: client.threadMessage,
+    filter: client.filter,
+    organizeJobRequest: client.organizeJobRequest,
+    storage: client.storage,
+    bodySync: client.bodySync,
+    bodySyncQueue: client.bodySyncQueue,
+    logger,
+    folders: { mailboxQueue: client.mailboxQueue, ...settle },
+    filters: { organizeQueue: client.queues.accountFanout, logger },
+});

package/dist/filter-tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpDeps } from "./deps.js";
+export declare const registerFilterTools: (server: McpServer, deps: McpDeps, userId: string) => void;

package/dist/filter-tools.js

@@ -0,0 +1,155 @@
+import { FILTER_NO_ACTION } from "@remit/data-ports";
+import { isNotFoundError } from "@remit/data-ports/errors";
+import { deriveAccountConfigId } from "@remit/data-ports/id";
+import { FilterClauseField, FilterMatchOperator, FilterScope, FilterState, } from "@remit/domain-enums";
+import { createFilter, listFilters, queueOrganizeJob, refuse, updateFilter, } from "@remit/mailbox-service";
+import { z } from "zod";
+import { asJson, refused } from "./tool-result.js";
+const FILTER_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+const toFilter = (item) => ({
+    filterId: item.filterId,
+    name: item.name,
+    scope: item.scope,
+    expiresAt: item.expiresAt,
+    state: item.state,
+    disabledReason: item.disabledReason,
+    matchOperator: item.matchOperator,
+    literalClauses: item.literalClauses,
+    actionLabelId: item.actionLabelId,
+    actionMailboxId: item.actionMailboxId,
+    ruleChangedAt: item.ruleChangedAt,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+});
+const notFound = (error) => {
+    if (!isNotFoundError(error))
+        throw error;
+    const message = error instanceof Error ? error.message : "Not found";
+    return refuse({
+        kind: "NotFound",
+        message: `${message}. Check the filterId against list_filters.`,
+    });
+};
+const accountId = z.string().min(1).describe("Account from list_mailboxes");
+const literalClauses = z
+    .array(z.object({
+    field: z
+        .enum(FilterClauseField)
+        .describe("Message attribute the clause matches"),
+    value: z.string().min(1).max(256).describe("Literal text to match"),
+}))
+    .min(1);
+const scope = z
+    .enum(FilterScope)
+    .describe("Standing runs until changed; Temporary stops at expiresAt");
+const expiresAt = z
+    .string()
+    .describe("ISO 8601 date-time with zone offset; only for a Temporary filter, e.g. 2026-12-31T23:59:59+01:00");
+const matchOperator = z
+    .enum(FilterMatchOperator)
+    .describe("And: every clause matches; Or: any clause matches");
+const actionMailboxId = z
+    .string()
+    .min(1)
+    .describe(`Folder from list_mailboxes to move matching mail into, or "${FILTER_NO_ACTION}"`);
+const actionLabelId = z
+    .string()
+    .min(1)
+    .describe(`Label to apply to matching mail, or "${FILTER_NO_ACTION}"`);
+export const registerFilterTools = (server, deps, userId) => {
+    const accountConfigId = deriveAccountConfigId(userId);
+    const organizeDeps = {
+        organizeJobRequest: deps.organizeJobRequest,
+        queue: deps.filters.organizeQueue,
+        logger: deps.filters.logger,
+    };
+    server.registerTool("list_filters", {
+        description: "List the user's mail filters: what each matches, where it moves or labels mail, and whether it is on. A page at a time.",
+        inputSchema: {
+            accountId,
+            continuationToken: z
+                .string()
+                .optional()
+                .describe("Opaque cursor from a previous response"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    }, async (args) => {
+        const page = await listFilters(deps, accountConfigId, {
+            accountId: args.accountId,
+            continuationToken: args.continuationToken,
+        }).catch(notFound);
+        if (!page.ok)
+            return refused(page.refusal);
+        return asJson({
+            items: page.value.items.map(toFilter),
+            continuationToken: page.value.continuationToken,
+        });
+    });
+    server.registerTool("create_filter", {
+        description: "Create a filter that sorts new mail, and queue a job that applies it to existing mail. Returns the filter and the organizeJobId of that job. A target folder must be confirmed by the mail server first.",
+        inputSchema: {
+            accountId,
+            name: z.string().min(1).max(256).describe("Name for the filter"),
+            scope: scope.default(FilterScope.Standing),
+            expiresAt: expiresAt.optional(),
+            matchOperator: matchOperator.default(FilterMatchOperator.And),
+            literalClauses,
+            actionMailboxId: actionMailboxId.default(FILTER_NO_ACTION),
+            actionLabelId: actionLabelId.default(FILTER_NO_ACTION),
+        },
+        annotations: FILTER_WRITE,
+    }, async ({ accountId, ...rule }) => {
+        const created = await createFilter({ ...deps, ...organizeDeps }, { accountConfigId, userId }, { accountId, filter: rule }).catch(notFound);
+        if (!created.ok)
+            return refused(created.refusal);
+        return asJson({
+            filter: toFilter(created.value.filter),
+            organizeJobId: created.value.organizeJob.organizeJobId,
+        });
+    });
+    server.registerTool("update_filter", {
+        description: "Change a filter: its name, clauses, target folder or label, scope, expiry, or turn it on or off. Only the fields given change. Set applyToExisting to also queue a job that applies the filter to existing mail; its organizeJobId is returned.",
+        inputSchema: {
+            accountId,
+            filterId: z.string().min(1).describe("Filter from list_filters"),
+            name: z.string().min(1).max(256).optional(),
+            scope: scope.optional(),
+            expiresAt: expiresAt.optional(),
+            matchOperator: matchOperator.optional(),
+            literalClauses: literalClauses.optional(),
+            actionMailboxId: actionMailboxId.optional(),
+            actionLabelId: actionLabelId.optional(),
+            state: z
+                .enum(FilterState)
+                .optional()
+                .describe("Active turns the filter on, Disabled turns it off"),
+            applyToExisting: z
+                .boolean()
+                .optional()
+                .describe("Also apply the filter to existing mail"),
+        },
+        annotations: FILTER_WRITE,
+    }, async ({ accountId, filterId, applyToExisting, ...patch }) => {
+        const updated = await updateFilter(deps, accountConfigId, {
+            accountId,
+            filterId,
+            patch,
+        }).catch(notFound);
+        if (!updated.ok)
+            return refused(updated.refusal);
+        const filter = toFilter(updated.value);
+        if (!applyToExisting)
+            return asJson({ filter });
+        const job = await queueOrganizeJob(organizeDeps, {
+            accountConfigId,
+            userId,
+            filterId,
+        });
+        return asJson({ filter, organizeJobId: job.organizeJobId });
+    });
+};

package/dist/folder-tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { McpDeps } from "./deps.js";
+export declare const registerFolderTools: (server: McpServer, deps: McpDeps, accountConfigId: string) => void;

package/dist/folder-tools.js

@@ -0,0 +1,125 @@
+import { isNotFoundError } from "@remit/data-ports/errors";
+import { MailboxSyncStatus } from "@remit/domain-enums";
+import { changeFolderPath, createFolder, settledFolder, } from "@remit/mailbox-service";
+import { z } from "zod";
+import { asJson, refused, toolError } from "./tool-result.js";
+const CREATE_DELIMITER = "/";
+const FOLDER_WRITE = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const awaitSettled = async (deps, folders, accountId, mailboxId) => {
+    const deadline = Date.now() + folders.settleTimeoutMs;
+    for (;;) {
+        const folder = await deps.mailbox
+            .get(accountId, mailboxId)
+            .catch((error) => {
+            if (isNotFoundError(error))
+                return undefined;
+            throw error;
+        });
+        if (!folder)
+            return { state: "Gone" };
+        if (folder.syncStatus !== MailboxSyncStatus.pending ||
+            Date.now() >= deadline) {
+            return { state: "Present", folder };
+        }
+        await folders.sleep(folders.pollIntervalMs);
+    }
+};
+const folderState = (folder) => ({
+    accountId: folder.accountId,
+    mailboxId: folder.mailboxId,
+    fullPath: folder.fullPath,
+    syncStatus: folder.syncStatus,
+});
+const pendingResult = (folder, retry) => asJson({
+    ...folderState(folder),
+    ...(folder.pendingPath ? { pendingPath: folder.pendingPath } : {}),
+    message: `The mail server has not confirmed this yet. ${retry}`,
+});
+const settledOrRefused = (folder) => {
+    const settled = settledFolder(folder);
+    if (!settled.ok)
+        return refused(settled.refusal);
+    return asJson(folderState(folder));
+};
+const createOutcome = (watched, requested) => {
+    if (watched.state === "Gone") {
+        return toolError(`The mail server already holds “${requested}” under another path. Call list_mailboxes to find it.`);
+    }
+    const { folder } = watched;
+    switch (folder.syncStatus) {
+        case MailboxSyncStatus.synced:
+            return asJson(folderState(folder));
+        case MailboxSyncStatus.pending:
+            return pendingResult(folder, "Call create_folder again with the same arguments to keep waiting; it will not create a second folder.");
+        case MailboxSyncStatus.failed:
+            return toolError(`The mail server refused to create “${folder.fullPath}”: ${folder.syncFailureReason || "no reason given"}. Pick another name.`);
+        default:
+            return settledOrRefused(folder);
+    }
+};
+const renameOutcome = (watched, requested) => {
+    if (watched.state === "Gone") {
+        return toolError(`The folder was removed before the rename to “${requested}” settled. Call list_mailboxes to see what is there now.`);
+    }
+    const { folder } = watched;
+    switch (folder.syncStatus) {
+        case MailboxSyncStatus.synced:
+            return asJson(folderState(folder));
+        case MailboxSyncStatus.pending:
+            return pendingResult(folder, "Call rename_folder again with the same arguments to keep waiting; it will not rename twice.");
+        case MailboxSyncStatus.failed:
+            return toolError(`The mail server refused to rename “${folder.fullPath}” to “${requested}”: ${folder.syncFailureReason || "no reason given"}. Call rename_folder again to retry, or pass the current path “${folder.fullPath}” to drop the failed rename.`);
+        default:
+            return settledOrRefused(folder);
+    }
+};
+export const registerFolderTools = (server, deps, accountConfigId) => {
+    server.registerTool("create_folder", {
+        description: "Create a folder in one email account and wait until the mail server confirms it. Returns the confirmed path, or the pending state if the server is slow; calling again with the same arguments resumes the wait.",
+        inputSchema: {
+            accountId: z.string().min(1).describe("Account from list_mailboxes"),
+            fullPath: z
+                .string()
+                .min(1)
+                .describe(`Full folder path, levels separated by "${CREATE_DELIMITER}", e.g. "Projects/Acme"`),
+        },
+        annotations: FOLDER_WRITE,
+    }, async ({ accountId, fullPath }) => {
+        const { folders } = deps;
+        const created = await createFolder({
+            account: deps.account,
+            mailbox: deps.mailbox,
+            mailboxQueue: folders.mailboxQueue,
+        }, accountConfigId, { accountId, namespaceType: "personal", fullPath });
+        if (!created.ok)
+            return refused(created.refusal);
+        return createOutcome(await awaitSettled(deps, folders, accountId, created.value.mailbox.mailboxId), fullPath);
+    });
+    server.registerTool("rename_folder", {
+        description: "Rename a folder, or move it under another parent by giving a new full path, and wait until the mail server confirms it. Subfolders move with it. Returns the confirmed path, or the pending state if the server is slow; calling again with the same arguments resumes the wait.",
+        inputSchema: {
+            accountId: z.string().min(1).describe("Account from list_mailboxes"),
+            mailboxId: z.string().min(1).describe("Folder from list_mailboxes"),
+            fullPath: z
+                .string()
+                .min(1)
+                .describe('New full path, e.g. "Archive/2025" to move "2025" under "Archive"'),
+        },
+        annotations: FOLDER_WRITE,
+    }, async ({ accountId, mailboxId, fullPath }) => {
+        const { folders } = deps;
+        const changed = await changeFolderPath({
+            account: deps.account,
+            mailbox: deps.mailbox,
+            mailboxQueue: folders.mailboxQueue,
+        }, accountConfigId, { accountId, mailboxId, fullPath });
+        if (!changed.ok)
+            return refused(changed.refusal);
+        return renameOutcome(await awaitSettled(deps, folders, accountId, mailboxId), fullPath);
+    });
+};

package/dist/main.d.ts

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

package/dist/main.js

@@ -0,0 +1,53 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { serve } from "@hono/node-server";
+import { resolveSignInEnabled } from "@remit/auth-service/verifier";
+import { getClient } from "@remit/backend/client";
+import { logger } from "@remit/logger";
+import { installNodeLogger } from "@remit/logger-lambda/node";
+import { createMcpApp } from "./app.js";
+import { createBetterAuthTokenVerifier } from "./auth/authorization-server.js";
+import { openMcpAuthDatabase } from "./auth/database.js";
+import { createSqliteMcpAuth } from "./auth/node-auth.js";
+import { resolveMcpServerConfig } from "./config.js";
+import { mcpDepsOf } from "./deps.js";
+import { ASSETS_PATH_PREFIX, serveAsset } from "./pages/assets.js";
+import { loadPageAssets } from "./pages/load-assets.js";
+installNodeLogger();
+const FOLDER_SETTLE_TIMEOUT_MS = 20_000;
+const FOLDER_POLL_INTERVAL_MS = 500;
+const config = resolveMcpServerConfig();
+const client = await getClient();
+const deps = mcpDepsOf(client, {
+    logger,
+    settle: {
+        settleTimeoutMs: FOLDER_SETTLE_TIMEOUT_MS,
+        pollIntervalMs: FOLDER_POLL_INTERVAL_MS,
+        sleep,
+    },
+});
+const authDb = openMcpAuthDatabase(config.databases.app).db;
+const { auth, routes } = createSqliteMcpAuth({
+    origin: config.origin,
+    secret: config.secret,
+    signInEnabled: resolveSignInEnabled(),
+}, authDb);
+const app = createMcpApp({
+    origin: config.origin,
+    authRoutes: routes,
+    verifier: createBetterAuthTokenVerifier(auth, config.origin),
+    deps,
+});
+const pageAssets = loadPageAssets(config.pageAssetsDir);
+serve({
+    fetch: (request) => {
+        const { pathname } = new URL(request.url);
+        if (pathname.startsWith(ASSETS_PATH_PREFIX)) {
+            return serveAsset(pageAssets, pathname);
+        }
+        return app(request);
+    },
+    hostname: "0.0.0.0",
+    port: config.port,
+});
+// biome-ignore lint/plugin/no-logger-info: one boot line names the origin the server answers on
+logger.info({ origin: config.origin, port: config.port }, "mcp server listening");

package/dist/pages/assets.d.ts

@@ -0,0 +1,8 @@
+export declare const ASSETS_PATH_PREFIX = "/assets/";
+export declare const STYLESHEET_PATH = "/assets/pages.css";
+export interface PageAsset {
+    body: Uint8Array<ArrayBuffer>;
+    contentType: string;
+}
+export type PageAssets = ReadonlyMap<string, PageAsset>;
+export declare const serveAsset: (assets: PageAssets, pathname: string) => Response;

package/dist/pages/assets.js

@@ -0,0 +1,14 @@
+export const ASSETS_PATH_PREFIX = "/assets/";
+export const STYLESHEET_PATH = `${ASSETS_PATH_PREFIX}pages.css`;
+export const serveAsset = (assets, pathname) => {
+    const asset = assets.get(pathname);
+    if (!asset)
+        return new Response("Not found", { status: 404 });
+    return new Response(asset.body, {
+        headers: {
+            "content-type": asset.contentType,
+            "cache-control": "public, max-age=3600",
+            "x-content-type-options": "nosniff",
+        },
+    });
+};