@mx-space/cli 0.14.2 → 0.15.1

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

@@ -0,0 +1,23 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const stage: Command.Command<"stage", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | 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 slugOrId: string;
+}>;

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

@@ -0,0 +1,55 @@
+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 { Resolver } from '../../services/Resolver';
+import { postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from './_flags';
+const slugOrId = Args.text({ name: 'slugOrId' });
+/** Draft-native fields; everything else rides along in `typeSpecificData`. */
+const DRAFT_CORE_KEYS = new Set([
+    'title',
+    'text',
+    'content',
+    'contentFormat',
+    'meta',
+]);
+export const stage = Command.make('stage', { slugOrId, ...postWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(rest);
+    const built = yield* buildPostPayload(flags);
+    const payload = yield* resolveCategoryRefs({ ...built.payload });
+    // Publish state never travels through staging: it would otherwise ride
+    // into `typeSpecificData` and unpublish the live post on `post apply`.
+    delete payload.isPublished;
+    // `contentFormat` is always defaulted by the payload builder; require
+    // some actual change beyond it so an empty stage fails loudly.
+    const changedKeys = Object.keys(payload).filter((k) => k !== 'contentFormat');
+    if (changedKeys.length === 0) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'nothing to stage: provide --file or content/meta flags',
+        }));
+    }
+    const draftBody = {};
+    const typeSpecificData = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (DRAFT_CORE_KEYS.has(key))
+            draftBody[key] = value;
+        else
+            typeSpecificData[key] = value;
+    }
+    if (Object.keys(typeSpecificData).length > 0) {
+        draftBody.typeSpecificData = typeSpecificData;
+    }
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolvePostId(slugOrId);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    // POST /drafts upserts: the server updates the existing draft for this
+    // ref (one draft per post, with internal version history).
+    const res = yield* api.request(`/drafts`, {
+        method: 'POST',
+        body: { refType: 'post', refId: id, ...draftBody },
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+})).pipe(Command.withDescription('stage changes as a draft attached to a published post (the live post is untouched until `post apply`)'));

package/dist/src/cli/post/unpublish.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 unpublish: Command.Command<"unpublish", Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/post/unpublish.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 unpublish = Command.make('unpublish', { 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: false },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('unpublish a post'));

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

@@ -0,0 +1,23 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const update: Command.Command<"update", import("@effect/platform/Path").Path | import("@effect/platform/FileSystem").FileSystem | Api | Renderer | 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 slugOrId: string;
+}>;

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

