poe-code 3.0.437 → 3.0.439

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.437",
+  "version": "3.0.439",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/tiny-http-mcp-server/dist/cli.d.ts

@@ -12,6 +12,8 @@ interface RunCliDependencies {
     stdout?: Pick<NodeJS.WriteStream, "write">;
     stderr?: Pick<NodeJS.WriteStream, "write">;
     waitForShutdown?: (shutdown: () => Promise<void>) => Promise<void>;
+    listenForShutdownSignals?: (listener: () => void) => () => void;
+    scheduleShutdownGrace?: (listener: () => void, graceMs: number) => () => void;
 }
 export declare function isCliInvocation(argv: string[], moduleUrl: string, realpath?: (path: string) => string): boolean;
 export declare function runCli(args?: string[], dependencies?: RunCliDependencies): Promise<number>;

package/packages/tiny-http-mcp-server/dist/cli.js

@@ -57,6 +57,8 @@ const HELP_TEXT = [
     "                        Node HTTP headers timeout",
     "  --keep-alive-timeout-ms <ms>",
     "                        Node HTTP keep-alive timeout",
+    "  --shutdown-grace-ms <ms>",
+    "                        Grace period before force-closing connections (default: 10000)",
     "  --oauth-resource <uri> Enable OAuth mode with this canonical resource URI",
     "  --oauth-authorization-server <issuer>",
     "                        Authorization server issuer URL (repeatable)",
@@ -70,6 +72,7 @@ const HELP_TEXT = [
     "                        Module that exports the TokenVerifier implementation",
     "  --oauth-verifier-export <name>",
     "                        Export name to load from the verifier module (default: default)",
+    "  --version              Show the package version",
     "  -h, --help             Show this help message"
 ].join("\n");
 function parsePort(value) {
@@ -206,6 +209,7 @@ function parseCliOptions(args) {
             "request-timeout-ms": { type: "string" },
             "headers-timeout-ms": { type: "string" },
             "keep-alive-timeout-ms": { type: "string" },
+            "shutdown-grace-ms": { type: "string" },
             "oauth-resource": { type: "string" },
             "oauth-authorization-server": { type: "string", multiple: true },
             "oauth-supported-scope": { type: "string", multiple: true },
@@ -213,7 +217,8 @@ function parseCliOptions(args) {
             "oauth-bearer-method": { type: "string", multiple: true },
             "oauth-verifier-module": { type: "string" },
             "oauth-verifier-export": { type: "string" },
-            help: { type: "boolean", short: "h" }
+            help: { type: "boolean", short: "h" },
+            version: { type: "boolean" }
         }
     });
     const maxRequestBytes = parseOptionalInteger(values["max-request-bytes"], "--max-request-bytes", 1);
@@ -228,8 +233,10 @@ function parseCliOptions(args) {
     const requestTimeoutMs = parseOptionalInteger(values["request-timeout-ms"], "--request-timeout-ms", 0);
     const headersTimeoutMs = parseOptionalInteger(values["headers-timeout-ms"], "--headers-timeout-ms", 0);
     const keepAliveTimeoutMs = parseOptionalInteger(values["keep-alive-timeout-ms"], "--keep-alive-timeout-ms", 0);
+    const shutdownGraceMs = parseOptionalInteger(values["shutdown-grace-ms"], "--shutdown-grace-ms", 0) ?? 10_000;
     return {
         help: values.help ?? false,
+        version: values.version ?? false,
         port: parsePort(values.port),
         hostname: values.hostname ?? "127.0.0.1",
         path: values.path ?? "/mcp",
@@ -256,18 +263,67 @@ function parseCliOptions(args) {
         ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
         ...(headersTimeoutMs === undefined ? {} : { headersTimeoutMs }),
         ...(keepAliveTimeoutMs === undefined ? {} : { keepAliveTimeoutMs }),
+        shutdownGraceMs,
         oauth: parseCliOAuthOptions(values)
     };
 }
-function waitForShutdown(shutdown) {
+function listenForShutdownSignals(listener) {
+    process.on("SIGINT", listener);
+    process.on("SIGTERM", listener);
+    return () => {
+        process.off("SIGINT", listener);
+        process.off("SIGTERM", listener);
+    };
+}
+function scheduleShutdownGrace(listener, graceMs) {
+    const timer = setTimeout(listener, graceMs);
+    return () => clearTimeout(timer);
+}
+function waitForShutdown(shutdown, forceShutdown, graceMs, listenForSignals, scheduleGrace) {
     return new Promise((resolve, reject) => {
+        let shutdownStarted = false;
+        let settled = false;
+        let cancelGrace = () => undefined;
+        let removeSignalListeners = () => undefined;
+        const finish = (forced) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cancelGrace();
+            removeSignalListeners();
+            resolve(forced);
+        };
+        const force = () => {
+            if (settled) {
+                return;
+            }
+            try {
+                forceShutdown();
+                finish(true);
+            }
+            catch {
+                finish(true);
+            }
+        };
         const onSignal = () => {
-            process.off("SIGINT", onSignal);
-            process.off("SIGTERM", onSignal);
-            void shutdown().then(resolve, reject);
+            if (shutdownStarted) {
+                force();
+                return;
+            }
+            shutdownStarted = true;
+            cancelGrace = scheduleGrace(force, graceMs);
+            void shutdown().then(() => finish(false), (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cancelGrace();
+                removeSignalListeners();
+                reject(error);
+            });
         };
-        process.once("SIGINT", onSignal);
-        process.once("SIGTERM", onSignal);
+        removeSignalListeners = listenForSignals(onSignal);
     });
 }
 export function isCliInvocation(argv, moduleUrl, realpath = realpathSync) {
@@ -290,13 +346,28 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
     const stdout = dependencies.stdout ?? process.stdout;
     const stderr = dependencies.stderr ?? process.stderr;
     const customWaitForShutdown = dependencies.waitForShutdown;
+    const listenForSignals = dependencies.listenForShutdownSignals ?? listenForShutdownSignals;
+    const scheduleGrace = dependencies.scheduleShutdownGrace ?? scheduleShutdownGrace;
     let handle;
+    let shutdownStarted = false;
+    let options;
+    try {
+        options = parseCliOptions(args);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        stderr.write(`${message}\nRun with --help for usage.\n`);
+        return 1;
+    }
     try {
-        const options = parseCliOptions(args);
         if (options.help) {
             stdout.write(`${HELP_TEXT}\n`);
             return 0;
         }
+        if (options.version) {
+            stdout.write(`${packageInfo.version}\n`);
+            return 0;
+        }
         const oauth = options.oauth === undefined
             ? undefined
             : {
@@ -360,12 +431,19 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
                 : { keepAliveTimeoutMs: options.keepAliveTimeoutMs })
         });
         const shutdown = async () => {
+            shutdownStarted = true;
             await handle?.close();
         };
-        const shutdownPromise = customWaitForShutdown === undefined ? waitForShutdown(shutdown) : undefined;
+        const forceShutdown = () => {
+            handle?.closeAllConnections();
+        };
+        const shutdownPromise = customWaitForShutdown === undefined
+            ? waitForShutdown(shutdown, forceShutdown, options.shutdownGraceMs, listenForSignals, scheduleGrace)
+            : undefined;
         stdout.write(`${handle.url}\n`);
         if (customWaitForShutdown === undefined) {
-            await shutdownPromise;
+            const forced = await shutdownPromise;
+            return forced ? 1 : 0;
         }
         else {
             await customWaitForShutdown(shutdown);
@@ -375,7 +453,12 @@ export async function runCli(args = process.argv.slice(2), dependencies = {}) {
     catch (error) {
         if (handle !== undefined) {
             try {
-                await handle.close();
+                if (shutdownStarted) {
+                    handle.closeAllConnections();
+                }
+                else {
+                    await handle.close();
+                }
             }
             catch {
                 // Preserve the original CLI failure below.

package/packages/tiny-http-mcp-server/dist/http-server.d.ts

@@ -28,6 +28,7 @@ export interface HttpServerHandle {
     url: string;
     port: number;
     close(): Promise<void>;
+    closeAllConnections(): void;
 }
 export interface HttpServer extends Omit<Server, "tool" | "registerTool"> {
     tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: HttpToolHandler<TIn, TOut>, outputSchema?: TypedSchema<TOut>): HttpServer;
@@ -37,6 +38,8 @@ export interface HttpServer extends Omit<Server, "tool" | "registerTool"> {
 }
 export interface HttpToolContext {
     request: AuthenticatedIncomingMessage;
+    sessionId?: string;
+    auth?: RequestAuthInfo;
 }
 export type HttpToolHandler<T = Record<string, unknown>, TOut = ToolReturn> = (args: T, context: HttpToolContext) => Promise<TOut | CallToolResult> | TOut | CallToolResult;
 export declare function createProtectedResourceMetadataDocument(options: ProtectedResourceMetadataOptions): Record<string, unknown>;

package/packages/tiny-http-mcp-server/dist/http-server.js

@@ -94,7 +94,11 @@ export function createHttpServer(options) {
         supportResourceSubscriptions: supportsSessions
     });
     const transport = new StreamableHttpTransport(server, options, async (req, callback) => requestContextStorage.run({
-        request: req
+        request: req,
+        sessionId: Array.isArray(req.headers["mcp-session-id"])
+            ? req.headers["mcp-session-id"][0]
+            : req.headers["mcp-session-id"],
+        auth: req.auth
     }, callback));
     const protectedResourceMetadataBody = options.oauth === undefined
         ? undefined
@@ -103,7 +107,7 @@ export function createHttpServer(options) {
     const registerTool = server.tool.bind(server);
     const registerRichTool = server.registerTool.bind(server);
     const defaultContext = {
-        request: {}
+        request: { headers: {}, socket: {} }
     };
     const authorizeHttpRequest = async (req, res, protectedResourcePath) => {
         if (options.oauth === undefined || req.method === "OPTIONS") {
@@ -238,7 +242,10 @@ export function createHttpServer(options) {
         return {
             url: buildUrl(hostname, resolvedPort, path),
             port: resolvedPort,
-            close
+            close,
+            closeAllConnections: () => {
+                nodeServer.closeAllConnections();
+            }
         };
     };
     httpServer.handleRequest = async (req, res) => {