@elixpo/lixblogs-cli 1.3.3 → 1.4.4

package/src/commands/auth/login.js

@@ -1,117 +0,0 @@
-/**
- * lixblogs auth login
- *
- * Per #135:
- * - Display verification URL, user code, expiry, and polling status;
- *   optionally open the browser
- * - Support multiple named accounts/profiles
- * - Destructive and publishing scopes require clear consent
- *
- * This command is deliberately provider-agnostic — it only calls the
- * AuthProvider interface, never a concrete implementation. In dev/tests
- * this is wired to MockAuthProvider; production wiring goes through
- * productionGate.assertProviderAllowed() before this ever runs (see
- * bin/lixblogs.mjs for where that check happens).
- */
-
-import { redactErrorMessage } from "../../config/redact.js";
-
-/**
- * @param {Object} params
- * @param {import("../../auth/AuthProvider.js").AuthProvider} params.provider
- * @param {import("../../config/CredentialStore.js").CredentialStore} params.credentialStore
- * @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 }>}
- */
-export async function authLogin({
-  provider,
-  credentialStore,
-  profileId,
-  scopes,
-  openBrowser,
-  resolveProfileId,
-  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-  onStatus = () => {},
-}) {
-  let deviceCode;
-  try {
-    deviceCode = await provider.requestDeviceCode({ scopes });
-  } catch (err) {
-    return { ok: false, reason: redactErrorMessage(err.message) };
-  }
-
-  onStatus({
-    type: "verification_pending",
-    verificationUri: deviceCode.verificationUri,
-    verificationUriComplete: deviceCode.verificationUriComplete,
-    userCode: deviceCode.userCode,
-    expiresInSeconds: deviceCode.expiresInSeconds,
-  });
-
-  if (openBrowser) {
-    await openBrowser(deviceCode.verificationUriComplete || deviceCode.verificationUri);
-  }
-
-  let pollIntervalMs = deviceCode.pollIntervalSeconds * 1000;
-  const deadline = Date.now() + deviceCode.expiresInSeconds * 1000;
-
-  while (Date.now() < deadline) {
-    await sleep(pollIntervalMs);
-
-    let result;
-    try {
-      result = await provider.pollDeviceCode({ deviceCode: deviceCode.deviceCode });
-    } catch (err) {
-      return { ok: false, reason: redactErrorMessage(err.message) };
-    }
-
-    if (result.status === "approved") {
-      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: resolvedProfileId };
-    }
-
-    if (result.status === "denied") {
-      onStatus({ type: "denied" });
-      return { ok: false, reason: "Login was denied." };
-    }
-
-    if (result.status === "expired") {
-      onStatus({ type: "expired" });
-      return { ok: false, reason: "Device code expired before login was approved." };
-    }
-
-    if (result.status === "slow_down") {
-      pollIntervalMs += result.pollIntervalIncreaseSeconds * 1000;
-      onStatus({ type: "slow_down", newIntervalMs: pollIntervalMs });
-      continue;
-    }
-
-    // status === "pending" — keep polling
-    onStatus({ type: "pending" });
-  }
-
-  return { ok: false, reason: "Device code expired before login was approved." };
-}

package/src/commands/auth/logout.js

@@ -1,21 +0,0 @@
-/**
- * lixblogs auth logout
- *
- * Clears locally stored credentials for a profile. This is a *local*
- * operation — it does not revoke the token server-side (that's `revoke`).
- * A user who just wants to stop using this machine, without invalidating
- * the token everywhere, should be able to do that — this command is that
- * lighter-weight action. See revoke.js for the destructive, server-side
- * equivalent.
- */
-
-/**
- * @param {Object} params
- * @param {import("../../config/CredentialStore.js").CredentialStore} params.credentialStore
- * @param {string} params.profileId
- * @returns {Promise<{ ok: true }>}
- */
-export async function authLogout({ credentialStore, profileId }) {
-  await credentialStore.delete(profileId);
-  return { ok: true };
-}

package/src/commands/auth/profileAlias.js

@@ -1,29 +0,0 @@
-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/auth/profiles.js

@@ -1,27 +0,0 @@
-/** List known profiles without exposing credentials. */
-export async function authProfiles({ credentialStore, profileRegistry }) {
-  const activeProfile = await profileRegistry.getActive();
-  const profileIds = await credentialStore.listProfiles();
-  const profiles = [];
-  for (const profileId of profileIds) {
-    const credentials = await credentialStore.get(profileId);
-    profiles.push({
-      profileId,
-      active: profileId === activeProfile,
-      loggedIn: Boolean(credentials),
-      expired: credentials ? Date.now() >= credentials.expiresAt : undefined,
-      scopes: credentials?.scopes || [],
-    });
-  }
-  return { activeProfile, profiles };
-}
-
-/** Select the profile used when --profile is omitted. */
-export async function authUse({ credentialStore, profileRegistry, profileId }) {
-  const credentials = await credentialStore.get(profileId);
-  if (!credentials) {
-    return { ok: false, reason: `Profile "${profileId}" is not logged in.` };
-  }
-  await profileRegistry.setActive(profileId);
-  return { ok: true, profileId };
-}

