@dumbmice/pi-mailbridge 0.0.0-stage → 0.1.0

package/dist/core/version.js

@@ -0,0 +1,44 @@
+// Which build is this? Diagnostic only - compatibility is `daemon/api.ts` (API_VERSION).
+//
+// The extension is loaded by pi and the daemon is a child process; after `pi update` the child
+// can still be executing the previous build. `/health` carries this string so a session can
+// notice and replace it, instead of talking to a daemon that mints routing ids it cannot resolve.
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const cache = new Map();
+/**
+ * The version from the package.json that owns this module.
+ *
+ * `dist/daemon/main.js` and `src/daemon/main.ts` are both two levels below the package root, so
+ * one lookup works for a checkout and for an installed build. Unknown is reported as `"unknown"`
+ * rather than guessing: a caller that cannot compare should do nothing.
+ */
+export function packageVersion(moduleUrl) {
+    const key = String(moduleUrl);
+    const cached = cache.get(key);
+    if (cached !== undefined)
+        return cached;
+    // Walk up rather than assuming a depth: `src/extension.ts` is one level below the package
+    // root, `src/daemon/main.ts` and its compiled twin are two, and a test file is one.
+    let version = "unknown";
+    let dir = dirname(fileURLToPath(moduleUrl));
+    for (let depth = 0; depth < 5; depth += 1) {
+        try {
+            const parsed = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+            if (typeof parsed.version === "string" && parsed.version.length > 0) {
+                version = parsed.version;
+                break;
+            }
+        }
+        catch {
+            /* keep walking */
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    cache.set(key, version);
+    return version;
+}

package/dist/daemon/api.js

@@ -0,0 +1,46 @@
+// The wire contract between the extension and the daemon.
+//
+// Two numbers, two clocks, deliberately separate (AGENTS.md "Compatibility"):
+//
+//   API_VERSION  - the HTTP surface: endpoints, payload fields, semantics. Bumped by any
+//                  breaking change to it; additive changes are gated by CAPABILITIES instead.
+//   package version (version.ts) - diagnostic only: which build someone is running.
+//
+// The daemon and the extension are spawned from one package, so a mismatch is recovered by
+// replacing the process rather than negotiating - but the *number* compared must be the
+// protocol, not the build, or a harmless patch bump would restart a working daemon.
+/** Bumped only for a breaking change to an endpoint, a payload shape, or a meaning. */
+export const API_VERSION = 1;
+/**
+ * Additive features inside API_VERSION.
+ *
+ * A client must check for a capability before using anything newer than the base contract, and
+ * must not fake it when absent (no fallback paths: tell the user to update, or skip the feature).
+ */
+export const CAPABILITIES = ["health", "version", "pending", "claim", "ack", "send"];
+/** Every endpoint, in one place, so the schema test can freeze the surface. */
+export const ENDPOINTS = [
+    "GET /events",
+    "GET /health",
+    "GET /pending",
+    "GET /mode",
+    "POST /claim",
+    "POST /ack",
+    "POST /register",
+    "DELETE /register",
+    "POST /ping",
+    "POST /bye",
+    "POST /shutdown",
+    "POST /reload",
+    "POST /mode",
+    "POST /send",
+];
+/**
+ * Is a daemon speaking `theirs` usable by this build?
+ *
+ * Missing means "from before the field existed" - that is protocol 0, which this build cannot
+ * assume anything about.
+ */
+export function apiCompatible(mine, theirs) {
+    return typeof theirs === "number" && theirs === mine;
+}

package/dist/daemon/imapflow.js

@@ -0,0 +1,75 @@
+// Real imapflow client factory.
+//
+// Kept separate from watcher.ts so the watcher stays testable: nothing here runs
+// in a unit test. Note the two auth modes mirror core/mailer.ts — LOGIN uses an
+// app password, XOAUTH2 needs an access token fetched before connect().
+import { ImapFlow, } from "imapflow";
+import { createCommandTokenProvider } from "../core/oauth.js";
+/** Auth block for imapflow, honouring the configured auth type. */
+export async function buildImapAuth(config, getAccessToken) {
+    const imap = config.mail.imap;
+    if (imap.authType === "XOAUTH2") {
+        if (!getAccessToken) {
+            throw new Error("pi-mailbridge: imap.authType is XOAUTH2 but no token provider is configured");
+        }
+        const accessToken = await getAccessToken();
+        if (!accessToken)
+            throw new Error("pi-mailbridge: OAuth2 token provider returned an empty token for IMAP");
+        return { user: imap.user, accessToken };
+    }
+    return { user: imap.user, pass: imap.password };
+}
+/**
+ * Adapt the real client to the narrow interface the watcher uses.
+ *
+ * An explicit adapter rather than a cast: every call below is checked against
+ * imapflow's real signature, so a major bump that renames or re-shapes a method
+ * fails the build instead of failing at 3am.
+ */
+export function adapt(client) {
+    return {
+        connect: () => client.connect(),
+        logout: () => client.logout(),
+        mailboxOpen: (path) => client.mailboxOpen(path),
+        // imapflow returns `false`/`undefined` for an empty result set. Normalizing
+        // here is not cosmetic: without it a quiet mailbox would throw inside the scan.
+        search: async (query, options) => {
+            const result = await client.search(query, options);
+            return Array.isArray(result) ? result : [];
+        },
+        fetchOne: (uid, query, options) => client.fetchOne(uid, query, options),
+        messageFlagsAdd: (uid, flags, options) => client.messageFlagsAdd(uid, flags, options),
+        // ImapFlow's event map cannot be expressed generically; this is the one
+        // boundary that needs a cast, and the events we listen for are covered by
+        // the watcher's own tests.
+        on: (event, listener) => {
+            client.on(event, listener);
+        },
+        get usable() {
+            return client.usable;
+        },
+        // Pass the whole mailbox through, never a hand-built subset: an enumerated copy has
+        // silently dropped a field twice (uidValidity, then uidNext) and both times the guard
+        // that read it went inert in production with the tests still green.
+        get mailbox() {
+            return client.mailbox === false ? undefined : client.mailbox;
+        },
+    };
+}
+export function createImapflowFactory(options = {}) {
+    return async (config, tuning) => {
+        const auth = await buildImapAuth(config, options.getAccessToken);
+        const client = new ImapFlow({
+            host: config.mail.imap.host,
+            port: config.mail.imap.port,
+            secure: config.mail.imap.secure,
+            // imapflow 2 exposes a typed AuthOptions; no cast needed.
+            auth,
+            // Renew IDLE well under the server's ~29 minute cutoff.
+            maxIdleTime: tuning.idleRenewMs,
+            // Never let imapflow log credentials or raw protocol.
+            logger: false,
+        });
+        return adapt(client);
+    };
+}