@mx-space/cli 0.14.2 → 0.15.1

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

@@ -0,0 +1,42 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { create } from './create';
+import { del } from './delete';
+import { get } from './get';
+import { list } from './list';
+import { publish } from './publish';
+import { update } from './update';
+const help = registerCommandHelp({
+    name: 'draft',
+    description: 'manage standalone drafts (server-side draft entities)',
+    skillChapter: 'commands-draft',
+    verbs: [
+        {
+            name: 'list',
+            args: ['[--type <t>]', '[--new]', '[--linked]'],
+            description: 'list drafts',
+        },
+        { name: 'get', args: ['<id>'], description: 'show a single draft' },
+        {
+            name: 'create',
+            args: ['--file <envelope.xml>', '[--title ...]', '...'],
+            description: 'create a standalone post draft',
+        },
+        {
+            name: 'update',
+            args: ['<id>', '--file <envelope.xml>', '...'],
+            description: 'update a draft (versioned)',
+        },
+        {
+            name: 'publish',
+            args: ['<id>', '[--silent]', '[--open]'],
+            description: 'publish a draft as a live post/note/page',
+        },
+        {
+            name: 'delete',
+            args: ['<id>', '[--force]'],
+            description: 'delete a draft',
+        },
+    ],
+});
+export const draftCmd = Command.make('draft').pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, create, update, publish, del]));

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

@@ -0,0 +1,11 @@
+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 type: Option.Option<"post" | "note" | "page">;
+    readonly new: boolean;
+    readonly linked: boolean;
+}>;

package/dist/src/cli/draft/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';
+const page = Options.integer('page').pipe(Options.optional);
+const size = Options.integer('size').pipe(Options.optional);
+const type = Options.choice('type', ['post', 'note', 'page']).pipe(Options.optional);
+const newOnly = Options.boolean('new').pipe(Options.withDescription('only drafts not linked to a published resource'));
+const linkedOnly = Options.boolean('linked').pipe(Options.withDescription('only drafts linked to a published resource'));
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('list', { page, size, type, new: newOnly, linked: linkedOnly }, ({ page, size, type, new: newOnly, linked: linkedOnly }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/drafts', {
+        query: {
+            page: unwrap(page),
+            size: unwrap(size),
+            refType: unwrap(type),
+            hasRef: newOnly ? false : linkedOnly ? true : undefined,
+        },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('list drafts'));

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

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

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

@@ -0,0 +1,64 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { Generic } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { extractId, openFlag, silentFlag } from '../post/_flags';
+import { camelizeDeep, normalizeDraftRow, parseTypeSpecificData, REF_TYPE_TO_RESOURCE, unwrapData, } from './_shared';
+const id = Args.text({ name: 'id' });
+export const publish = Command.make('publish', { id, open: openFlag, silent: silentFlag }, ({ id, open, silent }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const draft = normalizeDraftRow(unwrapData(yield* api.request(`/drafts/${encodeURIComponent(id)}`)));
+    if (!draft?.id || !draft.refType) {
+        return yield* Effect.fail(new Generic({ message: `draft not found: ${id}` }));
+    }
+    const resource = REF_TYPE_TO_RESOURCE[draft.refType];
+    if (!resource) {
+        return yield* Effect.fail(new Generic({
+            message: `unsupported draft refType: ${draft.refType}`,
+        }));
+    }
+    const body = {
+        ...parseTypeSpecificData(draft.typeSpecificData),
+    };
+    if (draft.title !== undefined)
+        body.title = draft.title;
+    if (draft.text !== undefined)
+        body.text = draft.text;
+    if (draft.content !== undefined && draft.content !== null)
+        body.content = draft.content;
+    if (draft.contentFormat !== undefined)
+        body.contentFormat = draft.contentFormat;
+    if (draft.meta !== undefined && draft.meta !== null)
+        body.meta = camelizeDeep(draft.meta);
+    // Sending draftId makes the server link the draft to the created
+    // resource and mark its current version as published; the draft is
+    // retained with its history.
+    body.draftId = draft.id;
+    let res;
+    if (draft.refId) {
+        // Draft is attached to an existing resource: apply changes and make
+        // sure the result is live.
+        if (draft.refType !== 'page')
+            body.isPublished = true;
+        res = yield* api.request(`/${resource}/${draft.refId}`, {
+            method: 'PATCH',
+            body,
+        });
+    }
+    else {
+        if (draft.refType !== 'page')
+            body.isPublished = true;
+        res = yield* api.request(`/${resource}`, {
+            method: 'POST',
+            body,
+        });
+    }
+    const publishedId = extractId(res) ?? draft.refId;
+    yield* renderer.emitSuccess(silent ? { ok: true, id: publishedId } : res);
+    if (open && publishedId && draft.refType !== 'page') {
+        yield* openAdminEdit(resource, publishedId);
+    }
+})).pipe(Command.withDescription('publish a draft: creates the post/note/page (or applies to the linked one) and marks it live'));

