@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/post/_flags.js

@@ -0,0 +1,96 @@
+import { Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Resolver } from '../../services/Resolver';
+// ---------------------------------------------------------------------------
+// Shared option definitions for `post create | edit | update`.
+// ---------------------------------------------------------------------------
+const optional = (self) => Options.optional(self);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const title = optional(Options.text('title'));
+export const slug = optional(Options.text('slug'));
+export const category = optional(Options.text('category'));
+export const content = optional(Options.text('content'));
+export const summary = optional(Options.text('summary'));
+export const file = optional(Options.text('file'));
+export const meta = optional(Options.text('meta'));
+export const pin = optional(Options.text('pin'));
+export const format = Options.choice('format', ['lexical', 'markdown']).pipe(Options.optional);
+export const state = Options.choice('state', ['publish', 'draft']).pipe(Options.optional);
+export const tags = optional(Options.text('tags'));
+export const related = optional(Options.text('related'));
+export const pinOrder = optional(Options.integer('pin-order'));
+export const copyright = optional(Options.text('copyright'));
+export const openFlag = Options.boolean('open').pipe(Options.withDescription('After success, open the admin edit page in the default browser.'));
+export const silentFlag = Options.boolean('silent').pipe(Options.withDescription('On success, emit a minimal `ok` instead of the full server response (saves output tokens). Errors still print normally.'));
+const parseCsv = (v) => {
+    if (v === undefined)
+        return undefined;
+    const parts = v
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return parts;
+};
+const parseCopyright = (v) => v === undefined ? undefined : v === 'true';
+export const postWriteOptions = {
+    title,
+    slug,
+    category,
+    content,
+    format,
+    summary,
+    state,
+    tags,
+    copyright,
+    pin,
+    pinOrder,
+    related,
+    meta,
+    file,
+    open: openFlag,
+    silent: silentFlag,
+};
+/** Resolve `__categoryName` placeholder (set by `buildPostPayload`) → `categoryId`. */
+export const resolveCategoryRefs = (payload) => Effect.gen(function* () {
+    const next = { ...payload };
+    const nameRef = next.__categoryName;
+    delete next.__categoryName;
+    if (typeof nameRef === 'string' && nameRef.length > 0 && !next.categoryId) {
+        const resolver = yield* Resolver;
+        next.categoryId = yield* resolver.resolveCategory(nameRef);
+    }
+    return next;
+});
+export const toPostFlagInputs = (opts) => ({
+    title: unwrap(opts.title),
+    slug: unwrap(opts.slug),
+    category: unwrap(opts.category),
+    content: unwrap(opts.content),
+    format: unwrap(opts.format),
+    summary: unwrap(opts.summary),
+    state: unwrap(opts.state),
+    tags: parseCsv(unwrap(opts.tags)),
+    copyright: parseCopyright(unwrap(opts.copyright)),
+    pin: unwrap(opts.pin),
+    pinOrder: unwrap(opts.pinOrder),
+    related: parseCsv(unwrap(opts.related)),
+    meta: unwrap(opts.meta),
+    file: unwrap(opts.file),
+});
+/**
+ * Extract the id from a server response — handles both `id` and `_id`,
+ * and unwraps the outer `data` envelope mx-core wraps single-object
+ * responses with (so `--open` works after `post create`).
+ */
+export const extractId = (res) => {
+    if (!res || typeof res !== 'object')
+        return undefined;
+    const r = res;
+    if (typeof r.id === 'string')
+        return r.id;
+    if (typeof r._id === 'string')
+        return r._id;
+    if (r.data && typeof r.data === 'object')
+        return extractId(r.data);
+    return undefined;
+};

package/dist/src/cli/post/apply.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const apply: Command.Command<"apply", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/post/apply.js

