@elixpo/lixblogs-cli 1.3.3 → 1.4.2

package/src/api/AnalyticsClient.js

@@ -1,40 +0,0 @@
-import { BlogApiError } from './BlogClient.js';
-
-async function parseResponse(response) {
-  let payload;
-  try { payload = await response.json(); } catch { payload = null; }
-  if (!response.ok || payload?.error) {
-    throw new BlogApiError(
-      payload?.error?.code || `http_${response.status}`,
-      payload?.error?.message || `LixBlogs returned HTTP ${response.status}.`,
-      { status: response.status, requestId: payload?.error?.requestId || response.headers.get('x-request-id'), details: payload?.error?.details },
-    );
-  }
-  return payload;
-}
-
-export class AnalyticsClient {
-  constructor(authenticatedClient) {
-    this.http = authenticatedClient;
-  }
-
-  async query(options = {}) {
-    const scope = options.scope || 'personal';
-    await this.http.requireScopes([
-      'lixblogs:analytics:read',
-      ...(scope.startsWith('org:') ? ['lixblogs:organizations:read'] : []),
-    ]);
-    const query = new URLSearchParams({
-      scope,
-      range: options.range || (options.from || options.to ? 'custom' : '30d'),
-      dimension: options.dimension || 'overview',
-      limit: String(options.limit || 20),
-    });
-    if (options.from) query.set('from', options.from);
-    if (options.to) query.set('to', options.to);
-    if (options.cursor) query.set('cursor', options.cursor);
-    return parseResponse(await this.http.request(`/api/v1/analytics?${query}`, {
-      headers: { accept: 'application/json' },
-    }));
-  }
-}

package/src/api/BlogClient.js