package/dist/src/cli/draft/update.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const update: Command.Command<"update", 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;
+    readonly id: string;
+}>;

package/dist/src/cli/draft/update.js

@@ -0,0 +1,29 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { buildPostPayload } from '../../domain/payload';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from '../post/_flags';
+import { splitDraftBody } from './_shared';
+const id = Args.text({ name: 'id' });
+export const update = Command.make('update', { id, ...postWriteOptions }, ({ id, ...rest }) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(rest);
+    const built = yield* buildPostPayload(flags);
+    const payload = yield* resolveCategoryRefs({ ...built.payload });
+    delete payload.isPublished;
+    const changedKeys = Object.keys(payload).filter((k) => k !== 'contentFormat');
+    if (changedKeys.length === 0) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'nothing to update: provide --file or content/meta flags',
+        }));
+    }
+    const body = splitDraftBody(payload);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/drafts/${encodeURIComponent(id)}`, {
+        method: 'PUT',
+        body,
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true, id } : res);
+})).pipe(Command.withDescription('update a draft (bumps its version and records history on content change)'));

package/dist/src/cli/file/_shared.d.ts

@@ -0,0 +1,6 @@
+import { Options } from '@effect/cli';
+/** Mirrors the server's `FileTypeEnum` (apps/core modules/file/file.type.ts). */
+export declare const FILE_TYPES: readonly ["file", "image", "icon", "avatar"];
+export type FileType = (typeof FILE_TYPES)[number];
+export declare const typeOption: Options.Options<"image" | "icon" | "file" | "avatar">;
+export declare const silentFlag: Options.Options<boolean>;

package/dist/src/cli/file/_shared.js

@@ -0,0 +1,5 @@
+import { Options } from '@effect/cli';
+/** Mirrors the server's `FileTypeEnum` (apps/core modules/file/file.type.ts). */
+export const FILE_TYPES = ['file', 'image', 'icon', 'avatar'];
+export const typeOption = Options.choice('type', FILE_TYPES).pipe(Options.withDescription('server-side storage bucket for the file'), Options.withDefault('file'));
+export const silentFlag = Options.boolean('silent').pipe(Options.withDescription('On success, emit a minimal `ok` instead of the full server response.'));

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

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

package/dist/src/cli/file/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 { typeOption } from './_shared';
+const name = Args.text({ name: 'name' });
+const force = Options.boolean('force').pipe(Options.withDescription('skip confirmation'));
+export const del = Command.make('delete', { name, type: typeOption, force }, ({ name, type, 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 api = yield* Api;
+    const renderer = yield* Renderer;
+    yield* api.request(`/objects/${type}/${encodeURIComponent(name)}`, {
+        method: 'DELETE',
+    });
+    yield* renderer.emitSuccess({ deleted: `${type}/${name}` });
+})).pipe(Command.withDescription('delete an uploaded file'));

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

@@ -0,0 +1,19 @@
+import { Command } from '@effect/cli';
+export declare const fileCmd: Command.Command<"file", import("../../services/Api").Api | import("../ai/_poll").Renderer, import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly name: string;
+        readonly type: "image" | "icon" | "file" | "avatar";
+        readonly force: boolean;
+    } | {
+        readonly type: "image" | "icon" | "file" | "avatar";
+    } | {
+        readonly name: string;
+        readonly newName: string;
+        readonly type: "image" | "icon" | "file" | "avatar";
+    } | {
+        readonly path: string;
+        readonly type: "image" | "icon" | "file" | "avatar";
+        readonly name: import("effect/Option").Option<string>;
+        readonly silent: boolean;
+    }>;
+}>;

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

@@ -0,0 +1,33 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { del } from './delete';
+import { list } from './list';
+import { rename } from './rename';
+import { upload } from './upload';
+const help = registerCommandHelp({
+    name: 'file',
+    description: 'upload and manage static files (images, icons, avatars)',
+    verbs: [
+        {
+            name: 'upload',
+            args: ['<path>', '[--type file|image|icon|avatar]', '[--name <n>]'],
+            description: 'upload a local file; returns { url, name }',
+        },
+        {
+            name: 'list',
+            args: ['[--type <t>]'],
+            description: 'list uploaded files of a type',
+        },
+        {
+            name: 'delete',
+            args: ['<name>', '[--type <t>]', '[--force]'],
+            description: 'delete an uploaded file',
+        },
+        {
+            name: 'rename',
+            args: ['<name>', '<newName>', '[--type <t>]'],
+            description: 'rename an uploaded file',
+        },
+    ],
+});
+export const fileCmd = Command.make('file').pipe(Command.withDescription(help.description), Command.withSubcommands([upload, list, del, rename]));

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

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"list", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly type: "image" | "icon" | "file" | "avatar";
+}>;

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

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { typeOption } from './_shared';
+export const list = Command.make('list', { type: typeOption }, ({ type }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/objects/${type}`);
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('list uploaded files of a type (name, url, created)'));

