@onmyway133/asc-cli 1.0.1

package/src/utils/output.ts

@@ -0,0 +1,79 @@
+import chalk from "chalk"
+import Table from "cli-table3"
+import type { ASCError } from "../api/client.ts"
+
+export type OutputFormat = "table" | "json" | "plain"
+
+export function detectFormat(override?: string): OutputFormat {
+  if (override === "json" || override === "table" || override === "plain") {
+    return override
+  }
+  return process.stdout.isTTY ? "table" : "json"
+}
+
+export function printJSON(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2))
+}
+
+export function printTable(
+  headers: string[],
+  rows: string[][],
+  title?: string,
+): void {
+  if (title) console.log(chalk.bold(title))
+  const t = new Table({
+    head: headers.map((h) => chalk.cyan(h)),
+    style: { head: [], border: [] },
+  })
+  for (const row of rows) {
+    t.push(row)
+  }
+  console.log(t.toString())
+}
+
+export function printPlain(lines: string[]): void {
+  for (const l of lines) console.log(l)
+}
+
+export function printSuccess(msg: string): void {
+  console.log(chalk.green("✓") + " " + msg)
+}
+
+export function printWarning(msg: string): void {
+  console.log(chalk.yellow("⚠") + " " + msg)
+}
+
+export function printError(err: unknown): void {
+  if (isASCError(err)) {
+    console.error(chalk.red("Error") + ` [${err.status}]: ${err.message}`)
+    if (err.errors && err.errors.length > 0) {
+      for (const e of err.errors) {
+        if (e.detail && e.detail !== err.message) {
+          console.error(chalk.dim(`  ${e.code}: ${e.detail}`))
+        }
+      }
+    }
+  } else if (err instanceof Error) {
+    console.error(chalk.red("Error: ") + err.message)
+  } else {
+    console.error(chalk.red("Error: ") + String(err))
+  }
+}
+
+function isASCError(err: unknown): err is ASCError {
+  return err instanceof Error && err.name === "ASCError"
+}
+
+export function truncate(s: string, max: number): string {
+  if (s.length <= max) return s
+  return s.slice(0, max - 1) + "…"
+}
+
+export function formatDate(iso?: string): string {
+  if (!iso) return "-"
+  return new Date(iso).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  })
+}

package/tests/auth.test.ts

