@pokelo/cli 0.1.0

package/src/config.mjs

@@ -0,0 +1,148 @@
+import { mkdirSync, readFileSync, writeFileSync, chmodSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { fail } from './exit.mjs';
+
+const LEGACY_CONFIG_PATH = join(homedir(), '.pokelo-cli.json');
+
+/** @typedef {{ url: string, token: string, defaultProjectId?: string | null }} PokeloConfig */
+
+export function xdgConfigPath() {
+  const xdg = process.env.XDG_CONFIG_HOME?.trim();
+  const base = xdg && xdg.length > 0 ? xdg : join(homedir(), '.config');
+  return join(base, 'pokelo', 'config.json');
+}
+
+/**
+ * Normalize instance URL to API base ending with /v1 (no trailing slash beyond that).
+ * Accepts https://host, https://host/, https://host/v1, https://host/v1/.
+ */
+export function normalizeApiBaseUrl(raw) {
+  const trimmed = String(raw ?? '').trim().replace(/\/+$/, '');
+  if (!trimmed) fail('url is required');
+  let url;
+  try {
+    url = new URL(trimmed.includes('://') ? trimmed : `https://${trimmed}`);
+  } catch {
+    fail(`invalid url: ${raw}`);
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    fail(`url must be http(s): ${raw}`);
+  }
+  let path = url.pathname.replace(/\/+$/, '') || '';
+  if (path === '' || path === '/') {
+    path = '/v1';
+  } else if (!path.endsWith('/v1')) {
+    path = `${path}/v1`.replace(/\/+/g, '/');
+  }
+  return `${url.origin}${path}`;
+}
+
+function readJsonFile(path) {
+  try {
+    const raw = readFileSync(path, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/** Load persisted config (XDG first, then legacy ~/.pokelo-cli.json). */
+export function loadPersistedConfig() {
+  const xdg = readJsonFile(xdgConfigPath());
+  if (xdg && typeof xdg === 'object') return sanitizeFileConfig(xdg);
+  const legacy = readJsonFile(LEGACY_CONFIG_PATH);
+  if (legacy && typeof legacy === 'object') {
+    return sanitizeFileConfig(migrateLegacy(legacy));
+  }
+  return null;
+}
+
+function migrateLegacy(legacy) {
+  const url = typeof legacy.url === 'string' ? legacy.url : '';
+  // Old PoC stored MCP URL (.../v1/mcp) — strip /mcp for REST base.
+  const cleaned = url.replace(/\/mcp\/?$/i, '');
+  return {
+    url: cleaned,
+    token: legacy.token,
+    defaultProjectId: legacy.defaultProjectId ?? null,
+  };
+}
+
+function sanitizeFileConfig(obj) {
+  const url = typeof obj.url === 'string' ? obj.url.trim() : '';
+  const token = typeof obj.token === 'string' ? obj.token.trim() : '';
+  const defaultProjectId =
+    typeof obj.defaultProjectId === 'string' && obj.defaultProjectId.trim()
+      ? obj.defaultProjectId.trim()
+      : null;
+  if (!url && !token) return null;
+  return { url, token, defaultProjectId };
+}
+
+/**
+ * Resolve runtime config.
+ * @param {{ url?: string, token?: string, project?: string }} flags
+ */
+export function resolveConfig(flags = {}) {
+  const file = loadPersistedConfig();
+  const urlRaw =
+    (typeof flags.url === 'string' && flags.url.trim()) ||
+    process.env.POKELO_URL?.trim() ||
+    file?.url ||
+    '';
+  const token =
+    (typeof flags.token === 'string' && flags.token.trim()) ||
+    process.env.POKELO_TOKEN?.trim() ||
+    file?.token ||
+    '';
+  const project =
+    (typeof flags.project === 'string' && flags.project.trim()) ||
+    process.env.POKELO_PROJECT?.trim() ||
+    file?.defaultProjectId ||
+    null;
+
+  if (!urlRaw) fail('missing Pokelo URL (set --url, POKELO_URL, or run: pokelo auth login)');
+  if (!token) fail('missing access token (set --token, POKELO_TOKEN, or run: pokelo auth login)');
+
+  return {
+    url: normalizeApiBaseUrl(urlRaw),
+    token,
+    defaultProjectId: project,
+  };
+}
+
+/**
+ * Persist config to XDG path. Never logs the token.
+ * @param {{ url: string, token: string, defaultProjectId?: string | null }} cfg
+ */
+export function saveConfig(cfg) {
+  const path = xdgConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  const payload = {
+    url: normalizeApiBaseUrl(cfg.url),
+    token: String(cfg.token).trim(),
+    defaultProjectId: cfg.defaultProjectId?.trim() || null,
+  };
+  writeFileSync(path, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  try {
+    chmodSync(path, 0o600);
+  } catch {
+    /* best-effort on platforms without chmod */
+  }
+  return path;
+}
+
+export function maskToken(token) {
+  const t = String(token ?? '');
+  if (!t) return null;
+  if (t.length <= 8) return `${t.slice(0, 2)}…`;
+  return `${t.slice(0, 6)}…${t.slice(-4)}`;
+}
+
+export function configExists() {
+  return existsSync(xdgConfigPath()) || existsSync(LEGACY_CONFIG_PATH);
+}
+
+export { LEGACY_CONFIG_PATH };

package/src/exit.mjs

@@ -0,0 +1,13 @@
+/** Usage / config errors. */
+export const EXIT_USAGE = 1;
+/** HTTP / API errors. */
+export const EXIT_API = 2;
+
+export function fail(message, code = EXIT_USAGE) {
+  process.stderr.write(`Error: ${message}\n`);
+  process.exit(code);
+}
+
+export function writeJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}

package/src/http.mjs

@@ -0,0 +1,71 @@
+import { EXIT_API, fail } from './exit.mjs';
+
+/**
+ * @param {import('./config.mjs').PokeloConfig} config
+ * @param {string} method
+ * @param {string} path - path under /v1, e.g. "/projects" or "projects"
+ * @param {{ body?: unknown, query?: Record<string, string | number | undefined | null> }} [opts]
+ */
+export async function apiRequest(config, method, path, opts = {}) {
+  const rel = path.startsWith('/') ? path : `/${path}`;
+  const url = new URL(`${config.url}${rel}`);
+  if (opts.query) {
+    for (const [k, v] of Object.entries(opts.query)) {
+      if (v === undefined || v === null || v === '') continue;
+      url.searchParams.set(k, String(v));
+    }
+  }
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+        Accept: 'application/json',
+        ...(opts.body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+      },
+      body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    fail(`network request failed: ${msg}`, EXIT_API);
+  }
+
+  if (res.status === 204) {
+    return null;
+  }
+
+  const text = await res.text().catch(() => '');
+  let json = null;
+  if (text) {
+    try {
+      json = JSON.parse(text);
+    } catch {
+      json = null;
+    }
+  }
+
+  if (json && typeof json === 'object' && 'success' in json) {
+    if (json.success === false) {
+      const err = json.error;
+      const message =
+        typeof err?.message === 'string'
+          ? err.message
+          : Array.isArray(err?.message)
+            ? err.message.join('; ')
+            : err?.code
+              ? String(err.code)
+              : `HTTP ${res.status}`;
+      fail(message, EXIT_API);
+    }
+    return json.data;
+  }
+
+  if (!res.ok) {
+    const snippet = text && text.length < 500 ? text : `HTTP ${res.status} ${res.statusText}`;
+    fail(snippet, EXIT_API);
+  }
+
+  return json ?? text;
+}