@chenguangyao/devflow-kit 0.1.43

package/src/providers/drivers/notify-smtp.js

@@ -0,0 +1,515 @@
+'use strict';
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const net = require('net');
+const tls = require('tls');
+const os = require('os');
+const crypto = require('crypto');
+const { Provider } = require('../base.js');
+
+/**
+ * notify-smtp — port of arb-workflow-kit deploy-submit/send-email.py to Node.
+ *
+ * Zero external deps: TLS/net + MIME composed by hand.
+ *
+ * Supports three connection modes:
+ *   465 → implicit TLS (SMTPS)
+ *   587 → STARTTLS upgrade (preferred for modern servers)
+ *   25  → plain (no auth recommended)
+ *
+ * Supports AUTH PLAIN (RFC 4616) and AUTH LOGIN (legacy, Exchange / QQ mail).
+ *
+ * Markdown → HTML conversion mirrors arb's `_md_to_html`:
+ *   - `# / ## / ###` → `<h2>/h3/h4>`
+ *   - `- item` → `<ul><li>`
+ *   - `N. item` → `<ol><li>`
+ *   - `| ... |` pipe tables (auto-detect header + separator row)
+ *   - `**bold**` → `<b>`, `` `code` `` → `<code>`
+ *
+ * Config schema:
+ *   {
+ *     host: "smtp.exmail.qq.com",
+ *     port: 465,                          // 465 | 587 | 25
+ *     secure: true,                       // auto-derived from port if omitted
+ *     user: "sender@corp.com",            // also taken from env SMTP_USER
+ *     pass: "...",                        // also taken from env SMTP_PASS (prefer env)
+ *     authMethod: "login" | "plain" | "auto"   (default "auto")
+ *     from: "Name <sender@corp.com>",     // defaults to user
+ *     defaults: { to, cc, signatureFile }  // optional, merged with call opts
+ *     rejectUnauthorized: true,
+ *     timeoutMs: 30000
+ *   }
+ *
+ * send(opts) — opts:
+ *   subject        required string
+ *   body_md        markdown body (either body_md or bodyFile required)
+ *   bodyFile       path to markdown file
+ *   to, cc         "a@b.com, c@d.com" (string) or array
+ *   attachments    [pathString, ...]
+ *   signatureFile  optional tail appendage
+ *   dryRun         bool — compose but do not open socket
+ *
+ * Returns: { id, accepted, response, raw? } where raw is included in dryRun.
+ */
+class SmtpNotifyProvider extends Provider {
+  constructor({ name, type, driver, config }) {
+    super({ name, type, driver, config });
+    this.host = config.host || process.env.SMTP_HOST || '';
+    this.port = Number(config.port || process.env.SMTP_PORT || 465);
+    this.secure = config.secure !== undefined ? !!config.secure : this.port === 465;
+    this.user = config.user || process.env.SMTP_USER || '';
+    this.pass = config.pass || process.env.SMTP_PASS || '';
+    this.from = config.from || this.user;
+    this.authMethod = (config.authMethod || 'auto').toLowerCase();
+    this.timeoutMs = Number(config.timeoutMs || 30000);
+    this.rejectUnauthorized = config.rejectUnauthorized !== false;
+    this.defaults = config.defaults || {};
+  }
+
+  async validate() {
+    if (!this.host) return { ok: false, reason: 'missing host (set SMTP_HOST)' };
+    if (!this.user) return { ok: false, reason: 'missing user (set SMTP_USER)', needsLogin: true };
+    if (!this.pass) return { ok: false, reason: 'missing pass (set SMTP_PASS)', needsLogin: true };
+    if (!this.from) return { ok: false, reason: 'missing from address' };
+    return { ok: true };
+  }
+
+  async send(opts = {}) {
+    const subject = opts.subject;
+    if (!subject) throw new Error('notify-smtp: subject required');
+    let bodyMd = opts.body_md || '';
+    if (!bodyMd && opts.bodyFile) {
+      bodyMd = await fsp.readFile(opts.bodyFile, 'utf8');
+    }
+    if (!bodyMd && opts.body) bodyMd = opts.body;
+    if (!bodyMd) throw new Error('notify-smtp: body_md / bodyFile required');
+
+    const sigFile = opts.signatureFile || this.defaults.signatureFile;
+    if (sigFile && fs.existsSync(sigFile)) {
+      bodyMd += '\n\n---\n' + (await fsp.readFile(sigFile, 'utf8'));
+    }
+
+    const html = mdToHtml(bodyMd);
+    const to = asAddrList(opts.to || this.defaults.to);
+    const cc = asAddrList(opts.cc || this.defaults.cc || []);
+    if (!to.length) throw new Error('notify-smtp: at least one "to" recipient required');
+
+    const attachments = [];
+    for (const ap of opts.attachments || []) {
+      if (!fs.existsSync(ap)) { process.stderr.write(`[notify-smtp] skipping missing attachment: ${ap}\n`); continue; }
+      const buf = await fsp.readFile(ap);
+      attachments.push({
+        filename: path.basename(ap),
+        contentType: guessContentType(ap),
+        content: buf,
+      });
+    }
+
+    const rfc822 = composeMime({
+      from: this.from,
+      to, cc,
+      subject,
+      html,
+      textFallback: stripTags(html).slice(0, 5000),
+      attachments,
+    });
+
+    const envelope = {
+      from: extractAddr(this.from),
+      recipients: [...to, ...cc].map(extractAddr).filter(Boolean),
+    };
+
+    if (opts.dryRun || process.env.DEVFLOW_NOTIFY_DRY_RUN === '1') {
+      const id = 'dryrun-' + crypto.randomBytes(4).toString('hex');
+      process.stdout.write(`[notify-smtp dry-run] would send to ${envelope.recipients.join(',')} subject=${subject}\n`);
+      return { id, accepted: envelope.recipients, response: 'dryRun', raw: rfc822 };
+    }
+
+    const response = await smtpSend({
+      host: this.host,
+      port: this.port,
+      secure: this.secure,
+      user: this.user,
+      pass: this.pass,
+      authMethod: this.authMethod,
+      rejectUnauthorized: this.rejectUnauthorized,
+      timeoutMs: this.timeoutMs,
+      envelope,
+      message: rfc822,
+    });
+
+    return {
+      id: response.messageId,
+      accepted: envelope.recipients,
+      response: response.lastLine,
+    };
+  }
+}
+
+// ─────────────────── SMTP protocol ───────────────────
+
+/**
+ * Minimal SMTP client. Exposed for testing via `_connectFactory` override on opts.
+ */
+async function smtpSend(opts) {
+  const connect = opts._connectFactory || createSmtpConnection;
+  const conn = await connect({
+    host: opts.host,
+    port: opts.port,
+    secure: opts.secure,
+    rejectUnauthorized: opts.rejectUnauthorized,
+    timeoutMs: opts.timeoutMs,
+  });
+
+  const expect = async (codes) => {
+    const lines = await conn.readResponse();
+    const first = parseInt(lines[lines.length - 1].slice(0, 3), 10);
+    if (!codes.includes(first)) {
+      throw new Error(`SMTP unexpected response: ${lines.join(' | ')} (wanted ${codes})`);
+    }
+    return lines;
+  };
+
+  await expect([220]);
+  await conn.send(`EHLO ${os.hostname() || 'devflow'}`);
+  const ehloLines = await expect([250]);
+  const caps = new Set(ehloLines.map((l) => l.slice(4).split(/\s/)[0].toUpperCase()));
+
+  // STARTTLS upgrade when not already secure and server supports it
+  if (!opts.secure && caps.has('STARTTLS')) {
+    await conn.send('STARTTLS');
+    await expect([220]);
+    await conn.upgradeTls({ host: opts.host, rejectUnauthorized: opts.rejectUnauthorized });
+    await conn.send(`EHLO ${os.hostname() || 'devflow'}`);
+    await expect([250]);
+  }
+
+  // Auth
+  const method = pickAuthMethod(opts.authMethod, caps);
+  if (method === 'PLAIN') {
+    const payload = Buffer.from(`\0${opts.user}\0${opts.pass}`, 'utf8').toString('base64');
+    await conn.send(`AUTH PLAIN ${payload}`);
+    await expect([235]);
+  } else if (method === 'LOGIN') {
+    await conn.send('AUTH LOGIN');
+    await expect([334]);
+    await conn.send(Buffer.from(opts.user, 'utf8').toString('base64'));
+    await expect([334]);
+    await conn.send(Buffer.from(opts.pass, 'utf8').toString('base64'));
+    await expect([235]);
+  }
+
+  // Envelope
+  await conn.send(`MAIL FROM:<${opts.envelope.from}>`);
+  await expect([250]);
+  for (const r of opts.envelope.recipients) {
+    await conn.send(`RCPT TO:<${r}>`);
+    await expect([250, 251]);
+  }
+
+  // Data
+  await conn.send('DATA');
+  await expect([354]);
+  const msg = opts.message.split(/\r?\n/).map((line) => line.startsWith('.') ? '.' + line : line).join('\r\n');
+  await conn.sendRaw(msg + '\r\n.');
+  const okLines = await expect([250]);
+
+  await conn.send('QUIT');
+  await conn.close();
+
+  return { messageId: extractMessageId(okLines), lastLine: okLines[okLines.length - 1] };
+}
+
+function pickAuthMethod(configured, caps) {
+  if (configured === 'plain' && caps.has('AUTH=PLAIN') || (configured === 'plain')) return 'PLAIN';
+  if (configured === 'login') return 'LOGIN';
+  // auto: prefer PLAIN (simpler), fall back to LOGIN
+  for (const cap of caps) {
+    if (cap.startsWith('AUTH')) {
+      const m = cap.split(/\s|=/);
+      if (m.includes('PLAIN') || m.some((x) => x === 'PLAIN')) return 'PLAIN';
+    }
+  }
+  // Default: LOGIN (most compatible with Exchange / QQ mail)
+  return 'LOGIN';
+}
+
+function extractMessageId(lines) {
+  for (const l of lines) {
+    const m = /queued as ([A-Za-z0-9._-]+)/i.exec(l);
+    if (m) return m[1];
+  }
+  return 'smtp-' + crypto.randomBytes(4).toString('hex');
+}
+
+function createSmtpConnection({ host, port, secure, rejectUnauthorized, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const common = { host, port };
+    const mkReader = (socket) => new SocketReader(socket, timeoutMs);
+    if (secure) {
+      const socket = tls.connect({ ...common, rejectUnauthorized }, () => resolve(wrap(socket, mkReader(socket))));
+      socket.on('error', reject);
+    } else {
+      const socket = net.connect(common, () => resolve(wrap(socket, mkReader(socket))));
+      socket.on('error', reject);
+    }
+  });
+
+  function wrap(socket, reader) {
+    let current = { socket, reader };
+    const self = {
+      async readResponse() {
+        return current.reader.readResponse();
+      },
+      async send(line) {
+        await new Promise((res, rej) => current.socket.write(line + '\r\n', (err) => err ? rej(err) : res()));
+      },
+      async sendRaw(data) {
+        await new Promise((res, rej) => current.socket.write(data + '\r\n', (err) => err ? rej(err) : res()));
+      },
+      async upgradeTls({ host, rejectUnauthorized }) {
+        const newSocket = tls.connect({ socket: current.socket, host, rejectUnauthorized });
+        await new Promise((res, rej) => {
+          newSocket.once('secureConnect', res);
+          newSocket.once('error', rej);
+        });
+        current.socket = newSocket;
+        current.reader = mkReader(newSocket);
+      },
+      async close() {
+        try { current.socket.end(); } catch (_) { /* noop */ }
+      },
+    };
+    return self;
+  }
+}
+
+class SocketReader {
+  constructor(socket, timeoutMs) {
+    this.socket = socket;
+    this.timeoutMs = timeoutMs;
+    this.buf = '';
+    this.waiters = [];
+    socket.setEncoding('utf8');
+    socket.on('data', (chunk) => { this.buf += chunk; this._flush(); });
+    socket.on('end',  () => { this._flush(true); });
+    socket.on('error', (err) => { for (const w of this.waiters) w.reject(err); this.waiters.length = 0; });
+  }
+  _flush() {
+    while (this.waiters.length) {
+      const lines = extractCompleteResponse(this.buf);
+      if (!lines) return;
+      const [resp, rest] = lines;
+      this.buf = rest;
+      const w = this.waiters.shift();
+      w.resolve(resp);
+    }
+  }
+  readResponse() {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const i = this.waiters.findIndex((w) => w.resolve === resolve);
+        if (i >= 0) this.waiters.splice(i, 1);
+        reject(new Error(`SMTP read timeout (${this.timeoutMs}ms)`));
+      }, this.timeoutMs);
+      this.waiters.push({
+        resolve: (v) => { clearTimeout(timer); resolve(v); },
+        reject:  (e) => { clearTimeout(timer); reject(e); },
+      });
+      this._flush();
+    });
+  }
+}
+
+/** Parse accumulated SMTP response buffer; returns [lines, remaining] once a full multiline response is read. */
+function extractCompleteResponse(buf) {
+  const raw = buf.split(/\r?\n/);
+  const lines = [];
+  for (let i = 0; i < raw.length; i++) {
+    const line = raw[i];
+    if (!/^\d{3}[- ]/.test(line)) {
+      if (i === raw.length - 1) return null; // still accumulating
+      continue;
+    }
+    lines.push(line);
+    if (line[3] === ' ') {
+      const rest = raw.slice(i + 1).join('\r\n');
+      return [lines, rest];
+    }
+  }
+  return null;
+}
+
+// ─────────────────── MIME composition ───────────────────
+
+function composeMime({ from, to, cc, subject, html, textFallback, attachments }) {
+  const hasAttachments = attachments && attachments.length > 0;
+  const headers = [
+    `From: ${from}`,
+    `To: ${to.join(', ')}`,
+    ...(cc.length ? [`Cc: ${cc.join(', ')}`] : []),
+    `Subject: ${encodeHeader(subject)}`,
+    `Date: ${new Date().toUTCString()}`,
+    `Message-ID: <${crypto.randomBytes(8).toString('hex')}@devflow>`,
+    `MIME-Version: 1.0`,
+  ];
+
+  if (!hasAttachments) {
+    headers.push(`Content-Type: text/html; charset="utf-8"`);
+    headers.push(`Content-Transfer-Encoding: base64`);
+    return headers.join('\r\n') + '\r\n\r\n' + chunk76(Buffer.from(html, 'utf8').toString('base64'));
+  }
+
+  const boundary = 'devflow-' + crypto.randomBytes(8).toString('hex');
+  headers.push(`Content-Type: multipart/mixed; boundary="${boundary}"`);
+
+  const parts = [];
+  parts.push(
+    `--${boundary}`,
+    `Content-Type: text/html; charset="utf-8"`,
+    `Content-Transfer-Encoding: base64`,
+    '',
+    chunk76(Buffer.from(html, 'utf8').toString('base64'))
+  );
+  for (const att of attachments) {
+    parts.push(
+      `--${boundary}`,
+      `Content-Type: ${att.contentType}; name="${att.filename}"`,
+      `Content-Transfer-Encoding: base64`,
+      `Content-Disposition: attachment; filename="${att.filename}"`,
+      '',
+      chunk76(att.content.toString('base64'))
+    );
+  }
+  parts.push(`--${boundary}--`);
+  return headers.join('\r\n') + '\r\n\r\n' + parts.join('\r\n');
+}
+
+function chunk76(s) {
+  const out = [];
+  for (let i = 0; i < s.length; i += 76) out.push(s.slice(i, i + 76));
+  return out.join('\r\n');
+}
+
+function encodeHeader(s) {
+  if (/^[\x00-\x7F]+$/.test(s)) return s;
+  return `=?UTF-8?B?${Buffer.from(s, 'utf8').toString('base64')}?=`;
+}
+
+function guessContentType(p) {
+  const ext = path.extname(p).toLowerCase();
+  const map = {
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.zip': 'application/zip',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  };
+  return map[ext] || 'application/octet-stream';
+}
+
+// ─────────────────── Markdown → HTML (mirror of arb) ───────────────────
+
+function mdToHtml(md) {
+  const lines = md.split('\n');
+  const out = [];
+  let inTable = false;
+  let inUl = false;
+  let inOl = false;
+
+  const closeLists = () => {
+    if (inUl) { out.push('</ul>'); inUl = false; }
+    if (inOl) { out.push('</ol>'); inOl = false; }
+  };
+  const closeTable = () => {
+    if (inTable) { out.push('</table>'); inTable = false; }
+  };
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    // Table
+    if (line.startsWith('|') && line.includes('|')) {
+      const cells = line.replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+      const isSeparator = cells.every((c) => /^[-:]+$/.test(c));
+      if (isSeparator) { continue; }
+      if (!inTable) {
+        out.push('<table border="1" cellpadding="8" cellspacing="0" style="border-collapse:collapse;border-color:#ddd;">');
+        inTable = true;
+        out.push('<tr style="background:#f5f5f5;">' + cells.map((c) => `<th>${escapeHtml(c)}</th>`).join('') + '</tr>');
+      } else {
+        out.push('<tr>' + cells.map((c) => `<td>${escapeHtml(c)}</td>`).join('') + '</tr>');
+      }
+      continue;
+    } else if (inTable) {
+      closeTable();
+    }
+
+    if (inUl && !line.startsWith('- ')) { out.push('</ul>'); inUl = false; }
+    if (inOl && !/^\d+\.\s/.test(line)) { out.push('</ol>'); inOl = false; }
+
+    if (line.startsWith('### ')) {
+      out.push(`<h4>${escapeHtml(line.slice(4))}</h4>`);
+    } else if (line.startsWith('## ')) {
+      out.push(`<h3>${escapeHtml(line.slice(3))}</h3>`);
+    } else if (line.startsWith('# ')) {
+      out.push(`<h2 style="color:#1a73e8;">${escapeHtml(line.slice(2))}</h2>`);
+    } else if (line.startsWith('- ')) {
+      if (!inUl) { out.push('<ul>'); inUl = true; }
+      out.push(`<li>${escapeHtml(line.slice(2))}</li>`);
+    } else if (/^\d+\.\s/.test(line)) {
+      if (!inOl) { out.push('<ol>'); inOl = true; }
+      out.push(`<li>${escapeHtml(line.replace(/^\d+\.\s*/, ''))}</li>`);
+    } else if (line === '') {
+      out.push('<br>');
+    } else {
+      out.push(`<p>${escapeHtml(line)}</p>`);
+    }
+  }
+  closeTable();
+  closeLists();
+
+  let body = out.join('\n');
+  body = body.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+  body = body.replace(/`([^`]+?)`/g, '<code>$1</code>');
+  return `<html><body style="font-family:Arial,sans-serif;font-size:14px;color:#333;">${body}</body></html>`;
+}
+
+function escapeHtml(s) {
+  return String(s)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function stripTags(html) {
+  return html.replace(/<[^>]+>/g, '').replace(/&[a-z]+;/g, ' ');
+}
+
+// ─────────────────── Address helpers ───────────────────
+
+function asAddrList(v) {
+  if (!v) return [];
+  if (Array.isArray(v)) return v.filter(Boolean);
+  return String(v).split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+}
+
+function extractAddr(s) {
+  if (!s) return '';
+  const m = /<([^>]+)>/.exec(s);
+  return m ? m[1] : String(s).trim();
+}
+
+module.exports = {
+  default: SmtpNotifyProvider,
+  SmtpNotifyProvider,
+  _internals: { mdToHtml, composeMime, smtpSend, extractCompleteResponse, asAddrList, extractAddr },
+};

package/src/providers/drivers/observability-oss.js

@@ -0,0 +1,43 @@
+'use strict';
+const { spawnSync } = require('child_process');
+const { Provider } = require('../base.js');
+
+class OssProvider extends Provider {
+  async validate() {
+    if (!this.config.endpoint) return { ok: false, reason: 'endpoint missing' };
+    if (!this.config.bucket) return { ok: false, reason: 'bucket missing' };
+    if (!this.config.queryCommand && (!this.config.accessKeyId || !this.config.accessKeySecret)) {
+      return { ok: false, reason: 'accessKeyId/accessKeySecret missing', needsLogin: true };
+    }
+    return { ok: true };
+  }
+
+  async query(opts = {}) {
+    const request = {
+      driver: 'oss',
+      endpoint: this.config.endpoint,
+      bucket: this.config.bucket,
+      prefix: this.config.prefix || '',
+      query: opts.query || '',
+      traceId: opts.traceId || '',
+      requestId: opts.requestId || '',
+      since: opts.since || '15m',
+      limit: opts.limit || 50,
+    };
+    if (!this.config.queryCommand || opts.dryRun) return { status: 'dry-run', request, items: [] };
+    const cmd = render(this.config.queryCommand, request);
+    const r = spawnSync(cmd, { shell: true, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+    return {
+      status: r.status === 0 ? 'pass' : 'fail',
+      command: cmd,
+      output: ((r.stdout || '') + (r.stderr || '')).slice(0, 12000),
+      items: [],
+    };
+  }
+}
+
+function render(s, vars) {
+  return String(s || '').replace(/\$\{([a-zA-Z0-9_]+)\}/g, (_, k) => vars[k] == null ? '' : String(vars[k]));
+}
+
+module.exports = { default: OssProvider };

package/src/providers/drivers/observability-sls.js

@@ -0,0 +1,50 @@
+'use strict';
+const { spawnSync } = require('child_process');
+const { Provider } = require('../base.js');
+
+class SlsProvider extends Provider {
+  async validate() {
+    if (!this.config.endpoint) return { ok: false, reason: 'endpoint missing' };
+    if (!this.config.project) return { ok: false, reason: 'project missing' };
+    if (!this.config.logstore) return { ok: false, reason: 'logstore missing' };
+    if (!this.config.queryCommand && (!this.config.accessKeyId || !this.config.accessKeySecret)) {
+      return { ok: false, reason: 'accessKeyId/accessKeySecret missing', needsLogin: true };
+    }
+    return { ok: true };
+  }
+
+  async query(opts = {}) {
+    return runQueryCommand('sls', this.config, opts);
+  }
+}
+
+function runQueryCommand(driver, config, opts) {
+  const request = {
+    driver,
+    endpoint: config.endpoint,
+    project: config.project,
+    logstore: config.logstore,
+    query: opts.query || '',
+    traceId: opts.traceId || '',
+    requestId: opts.requestId || '',
+    since: opts.since || '15m',
+    limit: opts.limit || 50,
+  };
+  if (!config.queryCommand || opts.dryRun) {
+    return { status: 'dry-run', request, items: [] };
+  }
+  const cmd = render(config.queryCommand, request);
+  const r = spawnSync(cmd, { shell: true, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+  return {
+    status: r.status === 0 ? 'pass' : 'fail',
+    command: cmd,
+    output: ((r.stdout || '') + (r.stderr || '')).slice(0, 12000),
+    items: [],
+  };
+}
+
+function render(s, vars) {
+  return String(s || '').replace(/\$\{([a-zA-Z0-9_]+)\}/g, (_, k) => vars[k] == null ? '' : String(vars[k]));
+}
+
+module.exports = { default: SlsProvider, _internals: { runQueryCommand } };