u-chan-secrets 5.0.0 → 5.1.0

package/dist/discord/http.js

@@ -0,0 +1,84 @@
+import { abortable } from '../core/abort.js';
+export class DiscordHttpError extends Error {
+    outcome;
+    retryAfter;
+    constructor(message, outcome, retryAfter) {
+        super(message);
+        this.outcome = outcome;
+        this.retryAfter = retryAfter;
+    }
+}
+async function bodyJson(response, signal) {
+    let bytes = 0;
+    const chunks = [];
+    const reader = response.body?.getReader();
+    try {
+        if (!reader || Number(response.headers.get('content-length')) > 1024 * 1024)
+            throw new Error();
+        for (;;) {
+            const { done, value } = await abortable(reader.read(), signal);
+            if (done)
+                break;
+            bytes += value.byteLength;
+            if (bytes > 1024 * 1024)
+                throw new Error();
+            chunks.push(value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        await reader?.cancel().catch(() => { });
+    }
+}
+export class DiscordHttp {
+    fetcher;
+    blockedUntil = 0;
+    constructor(fetcher = fetch) {
+        this.fetcher = fetcher;
+    }
+    async request(token, method, path, body, signal) {
+        if (!/^\/(guilds|channels|users)\/[A-Za-z0-9/@_-]+$/.test(path))
+            throw new DiscordHttpError('invalid Discord route', 'failed');
+        signal.throwIfAborted();
+        if (Date.now() < this.blockedUntil)
+            throw new DiscordHttpError('Discord rate limited; retry later', 'failed', Math.ceil((this.blockedUntil - Date.now()) / 1000));
+        const write = method !== 'GET';
+        let response;
+        try {
+            response = await abortable(this.fetcher(`https://discord.com/api/v10${path}`, {
+                method, redirect: 'error', signal,
+                headers: { Authorization: `Bot ${token}`, 'Content-Type': 'application/json', 'User-Agent': 'U-Chan-Secrets (https://github.com/anchuwithdeadline/u-chan-secrets)' },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+            }), signal);
+        }
+        catch {
+            throw new DiscordHttpError(write ? 'Discord write outcome unknown; inspect before retrying' : 'Discord request failed', write ? 'unknown' : 'failed');
+        }
+        const delay = (v) => (typeof v === 'string' || typeof v === 'number') && Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0;
+        if (response.status === 429) {
+            // Never replay a write automatically, including a rate-limited write.
+            let body;
+            try {
+                body = await bodyJson(response, signal);
+            }
+            catch { }
+            const retry = Math.max(delay(response.headers.get('retry-after')), delay(response.headers.get('x-ratelimit-reset-after')), body && typeof body === 'object' ? delay(body.retry_after) : 0) || 60;
+            this.blockedUntil = Date.now() + retry * 1000;
+            throw new DiscordHttpError('Discord rate limited; retry later', 'failed', retry);
+        }
+        if (response.headers.get('x-ratelimit-remaining') === '0')
+            this.blockedUntil = Date.now() + (delay(response.headers.get('x-ratelimit-reset-after')) || 1) * 1000;
+        if (!response.ok) {
+            await response.body?.cancel().catch(() => { });
+            throw new DiscordHttpError(write && response.status >= 500 ? 'Discord write outcome unknown; inspect before retrying' : `Discord request rejected (HTTP ${response.status})`, write && response.status >= 500 ? 'unknown' : 'failed');
+        }
+        if (response.status === 204)
+            return null;
+        try {
+            return await bodyJson(response, signal);
+        }
+        catch {
+            throw new DiscordHttpError(write ? 'Discord write outcome unknown; inspect before retrying' : 'Discord response unavailable or too large', write ? 'unknown' : 'failed');
+        }
+    }
+}

package/dist/discord/policy.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export const snowflake = z.string().refine(v => /^[1-9][0-9]{0,19}$/.test(v) && BigInt(v) <= 18446744073709551615n);
+const text = (max) => z.string().min(1).max(max).refine(v => !/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(v));
+export const aliasSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/);
+export const tokenFieldSchema = z.discriminatedUnion('kind', [z.strictObject({ kind: z.literal('password') }), z.strictObject({ kind: z.literal('hidden'), name: text(100) })]);
+export const connectionSchema = z.strictObject({ alias: aliasSchema, item: text(200).refine(v => !v.startsWith('-') && v.trim() === v), field: tokenFieldSchema, guildId: snowflake });
+/** Discovery requests omit both unknown fields; persisted connections always require exact resolved values. */
+export const connectionRequestSchema = z.union([connectionSchema, connectionSchema.omit({ field: true, guildId: true })]);
+// Deliberately supported permission subset. Unknown/new Discord bits require a reviewed upgrade.
+export const PERMISSIONS = ['CREATE_INSTANT_INVITE', 'KICK_MEMBERS', 'BAN_MEMBERS', 'ADMINISTRATOR', 'MANAGE_CHANNELS', 'MANAGE_GUILD', 'ADD_REACTIONS', 'VIEW_AUDIT_LOG', 'PRIORITY_SPEAKER', 'STREAM', 'VIEW_CHANNEL', 'SEND_MESSAGES', 'SEND_TTS_MESSAGES', 'MANAGE_MESSAGES', 'EMBED_LINKS', 'ATTACH_FILES', 'READ_MESSAGE_HISTORY', 'MENTION_EVERYONE', 'USE_EXTERNAL_EMOJIS', 'VIEW_GUILD_INSIGHTS', 'CONNECT', 'SPEAK', 'MUTE_MEMBERS', 'DEAFEN_MEMBERS', 'MOVE_MEMBERS', 'USE_VAD', 'CHANGE_NICKNAME', 'MANAGE_NICKNAMES', 'MANAGE_ROLES', 'MANAGE_WEBHOOKS', 'MANAGE_GUILD_EXPRESSIONS', 'USE_APPLICATION_COMMANDS', 'REQUEST_TO_SPEAK', 'MANAGE_EVENTS', 'MANAGE_THREADS', 'CREATE_PUBLIC_THREADS', 'CREATE_PRIVATE_THREADS', 'USE_EXTERNAL_STICKERS', 'SEND_MESSAGES_IN_THREADS', 'USE_EMBEDDED_ACTIVITIES', 'MODERATE_MEMBERS'];
+export const SUPPORTED_PERMISSION_MASK = (1n << BigInt(PERMISSIONS.length)) - 1n;
+export function permissionNames(bits) {
+    const known = PERMISSIONS.filter((_, i) => (BigInt(bits) & (1n << BigInt(i))) !== 0n);
+    const unknown = BigInt(bits) & ~SUPPORTED_PERMISSION_MASK;
+    return unknown ? [...known, `UNSUPPORTED_BITS(${unknown})`] : known;
+}
+const validPermissions = (v) => /^(0|[1-9][0-9]{0,12})$/.test(v) && BigInt(v) < (1n << BigInt(PERMISSIONS.length)) && (BigInt(v) & 8n) === 0n;
+const permissions = z.string().refine(validPermissions);
+const roleFields = { name: text(100), permissions, color: z.number().int().min(0).max(0xffffff), hoist: z.boolean(), mentionable: z.boolean() };
+const overwrite = z.strictObject({ id: snowflake, type: z.union([z.literal(0), z.literal(1)]), allow: permissions, deny: permissions }).refine(o => validPermissions(o.allow) && validPermissions(o.deny) && (BigInt(o.allow) & BigInt(o.deny)) === 0n);
+const channelFields = { name: text(100), parentId: snowflake.nullable(), topic: text(1024).or(z.literal('')), overwrites: z.array(overwrite).max(20).refine(v => new Set(v.map(o => o.id)).size === v.length) };
+const position = z.strictObject({ id: snowflake, position: z.number().int().min(0).max(500) });
+const positions = z.array(position).min(1).max(30).refine(v => new Set(v.map(p => p.id)).size === v.length);
+export const operationSchema = z.discriminatedUnion('type', [
+    z.strictObject({ type: z.literal('role_create'), ...roleFields, permissions: permissions.optional(), color: roleFields.color.optional(), hoist: z.boolean().optional(), mentionable: z.boolean().optional() }),
+    z.strictObject({ type: z.literal('role_edit'), roleId: snowflake, changes: z.strictObject(roleFields).partial().refine(v => Object.keys(v).length > 0) }),
+    z.strictObject({ type: z.literal('role_reorder'), positions }),
+    z.strictObject({ type: z.literal('channel_create'), kind: z.enum(['category', 'text', 'voice']), ...channelFields, parentId: snowflake.nullable().optional(), topic: channelFields.topic.optional(), overwrites: channelFields.overwrites.optional() }),
+    z.strictObject({ type: z.literal('channel_edit'), channelId: snowflake, changes: z.strictObject(channelFields).partial().refine(v => Object.keys(v).length > 0) }),
+    z.strictObject({ type: z.literal('channel_reorder'), positions }),
+    z.strictObject({ type: z.enum(['member_role_add', 'member_role_remove']), memberId: snowflake, roleId: snowflake }),
+]);
+function independentTargets(operations) {
+    const targets = operations.map(op => {
+        if ('memberId' in op)
+            return { writes: ['member:' + op.memberId], reads: ['role:' + op.roleId] };
+        if ('roleId' in op)
+            return { writes: ['role:' + op.roleId], reads: [] };
+        if ('channelId' in op)
+            return { writes: ['channel:' + op.channelId], reads: [] };
+        if ('positions' in op)
+            return { writes: op.positions.map(p => (op.type === 'role_reorder' ? 'role:' : 'channel:') + p.id), reads: [] };
+        return { writes: [], reads: [] };
+    });
+    return targets.every((a, i) => targets.every((b, j) => i === j || !a.writes.some(id => b.writes.includes(id) || b.reads.includes(id))));
+}
+export const batchSchema = z.array(operationSchema).min(1).max(10).refine(v => Buffer.byteLength(JSON.stringify(v)) <= 8192 && independentTargets(v));

package/dist/discord/service.js

@@ -0,0 +1,349 @@
+import { z } from 'zod';
+import { abortable } from '../core/abort.js';
+import { UserFacingError } from '../core/types.js';
+import { DiscordHttpError } from './http.js';
+import { aliasSchema, batchSchema, connectionSchema, connectionRequestSchema, permissionNames, snowflake, SUPPORTED_PERMISSION_MASK } from './policy.js';
+const bits = z.string().regex(/^(0|[1-9][0-9]{0,19})$/);
+const roleSchema = z.object({ id: snowflake, name: z.string().max(100), permissions: bits, position: z.number().int().min(0), managed: z.boolean(), color: z.number().optional(), hoist: z.boolean().optional(), mentionable: z.boolean().optional() });
+const overwriteSchema = z.object({ id: snowflake, type: z.union([z.literal(0), z.literal(1)]), allow: bits, deny: bits });
+const channelSchema = z.object({ id: snowflake, guild_id: snowflake.optional(), name: z.string().max(100), type: z.number().int(), parent_id: snowflake.nullable().optional(), topic: z.string().max(4096).nullable().optional(), position: z.number().optional(), permission_overwrites: z.array(overwriteSchema).max(100).optional() });
+const memberSchema = z.object({ user: z.object({ id: snowflake }), roles: z.array(snowflake).max(1000) });
+class Refused extends Error {
+}
+const refuse = (message) => { throw new Refused(message); };
+const safeJson = (value) => JSON.stringify(value).replace(/[\p{Cf}\p{Zl}\p{Zp}]/gu, c => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+const permissionsView = (value) => ({ bits: value, names: permissionNames(value) });
+/** Fixed-purpose broker. Credentials never cross this privileged module's boundary. */
+export class DiscordService {
+    d;
+    constructor(d) {
+        this.d = d;
+    }
+    run(work) {
+        return this.d.queue(async () => {
+            if (this.d.platform !== 'win32')
+                return { ok: false, message: 'Discord broker supports Windows only; complete protected review is required' };
+            const secrets = [];
+            try {
+                const result = await work(secrets);
+                const scrub = (s) => secrets.reduce((v, secret) => secret ? v.split(secret).join('[REDACTED]') : v, s);
+                try {
+                    result.message = safeJson(JSON.parse(JSON.stringify(JSON.parse(result.message), (_key, value) => typeof value === 'string' ? scrub(value) : value)));
+                }
+                catch {
+                    result.message = scrub(result.message);
+                }
+                if (Buffer.byteLength(result.message) > 60000)
+                    return { ok: false, message: 'Discord result exceeds the safe response limit; request a smaller metadata page' };
+                return result;
+            }
+            catch (e) {
+                const message = e instanceof Refused || e instanceof DiscordHttpError ? e.message : 'Discord operation failed; check vault, policy, and service diagnostics';
+                return { ok: false, message: secrets.reduce((s, secret) => secret ? s.split(secret).join('[REDACTED]') : s, message) };
+            }
+        }).catch(() => ({ ok: false, message: 'Discord service unavailable' }));
+    }
+    async audit(action, connection, result) {
+        await this.d.audit.record({ action, domain: `discord:${connection.alias}:${connection.guildId}`, result });
+    }
+    discordRequestAllow(proposal) {
+        const parsed = connectionRequestSchema.safeParse(proposal);
+        if (!parsed.success)
+            return Promise.resolve({ ok: false, message: 'invalid Discord connection policy' });
+        const request = parsed.data;
+        return this.run(async () => {
+            let c;
+            if ('guildId' in request)
+                c = request;
+            else {
+                const target = { alias: request.alias, guildId: 'pending' };
+                const approved = await this.d.approver.ask('U-Chan Secrets - Discord vault discovery', [
+                    'Read setup metadata from this exact Bitwarden item?', `Connection: ${safeJson(request.alias)}`, `Bitwarden item: ${safeJson(request.item)}`,
+                    'Extract only a labeled server ID and a password/hidden-token field selector. Token values and raw notes stay inside the service.',
+                    'This does not create a Discord grant or send a Discord request. A second protected prompt must approve the exact server and token field.',
+                ]);
+                await this.audit('discord_allow', target, approved ? 'discovery approved' : 'discovery denied');
+                if (!approved)
+                    return { ok: false, message: 'denied' };
+                if (!this.d.vault.getDiscordSetup)
+                    return refuse('service does not support protected Discord metadata discovery');
+                const signal = AbortSignal.timeout(30000);
+                if (await abortable(this.d.vault.status(signal), signal) !== 'unlocked')
+                    return refuse('vault locked or unavailable; run u-chan unlock');
+                try {
+                    const setup = await abortable(this.d.vault.getDiscordSetup(request.item, signal), signal);
+                    c = connectionSchema.parse({ alias: request.alias, item: setup.item, guildId: setup.guildId, field: setup.field });
+                }
+                catch (e) {
+                    return refuse(e instanceof UserFacingError ? e.message : 'Discord setup metadata is unavailable or ambiguous');
+                }
+            }
+            const approved = await this.d.approver.ask('U-Chan Secrets - Discord connection', [
+                'Allow server metadata reads? Writes always require a separate exact-batch approval.',
+                `Connection: ${safeJson(c.alias)}`, `Bitwarden item: ${safeJson(c.item)}`,
+                `Token field: ${safeJson(c.field)}`, `Server ID: ${c.guildId}`,
+                'Duration: permanent metadata reads until revoked. No message access.',
+                'The token stays inside the privileged service. No credential is fetched for this approval.',
+            ]);
+            await this.audit('discord_allow', c, approved ? 'approved' : 'denied');
+            if (!approved)
+                return { ok: false, message: 'denied' };
+            await this.d.store.upsert(c);
+            return { ok: true, message: 'Discord connection approved; every write batch still requires approval' };
+        });
+    }
+    discordListAllowed() {
+        return this.run(async () => ({ ok: true, message: safeJson({ connections: await this.d.store.list(), scope: 'server metadata; protected approval per write batch' }) }));
+    }
+    discordRevoke(alias) {
+        return this.run(async () => {
+            const c = await this.connection(alias);
+            await this.audit('discord_revoke', c, 'intent');
+            await this.d.store.remove(alias);
+            await this.audit('discord_revoke', c, 'revoked');
+            return { ok: true, message: 'Discord connection revoked; completed changes are not undone' };
+        });
+    }
+    async connection(alias) {
+        if (!aliasSchema.safeParse(alias).success)
+            return refuse('invalid Discord alias');
+        const c = await this.d.store.get(alias);
+        if (!c)
+            return refuse('Discord connection is not approved; use discord_request_allow');
+        return c;
+    }
+    async token(c, secrets, signal) {
+        if (await abortable(this.d.vault.status(signal), signal) !== 'unlocked')
+            return refuse('vault locked or unavailable; run u-chan unlock');
+        const token = await abortable(this.d.vault.getToken(c.item, c.field, signal), signal);
+        secrets.push(token);
+        return token;
+    }
+    async snapshot(c, token, signal, memberIds = []) {
+        const get = (path) => this.d.http.request(token, 'GET', path, undefined, signal);
+        const guild = z.object({ id: snowflake, name: z.string().max(100) }).parse(await get(`/guilds/${c.guildId}`));
+        if (guild.id !== c.guildId)
+            return refuse('Discord server does not match approval');
+        const roles = z.array(roleSchema).max(1000).parse(await get(`/guilds/${c.guildId}/roles`));
+        const channels = z.array(channelSchema).max(1000).parse(await get(`/guilds/${c.guildId}/channels`));
+        if (new Set(roles.map(r => r.id)).size !== roles.length || new Set(channels.map(r => r.id)).size !== channels.length || channels.some(ch => ch.guild_id !== undefined && ch.guild_id !== c.guildId))
+            return refuse('Discord metadata does not match approved server');
+        const user = z.object({ id: snowflake }).parse(await get('/users/@me'));
+        const bot = memberSchema.parse(await get(`/guilds/${c.guildId}/members/${user.id}`));
+        if (bot.user.id !== user.id || bot.roles.some(id => !roles.some(r => r.id === id)))
+            return refuse('Discord bot membership is invalid');
+        const members = new Map([[bot.user.id, bot]]);
+        for (const id of new Set(memberIds)) {
+            if (!snowflake.safeParse(id).success)
+                return refuse('invalid member ID');
+            const member = memberSchema.parse(await get(`/guilds/${c.guildId}/members/${id}`));
+            if (member.user.id !== id)
+                return refuse('member is outside approved server');
+            members.set(id, member);
+        }
+        return { guild, roles, channels, bot, members };
+    }
+    discordInspect(alias, memberId, page = 0) {
+        return this.run(async (secrets) => {
+            if (!Number.isInteger(page) || page < 0 || page > 999 || (memberId !== undefined && !snowflake.safeParse(memberId).success))
+                return refuse('invalid metadata page or member ID');
+            const c = await this.connection(alias), signal = AbortSignal.timeout(30000), token = await this.token(c, secrets, signal);
+            const s = await this.snapshot(c, token, signal, memberId ? [memberId] : []);
+            await this.audit('discord_read', c, `ok; metadata page ${page}`);
+            const channels = s.channels.slice(page, page + 1), roles = s.roles.slice(page, page + 1);
+            return { ok: true, message: safeJson({ guild: s.guild, channels, roles, member: memberId ? s.members.get(memberId) : undefined, page, nextPage: page + 1 < Math.max(s.channels.length, s.roles.length) ? page + 1 : null, totals: { channels: s.channels.length, roles: s.roles.length } }) };
+        });
+    }
+    membersFor(operations) {
+        return operations.flatMap(op => {
+            if ('memberId' in op)
+                return [op.memberId];
+            const fields = 'changes' in op ? op.changes : op;
+            return 'overwrites' in fields ? (fields.overwrites ?? []).filter(o => o.type === 1).map(o => o.id) : [];
+        });
+    }
+    validate(s, operations) {
+        const botRoles = s.roles.filter(r => r.id === s.guild.id || s.bot.roles.includes(r.id));
+        const highest = Math.max(0, ...botRoles.map(r => r.position));
+        const botPermissions = botRoles.reduce((bits, r) => bits | BigInt(r.permissions), 0n);
+        const can = (bit) => (botPermissions & 8n) !== 0n || (botPermissions & bit) !== 0n;
+        const role = (id) => s.roles.find(r => r.id === id) ?? refuse('role is outside approved server');
+        const channel = (id) => s.channels.find(c => c.id === id) ?? refuse('channel is outside approved server');
+        const editable = (id) => {
+            const r = role(id);
+            if (r.managed || s.bot.roles.includes(id) || (id !== s.guild.id && r.position >= highest))
+                return refuse('role is managed or controls bot authority');
+            return r;
+        };
+        for (const op of operations) {
+            if (op.type.startsWith('role_') || 'memberId' in op) {
+                if (!can(1n << 28n))
+                    return refuse('bot requires MANAGE_ROLES');
+            }
+            else if (!can(16n))
+                return refuse('bot requires MANAGE_CHANNELS');
+            if ('memberId' in op) {
+                const r = editable(op.roleId), m = s.members.get(op.memberId);
+                if (!m || op.memberId === s.bot.user.id || op.roleId === s.guild.id)
+                    return refuse('invalid member-role target');
+                if (m.roles.some(id => role(id).position >= highest))
+                    return refuse('member is above bot role hierarchy');
+                if (op.type === 'member_role_add' && (BigInt(r.permissions) & 8n) !== 0n)
+                    return refuse('administrator role assignment is not supported');
+                if (op.type === 'member_role_add' && (BigInt(r.permissions) & ~SUPPORTED_PERMISSION_MASK) !== 0n)
+                    return refuse('role contains unsupported permission bits; assignment is refused');
+            }
+            if (op.type === 'role_edit') {
+                editable(op.roleId);
+                if (op.roleId === s.guild.id && (op.changes.name !== undefined || op.changes.hoist !== undefined || op.changes.mentionable !== undefined || op.changes.color !== undefined))
+                    return refuse('only explicit permissions changes are supported for @everyone');
+            }
+            if (op.type === 'role_reorder')
+                for (const p of op.positions) {
+                    editable(p.id);
+                    if (p.id === s.guild.id || p.position >= highest)
+                        return refuse('role order would cross bot authority');
+                }
+            if (op.type === 'channel_reorder')
+                for (const p of op.positions)
+                    channel(p.id);
+            if (op.type === 'channel_create' || op.type === 'channel_edit') {
+                const current = op.type === 'channel_edit' ? channel(op.channelId) : undefined;
+                const fields = op.type === 'channel_edit' ? op.changes : op;
+                const kind = current?.type ?? (op.type === 'channel_create' ? { text: 0, voice: 2, category: 4 }[op.kind] : -1);
+                if (![0, 2, 4].includes(kind))
+                    return refuse('unsupported channel kind');
+                if (fields.topic !== undefined && kind !== 0)
+                    return refuse('topic is supported only for text channels');
+                if (fields.parentId && (kind === 4 || channel(fields.parentId).type !== 4))
+                    return refuse('parent must be an approved-server category');
+                if (fields.overwrites) {
+                    if (!can(1n << 28n))
+                        return refuse('permission overwrites require MANAGE_ROLES');
+                    for (const o of fields.overwrites) {
+                        if (o.type === 0)
+                            role(o.id);
+                        else if (!s.members.has(o.id))
+                            return refuse('overwrite member is outside approved server');
+                        if (s.bot.roles.includes(o.id) || o.id === s.bot.user.id)
+                            return refuse('cannot change bot authority overwrites');
+                    }
+                    // Replacement would silently remove an existing bot overwrite, too.
+                    if (current?.permission_overwrites?.some(o => s.bot.roles.includes(o.id) || o.id === s.bot.user.id))
+                        return refuse('channel has bot authority overwrites; edit manually');
+                }
+            }
+        }
+    }
+    review(c, s, operations) {
+        const before = operations.map(op => {
+            if ('memberId' in op)
+                return { role: s.roles.find(r => r.id === op.roleId), member: s.members.get(op.memberId) };
+            if ('roleId' in op)
+                return s.roles.find(r => r.id === op.roleId);
+            if ('channelId' in op)
+                return s.channels.find(ch => ch.id === op.channelId);
+            if ('positions' in op)
+                return op.positions.map(p => op.type === 'role_reorder' ? s.roles.find(r => r.id === p.id) : s.channels.find(ch => ch.id === p.id));
+            return undefined;
+        });
+        const named = (value) => {
+            if (Array.isArray(value))
+                return value.map(named);
+            if (!value || typeof value !== 'object')
+                return value;
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, ['permissions', 'allow', 'deny'].includes(k) && typeof v === 'string' ? permissionsView(v) : named(v)]));
+        };
+        const lines = ['Approve this exact Discord write batch once?', `Connection: ${c.alias}; server: ${safeJson(s.guild.name)}; server ID: ${c.guildId}`,
+            'No deletion. No administrator grants. Completed changes are not rolled back.',
+            `Current targets: ${safeJson(named(before))}`, `Exact operations: ${safeJson(named(operations))}`,
+            'An overwrite list REPLACES existing overwrites. It may expose private channels.',
+            'The server ID also identifies @everyone. Any target or overwrite with that ID affects EVERYONE.',
+        ];
+        if (Buffer.byteLength(JSON.stringify(lines)) > 12000)
+            return refuse('batch is too large for complete protected review; split into smaller batches');
+        return lines;
+    }
+    dispatch(c, op) {
+        const fields = (v) => Object.fromEntries(Object.entries(v).map(([k, val]) => [k === 'parentId' ? 'parent_id' : k === 'overwrites' ? 'permission_overwrites' : k, val]));
+        switch (op.type) {
+            case 'role_create': {
+                const { type, ...body } = op;
+                return { method: 'POST', path: `/guilds/${c.guildId}/roles`, body: { ...body, permissions: body.permissions ?? '0' } };
+            }
+            case 'role_edit': return { method: 'PATCH', path: `/guilds/${c.guildId}/roles/${op.roleId}`, body: op.changes };
+            case 'role_reorder': return { method: 'PATCH', path: `/guilds/${c.guildId}/roles`, body: op.positions };
+            case 'channel_create': {
+                const { type, kind, ...body } = op;
+                return { method: 'POST', path: `/guilds/${c.guildId}/channels`, body: { ...fields(body), type: { text: 0, voice: 2, category: 4 }[kind] } };
+            }
+            case 'channel_edit': return { method: 'PATCH', path: `/channels/${op.channelId}`, body: fields(op.changes) };
+            case 'channel_reorder': return { method: 'PATCH', path: `/guilds/${c.guildId}/channels`, body: op.positions };
+            case 'member_role_add':
+            case 'member_role_remove': return { method: op.type === 'member_role_add' ? 'PUT' : 'DELETE', path: `/guilds/${c.guildId}/members/${op.memberId}/roles/${op.roleId}` };
+        }
+    }
+    discordApply(alias, input) {
+        // Parse synchronously: callers cannot mutate a queued or approved proposal by reference.
+        const parsed = batchSchema.safeParse(input);
+        if (!parsed.success)
+            return Promise.resolve({ ok: false, message: 'invalid Discord batch; use independent targets, at most 10 typed operations and 8 KiB JSON' });
+        const operations = parsed.data;
+        return this.run(async (secrets) => {
+            const c = await this.connection(alias), preflight = AbortSignal.timeout(30000), token = await this.token(c, secrets, preflight);
+            const snapshot = await this.snapshot(c, token, preflight, this.membersFor(operations));
+            this.validate(snapshot, operations);
+            const lines = this.review(c, snapshot, operations);
+            if (!await this.d.approver.ask('U-Chan Secrets - Discord write batch', lines)) {
+                await this.audit('discord_write', c, 'denied');
+                return { ok: false, message: 'denied' };
+            }
+            const signal = AbortSignal.timeout(60000);
+            const completed = [];
+            let stopped = 0;
+            try {
+                for (const [index, op] of operations.entries()) {
+                    stopped = index;
+                    // Lock and policy may change during the protected prompt. Do not reuse the old credential blindly.
+                    const current = await this.connection(alias);
+                    if (safeJson(current) !== safeJson(c))
+                        return refuse('connection changed; request a new batch approval');
+                    if (await this.d.vault.status(signal) !== 'unlocked')
+                        return refuse('vault locked; remaining operations were not sent');
+                    const live = await this.snapshot(c, token, signal, this.membersFor([op]));
+                    this.validate(live, [op]);
+                    if (safeJson(this.review(c, live, [op])) !== safeJson(this.review(c, snapshot, [op])))
+                        return { ok: false, message: safeJson({ completed, stopped: index, outcome: 'not_sent', reason: 'server state changed after approval; inspect and propose again' }) };
+                    const request = this.dispatch(c, op);
+                    const auditTarget = `operation ${index}; ${op.type}; route ${request.path}`;
+                    await this.audit('discord_write', c, `intent; ${auditTarget}`);
+                    let raw;
+                    try {
+                        raw = await this.d.http.request(token, request.method, request.path, request.body, signal);
+                    }
+                    catch (e) {
+                        const outcome = e instanceof DiscordHttpError ? e.outcome : 'unknown';
+                        await this.audit('discord_write', c, `${outcome}; ${auditTarget}`).catch(() => { });
+                        return { ok: false, message: safeJson({ completed, stopped: index, outcome, reason: e instanceof DiscordHttpError ? e.message : 'inspect before retrying', retryAfter: e instanceof DiscordHttpError ? e.retryAfter : undefined }) };
+                    }
+                    const id = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw.id : undefined;
+                    if ((op.type === 'role_create' || op.type === 'channel_create') && !snowflake.safeParse(id).success) {
+                        await this.audit('discord_write', c, `unknown; ${auditTarget}; invalid create result`).catch(() => { });
+                        return { ok: false, message: safeJson({ completed, stopped: index, outcome: 'unknown', reason: 'write may have succeeded but no valid ID was returned; inspect before retrying' }) };
+                    }
+                    completed.push({ index, type: op.type, ...(snowflake.safeParse(id).success ? { id } : {}), outcome: 'completed' });
+                    try {
+                        await this.audit('discord_write', c, `completed; ${auditTarget}${typeof id === 'string' && snowflake.safeParse(id).success ? '; target ' + id : ''}`);
+                    }
+                    catch {
+                        return { ok: false, message: safeJson({ completed, stopped: index, outcome: 'executed_audit_failed', reason: 'write executed; audit failed; inspect before retrying' }) };
+                    }
+                }
+            }
+            catch (e) {
+                return { ok: false, message: safeJson({ completed, stopped, outcome: 'not_sent', reason: e instanceof Refused ? e.message : 'validation, credential, or audit check failed; remaining operations were not sent' }) };
+            }
+            return { ok: true, message: safeJson({ completed }) };
+        });
+    }
+}