@@ -0,0 +1,105 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { join } from "path"
+import { existsSync, unlinkSync, mkdirSync } from "fs"
+import {
+  loadCredentials,
+  saveCredentials,
+  addOrUpdateProfile,
+  removeProfile,
+  setActiveProfile,
+  type CredentialsFile,
+  type Profile,
+} from "../src/auth/credentials.ts"
+
+// Use a temp dir for tests to avoid touching real ~/.asc/credentials.json
+const TEST_HOME = join(import.meta.dir, "tmp_home")
+const TEST_ASC_DIR = join(TEST_HOME, ".asc")
+const TEST_CREDS = join(TEST_ASC_DIR, "credentials.json")
+
+// Override HOME for credential path
+const origHome = process.env["HOME"]
+beforeEach(() => {
+  process.env["HOME"] = TEST_HOME
+  mkdirSync(TEST_ASC_DIR, { recursive: true })
+  if (existsSync(TEST_CREDS)) unlinkSync(TEST_CREDS)
+})
+afterEach(() => {
+  process.env["HOME"] = origHome
+  if (existsSync(TEST_CREDS)) unlinkSync(TEST_CREDS)
+})
+
+describe("credentials", () => {
+  test("loadCredentials returns empty when no file", () => {
+    const creds = loadCredentials()
+    expect(creds.profiles).toHaveLength(0)
+    expect(creds.activeProfile).toBe("default")
+  })
+
+  test("saveCredentials + loadCredentials roundtrip", () => {
+    const data: CredentialsFile = {
+      activeProfile: "work",
+      profiles: [
+        {
+          name: "work",
+          keyId: "ABC123",
+          issuerId: "issuer-1",
+          privateKeyPath: "~/.asc/work.p8",
+          isDefault: true,
+        },
+      ],
+    }
+    saveCredentials(data)
+    const loaded = loadCredentials()
+    expect(loaded.activeProfile).toBe("work")
+    expect(loaded.profiles).toHaveLength(1)
+    expect(loaded.profiles[0]?.keyId).toBe("ABC123")
+  })
+
+  test("addOrUpdateProfile adds new profile", () => {
+    const profile: Profile = {
+      name: "personal",
+      keyId: "K1",
+      issuerId: "I1",
+      privateKeyPath: "~/.asc/personal.p8",
+      isDefault: false,
+    }
+    addOrUpdateProfile(profile)
+    const loaded = loadCredentials()
+    expect(loaded.profiles).toHaveLength(1)
+    expect(loaded.profiles[0]?.name).toBe("personal")
+    expect(loaded.activeProfile).toBe("personal") // first profile becomes active
+  })
+
+  test("addOrUpdateProfile updates existing profile", () => {
+    const p1: Profile = { name: "work", keyId: "K1", issuerId: "I1", privateKeyPath: "~/.asc/w.p8", isDefault: true }
+    addOrUpdateProfile(p1)
+    addOrUpdateProfile({ ...p1, keyId: "K2" })
+    const loaded = loadCredentials()
+    expect(loaded.profiles).toHaveLength(1)
+    expect(loaded.profiles[0]?.keyId).toBe("K2")
+  })
+
+  test("removeProfile removes by name", () => {
+    const p1: Profile = { name: "work", keyId: "K1", issuerId: "I1", privateKeyPath: "~/.asc/w.p8", isDefault: true }
+    const p2: Profile = { name: "personal", keyId: "K2", issuerId: "I2", privateKeyPath: "~/.asc/p.p8", isDefault: false }
+    addOrUpdateProfile(p1)
+    addOrUpdateProfile(p2)
+    removeProfile("work")
+    const loaded = loadCredentials()
+    expect(loaded.profiles).toHaveLength(1)
+    expect(loaded.profiles[0]?.name).toBe("personal")
+  })
+
+  test("setActiveProfile switches active", () => {
+    addOrUpdateProfile({ name: "a", keyId: "K1", issuerId: "I1", privateKeyPath: "~/.asc/a.p8", isDefault: true })
+    addOrUpdateProfile({ name: "b", keyId: "K2", issuerId: "I2", privateKeyPath: "~/.asc/b.p8", isDefault: false })
+    const ok = setActiveProfile("b")
+    expect(ok).toBe(true)
+    expect(loadCredentials().activeProfile).toBe("b")
+  })
+
+  test("setActiveProfile returns false for unknown profile", () => {
+    const ok = setActiveProfile("nope")
+    expect(ok).toBe(false)
+  })
+})

package/tests/client.test.ts

@@ -0,0 +1,22 @@
+import { describe, test, expect, mock } from "bun:test"
+import { ASCError } from "../src/api/client.ts"
+
+describe("ASCError", () => {
+  test("creates error with status and message", () => {
+    const err = new ASCError("Unauthorized", 401)
+    expect(err.message).toBe("Unauthorized")
+    expect(err.status).toBe(401)
+    expect(err.name).toBe("ASCError")
+  })
+
+  test("stores errors array", () => {
+    const errors = [{ status: "401", code: "NOT_AUTHORIZED", title: "Unauthorized" }]
+    const err = new ASCError("Unauthorized", 401, errors)
+    expect(err.errors).toEqual(errors)
+  })
+
+  test("is instance of Error", () => {
+    const err = new ASCError("test", 500)
+    expect(err instanceof Error).toBe(true)
+  })
+})

package/tests/output.test.ts

@@ -0,0 +1,36 @@
+import { describe, test, expect } from "bun:test"
+import { detectFormat, truncate, formatDate } from "../src/utils/output.ts"
+
+describe("output", () => {
+  test("detectFormat returns json for explicit json", () => {
+    expect(detectFormat("json")).toBe("json")
+  })
+
+  test("detectFormat returns table for explicit table", () => {
+    expect(detectFormat("table")).toBe("table")
+  })
+
+  test("detectFormat returns plain for explicit plain", () => {
+    expect(detectFormat("plain")).toBe("plain")
+  })
+
+  test("truncate returns string as-is when short", () => {
+    expect(truncate("hello", 10)).toBe("hello")
+  })
+
+  test("truncate truncates long strings", () => {
+    const result = truncate("hello world", 8)
+    expect(result.length).toBe(8)
+    expect(result.endsWith("…")).toBe(true)
+  })
+
+  test("formatDate formats ISO string", () => {
+    const result = formatDate("2024-03-15T00:00:00Z")
+    expect(result).toContain("2024")
+    expect(result).toContain("Mar")
+  })
+
+  test("formatDate returns dash for undefined", () => {
+    expect(formatDate(undefined)).toBe("-")
+  })
+})

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "lib": ["ESNext", "DOM"],
+    "types": ["bun-types"],
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*", "tests/**/*"]
+}