@fedify/cli 2.0.0-pr.458.1788 → 2.0.0-pr.458.1796

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/cli",
-  "version": "2.0.0-pr.458.1788+db30ba33",
+  "version": "2.0.0-pr.458.1796+f091195d",
   "license": "MIT",
   "exports": "./src/mod.ts",
   "imports": {

package/dist/deno.js

@@ -3,7 +3,7 @@
     
 //#region deno.json
 var name = "@fedify/cli";
-var version = "2.0.0-pr.458.1788+db30ba33";
+var version = "2.0.0-pr.458.1796+f091195d";
 var license = "MIT";
 var exports = "./src/mod.ts";
 var imports = {

package/dist/generate-vocab/action.js

@@ -8,12 +8,12 @@ import { message } from "@optique/core/message";
 import process from "node:process";
 
 //#region src/generate-vocab/action.ts
-async function runGenerateVocab({ schemaPath, generatedPath }) {
-	if (!(await stat(schemaPath)).isDirectory()) {
-		printError(message`${schemaPath} is not a directory.`);
+async function runGenerateVocab({ schemaDir, generatedPath }) {
+	if (!(await stat(schemaDir)).isDirectory()) {
+		printError(message`${schemaDir} is not a directory.`);
 		process.exit(1);
 	}
-	await generateVocab(schemaPath, generatedPath);
+	await generateVocab(schemaDir, generatedPath);
 }
 
 //#endregion

package/dist/generate-vocab/command.js

@@ -5,13 +5,21 @@ import { command, constant, message, object, option } from "@optique/core";
 import { path } from "@optique/run";
 
 //#region src/generate-vocab/command.ts
-const schemaPath = option("-i", "--input", path({ metavar: "SCHEMA FILES PATH" }));
-const generatedPath = option("-o", "--output", path({ metavar: "GENERATED CODE PATH" }));
+const schemaDir = option("-i", "--input", path({
+	metavar: "DIR",
+	type: "directory",
+	mustExist: true
+}));
+const generatedPath = option("-o", "--output", path({
+	metavar: "PATH",
+	type: "file",
+	allowCreate: true
+}));
 const generateVocabCommand = command("generate-vocab", object({
 	command: constant("generate-vocab"),
-	schemaPath,
+	schemaDir,
 	generatedPath
-}), { description: message`Generate Vocabulary Classes from Schema Files` });
+}), { description: message`Generate vocabulary classes from schema files.` });
 var command_default = generateVocabCommand;
 
 //#endregion

package/dist/mod.js

@@ -30,7 +30,7 @@ async function main() {
 	if (result.command === "webfinger") await runWebFinger(result);
 	if (result.command === "inbox") runInbox(result);
 	if (result.command === "nodeinfo") runNodeInfo(result);
-	if (result.command === "tunnel") runTunnel(result);
+	if (result.command === "tunnel") await runTunnel(result);
 	if (result.command === "generate-vocab") await runGenerateVocab(result);
 }
 await main();

package/dist/tunnel.js

@@ -1,20 +1,54 @@
 
       import { Temporal } from "@js-temporal/polyfill";
     
-import { debugOption } from "./globals.js";
-import { argument, command, constant, integer, merge, message, object } from "@optique/core";
+import { configureLogging, debugOption } from "./globals.js";
+import { argument, command, constant, integer, merge, message, object, option, optional } from "@optique/core";
+import { print, printError } from "@optique/run";
+import process from "node:process";
+import ora from "ora";
+import { openTunnel } from "@hongminhee/localtunnel";
+import { choice as choice$1 } from "@optique/core/valueparser";
 
 //#region src/tunnel.ts
-const tunnelCommand = command("tunnel", merge(object({
-	command: constant("tunnel"),
+const tunnelCommand = command("tunnel", merge("Tunnel options", object({ command: constant("tunnel") }), object({
 	port: argument(integer({
 		metavar: "PORT",
 		min: 0,
 		max: 65535
-	}))
-}), debugOption), { description: message`Expose a local HTTP server to the public internet using a secure tunnel.` });
-function runTunnel(command$1) {
-	console.debug(command$1);
+	}), { description: message`The local port number to expose.` }),
+	service: optional(option("-s", "--service", choice$1([
+		"localhost.run",
+		"serveo.net",
+		"pinggy.io"
+	]), { description: message`The localtunnel service to use.` }))
+}), debugOption), { description: message`Expose a local HTTP server to the public internet using a secure tunnel.\nNote that the HTTP requests through the tunnel have X-Forwarded-* headers.` });
+async function runTunnel(command$1, deps = {
+	openTunnel,
+	ora,
+	exit: process.exit
+}) {
+	if (command$1.debug) await configureLogging();
+	const spinner = deps.ora({
+		text: "Creating a secure tunnel...",
+		discardStdin: false
+	}).start();
+	let tunnel;
+	try {
+		tunnel = await deps.openTunnel({
+			port: command$1.port,
+			service: command$1.service
+		});
+	} catch (error) {
+		if (command$1.debug) printError(message`${String(error)}`);
+		spinner.fail("Failed to create a secure tunnel.");
+		deps.exit(1);
+	}
+	spinner.succeed(`Your local server at ${command$1.port} is now publicly accessible:\n`);
+	print(message`${tunnel.url.href}`);
+	print(message`\nPress ^C to close the tunnel.`);
+	process.on("SIGINT", async () => {
+		await tunnel.close();
+	});
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/cli",
-  "version": "2.0.0-pr.458.1788+db30ba33",
+  "version": "2.0.0-pr.458.1796+f091195d",
   "description": "CLI toolchain for Fedify and debugging ActivityPub",
   "keywords": [
     "fedify",
@@ -71,9 +71,10 @@
     "ora": "^8.2.0",
     "shiki": "^1.6.4",
     "srvx": "^0.8.7",
-    "@fedify/sqlite": "2.0.0-pr.458.1788+db30ba33",
-    "@fedify/vocab-runtime": "2.0.0-pr.458.1788+db30ba33",
-    "@fedify/fedify": "2.0.0-pr.458.1788+db30ba33"
+    "@fedify/fedify": "2.0.0-pr.458.1796+f091195d",
+    "@fedify/sqlite": "2.0.0-pr.458.1796+f091195d",
+    "@fedify/vocab-runtime": "2.0.0-pr.458.1796+f091195d",
+    "@fedify/vocab-tools": "2.0.0-pr.458.1796+f091195d"
   },
   "devDependencies": {
     "@types/bun": "^1.2.23",

package/src/generate-vocab/action.ts

@@ -6,12 +6,12 @@ import process from "node:process";
 import type { GenerateVocabCommand } from "./command.ts";
 
 export default async function runGenerateVocab(
-  { schemaPath, generatedPath }: GenerateVocabCommand,
+  { schemaDir, generatedPath }: GenerateVocabCommand,
 ) {
-  if (!(await stat(schemaPath)).isDirectory()) {
-    printError(message`${schemaPath} is not a directory.`);
+  if (!(await stat(schemaDir)).isDirectory()) {
+    printError(message`${schemaDir} is not a directory.`);
     process.exit(1);
   }
 
-  await generateVocab(schemaPath, generatedPath);
+  await generateVocab(schemaDir, generatedPath);
 }

package/src/generate-vocab/command.ts

@@ -8,26 +8,26 @@ import {
 } from "@optique/core";
 import { path } from "@optique/run";
 
-const schemaPath = option(
+const schemaDir = option(
   "-i",
   "--input",
-  path({ metavar: "SCHEMA FILES PATH" }),
+  path({ metavar: "DIR", type: "directory", mustExist: true }),
 );
 const generatedPath = option(
   "-o",
   "--output",
-  path({ metavar: "GENERATED CODE PATH" }),
+  path({ metavar: "PATH", type: "file", allowCreate: true }),
 );
 
 const generateVocabCommand = command(
   "generate-vocab",
   object({
     command: constant("generate-vocab"),
-    schemaPath,
+    schemaDir,
     generatedPath,
   }),
   {
-    description: message`Generate Vocabulary Classes from Schema Files`,
+    description: message`Generate vocabulary classes from schema files.`,
   },
 );
 

package/src/globals.ts

@@ -1,9 +1,9 @@
-import { message, object, option } from "@optique/core";
-import { configure, getConsoleSink } from "@logtape/logtape";
 import { getFileSink } from "@logtape/file";
-import { recordingSink } from "./log.ts";
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { message, object, option } from "@optique/core";
 import { AsyncLocalStorage } from "node:async_hooks";
 import process from "node:process";
+import { recordingSink } from "./log.ts";
 
 export const debugOption = object("Global options", {
   debug: option("-d", "--debug", {

package/src/mod.ts

@@ -43,7 +43,7 @@ async function main() {
     runNodeInfo(result);
   }
   if (result.command === "tunnel") {
-    runTunnel(result);
+    await runTunnel(result);
   }
   if (result.command === "generate-vocab") {
     await runGenerateVocab(result);

package/src/tunnel.test.ts

@@ -0,0 +1,157 @@
+import type { Tunnel, TunnelOptions } from "@hongminhee/localtunnel";
+import { run } from "@optique/run";
+import { deepEqual, rejects } from "node:assert/strict";
+import test from "node:test";
+import type { Ora } from "ora";
+import { runTunnel, tunnelCommand } from "./tunnel.ts";
+
+test("tunnel command structure", () => {
+  const testCommandWithOptions = run(tunnelCommand, {
+    args: ["tunnel", "3001", "-s", "pinggy.io", "-d"],
+  });
+  const testCommandWithoutOptions = run(tunnelCommand, {
+    args: ["tunnel", "3000"],
+  });
+
+  deepEqual(testCommandWithOptions.command, "tunnel");
+  deepEqual(testCommandWithOptions.port, 3001);
+  deepEqual(testCommandWithOptions.service, "pinggy.io");
+  deepEqual(testCommandWithOptions.debug, true);
+
+  deepEqual(testCommandWithoutOptions.port, 3000);
+  deepEqual(testCommandWithoutOptions.service, undefined);
+  deepEqual(testCommandWithoutOptions.debug, false);
+});
+
+test("tunnel successfully creates and manages tunnel", async () => {
+  const mockCommand = {
+    command: "tunnel" as const,
+    port: 3001,
+    service: "pinggy.io" as const,
+    debug: true,
+  };
+
+  const mockTunnel: Tunnel = {
+    url: new URL("https://droar-218-152-125-59.a.free.pinggy.link/"),
+    localPort: 3001,
+    pid: 123,
+    close: () => Promise.resolve(),
+  };
+
+  let openTunnelCalled = false;
+  let openTunnelPort;
+  let openTunnelService;
+  let spinnerCalled = false;
+  let openTunnelSucceed = false;
+  let openTunnelFailed = false;
+  let spinnerMsg;
+
+  const mockDeps = {
+    openTunnel: (args: TunnelOptions) => {
+      openTunnelCalled = true;
+      openTunnelPort = args.port;
+      openTunnelService = args.service;
+      return Promise.resolve(mockTunnel);
+    },
+    ora: () =>
+      ({
+        start() {
+          spinnerCalled = true;
+          return this;
+        },
+        fail(msg: string) {
+          openTunnelFailed = true;
+          spinnerMsg = msg;
+          return this;
+        },
+        succeed(msg: string) {
+          openTunnelSucceed = true;
+          spinnerMsg = msg;
+          return this;
+        },
+      }) as unknown as Ora,
+    exit: (): never => {
+      throw new Error();
+    },
+  };
+
+  try {
+    await runTunnel(mockCommand, mockDeps);
+  } finally {
+    deepEqual(openTunnelCalled, true);
+    deepEqual(openTunnelPort, 3001);
+    deepEqual(openTunnelService, "pinggy.io");
+    deepEqual(openTunnelSucceed, true);
+    deepEqual(openTunnelFailed, false);
+    deepEqual(spinnerCalled, true);
+    deepEqual(
+      spinnerMsg,
+      `Your local server at ${mockTunnel.localPort} is now publicly accessible:\n`,
+    );
+  }
+});
+
+test("tunnel fails to create a secure tunnel and handles error", async () => {
+  const mockCommand = {
+    command: "tunnel" as const,
+    port: 3001,
+    service: undefined,
+    debug: false,
+  };
+
+  let openTunnelCalled = false;
+  let openTunnelPort;
+  let openTunnelService;
+  let spinnerCalled = false;
+  let openTunnelSucceed = false;
+  let openTunnelFailed = false;
+  let spinnerMsg;
+
+  const mockDeps = {
+    openTunnel: (args: TunnelOptions) => {
+      openTunnelCalled = true;
+      openTunnelPort = args.port;
+      openTunnelService = args.service;
+      return Promise.reject();
+    },
+    ora: () =>
+      ({
+        start() {
+          spinnerCalled = true;
+          return this;
+        },
+        fail(msg: string) {
+          openTunnelFailed = true;
+          spinnerMsg = msg;
+          return this;
+        },
+        succeed(msg: string) {
+          openTunnelSucceed = true;
+          spinnerMsg = msg;
+          return this;
+        },
+      }) as unknown as Ora,
+    exit: (): never => {
+      throw new Error("Process exit called");
+    },
+  };
+
+  try {
+    await rejects(
+      () => runTunnel(mockCommand, mockDeps),
+      Error,
+      "Process exit called",
+    );
+  } finally {
+    deepEqual(openTunnelCalled, true);
+    deepEqual(openTunnelPort, 3001);
+    deepEqual(openTunnelService, undefined);
+    deepEqual(openTunnelSucceed, false);
+    deepEqual(openTunnelFailed, true);
+    deepEqual(spinnerCalled, true);
+    deepEqual(
+      spinnerMsg,
+      "Failed to create a secure tunnel.",
+    );
+  }
+});

package/src/tunnel.ts

@@ -1,3 +1,4 @@
+import { openTunnel, type Tunnel } from "@hongminhee/localtunnel";
 import {
   argument,
   command,
@@ -7,26 +8,83 @@ import {
   merge,
   message,
   object,
+  option,
+  optional,
 } from "@optique/core";
-import { debugOption } from "./globals.ts";
+import { choice } from "@optique/core/valueparser";
+import { print, printError } from "@optique/run";
+import process from "node:process";
+import ora from "ora";
+import { configureLogging, debugOption } from "./globals.ts";
 
 export const tunnelCommand = command(
   "tunnel",
   merge(
+    "Tunnel options",
     object({
       command: constant("tunnel"),
-      port: argument(integer({ metavar: "PORT", min: 0, max: 65_535 })),
+    }),
+    object({
+      port: argument(integer({ metavar: "PORT", min: 0, max: 65535 }), {
+        description: message`The local port number to expose.`,
+      }),
+      service: optional(
+        option(
+          "-s",
+          "--service",
+          choice(["localhost.run", "serveo.net", "pinggy.io"]),
+          {
+            description: message`The localtunnel service to use.`,
+          },
+        ),
+      ),
     }),
     debugOption,
   ),
   {
     description:
-      message`Expose a local HTTP server to the public internet using a secure tunnel.`,
+      message`Expose a local HTTP server to the public internet using a secure tunnel.\nNote that the HTTP requests through the tunnel have X-Forwarded-* headers.`,
   },
 );
 
-export function runTunnel(
+export async function runTunnel(
   command: InferValue<typeof tunnelCommand>,
+  deps: {
+    openTunnel: typeof openTunnel;
+    ora: typeof ora;
+    exit: typeof process.exit;
+  } = {
+    openTunnel,
+    ora,
+    exit: process.exit,
+  },
 ) {
-  console.debug(command);
+  if (command.debug) {
+    await configureLogging();
+  }
+  const spinner = deps.ora({
+    text: "Creating a secure tunnel...",
+    discardStdin: false,
+  }).start();
+  let tunnel: Tunnel;
+  try {
+    tunnel = await deps.openTunnel({
+      port: command.port,
+      service: command.service,
+    });
+  } catch (error) {
+    if (command.debug) {
+      printError(message`${String(error)}`);
+    }
+    spinner.fail("Failed to create a secure tunnel.");
+    deps.exit(1);
+  }
+  spinner.succeed(
+    `Your local server at ${command.port} is now publicly accessible:\n`,
+  );
+  print(message`${tunnel.url.href}`);
+  print(message`\nPress ^C to close the tunnel.`);
+  process.on("SIGINT", async () => {
+    await tunnel.close();
+  });
 }