package/src/commands/auth/revoke.js

@@ -1,45 +0,0 @@
-/**
- * lixblogs auth revoke
- *
- * Revokes the token server-side (via the AuthProvider) AND clears local
- * storage. This is destructive — per #135, "destructive and publishing
- * scopes require clear consent" and "destructive commands cannot run
- * accidentally in a non-interactive session."
- *
- * This function does not itself prompt — that's the CLI shell's job
- * (interactive confirmation prompt, or requiring an explicit --yes flag in
- * non-interactive mode). This function requires the caller to have already
- * obtained consent and pass confirmed: true; if confirmed is not exactly
- * true, it refuses to proceed. This makes "forgot to check for consent"
- * impossible to do accidentally at the call site.
- */
-
-/**
- * @param {Object} params
- * @param {import("../../auth/AuthProvider.js").AuthProvider} params.provider
- * @param {import("../../config/CredentialStore.js").CredentialStore} params.credentialStore
- * @param {string} params.profileId
- * @param {boolean} params.confirmed - must be exactly `true`; caller is
- *   responsible for having obtained real user consent before setting this.
- * @returns {Promise<{ ok: true } | { ok: false, reason: string }>}
- */
-export async function authRevoke({ provider, credentialStore, profileId, confirmed }) {
-  if (confirmed !== true) {
-    return {
-      ok: false,
-      reason:
-        "Revoke was not confirmed. This is a destructive action and requires " +
-        "explicit confirmation (interactive prompt, or --yes in a non-interactive session).",
-    };
-  }
-
-  const credentials = await credentialStore.get(profileId);
-  if (!credentials) {
-    return { ok: false, reason: `No stored credentials for profile "${profileId}".` };
-  }
-
-  await provider.revoke({ token: credentials.refreshToken });
-  await credentialStore.delete(profileId);
-
-  return { ok: true };
-}

package/src/commands/auth/status.js

@@ -1,33 +0,0 @@
-/**
- * lixblogs auth status
- *
- * Shows whether the given profile (or all profiles) is logged in, and
- * whether its token is expired. Never prints the token itself — only
- * derived, safe-to-display metadata (per #135's redaction requirement).
- */
-
-/**
- * @param {Object} params
- * @param {import("../../config/CredentialStore.js").CredentialStore} params.credentialStore
- * @param {string} [params.profileId] - if omitted, reports on all profiles
- * @returns {Promise<Array<{ profileId: string, loggedIn: boolean, expired?: boolean, scopes?: string[] }>>}
- */
-export async function authStatus({ credentialStore, profileId }) {
-  const profileIds = profileId ? [profileId] : await credentialStore.listProfiles();
-
-  const results = [];
-  for (const id of profileIds) {
-    const credentials = await credentialStore.get(id);
-    if (!credentials) {
-      results.push({ profileId: id, loggedIn: false });
-      continue;
-    }
-    results.push({
-      profileId: id,
-      loggedIn: true,
-      expired: Date.now() >= credentials.expiresAt,
-      scopes: credentials.scopes,
-    });
-  }
-  return results;
-}

package/src/commands/blog/index.js

