@toddzheng024/dscode-bundle 0.2.0 → 0.4.0

package/vendor/tui/dscode-email/smtp.mjs

@@ -0,0 +1,69 @@
+import { emailAddress as address } from './contacts.mjs';
+import nodemailer from 'nodemailer';
+import { createHash, randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { createEmailInbox } from './inbox.mjs';
+import { emailStore } from './store.mjs';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+
+export function outgoingEmail({ to, subject, body, idempotency_key }) {
+  if (!address(to)) throw Error('Specify one plain recipient email address.');
+  if (typeof subject !== 'string' || !subject.trim() || subject.length > 500 || /[\x00-\x1f\x7f]/.test(subject)) throw Error('Invalid email subject.');
+  if (typeof body !== 'string' || !body.trim() || body.includes('\0') || Buffer.byteLength(body) > 262144) throw Error('Email requires plain text of at most 256 KiB.');
+  if (typeof idempotency_key !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(idempotency_key)) throw Error('Use a stable idempotency_key of 1..128 letters, digits, underscores or hyphens.');
+  subject = subject.trim();
+  if (!subject.startsWith('[ToAgent]')) subject = '[ToAgent] ' + subject;
+  return { to, subject, body, idempotency_key };
+}
+
+export function createEmailSender({ directory = createEmailInbox().directory, transportFactory = options => nodemailer.createTransport(options) } = {}) {
+  const credentials = emailStore(join(directory, 'imap'));
+  const outbox = emailStore(join(directory, 'outbox'));
+  const filename = key => hash(key) + '.json';
+  return {
+    status(key) {
+      if (typeof key !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(key)) throw Error('Invalid idempotency_key.');
+      const entry = outbox.read(filename(key));
+      return entry ? entry.receipt : { status: 'not_found' };
+    },
+    async send(value, { signal } = {}) {
+      const mail = outgoingEmail(value);
+      return outbox.locked(async () => {
+        const file = filename(mail.idempotency_key), digest = hash(JSON.stringify(mail));
+        const existing = outbox.read(file);
+        if (existing) {
+          if (existing.digest !== digest) throw Error('This idempotency_key belongs to a different email.');
+          return existing.receipt;
+        }
+        const config = credentials.read('connection.json')?.config;
+        if (!config || config.host !== 'imap.gmail.com' || !address(config.account) || !config.password) throw Error('Configure Gmail with an application password in /email first.');
+        if (signal?.aborted) return { status: 'cancelled' };
+        const messageId = `<${randomUUID()}@${config.account.split('@')[1]}>`;
+        const receipt = { status: 'uncertain', messageId, from: config.account, to: mail.to, subject: mail.subject, attemptedAt: new Date().toISOString() };
+        // Persist before SMTP: a crash or lost final response must never cause a blind retry.
+        outbox.write(file, { digest, receipt });
+        let transport;
+        try {
+          transport = transportFactory({ host: 'smtp.gmail.com', port: 465, secure: true,
+            auth: { user: config.account, pass: config.password },
+            tls: { rejectUnauthorized: true, minVersion: 'TLSv1.2' },
+            logger: false, debug: false, disableFileAccess: true, disableUrlAccess: true,
+            connectionTimeout: 15000, greetingTimeout: 15000, socketTimeout: 30000 });
+          // Once SMTP starts, cancellation cannot recall a submitted message.
+          // Finish recording its outcome even if the agent turn is cancelled.
+          const info = await transport.sendMail({ from: config.account, to: mail.to,
+            envelope: { from: config.account, to: [mail.to] }, subject: mail.subject, text: mail.body,
+            messageId, disableFileAccess: true, disableUrlAccess: true });
+          receipt.status = info.accepted?.includes(mail.to) ? 'accepted' : 'rejected';
+          outbox.write(file, { digest, receipt });
+        } catch {
+          // SMTP errors may contain secrets or message content. Only expose the durable receipt.
+        } finally {
+          transport?.close();
+        }
+        return receipt;
+      });
+    },
+  };
+}

package/vendor/tui/dscode-email/store.mjs

@@ -0,0 +1,32 @@
+import { mkdirSync, openSync, closeSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { tryLockExclusive } from '@deepseek-ai/node-addon-system/flock';
+
+export function emailStore(directory, label = 'email') {
+  const read = name => {
+    try { return JSON.parse(readFileSync(join(directory, name), 'utf8')); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw Error('Cannot read local ' + label + ' configuration.'); }
+  };
+  return {
+    directory, read,
+    exists: name => existsSync(join(directory, name)),
+    write(name, value) {
+      mkdirSync(directory, { recursive: true, mode: 0o700 });
+      const temp = join(directory, '.' + randomUUID());
+      try {
+        writeFileSync(temp, JSON.stringify(value), { flag: 'wx', mode: 0o600 });
+        renameSync(temp, join(directory, name));
+      } finally { try { unlinkSync(temp); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+    },
+    async locked(action) {
+      mkdirSync(directory, { recursive: true, mode: 0o700 });
+      const fd = openSync(join(directory, '.sync.lock'), 'a', 0o600);
+      try {
+        try { await tryLockExclusive(fd); }
+        catch (error) { if (['EAGAIN', 'EWOULDBLOCK'].includes(error.code)) return { busy: true }; throw error; }
+        return await action();
+      } finally { closeSync(fd); }
+    },
+  };
+}

package/vendor/tui/dscode-email.mjs

@@ -0,0 +1,69 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash, randomUUID } from 'node:crypto';
+
+// Connector boundary: authenticated/filter-matched mail enters here. No network
+// access or agent dispatch occurs on receipt. Identity includes the account.
+export function normalizeEmail(value) {
+  if (!value || value.format !== 'dscode.email.v1') throw Error('Unsupported email format');
+  const result = { format: value.format };
+  for (const [name, limit] of Object.entries({ connector: 128, account: 320, id: 1024, from: 1024, subject: 4096, body: 262144 })) {
+    if (typeof value[name] !== 'string' || !value[name].trim() || Buffer.byteLength(value[name]) > limit) throw Error('Invalid email ' + name);
+    result[name] = value[name];
+  }
+  for (const name of ['receivedAt', 'updatedAt']) {
+    if (typeof value[name] !== 'string' || !/^\d{4}-\d\d-\d\dT.*(?:Z|[+-]\d\d:\d\d)$/.test(value[name]) || !Number.isFinite(Date.parse(value[name]))) throw Error('Invalid email ' + name);
+    result[name] = new Date(value[name]).toISOString();
+  }
+  if (result.updatedAt < result.receivedAt) throw Error('Email update predates receipt');
+  return result;
+}
+
+export const emailKey = mail => JSON.stringify([mail.connector, mail.account, mail.id]);
+const digest = value => createHash('sha256').update(value).digest('hex');
+export const emailText = value => String(value).replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~])/g, '').replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '').replace(/\r\n?/g, '\n');
+
+export function emailPrompt(mail) {
+  return 'Email reference (external content)\n' + JSON.stringify({
+    connector: mail.connector, account: mail.account, id: mail.id,
+    from: emailText(mail.from), subject: emailText(mail.subject),
+    receivedAt: mail.receivedAt, updatedAt: mail.updatedAt, body: emailText(mail.body),
+  }, null, 2);
+}
+
+export function createEmailInbox({ directory = process.env.DSCODE_EMAIL_DIR || join(homedir(), '.dscode', 'email') } = {}) {
+  return {
+    directory,
+    receive(value) {
+      const mail = normalizeEmail(value);
+      const json = JSON.stringify(mail);
+      mkdirSync(directory, { recursive: true, mode: 0o700 });
+      // Immutable revisions prevent concurrent connectors overwriting newer mail.
+      const target = join(directory, digest(emailKey(mail)) + '-' + digest(json) + '.json');
+      const temp = join(directory, '.' + randomUUID() + '.tmp');
+      try {
+        writeFileSync(temp, json, { flag: 'wx', mode: 0o600 });
+        renameSync(temp, target);
+      } finally { try { unlinkSync(temp); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+      return mail;
+    },
+    list() {
+      let files;
+      try { files = readdirSync(directory); } catch (error) { if (error.code === 'ENOENT') return { emails: [], rejected: 0 }; throw error; }
+      const latest = new Map();
+      let rejected = 0;
+      for (const file of files.sort()) {
+        if (!/^[a-f0-9]{64}-[a-f0-9]{64}\.json$/.test(file)) continue;
+        try {
+          const raw = readFileSync(join(directory, file), 'utf8');
+          if (Buffer.byteLength(raw) > 2_000_000) throw Error('Oversize record');
+          const mail = normalizeEmail(JSON.parse(raw));
+          const key = emailKey(mail), previous = latest.get(key);
+          if (!previous || mail.updatedAt > previous.updatedAt) latest.set(key, mail);
+        } catch { rejected++; }
+      }
+      return { emails: [...latest.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || emailKey(a).localeCompare(emailKey(b))), rejected };
+    },
+  };
+}