@elixpo/lixblogs-cli 1.1.2 → 1.3.3

package/src/commands/analytics/index.js

@@ -0,0 +1,57 @@
+import { writeFile } from 'node:fs/promises';
+
+const DIMENSIONS = new Set(['overview', 'timeline', 'posts', 'sources', 'devices', 'countries']);
+const RANGES = new Set(['7d', '30d', '90d', '12m', 'custom']);
+
+function normalizedOptions(options = {}) {
+  const dimension = options.dimension || 'overview';
+  const range = options.range || (options.from || options.to ? 'custom' : '30d');
+  if (!DIMENSIONS.has(dimension)) throw new Error(`Unsupported analytics dimension: ${dimension}.`);
+  if (!RANGES.has(range)) throw new Error(`Unsupported analytics range: ${range}.`);
+  if (range === 'custom' && (!options.from || !options.to)) throw new Error('Custom analytics ranges require --from and --to.');
+  return {
+    scope: options.scope?.[0] || options.publication || 'personal',
+    range,
+    from: options.from,
+    to: options.to,
+    dimension,
+    limit: options.limit,
+    cursor: options.cursor,
+  };
+}
+
+export async function analyticsQuery({ client, options }) {
+  return client.query(normalizedOptions(options));
+}
+
+function csvCell(value) {
+  const text = value === null || value === undefined ? '' : typeof value === 'object' ? JSON.stringify(value) : String(value);
+  return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+
+function rowsFromPayload(payload) {
+  const values = payload?.data?.values;
+  if (Array.isArray(values)) return values;
+  if (values?.labels && Array.isArray(values.labels)) {
+    return values.labels.map((label, index) => ({ label, views: values.views?.[index] || 0, reads: values.reads?.[index] || 0 }));
+  }
+  if (values?.totals) return Object.entries(values.totals).map(([metric, value]) => ({ metric, value, previous: values.previous?.[metric], change: values.changes?.[metric] }));
+  return [];
+}
+
+export async function analyticsExport({ client, options }) {
+  if (!options.output) throw new Error('Analytics export requires --output <file>.');
+  const format = options.format || 'json';
+  if (!['json', 'csv'].includes(format)) throw new Error('Analytics export format must be json or csv.');
+  const payload = await client.query(normalizedOptions(options));
+  let content;
+  if (format === 'json') {
+    content = `${JSON.stringify(payload, null, 2)}\n`;
+  } else {
+    const rows = rowsFromPayload(payload);
+    const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+    content = `${columns.map(csvCell).join(',')}\n${rows.map((row) => columns.map((column) => csvCell(row[column])).join(',')).join('\n')}\n`;
+  }
+  await writeFile(options.output, content, { encoding: 'utf8', flag: 'wx' });
+  return { output: options.output, format, rows: rowsFromPayload(payload).length };
+}

package/src/commands/auth/login.js

@@ -23,6 +23,7 @@ import { redactErrorMessage } from "../../config/redact.js";
  * @param {string} params.profileId - which named profile this login is for
  * @param {string[]} params.scopes - scopes being requested
  * @param {(url: string) => Promise<void>} [params.openBrowser] - optional browser opener
+ * @param {(params: { accessToken: string, requestedProfileId: string }) => Promise<string>} [params.resolveProfileId]
  * @param {(ms: number) => Promise<void>} [params.sleep] - injectable for tests
  * @param {(...args: any[]) => void} [params.onStatus] - callback for UI updates (verification URL, polling status, etc.)
  * @returns {Promise<{ ok: true, profileId: string } | { ok: false, reason: string }>}
@@ -33,6 +34,7 @@ export async function authLogin({
   profileId,
   scopes,
   openBrowser,
+  resolveProfileId,
   sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
   onStatus = () => {},
 }) {
@@ -69,14 +71,26 @@ export async function authLogin({
     }
 
     if (result.status === "approved") {
-      await credentialStore.set(profileId, {
+      let resolvedProfileId = profileId;
+      if (resolveProfileId) {
+        try {
+          resolvedProfileId = await resolveProfileId({
+            accessToken: result.token.accessToken,
+            requestedProfileId: profileId,
+          });
+        } catch (err) {
+          return { ok: false, reason: redactErrorMessage(err.message) };
+        }
+      }
+
+      await credentialStore.set(resolvedProfileId, {
         accessToken: result.token.accessToken,
         refreshToken: result.token.refreshToken,
         expiresAt: Date.now() + result.token.expiresInSeconds * 1000,
         scopes: result.token.scopes,
       });
       onStatus({ type: "approved" });
-      return { ok: true, profileId };
+      return { ok: true, profileId: resolvedProfileId };
     }
 
     if (result.status === "denied") {

package/src/commands/auth/profileAlias.js

@@ -0,0 +1,29 @@
+import { validateProfileId } from "../../config/ProfileRegistry.js";
+
+/** Resolve the authenticated Accounts username without persisting a temporary profile. */
+export async function profileAliasFromIdentity({
+  accessToken,
+  apiBaseUrl,
+  fetchImpl = globalThis.fetch,
+}) {
+  const endpoint = new URL("/api/v1/me", apiBaseUrl);
+  const response = await fetchImpl(endpoint, {
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("LixBlogs could not resolve the signed-in username.");
+  }
+
+  if (!response.ok || typeof payload?.data?.username !== "string") {
+    throw new Error(payload?.error?.message || "LixBlogs could not resolve the signed-in username.");
+  }
+
+  return validateProfileId(payload.data.username);
+}

package/src/commands/blog/index.js

@@ -4,6 +4,7 @@ import { metadataFromOptions, resolveMarkdownInput } from './input.js';
 import { validateBlogInput } from '../../content/validate.js';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { requireConfirmation } from '../../cli/contract.js';
 
 export async function blogList({ client, options }) {
   return client.list({ status: options.status, limit: options.limit, cursor: options.cursor });
@@ -55,6 +56,7 @@ export async function blogPublish({ client, id, options }) {
   const current = await client.get(id);
   validateBlogInput(current, { publishing: true });
   if (options['dry-run']) return { dryRun: true, id, from: current.status, to: 'published' };
+  requireConfirmation(options, 'Publishing this blog');
   return client.publish(id, { etag: options.etag || current.etag, idempotencyKey: options['idempotency-key'] });
 }
 
@@ -62,6 +64,7 @@ export async function blogUnpublish({ client, id, options }) {
   if (!id) throw new Error('A blog ID is required.');
   const current = await client.get(id);
   if (options['dry-run']) return { dryRun: true, id, from: current.status, to: 'draft' };
+  requireConfirmation(options, 'Unpublishing this blog');
   return client.unpublish(id, { etag: options.etag || current.etag });
 }
 
@@ -77,5 +80,6 @@ export async function blogRestore({ client, id, options }) {
   if (!id) throw new Error('A blog ID is required.');
   const current = await client.get(id);
   if (options['dry-run']) return { dryRun: true, id, restoreTo: current.preDeleteStatus || 'draft' };
+  requireConfirmation(options, 'Restoring this blog');
   return client.restore(id, { etag: options.etag || current.etag });
 }

package/src/commands/collab/index.js

@@ -0,0 +1,53 @@
+import { requireConfirmation } from '../../cli/contract.js';
+
+function requireBlogId(id) {
+  if (!id) throw new Error('A blog ID is required.');
+}
+
+export async function collabList({ client, id }) {
+  requireBlogId(id);
+  return client.list(id);
+}
+
+export async function collabInvitations({ client }) {
+  return client.invitations();
+}
+
+export async function collabInvite({ client, id, options }) {
+  requireBlogId(id);
+  if (!options.user) throw new Error('--user is required.');
+  if (!['viewer', 'editor', 'admin'].includes(options.role)) throw new Error('--role must be viewer, editor, or admin.');
+  if (options['dry-run']) return { dryRun: true, action: 'invite', blogId: id, user: options.user, role: options.role };
+  requireConfirmation(options, 'Inviting this collaborator');
+  return client.invite(id, { user: options.user, role: options.role, idempotencyKey: options['idempotency-key'] });
+}
+
+export async function collabRole({ client, id, options }) {
+  requireBlogId(id);
+  if (!options.user) throw new Error('--user is required.');
+  if (!['viewer', 'editor', 'admin'].includes(options.role)) throw new Error('--role must be viewer, editor, or admin.');
+  if (options['dry-run']) return { dryRun: true, action: 'role', blogId: id, user: options.user, role: options.role };
+  requireConfirmation(options, 'Changing this collaborator role');
+  return client.role(id, { user: options.user, role: options.role, idempotencyKey: options['idempotency-key'] });
+}
+
+export async function collabRemove({ client, id, options }) {
+  requireBlogId(id);
+  if (options['dry-run']) return { dryRun: true, action: 'remove', blogId: id, user: options.user || 'self' };
+  requireConfirmation(options, 'Removing this collaborator or invitation');
+  return client.remove(id, { user: options.user, idempotencyKey: options['idempotency-key'] });
+}
+
+export async function collabAccept({ client, id, options }) {
+  requireBlogId(id);
+  if (options['dry-run']) return { dryRun: true, action: 'accept', blogId: id, showOnProfile: !options['hide-on-profile'] };
+  requireConfirmation(options, 'Accepting this collaboration invitation');
+  return client.resolveInvitation(id, { action: 'accept', showOnProfile: !options['hide-on-profile'], idempotencyKey: options['idempotency-key'] });
+}
+
+export async function collabDecline({ client, id, options }) {
+  requireBlogId(id);
+  if (options['dry-run']) return { dryRun: true, action: 'decline', blogId: id };
+  requireConfirmation(options, 'Declining this collaboration invitation');
+  return client.resolveInvitation(id, { action: 'decline', idempotencyKey: options['idempotency-key'] });
+}

package/src/commands/org/index.js

@@ -0,0 +1,22 @@
+export async function orgList({ client }) {
+    return client.list();
+}
+
+export async function orgGet({ client, id }) {
+    if (!id) throw new Error("An organization ID or handle is required.");
+    return client.get(id);
+}
+
+export async function orgCollections({ client, id }) {
+    if (!id) throw new Error("An organization ID or handle is required.");
+    return client.collections(id);
+}
+
+export async function orgMembers({ client, id }) {
+    if (!id) throw new Error("An organization ID or handle is required.");
+    return client.members(id);
+}
+
+export async function orgTargets({ client }) {
+    return client.targets();
+}

package/src/commands/skill/index.js

@@ -0,0 +1,83 @@
+import { access, cp, readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { requireConfirmation } from '../../cli/contract.js';
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../..');
+const bundledRoot = path.join(packageRoot, 'skills');
+const developmentRoot = path.resolve(packageRoot, '../..', '.agents', 'skills');
+
+async function exists(candidate) {
+  try { await access(candidate); return true; } catch { return false; }
+}
+
+async function root() {
+  if (await exists(bundledRoot)) return bundledRoot;
+  if (await exists(developmentRoot)) return developmentRoot;
+  const error = new Error('No bundled LixBlogs skills were found. Reinstall @elixpo/lixblogs-cli.');
+  error.code = 'skills_unavailable';
+  throw error;
+}
+
+function validateName(name) {
+  if (!/^lixblogs-[a-z0-9-]+$/.test(name || '')) {
+    const error = new Error('A valid lixblogs-* skill name is required.');
+    error.code = 'invalid_skill_name';
+    throw error;
+  }
+  return name;
+}
+
+async function metadata(directory, name) {
+  const content = await readFile(path.join(directory, name, 'SKILL.md'), 'utf8');
+  const description = content.match(/^description:\s*(.+)$/m)?.[1] || content.match(/^description:\s*>-\s*\n\s*(.+)$/m)?.[1] || '';
+  const minimumCliVersion = content.match(/`@elixpo\/lixblogs-cli`\s+([0-9.]+)/)?.[1] || null;
+  return { name, description: description.trim(), minimumCliVersion, content };
+}
+
+export async function skillList() {
+  const directory = await root();
+  const entries = await readdir(directory, { withFileTypes: true });
+  return Promise.all(entries
+    .filter((entry) => entry.isDirectory() && entry.name.startsWith('lixblogs-'))
+    .map((entry) => metadata(directory, entry.name))
+  ).then((skills) => skills.map(({ content: _content, ...skill }) => skill).sort((a, b) => a.name.localeCompare(b.name)));
+}
+
+export async function skillInspect({ name }) {
+  const directory = await root();
+  const skillName = validateName(name);
+  if (!(await exists(path.join(directory, skillName, 'SKILL.md')))) {
+    const error = new Error(`Skill "${skillName}" is not bundled.`);
+    error.code = 'skill_not_found';
+    throw error;
+  }
+  return metadata(directory, skillName);
+}
+
+export async function skillInstall({ name, options }) {
+  const directory = await root();
+  const skillName = validateName(name);
+  const source = path.join(directory, skillName);
+  if (!(await exists(path.join(source, 'SKILL.md')))) {
+    const error = new Error(`Skill "${skillName}" is not bundled.`);
+    error.code = 'skill_not_found';
+    throw error;
+  }
+  const targetRoot = path.resolve(options.target || '.agents/skills');
+  const target = path.join(targetRoot, skillName);
+  if (options['dry-run']) return { dryRun: true, name: skillName, target, replace: await exists(target) };
+  if (await exists(target)) {
+    if (!options.force) {
+      const error = new Error(`Skill already exists at ${target}.`);
+      error.code = 'skill_exists';
+      error.hint = 'Inspect the existing skill or re-run with --force --yes to replace it.';
+      throw error;
+    }
+    requireConfirmation(options, `Replacing ${target}`);
+  } else {
+    requireConfirmation(options, `Installing ${skillName} into ${targetRoot}`);
+  }
+  await cp(source, target, { recursive: true, force: Boolean(options.force) });
+  return { installed: true, name: skillName, target };
+}

package/src/config/providerFactory.js

@@ -29,7 +29,7 @@ export function createAuthProvider(config) {
       accountsBaseUrl: config.accountsBaseUrl,
       clientId: config.clientId,
       audience: config.audience,
-      cliVersion: config.cliVersion || "1.1.0",
+      cliVersion: config.cliVersion || "1.2.0",
       fetchImpl: config.fetchImpl,
     });