@@ -0,0 +1,70 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Generic } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { asRecord, first, unwrapDocument, } from '../../services/Renderer/content';
+import { Resolver } from '../../services/Resolver';
+import { camelizeDeep } from '../draft/_shared';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const parseTypeSpecificData = (raw) => {
+    if (!raw)
+        return {};
+    if (typeof raw === 'object' && !Array.isArray(raw))
+        return raw;
+    if (typeof raw !== 'string')
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'object' &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+};
+export const apply = Command.make('apply', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolvePostId(slugOrId);
+    // The server returns null when there is no draft for this post or when
+    // the draft has no pending changes (publishedVersion === version).
+    const draft = asRecord(unwrapDocument(yield* api.request(`/drafts/by-ref/post/${id}`)));
+    const draftId = first(draft, 'id');
+    if (typeof draftId !== 'string' || !draftId) {
+        return yield* Effect.fail(new Generic({
+            message: `no staged changes for post ${slugOrId}`,
+            hint: 'stage changes first with `mxs post stage <slugOrId> --file <article.xml>`',
+        }));
+    }
+    const body = {
+        ...parseTypeSpecificData(first(draft, 'type_specific_data', 'typeSpecificData')),
+    };
+    const title = first(draft, 'title');
+    const text = first(draft, 'text');
+    const content = first(draft, 'content');
+    const contentFormat = first(draft, 'content_format', 'contentFormat');
+    const meta = first(draft, 'meta');
+    if (title !== undefined)
+        body.title = title;
+    if (text !== undefined)
+        body.text = text;
+    if (content !== undefined)
+        body.content = content;
+    if (contentFormat !== undefined)
+        body.contentFormat = contentFormat;
+    if (meta !== undefined)
+        body.meta = camelizeDeep(meta);
+    // Sending draftId makes the server mark the draft's current version as
+    // published; the draft itself is retained (with its history).
+    body.draftId = draftId;
+    const res = yield* api.request(`/posts/${id}`, {
+        method: 'PATCH',
+        body,
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('apply the staged draft of a post to the live post (the confirm step after `post stage`)'));

package/dist/src/cli/post/create.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const create: Command.Command<"create", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | import("../../services/Resolver").Resolver | import("../../services/Lexical").Lexical, import("../../domain/errors").ValidationXml | import("../../services/Api").ApiError, {
+    readonly title: import("effect/Option").Option<string>;
+    readonly slug: import("effect/Option").Option<string>;
+    readonly category: import("effect/Option").Option<string>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly summary: import("effect/Option").Option<string>;
+    readonly state: import("effect/Option").Option<"draft" | "publish">;
+    readonly tags: import("effect/Option").Option<string>;
+    readonly copyright: import("effect/Option").Option<string>;
+    readonly pin: import("effect/Option").Option<string>;
+    readonly pinOrder: import("effect/Option").Option<number>;
+    readonly related: import("effect/Option").Option<string>;
+    readonly meta: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}>;

package/dist/src/cli/post/create.js

@@ -0,0 +1,24 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { buildPostPayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { extractId, postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from './_flags';
+export const create = Command.make('create', postWriteOptions, (opts) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(opts);
+    const built = yield* buildPostPayload(flags);
+    const payload = yield* resolveCategoryRefs(built.payload);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/posts', {
+        method: 'POST',
+        body: payload,
+    });
+    yield* renderer.emitSuccess(opts.silent ? { ok: true } : res);
+    if (opts.open) {
+        const id = extractId(res);
+        if (id)
+            yield* openAdminEdit('posts', id);
+    }
+})).pipe(Command.withDescription('create a post'));

package/dist/src/cli/post/delete.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const del: Command.Command<"delete", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+    readonly force: boolean;
+}>;

package/dist/src/cli/post/delete.js

@@ -0,0 +1,21 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const force = Options.boolean('force').pipe(Options.withDescription('skip confirmation'));
+export const del = Command.make('delete', { slugOrId, force }, ({ slugOrId, force }) => Effect.gen(function* () {
+    if (!force && !process.stdin.isTTY) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'refusing to delete without --force in non-TTY context',
+        }));
+    }
+    const resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolvePostId(slugOrId);
+    yield* api.request(`/posts/${id}`, { method: 'DELETE' });
+    yield* renderer.emitSuccess({ deleted: id });
+})).pipe(Command.withDescription('delete a post'));

