@commercelayer/agent-cli 0.8.1 → 1.0.0-dev.1

package/dist/cursor.js

@@ -1,31 +0,0 @@
-// A small JSON state file under .commercelayer/ that a command rewrites on every run (the ops
-// cursor, the inbox cursor): read with defaults when missing or broken, kept out of git from
-// its first write, like the credentials.
-import fs from 'node:fs';
-import path from 'node:path';
-import { ignorePath } from './files.js';
-/** At most this many ids are remembered, newest first. */
-export const MAX_SEEN = 500;
-/** A cursor in `file`: parse turns what was read (or undefined when unreadable) into T. */
-export function jsonCursor(file, parse) {
-    return {
-        file,
-        read() {
-            try {
-                const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
-                return parse(raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : undefined);
-            }
-            catch {
-                return parse(undefined);
-            }
-        },
-        write(value) {
-            fs.mkdirSync(path.dirname(file), { recursive: true });
-            if (!fs.existsSync(file))
-                ignorePath(file);
-            fs.writeFileSync(file, JSON.stringify(value, null, 2) + '\n');
-        },
-    };
-}
-/** The strings of a list read back from a cursor file, at most MAX_SEEN. */
-export const strings = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string').slice(0, MAX_SEEN) : []);

package/dist/files.js