@@ -1,140 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-export class BlogApiError extends Error {
-  constructor(code, message, { status, requestId, details } = {}) {
-    super(message);
-    this.name = 'BlogApiError';
-    this.code = code || 'api_error';
-    this.status = status || 0;
-    this.requestId = requestId || null;
-    this.details = details || null;
-  }
-}
-
-async function parseResponse(response) {
-  let payload;
-  try { payload = await response.json(); } catch { payload = null; }
-  if (!response.ok || payload?.error) {
-    throw new BlogApiError(
-      payload?.error?.code || `http_${response.status}`,
-      payload?.error?.message || `LixBlogs returned HTTP ${response.status}.`,
-      {
-        status: response.status,
-        requestId: payload?.error?.requestId || response.headers.get('x-request-id'),
-        details: payload?.error?.details,
-      },
-    );
-  }
-  return { payload, etag: response.headers.get('etag') };
-}
-
-export class BlogClient {
-  constructor(authenticatedClient, { sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)) } = {}) {
-    this.http = authenticatedClient;
-    this.sleep = sleep;
-  }
-
-  async request(path, options = {}) {
-    const requestOptions = {
-      ...options,
-      headers: {
-        accept: 'application/json',
-        ...(options.body ? { 'content-type': 'application/json' } : {}),
-        ...options.headers,
-      },
-    };
-    const method = requestOptions.method || 'GET';
-    const retryable = method === 'GET' || Boolean(requestOptions.headers['idempotency-key']);
-    for (let attempt = 0; attempt < 2; attempt += 1) {
-      try {
-        const response = await this.http.request(path, requestOptions);
-        if (retryable && attempt === 0 && (response.status === 429 || response.status >= 500)) {
-          const seconds = Math.min(2, Number.parseInt(response.headers.get('retry-after') || '1', 10) || 1);
-          await this.sleep(seconds * 1000);
-          continue;
-        }
-        return parseResponse(response);
-      } catch (error) {
-        if (!retryable || attempt > 0 || error instanceof BlogApiError || error?.code) throw error;
-        await this.sleep(250);
-      }
-    }
-    throw new BlogApiError('request_failed', 'The LixBlogs request failed after retrying.');
-  }
-
-  async requireScopes(scopes) {
-    if (typeof this.http.requireScopes === 'function') await this.http.requireScopes(scopes);
-  }
-
-  async whoami() {
-    await this.requireScopes(['lixblogs:profile:read']);
-    return (await this.request('/api/v1/me')).payload.data;
-  }
-
-  async list({ status = 'all', limit = 20, cursor } = {}) {
-    await this.requireScopes(['lixblogs:blog:read']);
-    const query = new URLSearchParams({ status, limit: String(limit) });
-    if (cursor) query.set('cursor', cursor);
-    return (await this.request(`/api/v1/blogs?${query}`)).payload;
-  }
-
-  async get(id) {
-    await this.requireScopes(['lixblogs:blog:read']);
-    const result = await this.request(`/api/v1/blogs/${encodeURIComponent(id)}`);
-    return { ...result.payload.data, etag: result.etag || result.payload.data.etag };
-  }
-
-  async create(input, { idempotencyKey = randomUUID() } = {}) {
-    await this.requireScopes(['lixblogs:blog:write']);
-    return (await this.request('/api/v1/blogs', {
-      method: 'POST',
-      headers: { 'idempotency-key': idempotencyKey },
-      body: JSON.stringify(input),
-    })).payload.data;
-  }
-
-  async update(id, input, { etag }) {
-    await this.requireScopes(['lixblogs:blog:write']);
-    return (await this.request(`/api/v1/blogs/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      headers: { 'if-match': etag },
-      body: JSON.stringify(input),
-    })).payload.data;
-  }
-
-  async publish(id, { etag, idempotencyKey = randomUUID() }) {
-    await this.requireScopes(['lixblogs:blog:publish']);
-    return (await this.request(`/api/v1/blogs/${encodeURIComponent(id)}/publish`, {
-      method: 'POST',
-      headers: { 'if-match': etag, 'idempotency-key': idempotencyKey },
-    })).payload.data;
-  }
-
-  async unpublish(id, { etag }) {
-    await this.requireScopes(['lixblogs:blog:publish']);
-    return (await this.request(`/api/v1/blogs/${encodeURIComponent(id)}/unpublish`, {
-      method: 'POST', headers: { 'if-match': etag },
-    })).payload.data;
-  }
-
-  async delete(id, { etag, permanent = false }) {
-    await this.requireScopes([
-      'lixblogs:blog:delete',
-      ...(permanent ? ['lixblogs:blog:delete:permanent'] : []),
-    ]);
-    return (await this.request(`/api/v1/blogs/${encodeURIComponent(id)}${permanent ? '?permanent=true' : ''}`, {
-      method: 'DELETE',
-      headers: {
-        'if-match': etag,
-        ...(permanent ? { 'x-confirm-permanent-delete': id } : {}),
-      },
-    })).payload.data;
-  }
-
-  async restore(id, { etag }) {
-    await this.requireScopes(['lixblogs:blog:delete']);
-    return (await this.request(`/api/v1/blogs/${encodeURIComponent(id)}/restore`, {
-      method: 'POST', headers: { 'if-match': etag },
-    })).payload.data;
-  }
-}

package/src/api/CollaborationClient.js

@@ -1,73 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { BlogApiError } from './BlogClient.js';
-
-async function parseResponse(response) {
-  let payload;
-  try { payload = await response.json(); } catch { payload = null; }
-  if (!response.ok || payload?.error) {
-    throw new BlogApiError(payload?.error?.code || `http_${response.status}`, payload?.error?.message || `LixBlogs returned HTTP ${response.status}.`, {
-      status: response.status,
-      requestId: payload?.error?.requestId || response.headers.get('x-request-id'),
-      details: payload?.error?.details,
-    });
-  }
-  return payload.data;
-}
-
-export class CollaborationClient {
-  constructor(authenticatedClient) {
-    this.http = authenticatedClient;
-  }
-
-  async request(path, options = {}) {
-    const response = await this.http.request(path, {
-      ...options,
-      headers: {
-        accept: 'application/json',
-        ...(options.body ? { 'content-type': 'application/json' } : {}),
-        ...options.headers,
-      },
-    });
-    return parseResponse(response);
-  }
-
-  async list(blogId) {
-    await this.http.requireScopes(['lixblogs:collaboration:read']);
-    return this.request(`/api/v1/blogs/${encodeURIComponent(blogId)}/collaborators`);
-  }
-
-  async invitations() {
-    await this.http.requireScopes(['lixblogs:collaboration:read']);
-    return this.request('/api/v1/collaboration/invitations');
-  }
-
-  async invite(blogId, { user, role, idempotencyKey = randomUUID() }) {
-    await this.http.requireScopes(['lixblogs:collaboration:write']);
-    return this.request(`/api/v1/blogs/${encodeURIComponent(blogId)}/collaborators`, {
-      method: 'POST', headers: { 'idempotency-key': idempotencyKey }, body: JSON.stringify({ user, role }),
-    });
-  }
-
-  async role(blogId, { user, role, idempotencyKey = randomUUID() }) {
-    await this.http.requireScopes(['lixblogs:collaboration:write']);
-    return this.request(`/api/v1/blogs/${encodeURIComponent(blogId)}/collaborators`, {
-      method: 'PATCH', headers: { 'idempotency-key': idempotencyKey }, body: JSON.stringify({ user, role }),
-    });
-  }
-
-  async remove(blogId, { user, idempotencyKey = randomUUID() } = {}) {
-    await this.http.requireScopes(['lixblogs:collaboration:write']);
-    return this.request(`/api/v1/blogs/${encodeURIComponent(blogId)}/collaborators`, {
-      method: 'DELETE', headers: { 'idempotency-key': idempotencyKey }, body: JSON.stringify({ ...(user ? { user } : {}) }),
-    });
-  }
-
-  async resolveInvitation(blogId, { action, showOnProfile = true, idempotencyKey = randomUUID() }) {
-    await this.http.requireScopes(['lixblogs:collaboration:write']);
-    return this.request('/api/v1/collaboration/invitations', {
-      method: 'POST',
-      headers: { 'idempotency-key': idempotencyKey },
-      body: JSON.stringify({ blogId, action, showOnProfile }),
-    });
-  }
-}

package/src/api/OrgClient.js

@@ -1,158 +0,0 @@
-import { BlogApiError } from "./BlogClient.js";
-
-async function parseResponse(response) {
-    let payload;
-    try {
-        payload = await response.json();
-    } catch {
-        payload = null;
-    }
-    if (!response.ok || payload?.error) {
-        throw new BlogApiError(
-            payload?.error?.code || `http_${response.status}`,
-            payload?.error?.message ||
-                `LixBlogs returned HTTP ${response.status}.`,
-            {
-                status: response.status,
-                requestId:
-                    payload?.error?.requestId ||
-                    response.headers.get("x-request-id"),
-                details: payload?.error?.details,
-            },
-        );
-    }
-    return { payload, etag: response.headers.get("etag") };
-}
-
-export class OrgClient {
-    constructor(
-        authenticatedClient,
-        {
-            sleep = (milliseconds) =>
-                new Promise((resolve) => setTimeout(resolve, milliseconds)),
-        } = {},
-    ) {
-        this.http = authenticatedClient;
-        this.sleep = sleep;
-    }
-
-    async request(path, options = {}) {
-        const requestOptions = {
-            ...options,
-            headers: {
-                accept: "application/json",
-                ...(options.body ? { "content-type": "application/json" } : {}),
-                ...options.headers,
-            },
-        };
-        const method = requestOptions.method || "GET";
-        const retryable = method === "GET";
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            try {
-                const response = await this.http.request(path, requestOptions);
-                if (
-                    retryable &&
-                    attempt === 0 &&
-                    (response.status === 429 || response.status >= 500)
-                ) {
-                    const seconds = Math.min(
-                        2,
-                        Number.parseInt(
-                            response.headers.get("retry-after") || "1",
-                            10,
-                        ) || 1,
-                    );
-                    await this.sleep(seconds * 1000);
-                    continue;
-                }
-                return parseResponse(response);
-            } catch (error) {
-                if (
-                    !retryable ||
-                    attempt > 0 ||
-                    error instanceof BlogApiError ||
-                    error?.code
-                )
-                    throw error;
-                await this.sleep(250);
-            }
-        }
-        throw new BlogApiError(
-            "request_failed",
-            "The LixBlogs request failed after retrying.",
-        );
-    }
-
-    async requireScopes(scopes) {
-        if (typeof this.http.requireScopes === "function")
-            await this.http.requireScopes(scopes);
-    }
-
-    async list() {
-        await this.requireScopes(["lixblogs:organizations:read"]);
-        return (await this.request("/api/v1/orgs")).payload;
-    }
-
-    async get(id) {
-        if (!id) throw new Error("An organization ID or handle is required.");
-        await this.requireScopes(["lixblogs:organizations:read"]);
-        return (await this.request(`/api/v1/orgs/${encodeURIComponent(id)}`))
-            .payload.data;
-    }
-
-    async collections(id) {
-        if (!id) throw new Error("An organization ID or handle is required.");
-        await this.requireScopes(["lixblogs:organizations:read"]);
-        return (
-            await this.request(
-                `/api/v1/orgs/${encodeURIComponent(id)}/collections`,
-            )
-        ).payload.data;
-    }
-
-    async members(id) {
-        if (!id) throw new Error("An organization ID or handle is required.");
-        await this.requireScopes(["lixblogs:organizations:read"]);
-        return (
-            await this.request(`/api/v1/orgs/${encodeURIComponent(id)}/members`)
-        ).payload.data;
-    }
-
-    async targets() {
-        await this.requireScopes(["lixblogs:organizations:read"]);
-        const orgsList = await this.list();
-        const orgs = orgsList?.data || [];
-        const writableOrgs = orgs.filter((org) => org.canWrite);
-
-        const orgTargets = await Promise.all(
-            writableOrgs.map(async (org) => {
-                let cols = [];
-                try {
-                    cols = await this.collections(org.id);
-                } catch {
-                    cols = [];
-                }
-                return {
-                    target: `org:${org.id}`,
-                    orgId: org.id,
-                    slug: org.slug,
-                    name: org.name,
-                    role: org.role,
-                    collections: cols.map((col) => ({
-                        id: col.id,
-                        slug: col.slug,
-                        name: col.name,
-                    })),
-                };
-            }),
-        );
-
-        return {
-            personal: {
-                target: "personal",
-                name: "Personal Blog",
-            },
-            organizations: orgTargets,
-        };
-    }
-}

package/src/auth/AuthProvider.js

@@ -1,90 +0,0 @@
-/**
- * AuthProvider — the single interface every auth implementation must satisfy.
- *
- * No CLI or API code should ever call a provider-specific method directly.
- * Everything goes through this interface, so swapping MockAuthProvider for
- * the real ElixpoAuthProvider (once accounts.elixpo.com confirms device-flow
- * support) requires no changes to calling code.
- *
- * See: elixpo/blogs.elixpo#137 for the full requirements this interface
- * exists to satisfy.
- */
-
-/**
- * @typedef {Object} DeviceCodeResponse
- * @property {string} deviceCode - Opaque code the client polls with.
- * @property {string} userCode - Short code the user enters at verificationUri.
- * @property {string} verificationUri - URL the user visits to approve login.
- * @property {string} [verificationUriComplete] - Approval URL with user code pre-filled.
- * @property {number} expiresInSeconds - How long the device code is valid for.
- * @property {number} pollIntervalSeconds - Minimum seconds between poll attempts.
- */
-
-/**
- * @typedef {Object} TokenResponse
- * @property {string} accessToken
- * @property {string} refreshToken
- * @property {number} expiresInSeconds
- * @property {string[]} scopes - Scopes actually granted (may be a subset of requested).
- */
-
-/**
- * @typedef {"pending"|"approved"|"denied"|"expired"|"slow_down"} PollStatus
- */
-
-/**
- * @typedef {Object} PollResult
- * @property {PollStatus} status
- * @property {TokenResponse} [token] - Present only when status === "approved".
- * @property {number} [pollIntervalIncreaseSeconds] - Present only when
- *   status === "slow_down". Caller must add this to its current polling
- *   interval before the next poll (RFC 8628 §3.5 behavior).
- */
-
-export class AuthProvider {
-  /**
-   * Identifies which implementation this is. Used by the production safety
-   * gate to refuse anything but the approved provider in production.
-   * @returns {string} e.g. "mock" | "elixpo"
-   */
-  get providerId() {
-    throw new Error("AuthProvider.providerId must be implemented by subclass");
-  }
-
-  /**
-   * Start a device authorization request.
-   * @param {{ scopes: string[] }} params
-   * @returns {Promise<DeviceCodeResponse>}
-   */
-  async requestDeviceCode(_params) {
-    throw new Error("AuthProvider.requestDeviceCode must be implemented by subclass");
-  }
-
-  /**
-   * Poll for whether the user has approved/denied the device code yet.
-   * Callers are responsible for respecting pollIntervalSeconds between calls.
-   * @param {{ deviceCode: string }} params
-   * @returns {Promise<PollResult>}
-   */
-  async pollDeviceCode(_params) {
-    throw new Error("AuthProvider.pollDeviceCode must be implemented by subclass");
-  }
-
-  /**
-   * Exchange a refresh token for a new access token.
-   * @param {{ refreshToken: string, scopes?: string[] }} params
-   * @returns {Promise<TokenResponse>}
-   */
-  async refresh(_params) {
-    throw new Error("AuthProvider.refresh must be implemented by subclass");
-  }
-
-  /**
-   * Revoke a token (access or refresh). Must not throw if already revoked.
-   * @param {{ token: string }} params
-   * @returns {Promise<void>}
-   */
-  async revoke(_params) {
-    throw new Error("AuthProvider.revoke must be implemented by subclass");
-  }
-}

package/src/auth/AuthenticatedClient.js

@@ -1,131 +0,0 @@
-import { AuthProviderError } from "./ElixpoAuthProvider.js";
-
-const DEFAULT_REFRESH_SKEW_MS = 60_000;
-const storeLocks = new WeakMap();
-
-function profileLocks(credentialStore) {
-  let locks = storeLocks.get(credentialStore);
-  if (!locks) {
-    locks = new Map();
-    storeLocks.set(credentialStore, locks);
-  }
-  return locks;
-}
-
-export class LoginRequiredError extends Error {
-  constructor(profileId) {
-    super(`Profile "${profileId}" needs to log in again.`);
-    this.name = "LoginRequiredError";
-    this.code = "login_required";
-  }
-}
-
-export class ApiContractUnavailableError extends Error {
-  constructor(status, contentType) {
-    super("The configured LixBlogs origin is not serving the API v1 JSON contract.");
-    this.name = "ApiContractUnavailableError";
-    this.code = "api_contract_unavailable";
-    this.status = status;
-    this.details = { contentType: contentType || "unknown" };
-    this.hint = "Deploy the LixBlogs API v1 stack, or select an origin that exposes /api/v1.";
-  }
-}
-
-export class AuthenticatedClient {
-  constructor({
-    provider,
-    credentialStore,
-    profileId,
-    apiBaseUrl = "https://blogs.elixpo.com",
-    fetchImpl = globalThis.fetch,
-    refreshSkewMs = DEFAULT_REFRESH_SKEW_MS,
-  }) {
-    this.provider = provider;
-    this.credentialStore = credentialStore;
-    this.profileId = profileId;
-    this.apiBaseUrl = new URL(apiBaseUrl);
-    this.fetchImpl = fetchImpl;
-    this.refreshSkewMs = refreshSkewMs;
-  }
-
-  async _refresh(credentials, { force = false } = {}) {
-    const locks = profileLocks(this.credentialStore);
-    const existing = locks.get(this.profileId);
-    if (existing) return existing;
-
-    const operation = (async () => {
-      const latest = (await this.credentialStore.get(this.profileId)) || credentials;
-      if (!force && latest.expiresAt - Date.now() > this.refreshSkewMs) return latest;
-      try {
-        const token = await this.provider.refresh({
-          refreshToken: latest.refreshToken,
-          scopes: latest.scopes,
-        });
-        const rotated = {
-          accessToken: token.accessToken,
-          refreshToken: token.refreshToken,
-          expiresAt: Date.now() + token.expiresInSeconds * 1000,
-          scopes: token.scopes,
-        };
-        await this.credentialStore.set(this.profileId, rotated);
-        return rotated;
-      } catch (error) {
-        if (error instanceof AuthProviderError && error.requiresLogin) {
-          await this.credentialStore.delete(this.profileId);
-          throw new LoginRequiredError(this.profileId);
-        }
-        throw error;
-      }
-    })();
-
-    locks.set(this.profileId, operation);
-    try {
-      return await operation;
-    } finally {
-      if (locks.get(this.profileId) === operation) locks.delete(this.profileId);
-    }
-  }
-
-  async credentials({ forceRefresh = false } = {}) {
-    const stored = await this.credentialStore.get(this.profileId);
-    if (!stored) throw new LoginRequiredError(this.profileId);
-    if (forceRefresh || stored.expiresAt - Date.now() <= this.refreshSkewMs) {
-      return this._refresh(stored, { force: forceRefresh });
-    }
-    return stored;
-  }
-
-  async request(url, options = {}) {
-    const target = new URL(url, this.apiBaseUrl);
-    if (target.origin !== this.apiBaseUrl.origin || !target.pathname.startsWith("/api/v1/")) {
-      throw new Error("Authenticated CLI requests are restricted to the configured LixBlogs /api/v1 resource server.");
-    }
-    let credentials = await this.credentials();
-    const send = () => this.fetchImpl(target.toString(), {
-      ...options,
-      headers: { ...options.headers, authorization: `Bearer ${credentials.accessToken}` },
-    });
-    let response = await send();
-    if (response.status === 401) {
-      credentials = await this.credentials({ forceRefresh: true });
-      response = await send();
-    }
-    const contentType = response.headers.get("content-type") || "";
-    if (!contentType.toLowerCase().includes("application/json")) {
-      throw new ApiContractUnavailableError(response.status, contentType);
-    }
-    return response;
-  }
-
-  async requireScopes(required) {
-    const credentials = await this.credentials();
-    const missing = required.filter((scope) => !credentials.scopes.includes(scope));
-    if (missing.length) {
-      const error = new Error(`Login again with the required scope${missing.length > 1 ? 's' : ''}: ${missing.join(', ')}`);
-      error.name = 'InsufficientScopeError';
-      error.code = 'insufficient_scope';
-      error.missingScopes = missing;
-      throw error;
-    }
-  }
-}