@@ -0,0 +1,38 @@
+import { Args, 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 { Resolver } from '../../services/Resolver';
+import { postWriteOptions, resolveCategoryRefs, toPostFlagInputs, } from './_flags';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const update = Command.make('update', { slugOrId, ...postWriteOptions }, ({ slugOrId, ...rest }) => Effect.gen(function* () {
+    const flags = toPostFlagInputs(rest);
+    const built = yield* buildPostPayload(flags);
+    const payload = { ...built.payload };
+    if (flags.content === undefined && !flags.file) {
+        delete payload.content;
+        delete payload.text;
+        delete payload.contentFormat;
+    }
+    // Envelope <state> must not flip publish state on update: envelopes are
+    // routinely reused from `post create` (where <state>draft</state> is the
+    // norm), and a published post silently reverting to draft makes it
+    // vanish for readers. Only the explicit --state flag (or the dedicated
+    // publish/unpublish commands) changes publish state.
+    if (flags.state === undefined)
+        delete payload.isPublished;
+    const resolved = yield* resolveCategoryRefs(payload);
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolvePostId(slugOrId);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(`/posts/${id}`, {
+        method: 'PATCH',
+        body: resolved,
+    });
+    yield* renderer.emitSuccess(rest.silent ? { ok: true } : res);
+    if (rest.open)
+        yield* openAdminEdit('posts', id);
+})).pipe(Command.withDescription('partially update a post'));

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

@@ -0,0 +1,3 @@
+import type { View } from '../../services/Renderer/view';
+export declare const postView: View<unknown>;
+export declare const postListView: View<unknown>;

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

@@ -0,0 +1,150 @@
+import { asRecord, contentFormat, first, firstString, formatScalar, pickArticleTranslationMeta, publishState, relationLabel, relationSlugOrLabel, renderContent, unwrapDocument, } from '../../services/Renderer/content';
+import { tryFormatTimestamp } from '../../services/Renderer/datetime';
+import { frontmatter, renderEnvelope, renderMetadataBlock } from '../render';
+const normalize = (data) => asRecord(unwrapDocument(data));
+const collectFields = (doc, articleMeta) => {
+    const meta = articleMeta ?? {};
+    const fields = [
+        ['id', first(doc, 'id')],
+        ['slug', first(doc, 'slug')],
+        ['state', publishState(doc)],
+        ['category', relationLabel(first(doc, 'category'))],
+        ['tags', first(doc, 'tags')],
+        ['pin', first(doc, 'pin')],
+        ['created_at', first(doc, 'created_at', 'createdAt')],
+        ['modified_at', first(doc, 'modified_at', 'modifiedAt')],
+        [
+            'source_lang',
+            first(doc, 'source_lang', 'sourceLang') ??
+                first(meta, 'source_lang', 'sourceLang'),
+        ],
+        [
+            'translated',
+            first(doc, 'is_translated', 'isTranslated') ??
+                first(meta, 'is_translated', 'isTranslated'),
+        ],
+    ];
+    return fields.filter(([key, value]) => value !== undefined &&
+        value !== null &&
+        value !== '' &&
+        !(key === 'translated' && value === false));
+};
+const collectEnvelopeMeta = (doc) => [
+    ['title', first(doc, 'title')],
+    ['slug', first(doc, 'slug')],
+    ['category', relationSlugOrLabel(first(doc, 'category'))],
+    ['state', publishState(doc) === 'published' ? 'publish' : 'draft'],
+    ['summary', first(doc, 'summary')],
+    ['tags', first(doc, 'tags')],
+    ['format', contentFormat(doc)],
+];
+const pickSummary = (doc) => {
+    const summary = firstString(doc, 'summary', 'subtitle');
+    const subtitle = firstString(doc, 'subtitle');
+    return summary && summary !== subtitle ? summary : undefined;
+};
+export const postView = {
+    kind: 'post',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (data, ctx) => {
+        const doc = normalize(data);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        const content = renderContent(doc);
+        const title = firstString(doc, 'title');
+        return renderMetadataBlock({
+            title: title || undefined,
+            kind: 'post',
+            fields: collectFields(doc, articleMeta),
+            summary: pickSummary(doc),
+            body: content.body || undefined,
+            bodyFormat: content.format,
+        }, ctx);
+    },
+    llm: (data) => {
+        const doc = normalize(data);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        const content = renderContent(doc, true);
+        const title = firstString(doc, 'title');
+        const fm = frontmatter({
+            title: title || undefined,
+            fields: collectFields(doc, articleMeta),
+            summary: pickSummary(doc),
+        });
+        return content.body ? `${fm}\n\n${content.body}` : fm;
+    },
+    xml: (data) => {
+        const doc = normalize(data);
+        const content = renderContent(doc);
+        return renderEnvelope({
+            root: 'mxpost',
+            meta: collectEnvelopeMeta(doc),
+            content: content.body,
+        });
+    },
+};
+const collectListItemFields = (doc, articleMeta) => {
+    const meta = articleMeta ?? {};
+    return [
+        ['id', first(doc, 'id')],
+        ['title', first(doc, 'title')],
+        ['slug', first(doc, 'slug')],
+        ['state', publishState(doc)],
+        ['category', relationLabel(first(doc, 'category'))],
+        ['tags', first(doc, 'tags')],
+        ['summary', first(doc, 'summary')],
+        ['created_at', first(doc, 'created_at', 'createdAt')],
+        ['modified_at', first(doc, 'modified_at', 'modifiedAt')],
+        [
+            'source_lang',
+            first(doc, 'source_lang', 'sourceLang') ??
+                first(meta, 'source_lang', 'sourceLang'),
+        ],
+        [
+            'translated',
+            first(doc, 'is_translated', 'isTranslated') ??
+                first(meta, 'is_translated', 'isTranslated'),
+        ],
+    ];
+};
+const renderPostListReadable = (data) => {
+    const payload = asRecord(data);
+    const rows = Array.isArray(payload.data)
+        ? payload.data
+        : Array.isArray(data)
+            ? data
+            : [];
+    const meta = asRecord(first(payload, 'meta'));
+    const pagination = asRecord(first(meta, 'pagination'));
+    const lines = ['posts'];
+    if (rows.length > 0)
+        lines.push(`count: ${rows.length}`);
+    else
+        lines.push('count: 0');
+    const page = first(pagination, 'page', 'currentPage');
+    const size = first(pagination, 'size', 'pageSize');
+    const total = first(pagination, 'total', 'totalCount', 'total_count');
+    if (page !== undefined)
+        lines.push(`page: ${formatScalar(page)}`);
+    if (size !== undefined)
+        lines.push(`size: ${formatScalar(size)}`);
+    if (total !== undefined)
+        lines.push(`total: ${formatScalar(total)}`);
+    rows.forEach((row, index) => {
+        const doc = asRecord(row);
+        const articleMeta = pickArticleTranslationMeta(data, first(doc, 'id'));
+        lines.push('', `post ${index + 1}:`);
+        const fields = collectListItemFields(doc, articleMeta);
+        for (const [key, value] of fields) {
+            if (value === undefined || value === null || value === '')
+                continue;
+            const rendered = tryFormatTimestamp(value, { style: 'rel' }) ?? formatScalar(value);
+            lines.push(`${key}: ${rendered}`);
+        }
+    });
+    return lines.join('\n');
+};
+export const postListView = {
+    kind: 'post-list',
+    modes: new Set(['readable', 'llm']),
+    readable: (data) => renderPostListReadable(data),
+};

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

@@ -0,0 +1,13 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Generic, ValidationXml } from '../../domain/errors';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+export declare const previewCmd: Command.Command<"preview", Renderer | Editor, import("../../domain/errors").ValidationFailed | ValidationXml | Generic, {
+    readonly file: Option.Option<string>;
+    readonly theme: Option.Option<"light" | "dark">;
+    readonly variant: Option.Option<"note" | "comment" | "article">;
+    readonly save: Option.Option<string>;
+    readonly print: Option.Option<boolean>;
+    readonly open: Option.Option<boolean>;
+}>;

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