@@ -1,98 +0,0 @@
-// The files the CLI keeps in the repo: .commercelayer/store.yml and the product
-// files under .commercelayer/products/ (committed), and .commercelayer/credentials
-// (gitignored: the sandbox token, and the keys of a catalog source).
-import fs from 'node:fs';
-import path from 'node:path';
-import { fail } from './output.js';
-const dir = '.commercelayer';
-export const paths = {
-    dir,
-    store: path.join(dir, 'store.yml'),
-    products: path.join(dir, 'products'),
-    credentials: path.join(dir, 'credentials'),
-};
-/** Every KEY=value line of the credentials file; quotes around a value are dropped. */
-function credentialVars() {
-    const vars = {};
-    if (!fs.existsSync(paths.credentials))
-        return vars;
-    for (const line of fs.readFileSync(paths.credentials, 'utf8').split('\n')) {
-        const m = line.trim().match(/^([A-Z0-9_]+)=(.*)$/);
-        if (m)
-            vars[m[1]] = m[2].trim().replace(/^(["'])(.*)\1$/, '$2');
-    }
-    return vars;
-}
-/** A secret the CLI needs besides the store's own token: the environment wins over the credentials file. */
-export function credential(key) {
-    return process.env[key] || credentialVars()[key] || undefined;
-}
-export function readCredentials() {
-    if (!fs.existsSync(paths.credentials))
-        return null;
-    const vars = credentialVars();
-    if (!vars.C11R_ORG || !vars.C11R_TOKEN)
-        return null;
-    return { org: vars.C11R_ORG, token: vars.C11R_TOKEN };
-}
-export function writeCredentials(c) {
-    fs.mkdirSync(paths.dir, { recursive: true });
-    // Keep any other keys already in the file (C11R_SUPABASE_*, ...).
-    const others = Object.entries(credentialVars())
-        .filter(([k]) => k !== 'C11R_ORG' && k !== 'C11R_TOKEN')
-        .map(([k, v]) => `${k}=${v}\n`)
-        .join('');
-    fs.writeFileSync(paths.credentials, `C11R_ORG=${c.org}\nC11R_TOKEN=${c.token}\n${others}`, { mode: 0o600 });
-}
-/** The store and its credentials, or a failure telling the agent to run init. */
-export function requireCredentials() {
-    const c = readCredentials();
-    if (!c || !fs.existsSync(paths.store)) {
-        fail('no_store', 'There is no store in this repo.', 'Run `c11r init` in the repo root first.');
-    }
-    return c;
-}
-/** Make sure .gitignore lists the credentials file. Returns true if it changed. */
-export const ignoreCredentials = () => ignorePath(paths.credentials);
-/** Add a path to .gitignore unless it is there; whether it was added. */
-export function ignorePath(file) {
-    const existing = fs.existsSync('.gitignore') ? fs.readFileSync('.gitignore', 'utf8') : '';
-    if (existing.split('\n').includes(file))
-        return false;
-    const sep = existing && !existing.endsWith('\n') ? '\n' : '';
-    fs.appendFileSync('.gitignore', `${sep}${file}\n`);
-    return true;
-}
-/** The note that sends a future agent in this repo to the skills. No skill names: it never goes stale. */
-const AGENT_NOTE_HEADING = '# Store on Commerce Layer';
-const SKILLS = 'Before any task about the store (products, prices, markets, storefront, orders, promotions, agents), fetch `https://commercelayer.ai/skills.md` with `curl -fsSL` and load the skill for the task from `skills/<name>.md`; follow it rather than calling the Commerce Layer API directly. If `.commercelayer/store.yml` is missing, start from `https://commercelayer.ai/start.md`.';
-export const AGENT_NOTE = `${AGENT_NOTE_HEADING}
-This store is managed with \`c11r\`, run as \`npx -y @commercelayer/agent-cli@latest\`, configured in \`.commercelayer/store.yml\`. Always use that form, even if a \`c11r\` binary is installed: it stays on the current version. ${SKILLS}
-`;
-/** The note CLIs before 0.5.1 wrote: replaced by the current one when a file has it word for word. */
-const OLD_AGENT_NOTE = `${AGENT_NOTE_HEADING}
-This store is managed with \`c11r\` (\`npx @commercelayer/agent-cli\`), configured in \`.commercelayer/store.yml\`. ${SKILLS}
-`;
-/**
- * Write the note to AGENTS.md and CLAUDE.md (Claude Code reads that name) in the repo root:
- * created when absent, appended as a section when the file has other content, left alone
- * when the section is already there (replaced when it is an older CLI's, word for word).
- * Returns the files written.
- */
-export function writeAgentNotes() {
-    const written = [];
-    for (const file of ['AGENTS.md', 'CLAUDE.md']) {
-        const before = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : '';
-        // A note an older CLI wrote, untouched since: bring it up to date. An edited one stays as it is.
-        if (before.includes(OLD_AGENT_NOTE)) {
-            fs.writeFileSync(file, before.replace(OLD_AGENT_NOTE, AGENT_NOTE));
-            written.push(file);
-            continue;
-        }
-        if (before.split('\n').some((line) => line.trim() === AGENT_NOTE_HEADING))
-            continue;
-        fs.writeFileSync(file, before.trim() ? `${before.replace(/\s*$/, '')}\n\n${AGENT_NOTE}` : AGENT_NOTE);
-        written.push(file);
-    }
-    return written;
-}

package/dist/inbox/cursor.js

@@ -1,11 +0,0 @@
-// What the inbox commands remember between runs, in .commercelayer/inbox.json (gitignored):
-// when the inbox was last listed, and the messages already pulled, by Message-ID (or by id
-// when a message has none), so inbox list marks only the others as new.
-import path from 'node:path';
-import { jsonCursor, MAX_SEEN, strings } from '../cursor.js';
-import { paths } from '../files.js';
-const cursor = () => jsonCursor(path.join(paths.dir, 'inbox.json'), (c) => ({ last_check: typeof c?.last_check === 'string' ? c.last_check : null, seen: strings(c?.seen) }));
-export const readInboxCursor = () => cursor().read();
-export const writeInboxCursor = (c) => cursor().write({ last_check: c.last_check, seen: c.seen.slice(0, MAX_SEEN) });
-/** The key a message is remembered by. */
-export const seenKey = (m) => m.message_id ?? `id:${m.id}`;

package/dist/inbox/fake.js

@@ -1,95 +0,0 @@
-// A mailbox for tests (C11R_IMAP_FAKE=<dir>): the .eml files in the folder are the messages,
-// their id the file name's number (or the position), and flags.json keeps what IMAP would: seen,
-// labels, the folder a message was moved to. "gmail": true in flags.json makes labels Gmail
-// labels; "keywords": false makes a server with neither, which can only move.
-import fs from 'node:fs';
-import path from 'node:path';
-import { fail } from '../output.js';
-import { keywordOk } from './mailbox.js';
-import { parseMessage } from './message.js';
-export function openFake(dir, folder) {
-    const stateFile = path.join(dir, 'flags.json');
-    const read = () => {
-        const s = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : {};
-        return { ...s, messages: s.messages ?? {} };
-    };
-    const save = (s) => fs.writeFileSync(stateFile, JSON.stringify(s, null, 2) + '\n');
-    const files = () => fs
-        .readdirSync(dir)
-        .filter((f) => f.endsWith('.eml'))
-        .sort()
-        .map((f, i) => ({ id: /^\d+\.eml$/.test(f) ? String(Number(f.slice(0, -4))) : String(i + 1), file: path.join(dir, f) }));
-    const here = (s) => files().filter((m) => (s.messages[m.id]?.folder ?? 'INBOX') === folder);
-    const one = (id) => {
-        const s = read();
-        const m = here(s).find((x) => x.id === id);
-        return { s, m, st: (s.messages[id] ??= { flags: [], labels: [] }) };
-    };
-    const labelsOf = (s, id) => (s.gmail ? (s.messages[id]?.labels ?? []) : (s.messages[id]?.flags ?? []).filter((f) => !f.startsWith('\\')));
-    return {
-        host: 'fake',
-        user: 'orders@example.com',
-        folder,
-        async check() {
-            const s = read();
-            const all = here(s);
-            return { exists: all.length, unseen: all.filter((m) => !s.messages[m.id]?.flags.includes('\\Seen')).length };
-        },
-        async list({ unseen, since, limit }) {
-            const s = read();
-            const out = [];
-            for (const m of here(s)) {
-                const seen = s.messages[m.id]?.flags.includes('\\Seen') ?? false;
-                if (unseen && seen)
-                    continue;
-                const p = await parseMessage(fs.readFileSync(m.file));
-                if (since && p.date && Date.parse(p.date) < since.getTime())
-                    continue;
-                out.push({ id: m.id, message_id: p.message_id, from: p.from, subject: p.subject, date: p.date, seen, labels: labelsOf(s, m.id), size: fs.statSync(m.file).size });
-            }
-            return out.sort((a, b) => Number(b.id) - Number(a.id)).slice(0, limit);
-        },
-        async fetch(id) {
-            const { s, m } = one(id);
-            return m ? { raw: fs.readFileSync(m.file), labels: labelsOf(s, id) } : null;
-        },
-        async tag(id, t) {
-            const { s, m, st } = one(id);
-            if (!m)
-                fail('not_found', `There is no message ${id} in ${folder}.`, 'Run `c11r inbox list` for the ids.');
-            const r = { id, labels_as: null, labeled: [], unlabeled: [], seen: false };
-            if (t.label.length || t.unlabel.length) {
-                if (s.gmail) {
-                    r.labels_as = 'gmail_label';
-                    st.labels = [...new Set([...st.labels, ...t.label])].filter((l) => !t.unlabel.includes(l));
-                }
-                else if (s.keywords !== false) {
-                    const bad = [...t.label, ...t.unlabel].find((l) => !keywordOk(l));
-                    if (bad)
-                        fail('invalid_argument', `${bad} cannot be a keyword on fake: no spaces, parentheses, quotes or backslashes.`, 'Use a one-word label (ordered, order-pending), or --move <folder>.');
-                    r.labels_as = 'keyword';
-                    st.flags = [...new Set([...st.flags, ...t.label])].filter((l) => !t.unlabel.includes(l));
-                }
-                else if (!t.move)
-                    fail('labels_unsupported', `fake keeps no labels or keyword flags in ${folder}.`, 'Move the email to a folder instead: c11r inbox tag <id> --move <folder> [--seen].');
-                else
-                    r.notes = [`fake keeps no labels or keywords: the email was moved to ${t.move} instead${t.unlabel.length ? ', and there was nothing to remove' : ''}.`];
-                if (r.labels_as) {
-                    r.labeled = t.label;
-                    r.unlabeled = t.unlabel;
-                }
-            }
-            if (t.seen) {
-                st.flags = [...new Set([...st.flags, '\\Seen'])];
-                r.seen = true;
-            }
-            if (t.move) {
-                st.folder = t.move;
-                r.moved_to = t.move;
-            }
-            save(s);
-            return r;
-        },
-        async close() { },
-    };
-}

package/dist/inbox/imap.js

@@ -1,139 +0,0 @@
-// The inbox over IMAP with imapflow, loaded only here: the other commands never pay for it.
-// Gmail keeps labels (X-GM-EXT-1); other servers keep keyword flags when the folder allows any
-// (\*); a server with neither can only move the message to a folder.
-import { fail } from '../output.js';
-import { keywordOk } from './mailbox.js';
-const who = (list) => {
-    const a = list?.[0];
-    if (!a?.address)
-        return null;
-    return a.name ? `${a.name} <${a.address}>` : a.address;
-};
-export async function openImap(s) {
-    const { ImapFlow } = await import('imapflow');
-    // What an error may say: never the password, even if a server echoes it.
-    const clean = (msg) => (s.password ? msg.split(s.password).join('***') : msg);
-    const unreachable = (e) => {
-        const err = e;
-        const reason = clean(err.responseText || err.message || String(e));
-        const auth = err.authenticationFailed || /auth|credentials|login/i.test(reason);
-        fail('inbox_unreachable', `Could not open ${s.folder} on ${s.host}:${s.port} as ${s.user}: ${reason}`, auth
-            ? 'Check C11R_IMAP_USER and C11R_IMAP_PASSWORD in .commercelayer/credentials with the human: Gmail needs IMAP on and an app password (https://myaccount.google.com/apppasswords), not the account password.'
-            : 'Check C11R_IMAP_HOST and C11R_IMAP_PORT (993) in .commercelayer/credentials, and that this machine is online.');
-    };
-    const client = new ImapFlow({ host: s.host, port: s.port, secure: s.port !== 143, auth: { user: s.user, pass: s.password }, logger: false });
-    // An error after connecting (a dropped socket) must not crash the process.
-    client.on('error', () => { });
-    try {
-        await client.connect();
-    }
-    catch (e) {
-        unreachable(e);
-    }
-    let lock;
-    try {
-        lock = await client.getMailboxLock(s.folder);
-    }
-    catch (e) {
-        await client.logout().catch(() => { });
-        fail('inbox_unreachable', `There is no folder ${s.folder} on ${s.host} for ${s.user}: ${clean(e.message)}`, 'Set C11R_IMAP_FOLDER in .commercelayer/credentials to an existing folder, or leave it out for INBOX.');
-    }
-    const gmail = client.capabilities.has('X-GM-EXT-1');
-    const mailbox = () => (client.mailbox ? client.mailbox : undefined);
-    const envelopeOf = (m) => ({
-        id: String(m.uid),
-        message_id: m.envelope?.messageId ?? null,
-        from: who(m.envelope?.from),
-        subject: m.envelope?.subject ?? null,
-        date: m.envelope?.date ? new Date(m.envelope.date).toISOString() : null,
-        seen: m.flags?.has('\\Seen') ?? false,
-        labels: gmail ? [...(m.labels ?? [])] : [...(m.flags ?? [])].filter((f) => !f.startsWith('\\') && !f.startsWith('$')),
-        ...(m.size ? { size: m.size } : {}),
-    });
-    const uidOf = (id) => {
-        if (!/^\d+$/.test(id))
-            fail('invalid_argument', `${id} is not a message id.`, 'Use the id inbox list prints (a number).');
-        return id;
-    };
-    return {
-        host: s.host,
-        user: s.user,
-        folder: s.folder,
-        async check() {
-            const st = await client.status(s.folder, { messages: true, unseen: true });
-            return { exists: st ? (st.messages ?? 0) : 0, unseen: st ? (st.unseen ?? 0) : 0 };
-        },
-        async list({ unseen, since, limit }) {
-            const query = unseen ? { seen: false } : { all: true };
-            if (since)
-                query.since = since;
-            const found = await client.search(query, { uid: true });
-            const uids = (Array.isArray(found) ? found : []).sort((a, b) => b - a).slice(0, limit);
-            if (!uids.length)
-                return [];
-            const out = [];
-            for await (const m of client.fetch(uids.join(','), { uid: true, envelope: true, flags: true, size: true, ...(gmail ? { labels: true } : {}) }, { uid: true }))
-                out.push(envelopeOf(m));
-            return out.sort((a, b) => Number(b.id) - Number(a.id));
-        },
-        async fetch(id) {
-            const m = await client.fetchOne(uidOf(id), { uid: true, source: true, flags: true, ...(gmail ? { labels: true } : {}) }, { uid: true });
-            if (!m || !m.source)
-                return null;
-            return { raw: m.source, labels: envelopeOf(m).labels };
-        },
-        async tag(id, t) {
-            const uid = uidOf(id);
-            if (!(await client.fetchOne(uid, { uid: true }, { uid: true })))
-                fail('not_found', `There is no message ${id} in ${s.folder}.`, 'Run `c11r inbox list` for the ids.');
-            const result = { id, labels_as: null, labeled: [], unlabeled: [], seen: false };
-            const notes = [];
-            if (t.label.length || t.unlabel.length) {
-                const keywords = mailbox()?.permanentFlags?.has('\\*') ?? false;
-                if (gmail) {
-                    result.labels_as = 'gmail_label';
-                    if (t.label.length)
-                        await client.messageFlagsAdd(uid, t.label, { uid: true, useLabels: true });
-                    if (t.unlabel.length)
-                        await client.messageFlagsRemove(uid, t.unlabel, { uid: true, useLabels: true });
-                }
-                else if (keywords) {
-                    const bad = [...t.label, ...t.unlabel].find((l) => !keywordOk(l));
-                    if (bad)
-                        fail('invalid_argument', `${bad} cannot be a keyword on ${s.host}: no spaces, parentheses, quotes or backslashes.`, 'Use a one-word label (ordered, order-pending), or --move <folder>.');
-                    result.labels_as = 'keyword';
-                    if (t.label.length)
-                        await client.messageFlagsAdd(uid, t.label, { uid: true });
-                    if (t.unlabel.length)
-                        await client.messageFlagsRemove(uid, t.unlabel, { uid: true });
-                }
-                else if (!t.move) {
-                    fail('labels_unsupported', `${s.host} keeps no labels or keyword flags in ${s.folder}.`, 'Move the email to a folder instead: c11r inbox tag <id> --move <folder> [--seen].');
-                }
-                else
-                    notes.push(`${s.host} keeps no labels or keywords: the email was moved to ${t.move} instead${t.unlabel.length ? ', and there was nothing to remove' : ''}.`);
-                if (result.labels_as) {
-                    result.labeled = t.label;
-                    result.unlabeled = t.unlabel;
-                }
-            }
-            if (t.seen) {
-                await client.messageFlagsAdd(uid, ['\\Seen'], { uid: true });
-                result.seen = true;
-            }
-            // Last: once moved, the message has another id in another folder.
-            if (t.move) {
-                if (!(await client.messageMove(uid, t.move, { uid: true })))
-                    fail('inbox_unreachable', `${s.host} did not move message ${id} to ${t.move}.`, 'Check that the folder exists (create it in the mail app), then try again.');
-                result.moved_to = t.move;
-            }
-            if (notes.length)
-                result.notes = notes;
-            return result;
-        },
-        async close() {
-            lock.release();
-            await client.logout().catch(() => { });
-        },
-    };
-}

package/dist/inbox/mailbox.js

@@ -1,25 +0,0 @@
-// The inbox the merchant receives orders in, over IMAP: what inbox check, list, pull and tag
-// work on. The connection details are in .commercelayer/credentials (gitignored) or the
-// environment; the password is never printed, not even in an error. C11R_IMAP_FAKE=<dir> reads
-// a folder of .eml files instead (tests).
-import { credential } from '../files.js';
-import { fail } from '../output.js';
-const CREDENTIALS_HINT = 'Ask the human to add them to .commercelayer/credentials (gitignored), one per line: C11R_IMAP_HOST=imap.gmail.com, C11R_IMAP_USER=<their address>, C11R_IMAP_PASSWORD=<an app password>, and optionally C11R_IMAP_PORT (993) and C11R_IMAP_FOLDER (INBOX). For Gmail: turn on 2-Step Verification, then create an app password at https://myaccount.google.com/apppasswords; never the account password. They write the password into the file themselves: never ask for it in the chat.';
-export function imapSettings() {
-    const missing = ['C11R_IMAP_HOST', 'C11R_IMAP_USER', 'C11R_IMAP_PASSWORD'].filter((k) => !credential(k));
-    if (missing.length)
-        fail('missing_credentials', `The inbox is not set up: ${missing.join(', ')} ${missing.length === 1 ? 'is' : 'are'} missing.`, CREDENTIALS_HINT);
-    const rawPort = credential('C11R_IMAP_PORT') ?? '993';
-    const port = Number(rawPort);
-    if (!Number.isInteger(port) || port < 1 || port > 65535)
-        fail('invalid_credentials', `C11R_IMAP_PORT is ${rawPort}, not a port.`, 'Use 993 (IMAP over TLS), the usual one, or leave it out.');
-    return { host: credential('C11R_IMAP_HOST'), port, user: credential('C11R_IMAP_USER'), password: credential('C11R_IMAP_PASSWORD'), folder: credential('C11R_IMAP_FOLDER') ?? 'INBOX' };
-}
-export async function openMailbox() {
-    const fake = process.env.C11R_IMAP_FAKE;
-    if (fake)
-        return (await import('./fake.js')).openFake(fake, credential('C11R_IMAP_FOLDER') ?? 'INBOX');
-    return (await import('./imap.js')).openImap(imapSettings());
-}
-/** An IMAP keyword is one atom: no spaces, parentheses, quotes or backslashes. */
-export const keywordOk = (name) => /^[^\s(){}%*"\\\]]+$/.test(name);

package/dist/inbox/message.js

@@ -1,88 +0,0 @@
-// One email as the agent reads it: parsed with postal-mime (loaded only here, on first use) and
-// written to .commercelayer/inbox/<id>/: message.json (headers, text, the attachments' files),
-// body.txt (the text, or the HTML as text) and attachments/ with each file as it came. The
-// CLI does not read PDFs or sheets: the agent opens them with its own abilities.
-import fs from 'node:fs';
-import path from 'node:path';
-import { ignorePath, paths } from '../files.js';
-export const MAX_ATTACHMENT = 25 * 1024 * 1024;
-export const inboxDir = () => path.join(paths.dir, 'inbox');
-const who = (a) => (a.group ? a.group.flatMap(who) : a.address ? [a.name ? `${a.name} <${a.address}>` : a.address] : []);
-/** The HTML of a message as plain text, for one with no text part. */
-export function htmlText(html) {
-    return html
-        .replace(/<(script|style|head)[^>]*>[\s\S]*?<\/\1>/gi, '')
-        .replace(/<br\s*\/?>/gi, '\n')
-        .replace(/<\/(p|div|tr|li|h[1-6]|table)>/gi, '\n')
-        .replace(/<(td|th)[^>]*>/gi, '\t')
-        .replace(/<[^>]+>/g, '')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&amp;/g, '&')
-        .replace(/[ \t]+\n/g, '\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-}
-export async function parseMessage(raw) {
-    const { default: PostalMime } = await import('postal-mime');
-    const m = await PostalMime.parse(raw, { attachmentEncoding: 'arraybuffer' });
-    const text = m.text?.trim() ? m.text : m.html ? htmlText(m.html) : '';
-    return {
-        message_id: m.messageId ?? null,
-        from: m.from ? (who(m.from)[0] ?? null) : null,
-        to: (m.to ?? []).flatMap((a) => who(a)),
-        subject: m.subject ?? null,
-        date: m.date ?? null,
-        text,
-        ...(m.html ? { html: m.html } : {}),
-        attachments: m.attachments.map((a) => ({
-            name: a.filename,
-            content_type: a.mimeType,
-            bytes: typeof a.content === 'string' ? new TextEncoder().encode(a.content) : new Uint8Array(a.content),
-            inline: a.related === true || (a.disposition === 'inline' && !!a.contentId && a.mimeType.startsWith('image/')),
-        })),
-    };
-}
-const EXT = { 'application/pdf': 'pdf', 'text/plain': 'txt', 'text/csv': 'csv', 'image/png': 'png', 'image/jpeg': 'jpg', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx', 'application/vnd.ms-excel': 'xls', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx', 'application/msword': 'doc' };
-/** A file name safe on every system: no folders, no control characters, never empty. */
-export function safeName(name, i, type) {
-    // Slashes become underscores: "PO 2026/114.pdf" keeps its whole name and stays in its folder.
-    const base = (name ?? '').replace(/[/\\\u0000-\u001f<>:"|?*]+/g, '_').replace(/^[._]+/, '').trim().slice(0, 120);
-    return base || `attachment-${i + 1}${EXT[type] ? `.${EXT[type]}` : ''}`;
-}
-/** Write a parsed message under .commercelayer/inbox/<id>/; the folder is gitignored on first use. */
-export function writeMessage(id, m, labels) {
-    const root = inboxDir();
-    if (!fs.existsSync(root))
-        ignorePath(`${root}/`);
-    const dir = path.join(root, id.replace(/[^A-Za-z0-9._-]+/g, '_'));
-    fs.mkdirSync(dir, { recursive: true });
-    const warnings = [];
-    const attachments = [];
-    const used = new Set();
-    m.attachments.forEach((a, i) => {
-        if (a.inline)
-            return;
-        if (a.bytes.length > MAX_ATTACHMENT) {
-            warnings.push(`${a.name ?? `attachment ${i + 1}`} is over 25 MB and was not saved: open the email in the mail app.`);
-            return;
-        }
-        let name = safeName(a.name, i, a.content_type);
-        for (let n = 2; used.has(name.toLowerCase()); n++)
-            name = name.replace(/(?: \(\d+\))?(\.[^.]*)?$/, ` (${n})$1`);
-        used.add(name.toLowerCase());
-        fs.mkdirSync(path.join(dir, 'attachments'), { recursive: true });
-        const file = path.join(dir, 'attachments', name);
-        fs.writeFileSync(file, a.bytes);
-        attachments.push({ file, name: a.name, content_type: a.content_type, size: a.bytes.length });
-    });
-    const body = path.join(dir, 'body.txt');
-    fs.writeFileSync(body, m.text.endsWith('\n') ? m.text : `${m.text}\n`);
-    const message = path.join(dir, 'message.json');
-    const json = { id, message_id: m.message_id, from: m.from, to: m.to, subject: m.subject, date: m.date, labels, text: m.text, ...(m.html ? { html: m.html } : {}), attachments: attachments.map(({ file, name, content_type, size }) => ({ file, name, content_type, size })) };
-    fs.writeFileSync(message, JSON.stringify(json, null, 2) + '\n');
-    return { id, dir, message, body, subject: m.subject, from: m.from, message_id: m.message_id, attachments, ...(warnings.length ? { warnings } : {}) };
-}