dsh-email 0.1.0 → 0.3.0

package/lib/types.d.ts

@@ -15,6 +15,14 @@ export interface ListedMessage {
     size: number;
     hasAttachments: boolean;
 }
+/** One attachment of a read message (metadata only). */
+export interface EmailAttachmentMeta {
+    filename: string;
+    contentType: string;
+    size: number;
+    /** IMAP body part identifier used by email_attachment. */
+    part: string;
+}
 /** One fully read message body. */
 export interface ReadMessageBody {
     date: string;
@@ -24,52 +32,86 @@ export interface ReadMessageBody {
     subject: string;
     /** Plain-text body; HTML mail is converted. Truncated at maxBodyChars. */
     text: string;
-    attachments: Array<{
-        filename: string;
-        contentType: string;
-        size: number;
-    }>;
+    attachments: EmailAttachmentMeta[];
     truncated: boolean;
 }
 export interface EmailListResult {
+    account: string;
     count: number;
     folder: string;
     messages: ListedMessage[];
 }
 export interface EmailReadResult extends ReadMessageBody {
+    account: string;
     uid: number;
     folder: string;
 }
 export interface EmailSearchResult {
+    account: string;
     query: string;
     count: number;
     folder: string;
     messages: ListedMessage[];
 }
 export interface EmailSendResult {
+    account: string;
     messageId: string;
     accepted: string[];
     rejected: string[];
     response: string;
 }
-export interface EmailListArgs {
+export interface EmailFolderRow {
+    name: string;
+    path: string;
+    specialUse: string;
+    subscribed: boolean;
+}
+export interface EmailFoldersResult {
+    account: string;
+    folders: EmailFolderRow[];
+}
+export interface EmailAttachmentResult {
+    account: string;
+    uid: number;
+    filename: string;
+    contentType: string;
+    size: number;
+    /** Absolute path the attachment was written to. */
+    path: string;
+}
+/** Every tool accepts an optional account selector. */
+export interface AccountArg {
+    account?: string;
+}
+export interface EmailListArgs extends AccountArg {
     folder?: string;
     limit?: number;
     offset?: number;
     unreadOnly?: boolean;
 }
-export interface EmailReadArgs {
+export interface EmailReadArgs extends AccountArg {
     uid: number;
     folder?: string;
 }
-export interface EmailSearchArgs {
+export interface EmailSearchArgs extends AccountArg {
     query: string;
     folder?: string;
     limit?: number;
 }
-export interface EmailSendArgs {
+export interface EmailSendArgs extends AccountArg {
     to: string;
     subject: string;
     text?: string;
     cc?: string;
+    /** Absolute paths (or paths relative to the dsh process cwd) to attach. */
+    attachments?: string[];
+}
+export interface EmailFoldersArgs extends AccountArg {
+    subscribedOnly?: boolean;
+}
+export interface EmailAttachmentArgs extends AccountArg {
+    uid: number;
+    /** 0-based index into the attachments of email_read. Default 0. */
+    index?: number;
+    folder?: string;
 }

package/lib/web.d.ts

@@ -0,0 +1,42 @@
+import { type EmailSettingsValue } from './settings.js';
+import { type EmailConfig } from './config.js';
+/** Same-origin route the browser settings section talks to. */
+export declare const SETTINGS_ROUTE = "/_dsh/dsh-email/settings";
+/**
+ * Browser-facing backend: snapshot the settings namespace, save it with
+ * optimistic concurrency, and test a draft account over a live IMAP login.
+ */
+export declare class EmailSettingsBackend {
+    private readonly ctx;
+    private readonly scope;
+    private readonly rowConfig;
+    constructor(ctx: any, scope: any, rowConfig: EmailConfig);
+    private effective;
+    snapshot(): Promise<{
+        settings: {
+            value: EmailSettingsValue;
+            revision: any;
+            applies: any;
+        };
+        writable: boolean;
+        accounts: string[];
+    }>;
+    private effectiveAccounts;
+    save(value: EmailSettingsValue, expectedRevision: number): Promise<{
+        settings: {
+            value: EmailSettingsValue;
+            revision: any;
+            applies: any;
+        };
+        writable: boolean;
+        accounts: string[];
+    }>;
+    test(value: EmailSettingsValue): Promise<{
+        ok: boolean;
+        ms: number;
+    }>;
+    responseJson(res: any, status: number, body: unknown): void;
+    handle(req: any, res: any): Promise<void>;
+}
+/** Mount the same-origin route when a webServer service is present. */
+export declare function installEmailSettingsWeb(ctx: any, backend: EmailSettingsBackend): void;

package/lib/web.js

@@ -0,0 +1,138 @@
+import { SETTINGS_NAMESPACE, toEmailConfig, validateSettingsValue } from './settings.js';
+import { resolveEmailSettings } from './config.js';
+import { EmailPool } from './mail-client.js';
+/** Same-origin route the browser settings section talks to. */
+export const SETTINGS_ROUTE = '/_dsh/dsh-email/settings';
+function messageOf2(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Browser-facing backend: snapshot the settings namespace, save it with
+ * optimistic concurrency, and test a draft account over a live IMAP login.
+ */
+export class EmailSettingsBackend {
+    ctx;
+    scope;
+    rowConfig;
+    constructor(ctx, scope, rowConfig) {
+        this.ctx = ctx;
+        this.scope = scope;
+        this.rowConfig = rowConfig;
+    }
+    effective(value) {
+        return { ...this.rowConfig, ...toEmailConfig(value) };
+    }
+    async snapshot() {
+        const descriptor = (this.ctx.settings.describe?.() ?? []).find((row) => row.ns === SETTINGS_NAMESPACE);
+        const value = this.scope.get();
+        return {
+            settings: {
+                value,
+                revision: descriptor?.revision ?? 0,
+                applies: descriptor?.applies ?? 'live',
+            },
+            writable: this.ctx.settings.writable !== false,
+            accounts: [...(this.effectiveAccounts().keys())],
+        };
+    }
+    effectiveAccounts() {
+        try {
+            return resolveEmailSettings(this.effective(this.scope.get())).accounts;
+        }
+        catch {
+            return new Map();
+        }
+    }
+    async save(value, expectedRevision) {
+        if (this.ctx.settings.writable === false)
+            throw new Error('settings provider is read-only');
+        validateSettingsValue(value);
+        await this.ctx.settings.replace(SETTINGS_NAMESPACE, value, expectedRevision);
+        return this.snapshot();
+    }
+    async test(value) {
+        validateSettingsValue(value);
+        const settings = resolveEmailSettings(this.effective(value));
+        const pool = new EmailPool(settings);
+        try {
+            const started = Date.now();
+            await pool.withImap(settings.defaultAccount, null, async () => 'connected');
+            return { ok: true, ms: Date.now() - started };
+        }
+        finally {
+            pool.dispose();
+        }
+    }
+    responseJson(res, status, body) {
+        const bytes = Buffer.from(JSON.stringify(body));
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.setHeader('Content-Length', String(bytes.length));
+        res.setHeader('Cache-Control', 'no-store');
+        res.writeHead(status);
+        res.end(bytes);
+    }
+    async handle(req, res) {
+        if (req.method === 'GET') {
+            try {
+                this.responseJson(res, 200, { ok: true, value: await this.snapshot() });
+            }
+            catch (error) {
+                this.responseJson(res, 503, { ok: false, error: { code: 'unavailable', message: messageOf2(error) } });
+            }
+            return;
+        }
+        if (req.method !== 'POST') {
+            res.setHeader('Allow', 'GET, POST');
+            this.responseJson(res, 405, { ok: false, error: { code: 'method-not-allowed', message: 'Use GET or POST' } });
+            return;
+        }
+        let body;
+        try {
+            const chunks = [];
+            for await (const chunk of req) {
+                const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                if (chunks.reduce((n, c) => n + c.length, 0) + part.length > 256 * 1024)
+                    throw new RangeError('request body too large');
+                chunks.push(part);
+            }
+            body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch (error) {
+            this.responseJson(res, 400, { ok: false, error: { code: 'invalid-request', message: messageOf2(error) } });
+            return;
+        }
+        try {
+            if (body?.action === 'save') {
+                if (!Number.isSafeInteger(body.expectedRevision))
+                    throw new Error('expectedRevision must be a non-negative integer');
+                this.responseJson(res, 200, { ok: true, value: await this.save(body.value, body.expectedRevision) });
+            }
+            else if (body?.action === 'test') {
+                this.responseJson(res, 200, { ok: true, value: await this.test(body.value) });
+            }
+            else {
+                this.responseJson(res, 400, { ok: false, error: { code: 'invalid-request', message: 'unsupported action' } });
+            }
+        }
+        catch (error) {
+            const conflict = error?.code === 'SETTINGS_CONFLICT';
+            this.responseJson(res, conflict ? 409 : 400, {
+                ok: false,
+                error: { code: conflict ? 'settings-conflict' : 'rejected', message: messageOf2(error) },
+            });
+        }
+    }
+}
+/** Mount the same-origin route when a webServer service is present. */
+export function installEmailSettingsWeb(ctx, backend) {
+    ctx.inject(['webServer'], (webCtx) => {
+        webCtx.effect(() => {
+            const dispose = webCtx.webServer.register({
+                kind: 'exact',
+                path: SETTINGS_ROUTE,
+                handler: (req, res) => backend.handle(req, res),
+            });
+            return () => dispose();
+        }, 'dsh-email: web route');
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-email",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "IMAP/SMTP email tools for DeepSeek Harness: list, read, search and send mail, with QQ/163/126/Sina/Aliyun/Gmail/Outlook/iCloud presets.",
   "type": "module",
   "main": "lib/index.js",
@@ -9,7 +9,10 @@
     ".": {
       "types": "./lib/index.d.ts",
       "default": "./lib/index.js"
-    }
+    },
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
   },
   "files": [
     "lib",
@@ -31,7 +34,16 @@
     "smtp"
   ],
   "author": "stardustlc",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/STARDUSTLC666/dsh-email"
+  },
+  "bugs": {
+    "url": "https://github.com/STARDUSTLC666/dsh-email/issues"
+  },
+  "homepage": "https://github.com/STARDUSTLC666/dsh-email#readme",
   "license": "MIT",
+  "packageManager": "pnpm@11.7.0",
   "engines": {
     "node": ">=20"
   },
@@ -41,6 +53,7 @@
     }
   },
   "dependencies": {
+    "schemastery": "^3.18.0",
     "imapflow": "^1.7.0",
     "mailparser": "^3.9.15",
     "nodemailer": "^9.0.5"