@hono/cli 0.1.8 → 0.1.10

package/README.md

@@ -157,6 +157,12 @@ hono request [file] [options]
 - `-d, --data <data>` - Request body data
 - `-H, --header <header>` - Custom headers (can be used multiple times)
 - `-w, --watch` - Watch for changes and resend request
+- `-J, --json` - Output response as JSON
+- `-o, --output <file>` - Write to file instead of stdout
+- `-O, --remote-name` - Write output to file named as remote file
+- `-i, --include` - Include protocol and headers in the output
+- `-I, --head` - Show only protocol and headers in the output
+- `-e, --external <package>` - Mark package as external (can be used multiple times)
 
 **Examples:**
 
@@ -178,6 +184,9 @@ hono request -P /api/protected \
   -H 'Authorization: Bearer token' \
   -H 'User-Agent: MyApp' \
   src/your-app.ts
+
+# Request with external packages (useful for Node.js native modules)
+hono request -e pg -e dotenv src/your-app.ts
 ```
 
 **Response Format:**
@@ -212,6 +221,7 @@ hono serve [entry] [options]
 - `-p, --port <port>` - Port number (default: 7070)
 - `--show-routes` - Show registered routes
 - `--use <middleware>` - Use middleware (can be used multiple times)
+- `-e, --external <package>` - Mark package as external (can be used multiple times)
 
 **Examples:**
 
@@ -238,6 +248,9 @@ hono serve --use 'cors()' --use 'logger()' src/app.ts
 hono serve \
   --use 'basicAuth({ username: "foo", password: "bar" })' \
   --use "serveStatic({ root: './' })"
+
+# Start server with external packages (useful for Node.js native modules)
+hono serve -e pg -e prisma src/app.ts
 ```
 
 ### `optimize`

package/dist/cli.js

