@elixpo/lixblogs-cli 1.1.2 → 1.3.1

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,
     });