package/dist/src/cli/file/rename.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const rename: Command.Command<"rename", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly name: string;
+    readonly newName: string;
+    readonly type: "image" | "icon" | "file" | "avatar";
+}>;

package/dist/src/cli/file/rename.js

@@ -0,0 +1,16 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { typeOption } from './_shared';
+const name = Args.text({ name: 'name' });
+const newName = Args.text({ name: 'newName' });
+export const rename = Command.make('rename', { name, newName, type: typeOption }, ({ name, newName, type }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    yield* api.request(`/objects/${type}/${encodeURIComponent(name)}/rename`, {
+        method: 'PATCH',
+        query: { newName },
+    });
+    yield* renderer.emitSuccess({ renamed: `${type}/${name}`, to: newName });
+})).pipe(Command.withDescription('rename an uploaded file'));

package/dist/src/cli/file/upload.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const upload: Command.Command<"upload", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly path: string;
+    readonly type: "image" | "icon" | "file" | "avatar";
+    readonly name: import("effect/Option").Option<string>;
+    readonly silent: boolean;
+}>;

package/dist/src/cli/file/upload.js

@@ -0,0 +1,32 @@
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { Generic } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { FILE_TYPES, silentFlag, typeOption } from './_shared';
+const path = Args.text({ name: 'path' });
+const nameOption = Options.text('name').pipe(Options.withDescription('override the uploaded filename (defaults to the local basename)'), Options.optional);
+export const upload = Command.make('upload', { path, type: typeOption, name: nameOption, silent: silentFlag }, ({ path, type, name, silent }) => Effect.gen(function* () {
+    const buffer = yield* Effect.tryPromise({
+        try: () => readFile(path),
+        catch: (err) => new Generic({
+            message: `cannot read file: ${path}`,
+            cause: err,
+        }),
+    });
+    const filename = name._tag === 'Some' ? name.value : basename(path);
+    const form = new FormData();
+    // The server picks the first multipart file field and derives the mime
+    // type from the filename extension, so no explicit content-type needed.
+    form.append('file', new File([new Uint8Array(buffer)], filename));
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/objects/upload`, {
+        method: 'POST',
+        query: { type },
+        body: form,
+    });
+    yield* renderer.emitSuccess(silent ? { ok: true } : res);
+})).pipe(Command.withDescription(`upload a local file (--type ${FILE_TYPES.join('|')}); returns { url, name }`));

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

@@ -0,0 +1,62 @@
+import '../ai';
+import '../auth';
+import '../category';
+import '../comment';
+import '../config';
+import '../draft';
+import '../note';
+import '../page';
+import '../post';
+import '../preview';
+import '../profile';
+import '../project';
+import '../skill';
+import '../snippet';
+import '../topic';
+import '../update';
+import { type LeafOptionHelp, type VerbDescriptor } from './registry';
+export { renderMarkdownToAnsi } from '../render/markdown';
+export { type CommandHelp, isLeafCommand, type LeafOptionHelp, registerCommandHelp, type VerbDescriptor, } from './registry';
+export declare const GROUP_NAMES: readonly ["auth", "profile", "post", "note", "page", "draft", "project", "category", "topic", "comment", "snippet", "ai", "config", "skill", "preview", "update"];
+export type GroupName = (typeof GROUP_NAMES)[number];
+export declare const isGroupName: (s: string) => s is GroupName;
+export interface GlobalOptionHelp {
+    readonly flag: string;
+    readonly description: string;
+}
+export interface SubcommandHelp {
+    readonly name: string;
+    readonly description: string;
+    readonly verbs?: readonly string[];
+}
+export interface RootHelpData {
+    readonly programName: string;
+    readonly version: string;
+    readonly description: string;
+    readonly globalOptions: readonly GlobalOptionHelp[];
+    readonly commands: readonly SubcommandHelp[];
+    readonly examples?: readonly {
+        command: string;
+        description: string;
+    }[];
+}
+export declare const buildRootHelpData: (version: string) => RootHelpData;
+export declare const renderRootHelp: (data: RootHelpData) => string;
+/**
+ * Render the root help and write it to stdout, followed by a trailing
+ * newline. Honors `NO_COLOR` and non-TTY stdout (strips ANSI styling).
+ */
+export declare const emitHelp: (data: RootHelpData) => void;
+export interface GroupHelpData {
+    readonly programName: string;
+    readonly version: string;
+    readonly groupName: string;
+    readonly description: string;
+    readonly verbs: readonly VerbDescriptor[];
+    readonly isLeaf?: boolean;
+    readonly leafOptions?: readonly LeafOptionHelp[];
+    readonly skillChapter?: string;
+}
+export declare const groupHelpDataFor: (name: string, version: string) => GroupHelpData;
+export declare const renderGroupHelp: (data: GroupHelpData) => string;
+export declare const emitGroupHelp: (data: GroupHelpData) => void;