package/dist/src/cli/post/edit.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@effect/cli';
+import { ValidationXml } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Lexical } from '../../services/Lexical';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const edit: Command.Command<"edit", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | Resolver | Editor | Lexical, ValidationXml | import("../../services/Api").ApiError, {
+    readonly title: import("effect/Option").Option<string>;
+    readonly slug: import("effect/Option").Option<string>;
+    readonly category: import("effect/Option").Option<string>;
+    readonly content: import("effect/Option").Option<string>;
+    readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+    readonly summary: import("effect/Option").Option<string>;
+    readonly state: import("effect/Option").Option<"draft" | "publish">;
+    readonly tags: import("effect/Option").Option<string>;
+    readonly copyright: import("effect/Option").Option<string>;
+    readonly pin: import("effect/Option").Option<string>;
+    readonly pinOrder: import("effect/Option").Option<number>;
+    readonly related: import("effect/Option").Option<string>;
+    readonly meta: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/post/edit.js

@@ -0,0 +1,115 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { coerceMeta, parseEnvelope } from '../../domain/envelope';
+import { ValidationXml } from '../../domain/errors';
+import { buildPostPayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Lexical } from '../../services/Lexical';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from './_flags';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const escapeXml = (s) => s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+const materializeForEditor = (slugOrId) => Effect.gen(function* () {
+    const api = yield* Api;
+    const resolver = yield* Resolver;
+    const lexical = yield* Lexical;
+    const path = yield* resolver.resolvePostReadPath(slugOrId);
+    const post = (yield* api.request(path, {
+        query: { prefer: 'lexical' },
+    }));
+    const isLexical = post.contentFormat === 'lexical';
+    let innerXml;
+    if (isLexical && post.content) {
+        const state = JSON.parse(post.content);
+        innerXml = yield* lexical.payloadToLitexml(state);
+    }
+    else {
+        innerXml = post.content ?? '';
+    }
+    const tagsXml = (post.tags ?? [])
+        .map((t) => `    <tag>${escapeXml(t)}</tag>`)
+        .join('\n');
+    return `<mxpost>
+  <meta>
+    <title>${escapeXml(post.title ?? '')}</title>
+    <slug>${escapeXml(post.slug ?? '')}</slug>
+    <state>${post.isPublished ? 'publish' : 'draft'}</state>
+    ${post.summary ? `<summary>${escapeXml(post.summary)}</summary>` : ''}
+    ${tagsXml ? `<tags>\n${tagsXml}\n    </tags>` : ''}
+  </meta>
+  <content>
+${innerXml}
+  </content>
+</mxpost>
+`;
+});
+const metaFromEnvelope = (meta) => {
+    const overlay = {};
+    const m = coerceMeta(meta);
+    if (m.title !== undefined)
+        overlay.title = m.title;
+    if (m.slug !== undefined)
+        overlay.slug = m.slug;
+    if (m.summary !== undefined)
+        overlay.summary = m.summary;
+    if (m.state !== undefined)
+        overlay.isPublished = m.state === 'publish';
+    if (m.tags !== undefined)
+        overlay.tags = m.tags;
+    return overlay;
+};
+export const edit = Command.make('edit', { slugOrId, ...postWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(rest);
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    // Editor round-trip path: no --file and no --content → spawn $EDITOR.
+    if (!flags.file && flags.content === undefined) {
+        const xml = yield* materializeForEditor(slugOrId);
+        const next = yield* editor.openEditor({
+            filename: `post-${slugOrId}.xml`,
+            initialContent: xml,
+        });
+        if (next.trim() === xml.trim()) {
+            yield* renderer.emitInfo('no changes');
+            return;
+        }
+        const parsed = yield* Effect.try({
+            try: () => parseEnvelope(next, 'post'),
+            catch: (err) => err instanceof ValidationXml
+                ? err
+                : new ValidationXml({ message: String(err), cause: err }),
+        });
+        const built = yield* buildPostPayload({
+            ...flags,
+            content: parsed.contentXml,
+            format: flags.format ?? 'lexical',
+        });
+        const payload = { ...built.payload, ...metaFromEnvelope(parsed.meta) };
+        const resolved = yield* resolveCategoryRefs(payload);
+        const id = yield* resolver.resolvePostId(slugOrId);
+        const res = yield* api.request(`/posts/${id}`, {
+            method: 'PUT',
+            body: resolved,
+        });
+        yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+        if (rest.open)
+            yield* openAdminEdit('posts', id);
+        return;
+    }
+    // Non-interactive path: build from flags / file.
+    const built = yield* buildPostPayload(flags);
+    const resolved = yield* resolveCategoryRefs(built.payload);
+    const id = yield* resolver.resolvePostId(slugOrId);
+    const res = yield* api.request(`/posts/${id}`, {
+        method: 'PUT',
+        body: resolved,
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+    if (rest.open)
+        yield* openAdminEdit('posts', id);
+})).pipe(Command.withDescription('edit a post via $EDITOR or flags'));

package/dist/src/cli/post/get.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const get: Command.Command<"get", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/post/get.js

@@ -0,0 +1,15 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { postView } from './view';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const get = Command.make('get', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const path = yield* resolver.resolvePostReadPath(slugOrId);
+    const res = yield* api.request(path, { query: { prefer: 'lexical' } });
+    yield* renderer.emit(postView, res);
+})).pipe(Command.withDescription('get a post by slug or id'));

package/dist/src/cli/post/index.d.ts