@@ -1,85 +0,0 @@
-import { blocksToMarkdown } from '../../content/markdown.js';
-import { BlogApiError } from '../../api/BlogClient.js';
-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 });
-}
-
-export async function blogGet({ client, id }) {
-  if (!id) throw new Error('A blog ID is required.');
-  const blog = await client.get(id);
-  return { ...blog, markdown: blocksToMarkdown(blog.content) };
-}
-
-export async function blogCreate({ client, options, stdin }) {
-  const source = await resolveMarkdownInput(options, { stdin });
-  const input = { ...metadataFromOptions(options), content: source?.blocks || [] };
-  validateBlogInput(input);
-  if (options['dry-run']) return { dryRun: true, input, markdown: source?.markdown || '' };
-  return client.create(input, { idempotencyKey: options['idempotency-key'] });
-}
-
-export async function blogEdit({ client, id, options, stdin }) {
-  if (!id) throw new Error('A blog ID is required.');
-  const current = await client.get(id);
-  const source = await resolveMarkdownInput(options, { stdin, initial: blocksToMarkdown(current.content) });
-  const input = { ...metadataFromOptions(options), ...(source ? { content: source.blocks } : {}) };
-  if (!Object.keys(input).length) throw new Error('No blog changes were provided.');
-  validateBlogInput(input);
-  if (options['dry-run']) return { dryRun: true, id, etag: current.etag, input, markdown: source?.markdown };
-  try {
-    return await client.update(id, input, { etag: options.etag || current.etag });
-  } catch (error) {
-    if (!(error instanceof BlogApiError) || error.code !== 'revision_conflict') throw error;
-    const server = await client.get(id);
-    const directory = options.conflictDirectory || path.resolve('.lixblogs-conflicts');
-    await fs.mkdir(directory, { recursive: true });
-    const safeId = id.replace(/[^A-Za-z0-9._-]/g, '_');
-    const localPath = path.join(directory, `${safeId}-local.json`);
-    const serverPath = path.join(directory, `${safeId}-server.md`);
-    await Promise.all([
-      fs.writeFile(localPath, JSON.stringify(input, null, 2), { mode: 0o600 }),
-      fs.writeFile(serverPath, blocksToMarkdown(server.content), { mode: 0o600 }),
-    ]);
-    error.details = { ...error.details, localPath, serverPath, serverEtag: server.etag };
-    throw error;
-  }
-}
-
-export async function blogPublish({ client, id, options }) {
-  if (!id) throw new Error('A blog ID is required.');
-  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'] });
-}
-
-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 });
-}
-
-export async function blogDelete({ client, id, options }) {
-  if (!id) throw new Error('A blog ID is required.');
-  if (!options.yes) throw new Error('Deletion requires --yes. Trash is the default; add --permanent for irreversible deletion.');
-  const current = await client.get(id);
-  if (options['dry-run']) return { dryRun: true, id, permanent: options.permanent };
-  return client.delete(id, { etag: options.etag || current.etag, permanent: options.permanent });
-}
-
-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/blog/input.js

@@ -1,59 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { markdownToBlocks } from '../../content/markdown.js';
-
-async function stdinText(stream) {
-  let value = '';
-  stream.setEncoding('utf8');
-  for await (const chunk of stream) value += chunk;
-  return value;
-}
-
-async function editText(initial = '', editor = process.env.EDITOR || process.env.VISUAL) {
-  if (!editor) throw new Error('$EDITOR or $VISUAL must be set when using --editor.');
-  const directory = await fs.mkdtemp(path.join(tmpdir(), 'lixblogs-'));
-  const filename = path.join(directory, 'post.md');
-  await fs.writeFile(filename, initial, { mode: 0o600 });
-  try {
-    await new Promise((resolve, reject) => {
-      const child = spawn(editor, [filename], { stdio: 'inherit', shell: true });
-      child.once('error', reject);
-      child.once('exit', (code) => code === 0 ? resolve() : reject(new Error(`Editor exited with code ${code}.`)));
-    });
-    return await fs.readFile(filename, 'utf8');
-  } finally {
-    await fs.rm(directory, { recursive: true, force: true });
-  }
-}
-
-export async function resolveMarkdownInput(options, { stdin = process.stdin, initial = '' } = {}) {
-  const selected = [options.file !== undefined, options.stdin, options.content !== undefined, options.editor]
-    .filter(Boolean).length;
-  if (selected > 1) throw new Error('Use only one of --file, --stdin, --content, or --editor.');
-  if (!selected) return null;
-  let markdown;
-  if (options.file !== undefined) markdown = await fs.readFile(path.resolve(options.file), 'utf8');
-  else if (options.stdin) markdown = await stdinText(stdin);
-  else if (options.content !== undefined) markdown = options.content;
-  else markdown = await editText(initial);
-  return { markdown, blocks: markdownToBlocks(markdown) };
-}
-
-export function metadataFromOptions(options) {
-  const input = {};
-  const mappings = {
-    title: 'title', subtitle: 'subtitle', slug: 'slug', emoji: 'emoji',
-    publication: 'publishedAs', collection: 'collectionId', cover: 'coverUrl',
-  };
-  for (const [option, field] of Object.entries(mappings)) {
-    if (options[option] !== undefined) input[field] = options[option];
-  }
-  if (options.tag !== undefined) input.tags = options.tag;
-  if (options['member-only']) input.memberOnly = true;
-  if (options['no-member-only']) input.memberOnly = false;
-  if (options.secret) input.secret = true;
-  if (options['not-secret']) input.secret = false;
-  return input;
-}

package/src/commands/collab/index.js

@@ -1,53 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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 };
-}