@@ -0,0 +1,226 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Args, Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { parseEnvelope } from '../../domain/envelope';
+import { Generic, ValidationXml } from '../../domain/errors';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+import { registerCommandHelp } from '../help/registry';
+registerCommandHelp({
+    name: 'preview',
+    description: 'render a LiteXML fragment or <mxpost>/<mxnote> envelope to HTML and open it in a browser',
+    isLeaf: true,
+    skillChapter: 'commands-preview',
+    leafOptions: [
+        {
+            flag: '--theme <light|dark>',
+            description: 'HTML theme; default: light',
+        },
+        {
+            flag: '--variant <article|note|comment>',
+            description: 'HTML variant; auto-detected from envelope root, default: article',
+        },
+        {
+            flag: '--save <path>',
+            description: 'write HTML to <path> instead of opening a browser',
+        },
+        {
+            flag: '--print',
+            description: 'emit HTML to stdout instead of opening a browser',
+        },
+        {
+            flag: '--open',
+            description: 'explicitly open the rendered HTML in a browser (default behavior)',
+        },
+    ],
+});
+const fileArg = Args.text({ name: 'file' }).pipe(Args.optional);
+const themeOpt = Options.choice('theme', ['light', 'dark']).pipe(Options.optional);
+const variantOpt = Options.choice('variant', [
+    'article',
+    'note',
+    'comment',
+]).pipe(Options.optional);
+const saveOpt = Options.text('save').pipe(Options.optional);
+const printOpt = Options.boolean('print').pipe(Options.optional);
+const openOpt = Options.boolean('open').pipe(Options.optional);
+const requireFrom = createRequire(import.meta.url);
+const findCliPackageRoot = () => {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+        if (!dir || dir === dirname(dir))
+            break;
+        try {
+            const pkg = requireFrom(join(dir, 'package.json'));
+            if (pkg.name === '@mx-space/cli')
+                return dir;
+        }
+        catch {
+            // keep walking
+        }
+        dir = dirname(dir);
+    }
+    return null;
+};
+const resolveBundledLitexmlBin = () => {
+    const root = findCliPackageRoot();
+    if (!root)
+        return null;
+    const candidate = join(root, 'dist', 'vendor', 'litexml', 'cli.mjs');
+    return existsSync(candidate) ? candidate : null;
+};
+const isSourcePreviewModule = () => /[\\/]src[\\/]cli[\\/]preview[\\/]index\.ts$/.test(fileURLToPath(import.meta.url));
+const resolveLitexmlBin = () => {
+    const bundled = resolveBundledLitexmlBin();
+    if (!isSourcePreviewModule() && bundled)
+        return bundled;
+    try {
+        return requireFrom.resolve('@haklex/rich-litexml-cli/dist/cli.mjs');
+    }
+    catch {
+        // Older releases hide subpath imports behind exports; fall through to a
+        // best-effort scan of node_modules alongside the cli package.
+    }
+    const here = import.meta.url;
+    const filePath = here.startsWith('file://') ? here.slice(7) : here;
+    let dir = filePath.slice(0, Math.max(0, filePath.lastIndexOf('/')));
+    for (let i = 0; i < 8; i++) {
+        const candidate = `${dir}/node_modules/@haklex/rich-litexml-cli/dist/cli.mjs`;
+        if (existsSync(candidate))
+            return candidate;
+        const next = dir.slice(0, Math.max(0, dir.lastIndexOf('/')));
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    if (bundled)
+        return bundled;
+    throw new Generic({
+        message: 'cannot resolve LiteXML preview renderer',
+        hint: 'rebuild @mx-space/cli or reinstall mxs so the vendored preview renderer is present',
+    });
+};
+const detectVariant = (body) => {
+    const trimmed = body.trimStart();
+    if (trimmed.startsWith('<mxpost')) {
+        const parsed = parseEnvelope(trimmed, 'post');
+        return { contentXml: parsed.contentXml, variant: 'article' };
+    }
+    if (trimmed.startsWith('<mxnote')) {
+        const parsed = parseEnvelope(trimmed, 'note');
+        return { contentXml: parsed.contentXml, variant: 'note' };
+    }
+    return { contentXml: body, variant: 'article' };
+};
+const spawnLitexml = (bin, input, args, capture) => Effect.tryPromise({
+    try: () => new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [bin, '-', ...args], {
+            stdio: capture
+                ? ['pipe', 'pipe', 'inherit']
+                : ['pipe', 'inherit', 'inherit'],
+        });
+        const out = [];
+        if (capture && child.stdout) {
+            child.stdout.on('data', (chunk) => out.push(chunk));
+        }
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0) {
+                resolve(capture ? Buffer.concat(out).toString('utf8') : '');
+            }
+            else {
+                reject(new Error(`litexml exited with code ${code}`));
+            }
+        });
+        if (!child.stdin) {
+            reject(new Error('failed to open litexml stdin'));
+            return;
+        }
+        child.stdin.write(input);
+        child.stdin.end();
+    }),
+    catch: (err) => new Generic({
+        message: err instanceof Error ? err.message : String(err),
+        cause: err,
+    }),
+});
+export const previewCmd = Command.make('preview', {
+    file: fileArg,
+    theme: themeOpt,
+    variant: variantOpt,
+    save: saveOpt,
+    print: printOpt,
+    open: openOpt,
+}, ({ file, theme, variant, save, print, open: openFlag }) => Effect.gen(function* () {
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const filePath = Option.getOrUndefined(file);
+    const stdinIsTty = Boolean(process.stdin.isTTY);
+    const wantsStdin = filePath === undefined || filePath === '-' || filePath === '';
+    if (wantsStdin && stdinIsTty) {
+        return yield* Effect.fail(new ValidationXml({
+            message: 'mxs preview requires a file path or piped LiteXML on stdin',
+            hint: 'pass `mxs preview <file>` or pipe content: `cat post.xml | mxs preview -`',
+        }));
+    }
+    const raw = yield* editor.readFileOrStdin(filePath);
+    let body;
+    let detectedVariant = 'article';
+    try {
+        const det = detectVariant(raw);
+        body = det.contentXml;
+        detectedVariant = det.variant;
+    }
+    catch (err) {
+        return yield* Effect.fail(err instanceof ValidationXml
+            ? err
+            : new ValidationXml({
+                message: err instanceof Error ? err.message : String(err),
+            }));
+    }
+    // Wrap content in `<doc>` so haklex's deserializer recognises the root
+    // as a block container and strips whitespace between block-level nodes.
+    // Without this, the litexml preview client hydrates a Lexical state with
+    // stray whitespace text nodes as direct children of root, which Lexical
+    // rejects with error #282 ("invalid child of RootNode").
+    if (!body.includes('<doc')) {
+        body = `<doc>${body}</doc>`;
+    }
+    const resolvedVariant = Option.getOrElse(variant, () => detectedVariant);
+    const resolvedTheme = Option.getOrUndefined(theme);
+    const savePath = Option.getOrUndefined(save);
+    const printMode = Option.getOrElse(print, () => false);
+    const explicitOpen = Option.getOrElse(openFlag, () => false);
+    if (printMode && savePath) {
+        return yield* Effect.fail(new ValidationXml({
+            message: '--print and --save are mutually exclusive',
+        }));
+    }
+    if (explicitOpen && (printMode || savePath)) {
+        return yield* Effect.fail(new ValidationXml({
+            message: '--open conflicts with --print / --save',
+        }));
+    }
+    const args = ['--format', 'html', '--variant', resolvedVariant];
+    if (resolvedTheme)
+        args.push('--theme', resolvedTheme);
+    if (savePath)
+        args.push('-o', savePath);
+    else if (!printMode)
+        args.push('--open');
+    const bin = resolveLitexmlBin();
+    const html = yield* spawnLitexml(bin, body, args, printMode);
+    if (printMode) {
+        process.stdout.write(html.endsWith('\n') ? html : `${html}\n`);
+    }
+    else if (savePath) {
+        yield* renderer.emitInfo(`wrote HTML preview to ${savePath}`);
+    }
+    else {
+        yield* renderer.emitInfo(`opened HTML preview (variant=${resolvedVariant})`);
+    }
+}));

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

