@pitcher/cli-scripts 2.11.0 → 2.12.0

package/dist/src/commands/ld/course.js

@@ -0,0 +1,308 @@
+import { Command } from 'commander';
+import { ldClientFor, ldData, toLdCliError, requireInstance, pickTruthy } from '../../core/ld.js';
+import { ok, fail } from '../../core/envelope.js';
+import { createCliError } from '../../core/errors.js';
+import { parseJsonInput, resolveTextInput } from '../../core/readInput.js';
+import { emitEnvelope } from '../../core/output.js';
+import { listLimitOffsetParams } from '../../core/pagination.js';
+import { assertIntFlags } from '../../schema/content.js';
+import { withAuthFlags } from '../withAuth.js';
+import { withInstanceFlag } from '../withInstance.js';
+const ADMIN = '/admin/courses';
+// ---- run* functions ----
+export async function runLdCourseList(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        assertIntFlags(opts); // rejects --limit/--offset that parsed to NaN (matches sibling commands)
+        const params = { instanceId, ...listLimitOffsetParams(opts), ...pickTruthy(opts, ['status', 'title', 'tags']) };
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(ADMIN, { params });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseGet(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseTags(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/tags`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// Optional course fields that pass straight through when set. `tags` is a string[] (csv on the CLI);
+// `contentHtml` is handled separately (inline-or-file). An html course REQUIRES contentHtml server-side.
+const COURSE_OPTIONAL_FIELDS = [
+    'status',
+    'contentSource',
+    'completionCriteria',
+    'thumbnailUrl',
+    'scormPassRequired',
+    'tags',
+];
+function addOptional(body, opts) {
+    for (const k of COURSE_OPTIONAL_FIELDS)
+        if (opts[k] !== undefined)
+            body[k] = opts[k];
+    // contentHtml can be large HTML — resolve inline (--content-html) or file (--content-html-file).
+    const html = resolveTextInput(opts.contentHtml, opts.contentHtmlFile, 'content-html');
+    if (html !== undefined)
+        body.contentHtml = html;
+}
+// createCourseSchema requires ALL of these IN THE BODY (validateBody parses req.body alone; the
+// controller reads instanceId from the query AND strips a body copy, but validation runs first,
+// so instanceId must be in the body too). description ≥10, level enum, duration/sectionsCount ints.
+export async function runLdCourseCreate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.title)
+            throw createCliError('VALIDATION', '--title is required');
+        if (!opts.description)
+            throw createCliError('VALIDATION', '--description is required (min 10 chars)');
+        if (!opts.level)
+            throw createCliError('VALIDATION', '--level is required (Beginner|Intermediate|Advanced)');
+        if (opts.duration === undefined)
+            throw createCliError('VALIDATION', '--duration is required (minutes, integer)');
+        if (opts.sectionsCount === undefined)
+            throw createCliError('VALIDATION', '--sections-count is required (integer)');
+        const body = {
+            instanceId,
+            title: opts.title,
+            description: opts.description,
+            level: opts.level,
+            duration: opts.duration,
+            sectionsCount: opts.sectionsCount,
+        };
+        addOptional(body, opts);
+        // createCourseSchema (backend) requires contentHtml for an html course (the default source).
+        // Fail fast with a clear message rather than let the backend 400 with an opaque one.
+        const source = body.contentSource ?? 'html';
+        if (source === 'html' && body.contentHtml === undefined) {
+            throw createCliError('VALIDATION', '--content-html (or --content-html-file) is required for an html course');
+        }
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(ADMIN, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// updateCourseSchema is createCourseSchema.partial() — every field optional. Send only what changed.
+export async function runLdCourseUpdate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const body = {};
+        for (const k of ['title', 'description', 'level', 'duration', 'sectionsCount']) {
+            if (opts[k] !== undefined)
+                body[k] = opts[k];
+        }
+        addOptional(body, opts);
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseDelete(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { id: opts.id, deleted: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+async function patchCourseState(path, opts, deps) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.patch(`${ADMIN}/${opts.id}/${path}`, {}, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export const runLdCoursePublish = (o, d = {}) => patchCourseState('publish', o, d);
+export const runLdCourseUnpublish = (o, d = {}) => patchCourseState('unpublish', o, d);
+export async function runLdCourseGetCanvas(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`/app/courses/${opts.id}/canvas`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseSetCanvas(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const parsed = parseJsonInput(opts.canvas, opts.canvasFile, 'canvas');
+        // The L&D backend requires `canvas` to be a JSON OBJECT — a full canvas whose
+        // `content.data` holds the flat component array (verified live against the PIT-7609
+        // Lambda: a bare array 400s "Validation failed"). The flat content.data array is the
+        // natural authoring unit, so accept it and wrap it; an already-shaped object (with its
+        // own `theme` etc.) passes through untouched.
+        const canvas = Array.isArray(parsed) ? { content: { data: parsed } } : parsed;
+        // NB: no requireRecompletion here — the L&D backend (PIT-7609) rejects it for the org
+        // x-api-key (the only auth this CLI has), since a bulk rep-completion wipe is a
+        // human-admin-only action. Exposing it would only ever 403.
+        const client = await ldClientFor(opts, deps);
+        const res = await client.patch(`/app/courses/${opts.id}/canvas`, { canvas }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseListModules(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/modules`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseAddToModules(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.moduleIds?.length)
+            throw createCliError('VALIDATION', '--module-ids is required (comma-separated)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/modules`, { moduleIds: opts.moduleIds }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseRemoveFromModule(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.moduleId)
+            throw createCliError('VALIDATION', '--id and --module-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/modules/${opts.moduleId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseListAssessments(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/assessments`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseLinkAssessments(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.assessmentIds?.length)
+            throw createCliError('VALIDATION', '--assessment-ids is required (comma-separated)');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/assessments`, { assessmentIds: opts.assessmentIds }, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdCourseUnlinkAssessment(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.assessmentId)
+            throw createCliError('VALIDATION', '--id and --assessment-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/assessments/${opts.assessmentId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- commander subcommand ----
+// A comma-separated → string[] parser for repeatable id / tag flags. Exported so the
+// other resource subcommands (module/cert/assessment) reuse the exact same parser.
+export const csv = (v) => v.split(',').map((s) => s.trim()).filter(Boolean);
+// Boolean flag parser — `--is-required true|false`. Lenient (only 'true' is true) so a bad value
+// can't throw an InvalidArgumentError before the action (which would bypass the JSON envelope).
+export const boolFlag = (v) => v === 'true';
+// Per-subcommand auth + instance + ld-url, matching the shipped pattern (flags AFTER the
+// verb). NEVER use .requiredOption — commander aborts before the action and prints plain
+// text / exit 1, breaking the --output json envelope contract (house rule; PIT-7412). The
+// run* functions carry the real required-field guards (createCliError VALIDATION → exit 3).
+export const ldFlags = (c) => withInstanceFlag(withAuthFlags(c)).option('--ld-url <url>', 'Override L&D API base URL (CLI only)');
+// Shared commander action wrapper: merge global auth flags into the run* opts and render the
+// envelope. Exported so the module/cert/assessment subcommands reuse it (like csv/ldFlags).
+export const render = (fn) => async (o, c) => emitEnvelope(await fn({ ...c.optsWithGlobals(), ...o }), c.optsWithGlobals());
+export function createCourseSubcommand() {
+    const cmd = new Command('course').description('Author L&D courses');
+    ldFlags(cmd.command('list')).option('--status <s>').option('--title <t>').option('--tags <t>', 'Comma-separated', csv).option('--limit <n>', '', Number).option('--offset <n>', '', Number).action(render(runLdCourseList));
+    ldFlags(cmd.command('get')).option('--id <id>', 'Course ID (required)').action(render(runLdCourseGet));
+    ldFlags(cmd.command('tags')).action(render(runLdCourseTags));
+    ldFlags(cmd.command('create')).option('--title <t>', 'required').option('--description <d>', 'required, min 10 chars').option('--level <l>', 'Beginner|Intermediate|Advanced (required)').option('--duration <n>', 'minutes, integer (required)', Number).option('--sections-count <n>', 'integer (required)', Number).option('--content-source <s>', 'html|scorm|canvas (default html)').option('--content-html <html>', 'Inline HTML body (required for an html course)').option('--content-html-file <path>').option('--completion-criteria <c>').option('--thumbnail-url <url>').option('--scorm-pass-required <bool>', 'true|false', boolFlag).option('--status <s>').option('--tags <t>', 'Comma-separated', csv).action(render(runLdCourseCreate));
+    ldFlags(cmd.command('update')).option('--id <id>', 'required').option('--title <t>').option('--description <d>').option('--level <l>').option('--duration <n>', '', Number).option('--sections-count <n>', '', Number).option('--content-source <s>').option('--content-html <html>').option('--content-html-file <path>').option('--completion-criteria <c>').option('--thumbnail-url <url>').option('--scorm-pass-required <bool>', 'true|false', boolFlag).option('--status <s>').option('--tags <t>', 'Comma-separated', csv).action(render(runLdCourseUpdate));
+    ldFlags(cmd.command('delete')).option('--id <id>', 'required').action(render(runLdCourseDelete));
+    ldFlags(cmd.command('publish')).option('--id <id>', 'required').action(render(runLdCoursePublish));
+    ldFlags(cmd.command('unpublish')).option('--id <id>', 'required').action(render(runLdCourseUnpublish));
+    ldFlags(cmd.command('get-canvas')).option('--id <id>', 'required').action(render(runLdCourseGetCanvas));
+    ldFlags(cmd.command('set-canvas')).option('--id <id>', 'required').option('--canvas <json>', 'Inline canvas JSON: object { content: { data: [...] }, theme? } (a bare content.data array is auto-wrapped)').option('--canvas-file <path>').action(render(runLdCourseSetCanvas));
+    ldFlags(cmd.command('list-modules')).option('--id <id>', 'required').action(render(runLdCourseListModules));
+    ldFlags(cmd.command('add-to-modules')).option('--id <id>', 'required').option('--module-ids <ids>', 'Comma-separated (required)', csv).action(render(runLdCourseAddToModules));
+    ldFlags(cmd.command('remove-from-module')).option('--id <id>', 'required').option('--module-id <id>', 'required').action(render(runLdCourseRemoveFromModule));
+    ldFlags(cmd.command('list-assessments')).option('--id <id>', 'required').action(render(runLdCourseListAssessments));
+    ldFlags(cmd.command('link-assessments')).option('--id <id>', 'required').option('--assessment-ids <ids>', 'Comma-separated (required)', csv).action(render(runLdCourseLinkAssessments));
+    ldFlags(cmd.command('unlink-assessment')).option('--id <id>', 'required').option('--assessment-id <id>', 'required').action(render(runLdCourseUnlinkAssessment));
+    return cmd;
+}

package/dist/src/commands/ld/module.d.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { type LdCommonOpts, type LdDeps } from '../../core/ld.js';
+import { type Envelope } from '../../core/envelope.js';
+export declare function runLdModuleTags(opts: LdCommonOpts, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleList(opts: LdCommonOpts & {
+    status?: string;
+    title?: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleGet(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleCreate(opts: LdCommonOpts & Record<string, unknown>, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleUpdate(opts: LdCommonOpts & {
+    id?: string;
+} & Record<string, unknown>, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleDelete(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleListCourses(opts: LdCommonOpts & {
+    id?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleAddCourses(opts: LdCommonOpts & {
+    id?: string;
+    courseIds?: string[];
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleReorderCourses(opts: LdCommonOpts & {
+    id?: string;
+    courseId?: string;
+    newOrder?: number;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleUpdateCourse(opts: LdCommonOpts & {
+    id?: string;
+    courseId?: string;
+    isRequired?: boolean;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function runLdModuleRemoveCourse(opts: LdCommonOpts & {
+    id?: string;
+    courseId?: string;
+}, deps?: LdDeps): Promise<Envelope<unknown>>;
+export declare function createModuleSubcommand(): Command;

package/dist/src/commands/ld/module.js

@@ -0,0 +1,199 @@
+import { Command } from 'commander';
+import { ldClientFor, ldData, toLdCliError, requireInstance, pickTruthy } from '../../core/ld.js';
+import { ok, fail } from '../../core/envelope.js';
+import { createCliError } from '../../core/errors.js';
+import { listLimitOffsetParams } from '../../core/pagination.js';
+import { assertIntFlags } from '../../schema/content.js';
+import { csv, ldFlags, render, boolFlag } from './course.js';
+const ADMIN = '/admin/modules';
+// ---- run* functions ----
+export async function runLdModuleTags(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/tags`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleList(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        assertIntFlags(opts); // rejects --limit/--offset that parsed to NaN (matches sibling commands)
+        const params = { instanceId, ...listLimitOffsetParams(opts), ...pickTruthy(opts, ['status', 'title', 'tags']) };
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(ADMIN, { params });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleGet(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// createModuleSchema requires title, subtitle AND description in the body (validateBody parses
+// req.body alone; the controller reads instanceId from the query but validation runs first, so
+// instanceId must be in the body too — same shape as createCourseSchema).
+export async function runLdModuleCreate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.title)
+            throw createCliError('VALIDATION', '--title is required');
+        if (!opts.subtitle)
+            throw createCliError('VALIDATION', '--subtitle is required');
+        if (!opts.description)
+            throw createCliError('VALIDATION', '--description is required');
+        const body = {
+            instanceId,
+            title: opts.title,
+            subtitle: opts.subtitle,
+            description: opts.description,
+        };
+        if (opts.tags !== undefined)
+            body.tags = opts.tags;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(ADMIN, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// updateModuleSchema is createModuleSchema.partial() — every field optional. Send only what changed.
+export async function runLdModuleUpdate(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const body = {};
+        for (const k of ['title', 'subtitle', 'description', 'tags']) {
+            if (opts[k] !== undefined)
+                body[k] = opts[k];
+        }
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleDelete(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { id: opts.id, deleted: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleListCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.get(`${ADMIN}/${opts.id}/courses`, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// The API expects a `courses` array of `{ id }` objects — NOT a flat `{ courseIds }` array.
+export async function runLdModuleAddCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.courseIds?.length)
+            throw createCliError('VALIDATION', '--course-ids is required (comma-separated)');
+        const body = { courses: opts.courseIds.map((id) => ({ id })) };
+        const client = await ldClientFor(opts, deps);
+        const res = await client.post(`${ADMIN}/${opts.id}/courses`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleReorderCourses(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id)
+            throw createCliError('VALIDATION', '--id is required');
+        if (!opts.courseId)
+            throw createCliError('VALIDATION', '--course-id is required');
+        if (opts.newOrder === undefined || !Number.isInteger(opts.newOrder))
+            throw createCliError('VALIDATION', '--new-order is required (integer)');
+        const body = { courseId: opts.courseId, newOrder: opts.newOrder };
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/courses/order`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleUpdateCourse(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.courseId)
+            throw createCliError('VALIDATION', '--id and --course-id are required');
+        const body = {};
+        if (opts.isRequired !== undefined)
+            body.isRequired = opts.isRequired;
+        const client = await ldClientFor(opts, deps);
+        const res = await client.put(`${ADMIN}/${opts.id}/courses/${opts.courseId}`, body, { params: { instanceId } });
+        return ok(ldData(res));
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+export async function runLdModuleRemoveCourse(opts, deps = {}) {
+    try {
+        const instanceId = requireInstance(opts);
+        if (!opts.id || !opts.courseId)
+            throw createCliError('VALIDATION', '--id and --course-id are required');
+        const client = await ldClientFor(opts, deps);
+        const res = await client.delete(`${ADMIN}/${opts.id}/courses/${opts.courseId}`, { params: { instanceId } });
+        return ok(ldData(res) ?? { removed: true });
+    }
+    catch (e) {
+        return fail(toLdCliError(e));
+    }
+}
+// ---- commander subcommand ----
+export function createModuleSubcommand() {
+    const cmd = new Command('module').description('Author L&D modules');
+    ldFlags(cmd.command('tags')).action(render(runLdModuleTags));
+    ldFlags(cmd.command('list')).option('--status <s>').option('--title <t>').option('--tags <t>', 'Comma-separated', csv).option('--limit <n>', '', Number).option('--offset <n>', '', Number).action(render(runLdModuleList));
+    ldFlags(cmd.command('get')).option('--id <id>', 'Module ID (required)').action(render(runLdModuleGet));
+    ldFlags(cmd.command('create')).option('--title <t>', 'required').option('--subtitle <s>', 'required').option('--description <d>', 'required').option('--tags <t>', 'Comma-separated', csv).action(render(runLdModuleCreate));
+    ldFlags(cmd.command('update')).option('--id <id>', 'required').option('--title <t>').option('--subtitle <s>').option('--description <d>').option('--tags <t>', 'Comma-separated', csv).action(render(runLdModuleUpdate));
+    ldFlags(cmd.command('delete')).option('--id <id>', 'required').action(render(runLdModuleDelete));
+    ldFlags(cmd.command('list-courses')).option('--id <id>', 'required').action(render(runLdModuleListCourses));
+    ldFlags(cmd.command('add-courses')).option('--id <id>', 'required').option('--course-ids <ids>', 'Comma-separated (required)', csv).action(render(runLdModuleAddCourses));
+    ldFlags(cmd.command('reorder-courses')).option('--id <id>', 'required').option('--course-id <id>', 'required').option('--new-order <n>', 'integer (required)', Number).action(render(runLdModuleReorderCourses));
+    ldFlags(cmd.command('update-course')).option('--id <id>', 'required').option('--course-id <id>', 'required').option('--is-required <bool>', 'true|false', boolFlag).action(render(runLdModuleUpdateCourse));
+    ldFlags(cmd.command('remove-course')).option('--id <id>', 'required').option('--course-id <id>', 'required').action(render(runLdModuleRemoveCourse));
+    return cmd;
+}

package/dist/src/commands/ld.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createLdCommand(): Command;

package/dist/src/commands/ld.js

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { createCourseSubcommand } from './ld/course.js';
+import { createCanvasCourseSubcommand } from './ld/canvasCourse.js';
+import { createModuleSubcommand } from './ld/module.js';
+import { createCertSubcommand } from './ld/cert.js';
+import { createAssessmentSubcommand } from './ld/assessment.js';
+export function createLdCommand() {
+    const cmd = new Command('ld').description('Author L&D (MicroLearn) content via the L&D backend');
+    cmd.addCommand(createCourseSubcommand());
+    cmd.addCommand(createCanvasCourseSubcommand());
+    cmd.addCommand(createModuleSubcommand());
+    cmd.addCommand(createCertSubcommand());
+    cmd.addCommand(createAssessmentSubcommand());
+    return cmd;
+}

package/dist/src/core/ld.d.ts

@@ -0,0 +1,38 @@
+import type { AxiosInstance } from 'axios';
+import { type CommonOpts } from './http.js';
+import { type CliError } from './errors.js';
+export interface LdCommonOpts extends CommonOpts {
+    instanceId?: string;
+    ldUrl?: string;
+}
+export interface LdDeps {
+    ldClient?: AxiosInstance;
+    platformClient?: AxiosInstance;
+}
+/** Test-only: reset the resolved-base-URL cache between cases. */
+export declare function __clearLdBaseUrlCache(): void;
+/** Every L&D run* requires an instance; returns it narrowed to string, else VALIDATION. */
+export declare function requireInstance(opts: LdCommonOpts): string;
+/** Copy the truthy values of `keys` from `opts` into a params object (shared list-filter pick). */
+export declare function pickTruthy<T extends object>(opts: T, keys: readonly (keyof T)[]): Partial<Record<keyof T, unknown>>;
+/**
+ * Resolve the standalone L&D Lambda base URL. Order: --ld-url flag → NG_LD_API_URL env →
+ * ld-app app config (api_base_url) via the platform client. Cached per (org, instanceId).
+ * The org key can't be region-inferred, so app config (region-correct) is the default.
+ */
+export declare function resolveLdBaseUrl(opts: LdCommonOpts, deps?: LdDeps, env?: NodeJS.ProcessEnv): Promise<string>;
+/** Build (or inject, in tests) an axios client pointed at the resolved L&D Lambda base. */
+export declare function ldClientFor(opts: LdCommonOpts, deps?: LdDeps, env?: NodeJS.ProcessEnv): Promise<AxiosInstance>;
+/**
+ * Unwrap the L&D success envelope `{ success, data, message? }` to its resource payload.
+ * Falls back to the raw body if it is not enveloped (defensive).
+ */
+export declare function ldData(res: {
+    data?: unknown;
+}): unknown;
+/**
+ * Map an L&D axios error to a clean CliError. The L&D error body is `{ success:false,
+ * message, statusCode }`; the generic `extractApiMessage` would concatenate every key, so
+ * read `.message` explicitly and derive the code from the HTTP status. Falls back to `toCliError`.
+ */
+export declare function toLdCliError(e: unknown): CliError;