@k-msg/cli 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# @k-msg/cli
+
+## 0.1.1 — 2026-02-15
+
+### Patch changes
+
+- Initial CLI release.
+

package/README.md

@@ -0,0 +1,160 @@
+# k-msg CLI (`apps/cli`)
+
+This CLI is built with Bunli and uses the unified `k-msg` package (KMsg + Providers).
+
+## Install (recommended)
+
+### npm
+
+```bash
+npm install -g @k-msg/cli
+# or: pnpm add -g @k-msg/cli
+
+k-msg --help
+```
+
+Note: the npm package downloads a native binary from GitHub Releases on first run
+(`bunli build:all` artifacts: `k-msg-cli-<version>-<target>.tar.gz`), verifies it
+using `checksums.txt`, then extracts and caches it under your OS cache directory
+(`K_MSG_CLI_CACHE_DIR` to override).
+
+Env overrides:
+
+- `K_MSG_CLI_BASE_URL`: override GitHub release base URL (default: `https://github.com/k-otp/k-msg/releases/download/cli-v<version>`)
+- `K_MSG_CLI_CACHE_DIR`: override where the extracted binary is cached
+- `K_MSG_CLI_LOCAL_BINARY`: copy a local binary instead of downloading (useful for local testing)
+
+### GitHub Releases (manual)
+
+The distribution workflow also publishes prebuilt binaries to GitHub Releases as:
+
+- `k-msg-cli-<version>-darwin-arm64.tar.gz`
+- `k-msg-cli-<version>-darwin-x64.tar.gz`
+- `k-msg-cli-<version>-linux-arm64.tar.gz`
+- `k-msg-cli-<version>-linux-x64.tar.gz`
+- `k-msg-cli-<version>-windows-x64.tar.gz`
+
+After extracting, you'll find the binary at `<target>/k-msg` (or `<target>/k-msg.exe`).
+
+### macOS/Linux
+
+```bash
+tar -xzf k-msg-cli-<version>-<target>.tar.gz
+sudo install -m 0755 <target>/k-msg /usr/local/bin/k-msg
+
+# optional alias
+sudo ln -sf /usr/local/bin/k-msg /usr/local/bin/kmsg
+
+k-msg --help
+```
+
+### Windows
+
+Extract the archive and put `k-msg.exe` somewhere on your `PATH`.
+Optionally copy it as `kmsg.exe` as an alias.
+
+## Run (local/dev)
+
+```bash
+# Build native binary
+bun run --cwd apps/cli build
+./apps/cli/dist/k-msg --help
+
+# Build Bun-runtime JS bundle (optional)
+bun run --cwd apps/cli build:js
+bun --cwd apps/cli dist/k-msg.js --help
+
+# Or run TS directly (dev)
+bun --cwd apps/cli src/k-msg.ts --help
+```
+
+## Config (`k-msg.config.json`)
+
+Default config path: `./k-msg.config.json`
+
+Override:
+
+```bash
+k-msg --config /path/to/k-msg.config.json providers list
+```
+
+Example file: `apps/cli/k-msg.config.example.json`
+
+### `env:` substitution
+
+Any string value like `"env:NAME"` is replaced with the `NAME` environment variable at runtime.
+If the env var is missing/empty, commands that need runtime providers will fail with exit code `2`.
+
+## Commands
+
+- `k-msg config init|show|validate`
+- `k-msg providers list|health`
+- `k-msg sms send`
+- `k-msg alimtalk send`
+- `k-msg send --input <json> | --file <path> | --stdin`
+- `k-msg kakao channel categories|list|auth|add`
+- `k-msg kakao template list|get|create|update|delete|request`
+
+## Send
+
+### SMS
+
+```bash
+k-msg sms send --to 01012345678 --text "hello"
+```
+
+### AlimTalk
+
+Terminology: the CLI uses **Kakao Channel** and **senderKey** (never “profile”).
+
+```bash
+k-msg alimtalk send \
+  --to 01012345678 \
+  --template-code TPL_001 \
+  --vars '{"name":"Jane"}' \
+  --channel main
+```
+
+### Advanced JSON send
+
+```bash
+k-msg send --input '{"to":"01012345678","text":"hello"}'
+```
+
+## Kakao Channel (Aligo capability)
+
+```bash
+k-msg kakao channel categories
+k-msg kakao channel list
+k-msg kakao channel auth --plus-id @my_channel --phone 01012345678
+k-msg kakao channel add \
+  --plus-id @my_channel \
+  --auth-num 123456 \
+  --phone 01012345678 \
+  --category-code 001001001 \
+  --save main
+```
+
+## Kakao Template (IWINV/Aligo)
+
+Channel scope (Aligo): use `--channel <alias>` or `--sender-key <value>`.
+
+```bash
+k-msg kakao template list
+k-msg kakao template get --template-code TPL_001
+k-msg kakao template create --name "Welcome" --content "Hello #{name}" --channel main
+k-msg kakao template update --template-code TPL_001 --name "Updated"
+k-msg kakao template delete --template-code TPL_001
+
+# inspection request is provider-dependent (supported by Aligo)
+k-msg kakao template request --template-code TPL_001 --channel main
+```
+
+## Output / Exit Codes
+
+- `--json`: print machine-readable JSON
+- exit code:
+  - `0`: success
+  - `2`: input/config error
+  - `3`: provider/network error
+  - `4`: capability not supported