package/dist/discord/store.js

@@ -0,0 +1,85 @@
+import { lstat, readFile, open, rename, unlink } from 'node:fs/promises';
+import { dirname, resolve, parse } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { connectionSchema } from './policy.js';
+export class DiscordStore {
+    path;
+    beforeWrite;
+    constructor(path, beforeWrite = async () => { }) {
+        this.path = path;
+        this.beforeWrite = beforeWrite;
+    }
+    async safePath() {
+        for (let p = resolve(this.path);;) {
+            try {
+                if ((await lstat(p)).isSymbolicLink())
+                    throw new Error('Discord state refuses links');
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+            if (p === parse(p).root)
+                break;
+            p = dirname(p);
+        }
+    }
+    async list() {
+        await this.safePath();
+        let raw;
+        try {
+            if ((await lstat(this.path)).size > 65536)
+                throw new Error('Discord connection state is invalid');
+            raw = await readFile(this.path, 'utf8');
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return [];
+            throw e;
+        }
+        try {
+            const data = JSON.parse(raw);
+            if (!Array.isArray(data) || data.length > 50)
+                throw new Error();
+            const entries = data.map(e => connectionSchema.parse(e));
+            if (new Set(entries.map(e => e.alias)).size !== entries.length)
+                throw new Error();
+            return entries;
+        }
+        catch {
+            throw new Error('Discord connection state is invalid');
+        }
+    }
+    async get(alias) { return (await this.list()).find(e => e.alias === alias); }
+    async upsert(connection) {
+        const entry = connectionSchema.parse(connection);
+        const entries = (await this.list()).filter(e => e.alias !== entry.alias);
+        await this.write([...entries, entry]);
+    }
+    async remove(alias) {
+        const entries = await this.list(), rest = entries.filter(e => e.alias !== alias);
+        if (rest.length === entries.length)
+            return false;
+        await this.write(rest);
+        return true;
+    }
+    async write(entries) {
+        if (entries.length > 50 || Buffer.byteLength(JSON.stringify(entries)) > 65536)
+            throw new Error('Discord connection state is full');
+        await this.beforeWrite();
+        await this.safePath();
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        const file = await open(temp, 'wx', 0o600);
+        try {
+            await file.writeFile(JSON.stringify(entries, null, 2));
+            await file.sync();
+            await file.close();
+            await this.safePath();
+            await rename(temp, this.path);
+        }
+        finally {
+            await file.close();
+            await unlink(temp).catch(() => { });
+        }
+    }
+}