@khangal.j/fireside-cli 0.0.1

package/README.md

@@ -0,0 +1,33 @@
+# Fireside CLI
+
+Node.js CLI for Fireside.
+
+## Install
+
+```sh
+npm install -g @khangal.j/fireside-cli
+```
+
+## Usage
+
+```sh
+fireside login --base-url http://localhost:3000
+fireside status
+fireside hello
+fireside my-stuff
+fireside projects list
+```
+
+## Local State
+
+The CLI stores local files under the `fireside` config directory.
+
+- macOS: `~/Library/Application Support/fireside/{config,auth}.json`
+- Linux: `$XDG_CONFIG_HOME/fireside/{config,auth}.json` or `~/.config/fireside/{config,auth}.json`
+- Windows: `%APPDATA%\\fireside\\{config,auth}.json`
+
+`config.json` stores settings like `baseUrl`. `auth.json` stores the local session token.
+
+## Requirements
+
+- Node.js 20+

package/dist/index.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_commander = require("commander");
+
+// src/lib/api.ts
+var DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var CLI_CLIENT_ID = "fireside-cli";
+async function readResponseBody(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text();
+}
+function getErrorMessage(body, fallbackMessage) {
+  if (typeof body === "string" && body.trim()) {
+    return body;
+  }
+  if (body && typeof body === "object") {
+    const candidate = body;
+    return candidate.error_description || candidate.message || candidate.error || fallbackMessage;
+  }
+  return fallbackMessage;
+}
+async function requestJson(url, init) {
+  const response = await fetch(url, init);
+  const body = await readResponseBody(response);
+  if (!response.ok) {
+    throw new Error(
+      getErrorMessage(body, `Request failed with status ${response.status}.`)
+    );
+  }
+  if (!body || typeof body !== "object") {
+    throw new Error("Expected a JSON response.");
+  }
+  return body;
+}
+function getAuthHeaders(accessToken) {
+  return {
+    Authorization: `Bearer ${accessToken}`
+  };
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function createDeviceCode(baseUrl) {
+  return requestJson(`${baseUrl}/api/auth/device/code`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      client_id: CLI_CLIENT_ID,
+      scope: "openid profile email"
+    })
+  });
+}
+async function pollForAccessToken(baseUrl, deviceCode, intervalSeconds = 5) {
+  let pollingIntervalSeconds = intervalSeconds;
+  for (; ; ) {
+    await delay(pollingIntervalSeconds * 1e3);
+    const response = await fetch(`${baseUrl}/api/auth/device/token`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "user-agent": "fireside-cli"
+      },
+      body: JSON.stringify({
+        grant_type: DEVICE_CODE_GRANT_TYPE,
+        device_code: deviceCode,
+        client_id: CLI_CLIENT_ID
+      })
+    });
+    const body = await readResponseBody(response);
+    if (response.ok && typeof body === "object" && body.access_token) {
+      return body.access_token;
+    }
+    const errorCode = typeof body === "object" && body && typeof body.error === "string" ? body.error : void 0;
+    switch (errorCode) {
+      case "authorization_pending":
+        continue;
+      case "slow_down":
+        pollingIntervalSeconds += 5;
+        continue;
+      case "access_denied":
+        throw new Error("Access denied by user.");
+      case "expired_token":
+        throw new Error("Device code expired. Run the login command again.");
+      default:
+        throw new Error(
+          getErrorMessage(
+            body,
+            `Token request failed with status ${response.status}.`
+          )
+        );
+    }
+  }
+}
+async function getCurrentUser(baseUrl, accessToken) {
+  const data = await requestJson(`${baseUrl}/api/me`, {
+    headers: getAuthHeaders(accessToken)
+  });
+  return data.user;
+}
+async function listProjects(baseUrl, accessToken) {
+  return requestJson(`${baseUrl}/api/projects`, {
+    headers: getAuthHeaders(accessToken)
+  });
+}
+async function listAssignedTasks(baseUrl, accessToken) {
+  return requestJson(`${baseUrl}/api/my-stuff`, {
+    headers: getAuthHeaders(accessToken)
+  });
+}
+async function getHello(baseUrl, accessToken) {
+  const response = await fetch(`${baseUrl}/api/hello`, {
+    headers: getAuthHeaders(accessToken)
+  });
+  const body = await readResponseBody(response);
+  if (!response.ok) {
+    throw new Error(
+      getErrorMessage(body, `Request failed with status ${response.status}.`)
+    );
+  }
+  if (typeof body !== "string") {
+    throw new Error("Expected a text response.");
+  }
+  return body;
+}
+
+// src/lib/auth-state.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var DEFAULT_BASE_URL = "http://localhost:3000";
+var legacyMigrationPromise = null;
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+function getConfigDirectory(appName = "fireside") {
+  switch (process.platform) {
+    case "darwin":
+      return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", appName);
+    case "win32":
+      return (0, import_node_path.join)(
+        process.env.APPDATA || (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Roaming"),
+        appName
+      );
+    default:
+      return (0, import_node_path.join)(
+        process.env.XDG_CONFIG_HOME || (0, import_node_path.join)((0, import_node_os.homedir)(), ".config"),
+        appName
+      );
+  }
+}
+function getAuthStateFilePath() {
+  return (0, import_node_path.join)(getConfigDirectory(), "auth.json");
+}
+function getConfigStateFilePath() {
+  return (0, import_node_path.join)(getConfigDirectory(), "config.json");
+}
+function getLegacyAuthStateFilePath() {
+  return (0, import_node_path.join)(getConfigDirectory("fireside-cli"), "auth.json");
+}
+async function fileExists(filePath) {
+  try {
+    await (0, import_promises.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureConfigDirectory(filePath) {
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), {
+    recursive: true,
+    mode: 448
+  });
+}
+async function writeStateFile(filePath, value) {
+  await ensureConfigDirectory(filePath);
+  await (0, import_promises.writeFile)(filePath, `${JSON.stringify(value, null, 2)}
+`, {
+    mode: 384
+  });
+  await (0, import_promises.chmod)(filePath, 384);
+}
+async function readStateFile(filePath) {
+  try {
+    const raw = await (0, import_promises.readFile)(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+function isAuthState(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.accessToken === "string" && typeof candidate.createdAt === "string";
+}
+function isConfigState(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.baseUrl === "string";
+}
+function isLegacyAuthState(value) {
+  return isAuthState(value) && isConfigState(value);
+}
+async function migrateLegacyState() {
+  const legacyState = await readStateFile(getLegacyAuthStateFilePath());
+  if (legacyState === null) {
+    return;
+  }
+  if (!isLegacyAuthState(legacyState)) {
+    throw new Error("Invalid legacy auth state file format.");
+  }
+  const authStateFilePath = getAuthStateFilePath();
+  const configStateFilePath = getConfigStateFilePath();
+  if (!await fileExists(authStateFilePath)) {
+    await writeStateFile(authStateFilePath, {
+      accessToken: legacyState.accessToken,
+      createdAt: legacyState.createdAt
+    });
+  }
+  if (!await fileExists(configStateFilePath)) {
+    await writeStateFile(configStateFilePath, {
+      baseUrl: normalizeBaseUrl(legacyState.baseUrl)
+    });
+  }
+  await (0, import_promises.rm)(getLegacyAuthStateFilePath(), { force: true });
+}
+async function ensureLegacyStateMigrated() {
+  legacyMigrationPromise ??= migrateLegacyState();
+  await legacyMigrationPromise;
+}
+async function resolveBaseUrl(baseUrl, configState) {
+  const resolvedConfigState = configState === void 0 ? await loadConfigState() : configState;
+  return normalizeBaseUrl(
+    baseUrl || process.env.FIRESIDE_BASE_URL || resolvedConfigState?.baseUrl || DEFAULT_BASE_URL
+  );
+}
+async function loadAuthState() {
+  await ensureLegacyStateMigrated();
+  const parsed = await readStateFile(getAuthStateFilePath());
+  if (parsed === null) {
+    return null;
+  }
+  if (!isAuthState(parsed)) {
+    throw new Error("Invalid auth state file format.");
+  }
+  return parsed;
+}
+async function loadConfigState() {
+  await ensureLegacyStateMigrated();
+  const parsed = await readStateFile(getConfigStateFilePath());
+  if (parsed === null) {
+    return null;
+  }
+  if (!isConfigState(parsed)) {
+    throw new Error("Invalid config state file format.");
+  }
+  return {
+    baseUrl: normalizeBaseUrl(parsed.baseUrl)
+  };
+}
+async function saveAuthState(state) {
+  await ensureLegacyStateMigrated();
+  await writeStateFile(getAuthStateFilePath(), state);
+}
+async function saveConfigState(state) {
+  await ensureLegacyStateMigrated();
+  await writeStateFile(getConfigStateFilePath(), {
+    baseUrl: normalizeBaseUrl(state.baseUrl)
+  });
+}
+async function clearAuthState() {
+  await ensureLegacyStateMigrated();
+  await (0, import_promises.rm)(getAuthStateFilePath(), { force: true });
+}
+
+// src/lib/browser.ts
+var import_node_child_process = require("child_process");
+function getBrowserOpenCommand(url) {
+  switch (process.platform) {
+    case "darwin":
+      return {
+        command: "open",
+        args: [url]
+      };
+    case "win32":
+      return {
+        command: "cmd",
+        args: ["/c", "start", "", url]
+      };
+    default:
+      return {
+        command: "xdg-open",
+        args: [url]
+      };
+  }
+}
+function openBrowser(url) {
+  const { command, args } = getBrowserOpenCommand(url);
+  try {
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      detached: process.platform !== "win32",
+      stdio: "ignore"
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/index.ts
+function formatUserCodeForDisplay(userCode) {
+  return userCode.match(/.{1,4}/g)?.join("-") || userCode;
+}
+function addBaseUrlOption(command) {
+  return command.option(
+    "-b, --base-url <url>",
+    "Fireside base URL",
+    process.env.FIRESIDE_BASE_URL
+  );
+}
+async function requireAuthState() {
+  const state = await loadAuthState();
+  if (!state) {
+    throw new Error("Not signed in. Run `fireside login` first.");
+  }
+  return state;
+}
+function printProjects(projects) {
+  if (!projects.length) {
+    console.log("No projects found.");
+    return;
+  }
+  for (const project of projects) {
+    console.log(`${project.title} (${project.id})`);
+    console.log(`  Color: ${project.color}`);
+    console.log(`  Members: ${project.members.length}`);
+    console.log(`  ${project.description}`);
+    console.log("");
+  }
+}
+function formatDueDate(dueDate) {
+  if (!dueDate) {
+    return "No due date";
+  }
+  return new Intl.DateTimeFormat(void 0, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  }).format(/* @__PURE__ */ new Date(`${dueDate}T00:00:00`));
+}
+function printAssignedTasks(baseUrl, tasks) {
+  if (!tasks.length) {
+    console.log("Nothing assigned right now.");
+    return;
+  }
+  for (const task of tasks) {
+    console.log(`${task.title} (${task.id})`);
+    console.log(
+      `  ${task.projectTitle} / ${task.boardTitle} / ${task.columnTitle}`
+    );
+    console.log(`  Due: ${formatDueDate(task.dueDate)}`);
+    console.log(
+      `  Assignees: ${task.assignees.map((assignee) => assignee.name).join(", ") || "None"}`
+    );
+    if (task.description) {
+      console.log(`  ${task.description}`);
+    }
+    console.log(
+      `  ${baseUrl}/projects/${encodeURIComponent(task.projectId)}/boards/tasks/${encodeURIComponent(task.id)}`
+    );
+    console.log("");
+  }
+}
+var program = new import_commander.Command();
+program.name("fireside").description("Fireside CLI").version("0.0.1").showHelpAfterError();
+addBaseUrlOption(
+  program.command("login").description("Authenticate with Fireside using device authorization").option("--no-open", "Do not open the browser automatically").action(async (options) => {
+    const configState = await loadConfigState();
+    const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
+    const deviceCode = await createDeviceCode(baseUrl);
+    const verificationUrl = deviceCode.verification_uri;
+    console.log(`Base URL: ${baseUrl}`);
+    console.log(`Open this URL: ${verificationUrl}`);
+    console.log(
+      `Enter this code in the browser: ${formatUserCodeForDisplay(deviceCode.user_code)}`
+    );
+    if (options.open) {
+      const opened = openBrowser(verificationUrl);
+      if (opened) {
+        console.log("Opened the browser for approval.");
+      }
+    }
+    console.log("Waiting for approval...");
+    const accessToken = await pollForAccessToken(
+      baseUrl,
+      deviceCode.device_code,
+      deviceCode.interval
+    );
+    await saveConfigState({ baseUrl });
+    await saveAuthState({
+      accessToken,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const user = await getCurrentUser(baseUrl, accessToken);
+    console.log(`Signed in as ${user.email}.`);
+  })
+);
+program.command("logout").description("Remove the local CLI session").action(async () => {
+  const state = await loadAuthState();
+  if (!state) {
+    console.log("Already signed out.");
+    return;
+  }
+  await clearAuthState();
+  console.log("Removed the local CLI session.");
+});
+addBaseUrlOption(
+  program.command("status").description("Show the current authenticated CLI user").action(async (options) => {
+    const state = await requireAuthState();
+    const configState = await loadConfigState();
+    const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
+    const user = await getCurrentUser(baseUrl, state.accessToken);
+    console.log(`Base URL: ${baseUrl}`);
+    console.log(`Signed in as: ${user.name} <${user.email}>`);
+  })
+);
+addBaseUrlOption(
+  program.command("hello").description("Call the sample authenticated API endpoint").action(async (options) => {
+    const state = await requireAuthState();
+    const configState = await loadConfigState();
+    const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
+    const message = await getHello(baseUrl, state.accessToken);
+    console.log(message);
+  })
+);
+addBaseUrlOption(
+  program.command("my-stuff").description("List tasks currently assigned to you").action(async (options) => {
+    const state = await requireAuthState();
+    const configState = await loadConfigState();
+    const baseUrl = await resolveBaseUrl(options.baseUrl, configState);
+    const tasks = await listAssignedTasks(baseUrl, state.accessToken);
+    printAssignedTasks(baseUrl, tasks);
+  })
+);
+addBaseUrlOption(
+  program.command("projects").description("Interact with project APIs").command("list").description("List accessible projects").action(async function() {
+    const state = await requireAuthState();
+    const configState = await loadConfigState();
+    const baseUrl = await resolveBaseUrl(
+      this.optsWithGlobals().baseUrl,
+      configState
+    );
+    const projects = await listProjects(baseUrl, state.accessToken);
+    printProjects(projects);
+  })
+);
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown CLI error.";
+    console.error(message);
+    process.exitCode = 1;
+  }
+}
+void main();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@khangal.j/fireside-cli",
+  "version": "0.0.1",
+  "description": "Fireside CLI",
+  "license": "MIT",
+  "private": false,
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "bin": {
+    "fireside": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --platform node --target node20 --out-dir dist --clean",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^14.0.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0"
+  }
+}