package/bin/k-msg.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { get as httpsGet } from "node:https";
+import { gunzipSync } from "node:zlib";
+
+function pkgRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, "..");
+}
+
+function readJsonFile(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function readVersion() {
+  const pkg = readJsonFile(path.join(pkgRoot(), "package.json"));
+  if (typeof pkg.version !== "string" || pkg.version.trim().length === 0) {
+    throw new Error("Invalid package.json version");
+  }
+  return pkg.version;
+}
+
+function resolveTarget(platform, arch) {
+  if (platform === "darwin" && arch === "arm64") return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "darwin-x64";
+  if (platform === "linux" && arch === "arm64") return "linux-arm64";
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "win32" && arch === "x64") return "windows-x64";
+  throw new Error(`Unsupported platform/arch: ${platform}/${arch}`);
+}
+
+function cacheBaseDir() {
+  const override = process.env.K_MSG_CLI_CACHE_DIR;
+  if (typeof override === "string" && override.trim().length > 0) {
+    return override;
+  }
+
+  if (process.platform === "win32") {
+    return (
+      process.env.LOCALAPPDATA ||
+      process.env.APPDATA ||
+      path.join(os.homedir(), "AppData", "Local")
+    );
+  }
+
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Caches");
+  }
+
+  return process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
+}
+
+function downloadText(url) {
+  return new Promise((resolve, reject) => {
+    const req = httpsGet(url, { headers: { "User-Agent": "@k-msg/cli" } }, (res) => {
+      const status = res.statusCode || 0;
+      if (status >= 300 && status < 400 && res.headers.location) {
+        const redirected = new URL(res.headers.location, url).toString();
+        res.resume();
+        downloadText(redirected).then(resolve, reject);
+        return;
+      }
+      if (status !== 200) {
+        res.resume();
+        reject(new Error(`GET ${url} failed (status=${status})`));
+        return;
+      }
+      res.setEncoding("utf8");
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => resolve(data));
+    });
+    req.on("error", reject);
+  });
+}
+
+function downloadToFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const req = httpsGet(url, { headers: { "User-Agent": "@k-msg/cli" } }, (res) => {
+      const status = res.statusCode || 0;
+      if (status >= 300 && status < 400 && res.headers.location) {
+        const redirected = new URL(res.headers.location, url).toString();
+        res.resume();
+        downloadToFile(redirected, destPath).then(resolve, reject);
+        return;
+      }
+      if (status !== 200) {
+        res.resume();
+        reject(new Error(`GET ${url} failed (status=${status})`));
+        return;
+      }
+
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      const file = fs.createWriteStream(destPath);
+      res.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+    req.on("error", reject);
+  });
+}
+
+function sha256File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+function parseChecksums(text) {
+  const out = new Map();
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const m = /^([a-f0-9]{64})\s+\*?(.+)$/.exec(trimmed);
+    if (!m) continue;
+    const [, sum, file] = m;
+    out.set(file, sum);
+  }
+  return out;
+}
+
+function tarReadString(header, start, len) {
+  const slice = header.subarray(start, start + len);
+  const zero = slice.indexOf(0);
+  const end = zero === -1 ? slice.length : zero;
+  return slice.subarray(0, end).toString("utf8");
+}
+
+function tarIsEmptyBlock(block) {
+  for (let i = 0; i < block.length; i++) {
+    if (block[i] !== 0) return false;
+  }
+  return true;
+}
+
+function extractFileFromTarGz({ archivePath, filePathInTar, outPath }) {
+  const tar = gunzipSync(fs.readFileSync(archivePath));
+  let off = 0;
+
+  while (off + 512 <= tar.length) {
+    const header = tar.subarray(off, off + 512);
+    if (tarIsEmptyBlock(header)) break;
+
+    const name = tarReadString(header, 0, 100);
+    const prefix = tarReadString(header, 345, 155);
+    const fullName = prefix ? `${prefix}/${name}` : name;
+
+    const sizeOct = tarReadString(header, 124, 12).trim();
+    const size = sizeOct.length ? Number.parseInt(sizeOct, 8) : 0;
+    const typeflag = header[156];
+
+    const dataStart = off + 512;
+    const dataEnd = dataStart + size;
+
+    const isFile = typeflag === 0 || typeflag === 48; // '\0' or '0'
+    if (isFile && fullName === filePathInTar) {
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, tar.subarray(dataStart, dataEnd));
+      return;
+    }
+
+    const blocks = Math.ceil(size / 512);
+    off = dataStart + blocks * 512;
+  }
+
+  throw new Error(`Missing file in archive: ${filePathInTar}`);
+}
+
+async function ensureBinary() {
+  const version = readVersion();
+  const target = resolveTarget(process.platform, process.arch);
+  const ext = process.platform === "win32" ? ".exe" : "";
+
+  const cacheDir = path.join(cacheBaseDir(), "k-msg", "cli", version, target);
+  const dest = path.join(cacheDir, `k-msg${ext}`);
+
+  if (fs.existsSync(dest)) return dest;
+
+  const local = process.env.K_MSG_CLI_LOCAL_BINARY;
+  if (typeof local === "string" && local.trim().length > 0) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.copyFileSync(local, dest);
+    if (process.platform !== "win32") {
+      fs.chmodSync(dest, 0o755);
+    }
+    return dest;
+  }
+
+  const baseUrl =
+    process.env.K_MSG_CLI_BASE_URL ||
+    `https://github.com/k-otp/k-msg/releases/download/cli-v${version}`;
+  const assetName = `k-msg-cli-${version}-${target}.tar.gz`;
+  const assetUrl = `${baseUrl}/${assetName}`;
+  const checksumsUrl = `${baseUrl}/checksums.txt`;
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const archiveTmp = `${dest}.tar.gz.download`;
+  const binTmp = `${dest}.download`;
+
+  console.error(`[k-msg] Installing native binary (${target})...`);
+
+  try {
+    const checksumsText = await downloadText(checksumsUrl);
+    const checksums = parseChecksums(checksumsText);
+    const expected = checksums.get(assetName);
+    if (!expected) {
+      throw new Error(`Missing checksum entry for ${assetName}`);
+    }
+
+    await downloadToFile(assetUrl, archiveTmp);
+    const actual = await sha256File(archiveTmp);
+    if (actual !== expected) {
+      throw new Error(
+        `Checksum mismatch for ${assetName}\nexpected=${expected}\nactual=${actual}`,
+      );
+    }
+
+    extractFileFromTarGz({
+      archivePath: archiveTmp,
+      filePathInTar: `${target}/k-msg${ext}`,
+      outPath: binTmp,
+    });
+
+    fs.renameSync(binTmp, dest);
+    if (process.platform !== "win32") {
+      fs.chmodSync(dest, 0o755);
+    }
+    fs.rmSync(archiveTmp, { force: true });
+    return dest;
+  } catch (err) {
+    fs.rmSync(archiveTmp, { force: true });
+    fs.rmSync(binTmp, { force: true });
+    throw err;
+  }
+}
+
+async function main() {
+  const bin = await ensureBinary();
+  const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit" });
+  if (result.error) {
+    console.error(result.error);
+    process.exitCode = 1;
+    return;
+  }
+  if (typeof result.status === "number") {
+    process.exitCode = result.status;
+    return;
+  }
+  process.exitCode = 1;
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@k-msg/cli",
+  "version": "0.1.1",
+  "private": false,
+  "description": "k-msg CLI (prebuilt binaries via GitHub Releases)",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "k-msg": "./bin/k-msg.js",
+    "kmsg": "./bin/k-msg.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "bunli build",
+    "build:all": "bunli build --targets all",
+    "build:native": "bunli build --targets native",
+    "build:js": "bun build src/k-msg.ts --outdir=dist --format=esm --target=bun",
+    "dev": "bun --watch src/k-msg.ts",
+    "test": "bun test",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@bunli/core": "^0.5.4",
+    "@bunli/test": "^0.3.2",
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "k-msg": "0.7.3",
+    "bunli": "^0.5.3",
+    "typescript": "^5.7.2",
+    "zod": "^4.0.14"
+  },
+  "keywords": [
+    "alimtalk",
+    "cli",
+    "messaging",
+    "kakao"
+  ],
+  "license": "MIT"
+}