@@ -0,0 +1,91 @@
+import { Command } from '@effect/cli';
+export declare const postCmd: Command.Command<"post", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Resolver").Resolver | import("../../services/Editor").Editor | import("../../services/Lexical").Lexical, import("../../domain/errors").ValidationXml | import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+        readonly force: boolean;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly page: import("effect/Option").Option<number>;
+        readonly size: import("effect/Option").Option<number>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly sort: import("effect/Option").Option<"created" | "modified">;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly slugOrId: string;
+    } | {
+        readonly slugOrId: string;
+    } | {
+        readonly title: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly category: import("effect/Option").Option<string>;
+        readonly content: import("effect/Option").Option<string>;
+        readonly format: import("effect/Option").Option<"markdown" | "lexical">;
+        readonly summary: import("effect/Option").Option<string>;
+        readonly state: import("effect/Option").Option<"draft" | "publish">;
+        readonly tags: import("effect/Option").Option<string>;
+        readonly copyright: import("effect/Option").Option<string>;
+        readonly pin: import("effect/Option").Option<string>;
+        readonly pinOrder: import("effect/Option").Option<number>;
+        readonly related: import("effect/Option").Option<string>;
+        readonly meta: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly slugOrId: string;
+    }>;
+}>;

package/dist/src/cli/post/index.js

@@ -0,0 +1,73 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { apply } from './apply';
+import { create } from './create';
+import { del } from './delete';
+import { edit } from './edit';
+import { get } from './get';
+import { list } from './list';
+import { publish } from './publish';
+import { stage } from './stage';
+import { unpublish } from './unpublish';
+import { update } from './update';
+const help = registerCommandHelp({
+    name: 'post',
+    description: 'manage posts',
+    skillChapter: 'commands-post',
+    verbs: [
+        {
+            name: 'list',
+            args: ['[--page <n>]', '[--size <n>]', '[--state <s>]', '[--sort <s>]'],
+            description: 'list posts',
+        },
+        { name: 'get', args: ['<slugOrId>'], description: 'show a single post' },
+        {
+            name: 'create',
+            args: ['[--title ...]', '[--file <path>]', '...'],
+            description: 'create a post',
+        },
+        {
+            name: 'edit',
+            args: ['<slugOrId>', '[--file <path>]', '...'],
+            description: 'edit a post via $EDITOR or flags',
+        },
+        {
+            name: 'update',
+            args: ['<slugOrId>', '[--title ...]', '...'],
+            description: 'partially update a post',
+        },
+        {
+            name: 'delete',
+            args: ['<slugOrId>', '[--force]'],
+            description: 'delete a post',
+        },
+        { name: 'publish', args: ['<slugOrId>'], description: 'publish a post' },
+        {
+            name: 'unpublish',
+            args: ['<slugOrId>'],
+            description: 'unpublish a post',
+        },
+        {
+            name: 'stage',
+            args: ['<slugOrId>', '[--file <path>]', '...'],
+            description: 'stage changes as a draft; the live post stays untouched',
+        },
+        {
+            name: 'apply',
+            args: ['<slugOrId>'],
+            description: 'apply the staged draft to the live post',
+        },
+    ],
+});
+export const postCmd = Command.make('post').pipe(Command.withDescription(help.description), Command.withSubcommands([
+    list,
+    get,
+    create,
+    edit,
+    update,
+    del,
+    publish,
+    unpublish,
+    stage,
+    apply,
+]));

package/dist/src/cli/post/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"list", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly page: Option.Option<number>;
+    readonly size: Option.Option<number>;
+    readonly state: Option.Option<"draft" | "publish">;
+    readonly sort: Option.Option<"created" | "modified">;
+}>;

package/dist/src/cli/post/list.js

@@ -0,0 +1,23 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { postListView } from './view';
+const page = Options.integer('page').pipe(Options.optional);
+const size = Options.integer('size').pipe(Options.optional);
+const state = Options.choice('state', ['publish', 'draft']).pipe(Options.optional);
+const sort = Options.choice('sort', ['created', 'modified']).pipe(Options.optional);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('list', { page, size, state, sort }, ({ page, size, state, sort }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/posts', {
+        query: {
+            page: unwrap(page),
+            size: unwrap(size),
+            state: unwrap(state),
+            sortBy: unwrap(sort),
+        },
+    });
+    yield* renderer.emit(postListView, res);
+})).pipe(Command.withDescription('list posts'));

package/dist/src/cli/post/publish.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const publish: Command.Command<"publish", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/post/publish.js

@@ -0,0 +1,17 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const publish = Command.make('publish', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolvePostId(slugOrId);
+    const res = yield* api.request(`/posts/${id}`, {
+        method: 'PATCH',
+        body: { isPublished: true },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('publish a post'));