@@ -14665,7 +14665,7 @@ var require_lib = __commonJS({
 // src/cli.ts
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname3, join as join2 } from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/docs/index.ts
@@ -16206,43 +16206,179 @@ var isIdentifier = (key) => key.type === "Identifier";
 var isPrivateIdentifier = (key) => key.type === "PrivateName";
 
 // src/commands/request/index.ts
-import { existsSync as existsSync2, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve2 } from "path";
+
+// src/utils/file.ts
+import { getExtension } from "hono/utils/mime";
+import { existsSync as existsSync2, createWriteStream } from "fs";
+import { dirname as dirname2, basename } from "path";
+var getFilenameFromPath = (path, contentType) => {
+  const url = new URL(path, "http://localhost");
+  const pathname = url.pathname;
+  if (pathname === "/") {
+    if (contentType) {
+      const parts = contentType.split(";");
+      for (const part of parts) {
+        const mimeType = part.trim().toLowerCase();
+        const extension = getExtension(mimeType);
+        if (extension) {
+          return `index.${extension}`;
+        }
+      }
+    }
+    return "index";
+  }
+  const name = basename(pathname);
+  return name;
+};
+var saveFile = async (buffer, filepath) => {
+  if (existsSync2(filepath)) {
+    throw new Error(`File ${filepath} already exists.`);
+  }
+  const dir = dirname2(filepath);
+  if (!existsSync2(dir)) {
+    throw new Error(`Directory ${dir} does not exist.`);
+  }
+  const totalBytes = buffer.byteLength;
+  const view = new Uint8Array(buffer);
+  const chunkSize = 1024 * 64;
+  let savedBytes = 0;
+  const stream = createWriteStream(filepath);
+  return new Promise((resolve4, reject) => {
+    stream.on("error", (err) => reject(err));
+    const writeChunk = (index) => {
+      if (index >= totalBytes) {
+        stream.end(() => {
+          resolve4();
+        });
+        return;
+      }
+      const end = Math.min(index + chunkSize, totalBytes);
+      const chunk = view.slice(index, end);
+      stream.write(chunk, (err) => {
+        if (err) {
+          stream.destroy(err);
+          reject(err);
+          return;
+        }
+        savedBytes += chunk.length;
+        console.log(`Saved ${savedBytes} of ${totalBytes} bytes`);
+        writeChunk(end);
+      });
+    };
+    writeChunk(0);
+  });
+};
+
+// src/commands/request/index.ts
 var DEFAULT_ENTRY_CANDIDATES2 = ["src/index.ts", "src/index.tsx", "src/index.js", "src/index.jsx"];
 function requestCommand(program2) {
-  program2.command("request").description("Send request to Hono app using app.request()").argument("[file]", "Path to the Hono app file").option("-P, --path <path>", "Request path", "/").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <data>", "Request body data").option("-w, --watch", "Watch for changes and resend request", false).option(
+  program2.command("request").description("Send request to Hono app using app.request()").argument("[file]", "Path to the Hono app file").option("-P, --path <path>", "Request path", "/").option("-X, --method <method>", "HTTP method", "GET").option("-d, --data <data>", "Request body data").option("-w, --watch", "Watch for changes and resend request", false).option("-J, --json", "Output response as JSON", false).option(
     "-H, --header <header>",
     "Custom headers",
     (value, previous) => {
       return previous ? [...previous, value] : [value];
     },
     []
+  ).option("-o, --output <file>", "Write to file instead of stdout").option("-O, --remote-name", "Write output to file named as remote file", false).option("-i, --include", "Include protocol and headers in the output", false).option("-I, --head", "Show only protocol and headers in the output", false).option(
+    "-e, --external <package>",
+    "Mark package as external (can be used multiple times)",
+    (value, previous) => {
+      return previous ? [...previous, value] : [value];
+    },
+    []
   ).action(async (file, options) => {
+    const doSaveFile = options.output || options.remoteName;
     const path = options.path || "/";
     const watch = options.watch;
-    const buildIterator = getBuildIterator(file, watch);
+    const external = options.external || [];
+    const buildIterator = getBuildIterator(file, watch, external);
     for await (const app of buildIterator) {
       const result = await executeRequest(app, path, options);
-      console.log(JSON.stringify(result, null, 2));
+      const contentType = result.headers["content-type"];
+      const outputBody = formatResponseBody(
+        result.body,
+        contentType,
+        options.json && !options.include
+      );
+      const buffer = await result.response.clone().arrayBuffer();
+      const isBinaryData = isBinaryResponse(buffer);
+      if (isBinaryData && !doSaveFile) {
+        console.warn("Binary output can mess up your terminal.");
+        continue;
+      }
+      const outputData = getOutputData(
+        buffer,
+        outputBody,
+        isBinaryData,
+        options,
+        result.status,
+        result.headers
+      );
+      if (!isBinaryData) {
+        console.log(outputData);
+      }
+      if (doSaveFile) {
+        await handleSaveOutput(outputData, path, options, contentType);
+      }
     }
   });
 }
-function getBuildIterator(appPath, watch) {
+function getOutputData(buffer, outputBody, isBinaryData, options, status, headers) {
+  if (isBinaryData) {
+    return buffer;
+  }
+  const headerLines = [];
+  headerLines.push(`${status}`);
+  for (const key in headers) {
+    headerLines.push(`\x1B[1m${key}\x1B[0m: ${headers[key]}`);
+  }
+  const headerOutput = headerLines.join("\n");
+  if (options.head) {
+    return headerOutput + "\n";
+  }
+  if (options.include) {
+    return headerOutput + "\n\n" + outputBody;
+  }
+  if (options.json) {
+    return JSON.stringify({ status, body: outputBody, headers }, null, 2);
+  }
+  return outputBody;
+}
+async function handleSaveOutput(saveData, requestPath, options, contentType) {
+  let filepath;
+  if (options.output) {
+    filepath = options.output;
+  } else {
+    filepath = getFilenameFromPath(requestPath, contentType);
+  }
+  try {
+    await saveFile(
+      typeof saveData === "string" ? new TextEncoder().encode(saveData).buffer : saveData instanceof ArrayBuffer ? saveData : new TextEncoder().encode(JSON.stringify(saveData)).buffer,
+      filepath
+    );
+    console.log(`Saved response to ${filepath}`);
+  } catch (error) {
+    console.error(`Error saving file: ${error.message}`);
+  }
+}
+function getBuildIterator(appPath, watch, external = []) {
   let entry;
   let resolvedAppPath;
   if (appPath) {
     entry = appPath;
     resolvedAppPath = resolve2(process.cwd(), entry);
   } else {
-    entry = DEFAULT_ENTRY_CANDIDATES2.find((candidate) => existsSync2(resolve2(process.cwd(), candidate))) ?? DEFAULT_ENTRY_CANDIDATES2[0];
+    entry = DEFAULT_ENTRY_CANDIDATES2.find((candidate) => existsSync3(resolve2(process.cwd(), candidate))) ?? DEFAULT_ENTRY_CANDIDATES2[0];
     resolvedAppPath = resolve2(process.cwd(), entry);
   }
-  if (!existsSync2(resolvedAppPath)) {
+  if (!existsSync3(resolvedAppPath)) {
     throw new Error(`Entry file ${entry} does not exist`);
   }
   const appFilePath = realpathSync2(resolvedAppPath);
   return buildAndImportApp(appFilePath, {
-    external: ["@hono/node-server"],
+    external: ["@hono/node-server", ...external],
     watch,
     sourcemap: true
   });
@@ -16271,13 +16407,39 @@ async function executeRequest(app, requestPath, options) {
   response.headers.forEach((value, key) => {
     responseHeaders[key] = value;
   });
-  const body = await response.text();
+  const body = await response.clone().text();
   return {
     status: response.status,
     body,
-    headers: responseHeaders
+    headers: responseHeaders,
+    response
   };
 }
+var formatResponseBody = (responseBody, contentType, jsonOption) => {
+  if (contentType && /^application\/(json|[^;\s]+\+json)($|;)/i.test(contentType)) {
+    try {
+      const parsedJSON = JSON.parse(responseBody);
+      if (jsonOption) {
+        return parsedJSON;
+      }
+      return JSON.stringify(parsedJSON, null, 2);
+    } catch {
+      console.error("Response indicated JSON content type but failed to parse JSON.");
+      return responseBody;
+    }
+  }
+  return responseBody;
+};
+var isBinaryResponse = (buffer) => {
+  const view = new Uint8Array(buffer);
+  const len = Math.min(view.length, 2e3);
+  for (let i = 0; i < len; i++) {
+    if (view[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+};
 
 // src/commands/search/index.ts
 function searchCommand(program2) {
@@ -16403,7 +16565,7 @@ import { serve } from "@hono/node-server";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { Hono } from "hono";
 import { showRoutes } from "hono/dev";
-import { existsSync as existsSync3, realpathSync as realpathSync3 } from "fs";
+import { existsSync as existsSync4, realpathSync as realpathSync3 } from "fs";
 import { resolve as resolve3 } from "path";
 
 // src/commands/serve/builtin-map.ts
@@ -16496,67 +16658,72 @@ function serveCommand(program2) {
       return previous ? [...previous, value] : [value];
     },
     []
-  ).action(
-    async (entry, options) => {
-      let app;
-      if (!entry) {
+  ).option(
+    "-e, --external <package>",
+    "Mark package as external (can be used multiple times)",
+    (value, previous) => {
+      return previous ? [...previous, value] : [value];
+    },
+    []
+  ).action(async (entry, options) => {
+    let app;
+    if (!entry) {
+      app = new Hono();
+    } else {
+      const appPath = resolve3(process.cwd(), entry);
+      if (!existsSync4(appPath)) {
         app = new Hono();
       } else {
-        const appPath = resolve3(process.cwd(), entry);
-        if (!existsSync3(appPath)) {
-          app = new Hono();
-        } else {
-          const appFilePath = realpathSync3(appPath);
-          const buildIterator = buildAndImportApp(appFilePath, {
-            external: ["@hono/node-server"],
-            sourcemap: true
-          });
-          app = (await buildIterator.next()).value;
-        }
+        const appFilePath = realpathSync3(appPath);
+        const buildIterator = buildAndImportApp(appFilePath, {
+          external: ["@hono/node-server", ...options.external || []],
+          sourcemap: true
+        });
+        app = (await buildIterator.next()).value;
       }
-      const allFunctions = {};
-      const uniqueModules = [...new Set(Object.values(builtinMap))];
-      for (const modulePath of uniqueModules) {
-        try {
-          const module = await import(modulePath);
-          for (const [funcName, modulePathInMap] of Object.entries(builtinMap)) {
-            if (modulePathInMap === modulePath && module[funcName]) {
-              allFunctions[funcName] = module[funcName];
-            }
+    }
+    const allFunctions = {};
+    const uniqueModules = [...new Set(Object.values(builtinMap))];
+    for (const modulePath of uniqueModules) {
+      try {
+        const module = await import(modulePath);
+        for (const [funcName, modulePathInMap] of Object.entries(builtinMap)) {
+          if (modulePathInMap === modulePath && module[funcName]) {
+            allFunctions[funcName] = module[funcName];
           }
-        } catch (error) {
         }
+      } catch (error) {
       }
-      const baseApp = new Hono();
-      for (const use of options.use || []) {
-        const functionNames = Object.keys(allFunctions);
-        const functionValues = Object.values(allFunctions);
-        const func = new Function("c", "next", ...functionNames, `return (${use})`);
-        baseApp.use(async (c, next) => {
-          const middleware = func(c, next, ...functionValues);
-          return typeof middleware === "function" ? middleware(c, next) : middleware;
-        });
-      }
-      baseApp.route("/", app);
-      if (options.showRoutes) {
-        showRoutes(baseApp);
-      }
-      serve(
-        {
-          fetch: baseApp.fetch,
-          port: options.port ?? 7070
-        },
-        (info) => {
-          console.log(`Listening on http://localhost:${info.port}`);
-        }
-      );
     }
-  );
+    const baseApp = new Hono();
+    for (const use of options.use || []) {
+      const functionNames = Object.keys(allFunctions);
+      const functionValues = Object.values(allFunctions);
+      const func = new Function("c", "next", ...functionNames, `return (${use})`);
+      baseApp.use(async (c, next) => {
+        const middleware = func(c, next, ...functionValues);
+        return typeof middleware === "function" ? middleware(c, next) : middleware;
+      });
+    }
+    baseApp.route("/", app);
+    if (options.showRoutes) {
+      showRoutes(baseApp);
+    }
+    serve(
+      {
+        fetch: baseApp.fetch,
+        port: options.port ?? 7070
+      },
+      (info) => {
+        console.log(`Listening on http://localhost:${info.port}`);
+      }
+    );
+  });
 }
 
 // src/cli.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname3(__filename);
 var packageJson = JSON.parse(readFileSync2(join2(__dirname, "../package.json"), "utf-8"));
 var program = new Command();
 program.name("hono").description("CLI for Hono").version(packageJson.version, "-v, --version", "display version number");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hono/cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "bin": {
     "hono": "dist/cli.js"