@push.rocks/smartacme 6.1.3 → 6.2.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartacme',
-    version: '6.1.3',
+    version: '6.2.0',
     description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZHQUE2RztDQUMzSCxDQUFBIn0=

package/dist_ts/handlers/Http01Handler.d.ts

@@ -3,20 +3,20 @@ import type { IChallengeHandler } from './IChallengeHandler.js';
  * HTTP-01 ACME challenge handler using file-system webroot.
  * Writes and removes the challenge file under <webroot>/.well-known/acme-challenge/.
  */
-export interface Http01HandlerOptions {
+export interface Http01WebrootOptions {
     /**
      * Directory that serves HTTP requests for /.well-known/acme-challenge
      */
     webroot: string;
 }
-export declare class Http01Handler implements IChallengeHandler<{
+export declare class Http01Webroot implements IChallengeHandler<{
     type: string;
     token: string;
     keyAuthorization: string;
     webPath: string;
 }> {
     private webroot;
-    constructor(options: Http01HandlerOptions);
+    constructor(options: Http01WebrootOptions);
     getSupportedTypes(): string[];
     prepare(ch: {
         token: string;

package/dist_ts/handlers/Http01Handler.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-export class Http01Handler {
+export class Http01Webroot {
     constructor(options) {
         this.webroot = options.webroot;
     }

package/dist_ts/handlers/Http01MemoryHandler.d.ts

@@ -0,0 +1,26 @@
+import type { IChallengeHandler } from './IChallengeHandler.js';
+/**
+ * HTTP-01 ACME challenge handler using in-memory storage.
+ * Stores challenge tokens and key authorizations in memory
+ * and serves them via handleRequest for arbitrary HTTP servers.
+ */
+export interface Http01MemoryHandlerChallenge {
+    type: string;
+    token: string;
+    keyAuthorization: string;
+    webPath: string;
+}
+export declare class Http01MemoryHandler implements IChallengeHandler<Http01MemoryHandlerChallenge> {
+    private store;
+    getSupportedTypes(): string[];
+    prepare(ch: Http01MemoryHandlerChallenge): Promise<void>;
+    verify(_ch: Http01MemoryHandlerChallenge): Promise<void>;
+    cleanup(ch: Http01MemoryHandlerChallenge): Promise<void>;
+    /**
+     * HTTP request handler for serving ACME HTTP-01 challenges.
+     * @param req HTTP request object (should have url property)
+     * @param res HTTP response object
+     * @param next Optional next() callback for Express-style fallthrough
+     */
+    handleRequest(req: any, res: any, next?: () => void): void;
+}

package/dist_ts/handlers/Http01MemoryHandler.js

@@ -0,0 +1,51 @@
+export class Http01MemoryHandler {
+    constructor() {
+        this.store = new Map();
+    }
+    getSupportedTypes() {
+        return ['http-01'];
+    }
+    async prepare(ch) {
+        this.store.set(ch.token, ch.keyAuthorization);
+    }
+    async verify(_ch) {
+        // No-op
+        return;
+    }
+    async cleanup(ch) {
+        this.store.delete(ch.token);
+    }
+    /**
+     * HTTP request handler for serving ACME HTTP-01 challenges.
+     * @param req HTTP request object (should have url property)
+     * @param res HTTP response object
+     * @param next Optional next() callback for Express-style fallthrough
+     */
+    handleRequest(req, res, next) {
+        const url = req.url || '';
+        const prefix = '/.well-known/acme-challenge/';
+        if (!url.startsWith(prefix)) {
+            if (next) {
+                return next();
+            }
+            res.statusCode = 404;
+            return res.end();
+        }
+        const token = url.slice(prefix.length);
+        const keyAuth = this.store.get(token);
+        if (keyAuth !== undefined) {
+            if (typeof res.status === 'function' && typeof res.send === 'function') {
+                return res.status(200).send(keyAuth);
+            }
+            res.statusCode = 200;
+            res.setHeader('content-type', 'text/plain');
+            return res.end(keyAuth);
+        }
+        if (next) {
+            return next();
+        }
+        res.statusCode = 404;
+        return res.end();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/handlers/index.d.ts

@@ -1,3 +1,4 @@
 export type { IChallengeHandler } from './IChallengeHandler.js';
 export { Dns01Handler } from './Dns01Handler.js';
-export { Http01Handler } from './Http01Handler.js';
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';

package/dist_ts/handlers/index.js

@@ -1,4 +1,5 @@
 // Removed legacy handler adapter
 export { Dns01Handler } from './Dns01Handler.js';
-export { Http01Handler } from './Http01Handler.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartacme",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "private": false,
   "description": "A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -61,7 +61,7 @@ const smartAcmeInstance = new SmartAcme({
   retryOptions: {},         // optional retry/backoff settings
   challengeHandlers: [
     new Dns01Handler(cfAccount),
-    // you can add more handlers, e.g. Http01Handler
+    // you can add more handlers, e.g. Http01Webroot
   ],
   challengePriority: ['dns-01'], // optional ordering of challenge types
 });
@@ -143,7 +143,7 @@ async function main() {
  
  ## Built-in Challenge Handlers
  
- This module includes two out-of-the-box ACME challenge handlers:
+ This module includes three out-of-the-box ACME challenge handlers:
  
  - **Dns01Handler**
    - Uses a Cloudflare account (from `@apiclient.xyz/cloudflare`) and Smartdns client to set and remove DNS TXT records, then wait for propagation.
@@ -158,18 +158,31 @@ async function main() {
      const dnsHandler = new Dns01Handler(cfAccount);
      ```
  
- - **Http01Handler**
+ - **Http01Webroot**
    - Writes ACME HTTP-01 challenge files under a file-system webroot (`/.well-known/acme-challenge/`), and removes them on cleanup.
    - Import path:
      ```typescript
-     import { Http01Handler } from '@push.rocks/smartacme/ts/handlers/Http01Handler.js';
+     import { Http01Webroot } from '@push.rocks/smartacme/ts/handlers/Http01Handler.js';
      ```
    - Example:
      ```typescript
-     const httpHandler = new Http01Handler({ webroot: '/var/www/html' });
+     const httpHandler = new Http01Webroot({ webroot: '/var/www/html' });
      ```
  
- Both handlers implement the `IChallengeHandler<T>` interface and can be combined in the `challengeHandlers` array.
+ - **Http01MemoryHandler**
+   - In-memory HTTP-01 challenge handler that stores and serves ACME tokens without disk I/O.
+   - Import path:
+     ```typescript
+     import { Http01MemoryHandler } from '@push.rocks/smartacme/ts/handlers/Http01MemoryHandler.js';
+     ```
+   - Example (Express integration):
+     ```typescript
+     import { Http01MemoryHandler } from '@push.rocks/smartacme/ts/handlers/Http01MemoryHandler.js';
+     const memoryHandler = new Http01MemoryHandler();
+     app.use((req, res, next) => memoryHandler.handleRequest(req, res, next));
+     ```
+  
+ All handlers implement the `IChallengeHandler<T>` interface and can be combined in the `challengeHandlers` array.
  
  ## Creating Custom Handlers
  

package/readme.plan.md

@@ -0,0 +1,44 @@
+# Plan: Diskless HTTP-01 Handler and Renaming Existing Handler
+
+This plan outlines steps to rename the existing filesystem-based HTTP-01 handler to `Http01Webroot`
+and introduce a new diskless (in-memory) HTTP-01 handler for integration with arbitrary HTTP servers
+(e.g., Express).
+
+## 1. Rename existing handler to Http01Webroot
+- In `ts/handlers/Http01Handler.ts`:
+  - Rename `Http01HandlerOptions` to `Http01WebrootOptions`.
+  - Rename class `Http01Handler` to `Http01Webroot`.
+  - Remove the legacy alias; rename the handler directly.
+  - In `ts/handlers/index.ts`:
+    - Export `Http01Webroot` under its new name.
+    - Remove any `Http01Handler` export.
+    - Update existing tests (e.g., `test.handlers-http01.ts`) to import `Http01Webroot` instead of `Http01Handler`.
+
+## 2. Add new diskless (in-memory) HTTP-01 handler
+- Create `ts/handlers/Http01MemoryHandler.ts`:
+  - Implement `IChallengeHandler<{ token: string; keyAuthorization: string; webPath: string }>`, storing challenges in a private `Map<string, string>`.
+  - `prepare()`: add token→keyAuthorization mapping.
+  - `verify()`: no-op.
+  - `cleanup()`: remove mapping.
+  - Add `handleRequest(req, res, next?)` method:
+    - Parse `/.well-known/acme-challenge/:token` from `req.url`.
+    - If token exists, respond with the key authorization and status 200.
+    - If missing and `next` provided, call `next()`, otherwise respond 404.
+- Export `Http01MemoryHandler` in `ts/handlers/index.ts`.
+
+## 3. Write tests for Http01MemoryHandler
+- Create `test/test.handlers-http01-memory.ts`:
+  - Use `tap` and `expect` to:
+    1. `prepare()` a challenge.
+    2. Invoke `handleRequest()` with a fake `req`/`res` to confirm 200 and correct body.
+    3. `cleanup()` the challenge.
+    4. Confirm `handleRequest()` now yields 404.
+
+## 4. Update documentation
+- Add examples in `readme.md` showing how to use both `Http01Webroot` and the new `Http01MemoryHandler`:
+  - Sample code for Express integration using `handleRequest`.
+
+## 5. Build and test
+- Run `pnpm build` and `pnpm test`, ensuring existing tests are updated for `Http01Webroot` and new tests pass.
+
+Please review and let me know if this plan makes sense before proceeding with implementation.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartacme',
-  version: '6.1.3',
+  version: '6.2.0',
   description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
 }

package/ts/handlers/Http01Handler.ts

@@ -6,14 +6,14 @@ import type { IChallengeHandler } from './IChallengeHandler.js';
  * HTTP-01 ACME challenge handler using file-system webroot.
  * Writes and removes the challenge file under <webroot>/.well-known/acme-challenge/. 
  */
-export interface Http01HandlerOptions {
+export interface Http01WebrootOptions {
   /**
    * Directory that serves HTTP requests for /.well-known/acme-challenge
    */
   webroot: string;
 }
 
-export class Http01Handler implements IChallengeHandler<{
+export class Http01Webroot implements IChallengeHandler<{
   type: string;
   token: string;
   keyAuthorization: string;
@@ -21,7 +21,7 @@ export class Http01Handler implements IChallengeHandler<{
 }> {
   private webroot: string;
 
-  constructor(options: Http01HandlerOptions) {
+  constructor(options: Http01WebrootOptions) {
     this.webroot = options.webroot;
   }
 

package/ts/handlers/Http01MemoryHandler.ts

@@ -0,0 +1,67 @@
+import type { IChallengeHandler } from './IChallengeHandler.js';
+
+/**
+ * HTTP-01 ACME challenge handler using in-memory storage.
+ * Stores challenge tokens and key authorizations in memory
+ * and serves them via handleRequest for arbitrary HTTP servers.
+ */
+export interface Http01MemoryHandlerChallenge {
+  type: string;
+  token: string;
+  keyAuthorization: string;
+  webPath: string;
+}
+
+export class Http01MemoryHandler implements IChallengeHandler<Http01MemoryHandlerChallenge> {
+  private store: Map<string, string> = new Map();
+
+  public getSupportedTypes(): string[] {
+    return ['http-01'];
+  }
+
+  public async prepare(ch: Http01MemoryHandlerChallenge): Promise<void> {
+    this.store.set(ch.token, ch.keyAuthorization);
+  }
+
+  public async verify(_ch: Http01MemoryHandlerChallenge): Promise<void> {
+    // No-op
+    return;
+  }
+
+  public async cleanup(ch: Http01MemoryHandlerChallenge): Promise<void> {
+    this.store.delete(ch.token);
+  }
+
+  /**
+   * HTTP request handler for serving ACME HTTP-01 challenges.
+   * @param req HTTP request object (should have url property)
+   * @param res HTTP response object
+   * @param next Optional next() callback for Express-style fallthrough
+   */
+  public handleRequest(req: any, res: any, next?: () => void): void {
+    const url = req.url || '';
+    const prefix = '/.well-known/acme-challenge/';
+    if (!url.startsWith(prefix)) {
+      if (next) {
+        return next();
+      }
+      res.statusCode = 404;
+      return res.end();
+    }
+    const token = url.slice(prefix.length);
+    const keyAuth = this.store.get(token);
+    if (keyAuth !== undefined) {
+      if (typeof res.status === 'function' && typeof res.send === 'function') {
+        return res.status(200).send(keyAuth);
+      }
+      res.statusCode = 200;
+      res.setHeader('content-type', 'text/plain');
+      return res.end(keyAuth);
+    }
+    if (next) {
+      return next();
+    }
+    res.statusCode = 404;
+    return res.end();
+  }
+}

package/ts/handlers/index.ts

@@ -1,4 +1,5 @@
 export type { IChallengeHandler } from './IChallengeHandler.js';
 // Removed legacy handler adapter
 export { Dns01Handler } from './Dns01Handler.js';
-export { Http01Handler } from './Http01Handler.js';
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';