@@ -0,0 +1,14 @@
+import { Command } from '@effect/cli';
+export declare const profileCmd: Command.Command<"profile", import("@effect/platform/FileSystem").FileSystem | import("../../services/Config").Config | import("../ai/_poll").Renderer | import("../../services/Editor").Editor | import("../../services/Profile").Profile, import("../../domain/errors").ValidationFailed | import("../../domain/errors").ResourceNotFound | import("../../domain/errors").ProfileNotFound | import("../../domain/errors").ProfileNoneActive | import("../../domain/errors").ProfileInvalidName | import("../../domain/errors").Generic, {
+    readonly subcommand: import("effect/Option").Option<{} | {
+        readonly name: string;
+        readonly production: import("effect/Option").Option<boolean>;
+    } | {
+        readonly name: string;
+        readonly force: import("effect/Option").Option<boolean>;
+    } | {
+        readonly name: import("effect/Option").Option<string>;
+    } | {
+        readonly name: string;
+    }>;
+}>;

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

@@ -0,0 +1,36 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { ls } from './ls';
+import { mark } from './mark';
+import { rm } from './rm';
+import { show } from './show';
+import { use } from './use';
+const help = registerCommandHelp({
+    name: 'profile',
+    description: 'manage mxs profiles',
+    skillChapter: 'commands-profile',
+    verbs: [
+        { name: 'ls', description: 'list all known profiles' },
+        {
+            name: 'show',
+            args: ['[<name>]'],
+            description: 'show one profile (defaults to active)',
+        },
+        {
+            name: 'use',
+            args: ['<name>'],
+            description: 'switch the active profile',
+        },
+        {
+            name: 'mark',
+            args: ['<name>', '[--production|--no-production]'],
+            description: 'flag a profile as production / non-production',
+        },
+        {
+            name: 'rm',
+            args: ['<name>', '[--force]'],
+            description: 'delete a profile',
+        },
+    ],
+});
+export const profileCmd = Command.make('profile').pipe(Command.withDescription(help.description), Command.withSubcommands([ls, show, use, mark, rm]));

