@hasagi/cli 0.9.8 → 0.9.10

package/README.md

@@ -1,4 +1,84 @@
-# @hasagi/cli
-
-# Disclaimer
-Hasagi is not endorsed by Riot Games and does not reflect the views or opinions of Riot Games or anyone officially involved in producing or managing Riot Games properties. Riot Games and all associated properties are trademarks or registered trademarks of Riot Games, Inc
+# @hasagi/cli
+
+A command-line interface for the League of Legends client API (LCU). Send requests, listen to
+WebSocket events, read credentials, and generate the LCU schema / TypeScript types — all against a
+running League client, with credentials discovered automatically.
+
+## Installation
+
+```bash
+npm install -g @hasagi/cli
+```
+
+This exposes the `hasagi` command. (Or run without installing via `npx @hasagi/cli <command>`.)
+
+## Commands
+
+### `request <method> <path>`
+
+Send an HTTP request to the LCU.
+
+```bash
+hasagi request get /lol-summoner/v1/current-summoner
+hasagi request post /lol-lobby/v2/lobby --body '{ "queueId": 430 }'
+hasagi request get /lol-summoner/v1/summoners --query '{ "name": "Faker" }'
+```
+
+| Option | Alias | Description |
+| --- | --- | --- |
+| `--body` | `-b` | JSON request body |
+| `--query` | `-q` | JSON query parameters |
+| `--out` | `-o` | Write the response to a file (or a directory to auto-name it) |
+
+### `listen`
+
+Subscribe to LCU WebSocket events and print them. With neither `--name` nor `--path`, subscribes to
+the `OnJsonApiEvent` catch-all.
+
+```bash
+hasagi listen
+hasagi listen --path /lol-gameflow/v1/gameflow-phase --type Update
+hasagi listen --name OnJsonApiEvent_lol-champ-select_v1_session --out ./events
+```
+
+| Option | Alias | Description |
+| --- | --- | --- |
+| `--path` | `-p` | Filter by URI path (conflicts with `--name`) |
+| `--name` | `-n` | Subscribe to a specific event name (conflicts with `--path`) |
+| `--type` | `-t` | Filter by event type(s): `Create`, `Update`, `Delete` |
+| `--out` | `-o` | Append events to a file (or a directory for the default file name) |
+
+### `credentials`
+
+Print the LCU base URL and `Authorization` header for the running client.
+
+```bash
+hasagi credentials
+```
+
+### `schema`
+
+Generate the LCU schema and/or TypeScript types from the running client (powered by
+[`@hasagi/schema`](https://www.npmjs.com/package/@hasagi/schema)).
+
+```bash
+# Emit the generated TypeScript types into ./src/types
+hasagi schema --typescript ./src/types
+
+# Emit the OpenAPI (swagger) document
+hasagi schema --swagger ./
+```
+
+| Option | Alias | Description |
+| --- | --- | --- |
+| `--typescript` | `-t` | Output directory for the generated `.d.ts` files |
+| `--tsnamespace` | | Wrap the generated types in a namespace |
+| `--swagger` | `-s` | Output directory for `swagger.json` |
+| `--raw` | `-r` | Output directory for the raw/extended schema JSON |
+| `--index` / `--no-index` | | Emit (default) or skip an `index.d.ts` barrel re-export |
+
+## Disclaimer
+
+Hasagi is not endorsed by Riot Games and does not reflect the views or opinions of Riot Games or
+anyone officially involved in producing or managing Riot Games properties. Riot Games and all
+associated properties are trademarks or registered trademarks of Riot Games, Inc.

package/bin/format.js

@@ -0,0 +1,22 @@
+import { LCUError, RequestError } from "@hasagi/core";
+/**
+ * Serializes a `request` command result for writing to disk. `LCUError`/`RequestError` instances
+ * aren't JSON-enumerable (`JSON.stringify(error)` yields `"{}"`), so their fields are mapped
+ * explicitly; any other (successful) result passes through unchanged.
+ */
+export function serializeRequestResult(result) {
+    if (result instanceof LCUError)
+        return { error: "LCUError", statusCode: result.statusCode, errorCode: result.errorCode, message: result.message, implementationDetails: result.implementationDetails };
+    if (result instanceof RequestError)
+        return { error: "RequestError", errorCode: result.errorCode, message: result.message };
+    return result;
+}
+/**
+ * Resolves the LCU event name the `listen` command should subscribe to. With neither a name nor a
+ * path, core subscribes to nothing, so default to the `OnJsonApiEvent` catch-all so a bare
+ * `hasagi listen` still receives events. An explicit name always wins; a path-only filter keeps the
+ * name unset (core defaults it to `OnJsonApiEvent` itself).
+ */
+export function resolveListenEventName(name, path) {
+    return name ?? (path ? undefined : "OnJsonApiEvent");
+}

package/bin/index.js

@@ -4,6 +4,7 @@ import { HasagiClient, LCUError, RequestError } from "@hasagi/core";
 import fs from "fs/promises";
 import _path from "path";
 import { getExtendedHelp, getSwagger, getTypeScript } from "@hasagi/schema";
+import { resolveListenEventName, serializeRequestResult } from "./format.js";
 export const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 function log(text) {
     console.log(`[hasagi] ${text}`);
@@ -24,7 +25,8 @@ const options = await yargs().scriptName("hasagi")
     .option("typescript", { alias: "t", string: true })
     .option("tsnamespace", { string: true })
     .option("swagger", { alias: "s", string: true })
-    .option("raw", { alias: "r", string: true }))
+    .option("raw", { alias: "r", string: true })
+    .option("index", { boolean: true, default: true, description: "Also emit an index.d.ts barrel re-exporting the generated types (use --no-index to disable)" }))
     .command("credentials", "prints the lcu port and auth token")
     .demandCommand()
     .help("help")
@@ -46,13 +48,14 @@ if (cmd === "request") {
         url: path,
         returnAxiosResponse: true,
         data: body,
-        params: query
+        params: query,
     }).then(res => ({
         statusCode: res.status,
-        body: res.data
+        body: res.data,
     }), (err) => err);
     if (out) {
-        await fs.writeFile(isDirectory ? _path.join(out, `${method}-${path.substring(1).replaceAll("/", "_")}-${Date.now()}.json`) : out, JSON.stringify(result, null, 4));
+        const fileContent = serializeRequestResult(result);
+        await fs.writeFile(isDirectory ? _path.join(out, `${method}-${path.substring(1).replaceAll("/", "_")}-${Date.now()}.json`) : out, JSON.stringify(fileContent, null, 4));
     }
     if (result instanceof LCUError) {
         log(`Received response with non-success status code '${result.statusCode}'.`);
@@ -79,7 +82,7 @@ else if (cmd === "listen") {
     const out = (options.out === undefined ? undefined : options.out !== "" ? options.out : "./");
     const isDirectory = out !== undefined ? await fs.stat(out).then(stat => stat.isDirectory(), () => false) : false;
     client.addLCUEventListener({
-        name,
+        name: resolveListenEventName(name, path),
         path,
         types,
         callback: async (event) => {
@@ -120,6 +123,10 @@ else if (cmd === "schema") {
             await fs.writeFile(_path.join(out, "lcu-types.d.ts"), lcuTypes);
             await fs.writeFile(_path.join(out, "lcu-endpoints.d.ts"), lcuEndpoints);
             await fs.writeFile(_path.join(out, "lcu-events.d.ts"), lcuEvents);
+            // Barrel so the generated types can be imported by name from a single entry point (disable with --no-index).
+            // The `LCUTypes` namespace re-export preserves backwards compatibility with older @hasagi/types versions.
+            if (options.index !== false)
+                await fs.writeFile(_path.join(out, "index.d.ts"), "export * from \"./lcu-types\";\nexport * from \"./lcu-endpoints\";\nexport * from \"./lcu-events\";\nexport * as LCUTypes from \"./lcu-types\";\n");
         }
     }
 }

package/package.json

@@ -1,33 +1,23 @@
 {
   "name": "@hasagi/cli",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "This package provides the 'hasagi' command-line interface",
   "bin": {
     "hasagi": "bin/index.js"
   },
-  "main": "bin/index.js",
-  "scripts": {
-    "build": "tsc",
-    "pub": "npm run build && npm publish --access public",
-    "update": "npm i @hasagi/core@latest @hasagi/schema@latest"
-  },
   "keywords": [
     "hasagi"
   ],
   "author": "dysolix",
   "license": "MIT",
   "dependencies": {
-    "@hasagi/core": "^0.6.3",
-    "@hasagi/schema": "^0.6.7",
-    "yargs": "^17.7.2"
+    "@hasagi/core": "0.7.0",
+    "@hasagi/schema": "0.7.1",
+    "yargs": "17.7.2"
   },
   "type": "module",
-  "devDependencies": {
-    "@types/node": "^20.6.2",
-    "@types/yargs": "^17.0.24"
-  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dysolix/hasagi-cli.git"
+    "url": "git+https://github.com/dysolix/hasagi-cli.git"
   }
-}
+}