package/dist/src/cli/profile/ls.d.ts

@@ -0,0 +1,5 @@
+import { Command } from '@effect/cli';
+import { Config } from '../../services/Config';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const ls: Command.Command<"ls", Config | Renderer | Profile, import("../../domain/errors").Generic, {}>;

package/dist/src/cli/profile/ls.js

@@ -0,0 +1,26 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Config } from '../../services/Config';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+import { profileListView } from './view';
+export const ls = Command.make('ls', {}, () => Effect.gen(function* () {
+    const profile = yield* Profile;
+    const config = yield* Config;
+    const renderer = yield* Renderer;
+    const names = yield* profile.list;
+    const current = yield* profile.current;
+    const rows = [];
+    for (const name of names) {
+        const cfg = yield* config
+            .readProfileConfig(name)
+            .pipe(Effect.catchAll(() => Effect.succeed({})));
+        rows.push({
+            current: name === current ? '*' : '',
+            name,
+            api_url: cfg.api_url ?? '',
+            production: cfg.production ? 'yes' : 'no',
+        });
+    }
+    yield* renderer.emit(profileListView, rows);
+}));

package/dist/src/cli/profile/mark.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const mark: Command.Command<"mark", Renderer | Profile, ValidationFailed | import("../../domain/errors").ProfileNotFound | import("../../domain/errors").ProfileInvalidName | import("../../domain/errors").Generic, {
+    readonly name: string;
+    readonly production: Option.Option<boolean>;
+}>;