@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/ai/tts/list.js

@@ -0,0 +1,20 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Ai } from '../../../services/Ai';
+import { Renderer } from '../../../services/Renderer';
+const page = Options.integer('page').pipe(Options.optional);
+const size = Options.integer('size').pipe(Options.optional);
+const grouped = Options.boolean('grouped').pipe(Options.withDescription('group rows by article'));
+const search = Options.text('search').pipe(Options.optional, Options.withDescription('filter by article title (grouped mode)'));
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('list', { page, size, grouped, search }, ({ page, size, grouped, search }) => Effect.gen(function* () {
+    const ai = yield* Ai;
+    const renderer = yield* Renderer;
+    const res = yield* ai.listTts({
+        page: unwrap(page),
+        size: unwrap(size),
+        grouped,
+        search: unwrap(search),
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('list AI narrations'));

package/dist/src/cli/ai/tts/run.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Ai } from '../../../services/Ai';
+import { Renderer } from '../../../services/Renderer';
+import { Resolver } from '../../../services/Resolver';
+export declare const run: Command.Command<"run", Ai | Renderer | Resolver, import("../../../domain/errors").AiTaskCreateFailed | import("../../../domain/errors").AiTaskFailed | import("../../../services/Api").ApiError, {
+    readonly id: string;
+    readonly to: string[];
+    readonly force: boolean;
+    readonly noWait: boolean;
+}>;

package/dist/src/cli/ai/tts/run.js

@@ -0,0 +1,25 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { Ai } from '../../../services/Ai';
+import { Renderer } from '../../../services/Renderer';
+import { Resolver } from '../../../services/Resolver';
+import { followTask } from '../_poll';
+import { resolveArticleId } from '../_resolve';
+import { aiTaskView } from '../views';
+const id = Args.text({ name: 'idOrSlug' });
+const to = Options.text('to').pipe(Options.repeated, Options.withDescription('narration language code (repeatable)'));
+const force = Options.boolean('force').pipe(Options.withDescription('regenerate even when an up-to-date result exists'));
+const noWait = Options.boolean('no-wait').pipe(Options.withDescription('return immediately after creating the task'));
+export const run = Command.make('run', { id, to, force, noWait }, ({ id, to, force, noWait }) => Effect.gen(function* () {
+    const ai = yield* Ai;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const refId = yield* resolveArticleId(resolver, id);
+    const created = yield* ai.runTts({
+        refId,
+        targetLanguages: to.length ? to : undefined,
+        force,
+    });
+    const final = yield* followTask(ai, renderer, created, noWait);
+    yield* renderer.emit(aiTaskView, final);
+})).pipe(Command.withDescription('generate AI narration for an article'));

package/dist/src/cli/ai/tts/voices.d.ts

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

package/dist/src/cli/ai/tts/voices.js

@@ -0,0 +1,12 @@
+import { Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { Ai } from '../../../services/Ai';
+import { Renderer } from '../../../services/Renderer';
+const provider = Options.text('provider').pipe(Options.withDescription('AI provider id'));
+const model = Options.text('model').pipe(Options.withDescription('TTS model id'));
+export const voices = Command.make('voices', { provider, model }, ({ provider, model }) => Effect.gen(function* () {
+    const ai = yield* Ai;
+    const renderer = yield* Renderer;
+    const res = yield* ai.discoverTtsVoices({ providerId: provider, model });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('discover TTS voices for a provider/model pair'));

package/dist/src/cli/ai/views.d.ts

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

package/dist/src/cli/ai/views.js

@@ -0,0 +1,45 @@
+const formatField = (key, value) => `  ${key.padEnd(15)}${value === undefined || value === null || value === '' ? '-' : String(value)}`;
+const formatCost = (cost) => {
+    if (cost === undefined)
+        return undefined;
+    // Core stores totalCost as cents; show as `<x.xx> ¢`.
+    return `${cost.toFixed(2)} ¢`;
+};
+const formatList = (values) => values && values.length ? values.join(', ') : undefined;
+export const aiTaskView = {
+    kind: 'ai-task',
+    modes: new Set(['readable', 'llm']),
+    readable: (data) => {
+        const lines = [`ai ${data.type} task ${data.status}`];
+        const fields = [
+            ['taskId', data.taskId],
+            ['refId', data.refId],
+            ['targetLanguages', formatList(data.targetLanguages)],
+            ['totalTokens', data.totalTokens],
+            ['totalCost', formatCost(data.totalCost)],
+            ['resultIds', formatList(data.resultIds)],
+        ];
+        for (const [k, v] of fields) {
+            if (v === undefined || v === null || v === '')
+                continue;
+            lines.push(formatField(k, v));
+        }
+        if (data.error?.message) {
+            lines.push(formatField('error', data.error.message));
+        }
+        return lines.join('\n');
+    },
+    llm: (data) => [
+        `${data.status}`,
+        `type=${data.type}`,
+        `taskId=${data.taskId}`,
+        data.refId ? `refId=${data.refId}` : null,
+        data.totalTokens !== undefined ? `tokens=${data.totalTokens}` : null,
+        data.totalCost !== undefined
+            ? `cost=${data.totalCost.toFixed(2)}c`
+            : null,
+        data.error?.message ? `error=${data.error.message}` : null,
+    ]
+        .filter((s) => s !== null)
+        .join(' '),
+};

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

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+export declare const authCmd: Command.Command<"auth", import("../../services/Config").Config | import("../../services/Auth").Auth | import("../ai/_poll").Renderer | import("../../services/Editor").Editor | import("../../services/Profile").Profile, import("../../domain/errors").AuthMissing | import("../../domain/errors").AuthExpired | import("../../domain/errors").AuthDenied | import("../../domain/errors").AuthProbe | import("../../domain/errors").ProfileNotFound | import("../../domain/errors").ProfileNoneActive | import("../../domain/errors").Generic, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly production: import("effect/Option").Option<boolean>;
+    } | {} | {} | {}>;
+}>;

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

@@ -0,0 +1,22 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { login } from './login';
+import { logout } from './logout';
+import { status } from './status';
+import { whoami } from './whoami';
+const help = registerCommandHelp({
+    name: 'auth',
+    description: 'authentication',
+    skillChapter: 'commands-auth',
+    verbs: [
+        {
+            name: 'login',
+            args: ['[--production]'],
+            description: 'start device authorization flow',
+        },
+        { name: 'logout', description: 'delete stored credentials' },
+        { name: 'whoami', description: 'show the authenticated user' },
+        { name: 'status', description: 'show token validity and expiry' },
+    ],
+});
+export const authCmd = Command.make('auth').pipe(Command.withDescription(help.description), Command.withSubcommands([login, logout, whoami, status]));

package/dist/src/cli/auth/login.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Generic } from '../../domain/errors';
+import { Auth } from '../../services/Auth';
+import { Config } from '../../services/Config';
+import { Editor } from '../../services/Editor';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const login: Command.Command<"login", Config | Auth | Renderer | Editor | Profile, import("../../domain/errors").AuthExpired | import("../../domain/errors").AuthDenied | import("../../domain/errors").AuthProbe | Generic, {
+    readonly production: Option.Option<boolean>;
+}>;

package/dist/src/cli/auth/login.js

@@ -0,0 +1,168 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, FiberRef, Option } from 'effect';
+import open from 'open';
+import { Generic } from '../../domain/errors';
+import { currentProfileFlag } from '../../domain/runtime-flags';
+import { Auth, toCredentials } from '../../services/Auth';
+import { Config, DEFAULT_CLIENT_ID, parseApiUrl, } from '../../services/Config';
+import { Editor } from '../../services/Editor';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+import { arrow, bold, dim, humanDuration, indent, ok, roundedBox } from '../ui';
+const production = Options.boolean('production', {
+    negationNames: ['no-production'],
+}).pipe(Options.optional);
+const DEFAULT_PROFILE = 'default';
+export const login = Command.make('login', { production }, ({ production }) => Effect.gen(function* () {
+    const auth = yield* Auth;
+    const profile = yield* Profile;
+    const config = yield* Config;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const opts = yield* renderer.options;
+    // 1. Resolve api-url + target profile from current config; prompt when
+    //    no URL is available on a fresh install.
+    //
+    //    The `--profile` global flag is pre-parsed and propagated via a
+    //    FiberRef; forward it as an override so `auth login --profile foo`
+    //    targets `foo` even when the active-profile pointer is missing or
+    //    points at a profile whose directory has been deleted manually.
+    const flagProfile = yield* FiberRef.get(currentProfileFlag);
+    const resolved = yield* profile
+        .resolve(flagProfile ? { profile: flagProfile } : {})
+        .pipe(Effect.catchTags({
+        Generic: (e) => {
+            // ConfigMissingApiUrl is collapsed into Generic by Profile.resolve;
+            // detect it via the preserved `cause` and prompt instead of failing.
+            const cause = e.cause;
+            return cause?._tag === 'ConfigMissingApiUrl'
+                ? Effect.succeed(null)
+                : Effect.fail(e);
+        },
+        // The active-profile pointer (or the resolved profile name) refers
+        // to a directory that does not exist. `auth login` is the command
+        // that *creates* a profile, so treat this as a fresh-install path
+        // rather than a hard error.
+        ProfileNotFound: () => Effect.succeed(null),
+    }));
+    let apiUrl;
+    let targetProfile;
+    if (resolved) {
+        apiUrl = resolved.apiUrl;
+        targetProfile = resolved.profileName;
+    }
+    else {
+        const answer = yield* editor.prompt('Enter your mx-space API URL (e.g. https://blog.example.com):', { placeholder: 'https://blog.example.com' });
+        const trimmed = answer.trim();
+        if (!trimmed) {
+            return yield* Effect.fail(new Generic({ message: 'API URL is required' }));
+        }
+        const parsed = yield* parseApiUrl(trimmed).pipe(Effect.mapError((e) => new Generic({ message: e.message, cause: e })));
+        apiUrl = parsed.baseUrl;
+        // Prefer the explicit `--profile` flag over a stale `current` pointer.
+        // Falling back to `readCurrent` preserves the historical behaviour on
+        // fresh installs (no flag, no pointer → step 5 lands on DEFAULT_PROFILE).
+        targetProfile = flagProfile?.trim() || (yield* config.readCurrent);
+    }
+    yield* renderer.emitInfoBlock(({ color }) => `${arrow(`probing ${apiUrl}…`, color)}`);
+    // 2. Probe the auth endpoint. Preserve AuthProbe verbatim so the hint
+    //    (attempted endpoints + URL guidance) reaches the renderer; only
+    //    collapse transport-level errors into Generic.
+    const probeResult = yield* auth.probe(apiUrl).pipe(Effect.catchTags({
+        NetworkTimeout: (e) => Effect.fail(new Generic({ message: e.message ?? 'auth probe failed', cause: e })),
+        NetworkDns: (e) => Effect.fail(new Generic({ message: e.message ?? 'auth probe failed', cause: e })),
+        NetworkRefused: (e) => Effect.fail(new Generic({ message: e.message ?? 'auth probe failed', cause: e })),
+    }));
+    // 3. Request the device code.
+    const code = yield* auth.requestDeviceCode(probeResult.authBase, DEFAULT_CLIENT_ID);
+    // Boxed device-code banner: verification URL on top, code in a rounded
+    // box for legibility, expiry hint underneath.
+    yield* renderer.emitInfoBlock(({ color }) => {
+        const ttl = humanDuration(code.expires_in);
+        const lines = [
+            `  ${dim('API base:', color)} ${probeResult.apiBase}`,
+            '',
+            `  Visit ${bold(code.verification_uri, color)} and enter:`,
+            '',
+            indent(roundedBox([`  ${bold(code.user_code, color)}  `]), 6),
+            '',
+            `  ${dim(`Expires in ${ttl}.`, color)}`,
+        ];
+        return lines.join('\n');
+    });
+    if (opts.json) {
+        yield* renderer.emitSuccess({
+            verification_uri: code.verification_uri,
+            verification_uri_complete: code.verification_uri_complete,
+            user_code: code.user_code,
+            expires_in: code.expires_in,
+            interval: code.interval,
+        });
+    }
+    else if (!opts.quiet && code.verification_uri_complete) {
+        yield* Effect.sync(() => {
+            void open(code.verification_uri_complete).catch(() => undefined);
+        });
+    }
+    // 4. Poll for token.
+    const token = yield* auth.pollDeviceToken(probeResult.authBase, DEFAULT_CLIENT_ID, code.device_code, {
+        intervalSec: code.interval,
+        expiresInSec: code.expires_in,
+        onTick: (state) => {
+            if (state === 'slow_down' && !opts.quiet && !opts.json) {
+                process.stderr.write('slow_down — increasing interval\n');
+            }
+        },
+    });
+    const cred = toCredentials(token);
+    // 5. Determine target profile per legacy precedence:
+    //    1. resolved profileName (which itself honours --profile / MXS_PROFILE / current)
+    //    2. fresh install → 'default'
+    const target = targetProfile?.trim() || DEFAULT_PROFILE;
+    const existing = yield* config
+        .readProfileConfig(target)
+        .pipe(Effect.catchAll(() => Effect.succeed({})));
+    const productionFlag = Option.getOrElse(production, () => undefined);
+    yield* config.writeProfileConfig(target, {
+        ...existing,
+        api_url: apiUrl,
+        api_version: probeResult.apiVersion,
+        ...(productionFlag !== undefined
+            ? { production: productionFlag }
+            : existing.production !== undefined
+                ? { production: existing.production }
+                : {}),
+    });
+    yield* config.writeProfileCredentials(target, cred);
+    yield* config.writeCurrent(target);
+    // Some servers (notably local-dev) omit `user` from the device-token
+    // response. Probe `/get-session` to backfill so `whoami` / `status` have
+    // something to display. Best-effort: failures fall back to the original
+    // creds and are surfaced only via the missing-user readable output.
+    const enriched = yield* auth
+        .enrichUser(target, probeResult.authBase, cred)
+        .pipe(Effect.catchAll(() => Effect.succeed(cred)));
+    // 6. Mark production via the Profile service when explicitly requested
+    //    (idempotent with the write above — Profile.mark enforces the
+    //    profile-exists invariant and is the documented surface).
+    if (productionFlag === true) {
+        yield* profile
+            .mark(target, { production: true })
+            .pipe(Effect.catchAll((e) => Effect.fail(new Generic({ message: e.message ?? String(e), cause: e }))));
+    }
+    yield* renderer.emitView({
+        user: enriched.user ?? null,
+        expires_at: enriched.expires_at,
+        profile: target,
+    }, ({ color }) => {
+        const head = ok(`logged in to '${target}'`, color);
+        const user = enriched.user;
+        if (!user || (!user.name && !user.email))
+            return head;
+        const name = user.name ?? user.email ?? '';
+        const email = user.name && user.email ? ` (${user.email})` : '';
+        const role = user.role;
+        const meta = role ? `${name}${email} · ${role}` : `${name}${email}`;
+        return `${head}\n  ${dim(meta, color)}`;
+    });
+}));

package/dist/src/cli/auth/logout.d.ts

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

package/dist/src/cli/auth/logout.js

@@ -0,0 +1,21 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { ProfileNoneActive } from '../../domain/errors';
+import { Auth } from '../../services/Auth';
+import { Config } from '../../services/Config';
+import { Renderer } from '../../services/Renderer';
+export const logout = Command.make('logout', {}, () => Effect.gen(function* () {
+    const auth = yield* Auth;
+    const config = yield* Config;
+    const renderer = yield* Renderer;
+    const target = yield* config.readCurrent;
+    if (!target) {
+        return yield* Effect.fail(new ProfileNoneActive({
+            message: 'no active profile to log out of',
+            hint: 'pass --profile <name> or set an active profile with `mxs profile use <name>`',
+        }));
+    }
+    yield* auth.logout(target);
+    yield* renderer.emitInfo(`mxs: logged out of profile '${target}'`);
+    yield* renderer.emitSuccess({ ok: true });
+}));

package/dist/src/cli/auth/status.d.ts

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

package/dist/src/cli/auth/status.js

@@ -0,0 +1,31 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { isExpiringSoon } from '../../services/Auth';
+import { Config } from '../../services/Config';
+import { Renderer } from '../../services/Renderer';
+import { statusView } from './view';
+export const status = Command.make('status', {}, () => Effect.gen(function* () {
+    const config = yield* Config;
+    const renderer = yield* Renderer;
+    const envProfile = process.env.MXS_PROFILE?.trim() || null;
+    const profileName = envProfile || (yield* config.readCurrent) || null;
+    const cred = profileName
+        ? yield* config.readProfileCredentials(profileName)
+        : null;
+    if (!cred) {
+        yield* renderer.emit(statusView, {
+            authenticated: false,
+            profile: profileName,
+        });
+        return;
+    }
+    const expiringSoon = isExpiringSoon(cred);
+    yield* renderer.emit(statusView, {
+        authenticated: true,
+        expires_at: cred.expires_at,
+        expiring_soon: expiringSoon,
+        has_refresh: Boolean(cred.refresh_token),
+        user: cred.user ?? null,
+        profile: profileName,
+    });
+}));

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

@@ -0,0 +1,25 @@
+import type { View } from '../../services/Renderer/view';
+export interface WhoamiData {
+    readonly user: {
+        readonly name?: string;
+        readonly email?: string;
+        readonly role?: string;
+    } | null;
+    readonly api_url: string;
+    readonly profile: string | null;
+    readonly expires_at?: number | null;
+}
+export declare const whoamiView: View<WhoamiData>;
+export interface StatusData {
+    readonly authenticated: boolean;
+    readonly profile: string | null;
+    readonly expires_at?: number;
+    readonly expiring_soon?: boolean;
+    readonly has_refresh?: boolean;
+    readonly user?: {
+        readonly name?: string;
+        readonly email?: string;
+        readonly role?: string;
+    } | null;
+}
+export declare const statusView: View<StatusData>;

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

@@ -0,0 +1,46 @@
+import { bold, dim, dot, fail, humanUntil } from '../ui';
+const renderIdentLine = (user, color) => {
+    if (user?.name) {
+        return `${bold(user.name, color)}${user.email ? ` ${dim(`· ${user.email}`, color)}` : ''}`;
+    }
+    if (user?.email)
+        return bold(user.email, color);
+    return dim('(no user data)', color);
+};
+export const whoamiView = {
+    kind: 'whoami',
+    modes: new Set(['readable', 'llm']),
+    readable: (data, { color }) => {
+        const head = dot('signed in', color);
+        const ident = renderIdentLine(data.user, color);
+        const meta = [];
+        if (data.user?.role)
+            meta.push(`role: ${data.user.role}`);
+        meta.push(`api: ${data.api_url}`);
+        if (data.expires_at) {
+            meta.push(`session expires in ${humanUntil(data.expires_at)}`);
+        }
+        return `${head}\n\n  ${ident}\n  ${dim(meta.join('  ·  '), color)}`;
+    },
+};
+export const statusView = {
+    kind: 'status',
+    modes: new Set(['readable', 'llm']),
+    readable: (data, { color }) => {
+        if (!data.authenticated) {
+            return `${fail('not authenticated', color)}\n  ${dim('run `mxs auth login`', color)}`;
+        }
+        const head = dot('signed in', color);
+        const ident = renderIdentLine(data.user ?? null, color);
+        const meta = [];
+        if (data.profile)
+            meta.push(`profile: ${data.profile}`);
+        if (data.user?.role)
+            meta.push(`role: ${data.user.role}`);
+        if (data.expires_at !== undefined) {
+            const expires = `expires in ${humanUntil(data.expires_at)}`;
+            meta.push(data.expiring_soon ? `${expires} (expiring soon)` : expires);
+        }
+        return `${head}\n\n  ${ident}\n  ${dim(meta.join('  ·  '), color)}`;
+    },
+};

package/dist/src/cli/auth/whoami.d.ts

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

package/dist/src/cli/auth/whoami.js

@@ -0,0 +1,44 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { AuthMissing } from '../../domain/errors';
+import { Auth } from '../../services/Auth';
+import { Config } from '../../services/Config';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+import { whoamiView } from './view';
+export const whoami = Command.make('whoami', {}, () => Effect.gen(function* () {
+    const auth = yield* Auth;
+    const profile = yield* Profile;
+    const config = yield* Config;
+    const renderer = yield* Renderer;
+    const resolved = yield* profile.resolve();
+    const cred = resolved.profileName
+        ? yield* config.readProfileCredentials(resolved.profileName)
+        : null;
+    if (!cred && !resolved.token && !resolved.apiKey) {
+        return yield* Effect.fail(new AuthMissing({
+            message: 'not authenticated',
+            hint: 'run `mxs auth login`',
+        }));
+    }
+    // Refresh credentials when near expiry; on missing/expired surface the
+    // failure so the entry-point exits with the right code. On generic
+    // refresh failure (e.g. server unreachable) fall back to the cached user.
+    const refreshed = yield* auth
+        .ensureFresh(resolved)
+        .pipe(Effect.catchTag('Generic', () => Effect.succeed(cred)));
+    // Backfill user via /get-session when the cached cred lacks it (servers
+    // that omit `user` from the device-token response). Best-effort.
+    const active = refreshed ?? cred;
+    const enriched = active && !active.user && resolved.profileName
+        ? yield* auth
+            .enrichUser(resolved.profileName, resolved.authBase, active)
+            .pipe(Effect.catchAll(() => Effect.succeed(active)))
+        : active;
+    yield* renderer.emit(whoamiView, {
+        user: enriched?.user ?? null,
+        api_url: resolved.apiUrl,
+        profile: resolved.profileName,
+        expires_at: enriched?.expires_at ?? null,
+    });
+}));

package/dist/src/cli/category/create.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 create: Command.Command<"create", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly name: string;
+    readonly slug: string;
+    readonly type: Option.Option<"tag" | "category">;
+    readonly icon: Option.Option<string>;
+}>;

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

@@ -0,0 +1,24 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const name = Options.text('name');
+const slug = Options.text('slug');
+const type_ = Options.choice('type', ['category', 'tag']).pipe(Options.optional);
+const icon = Options.text('icon').pipe(Options.optional);
+export const create = Command.make('create', { name, slug, type: type_, icon }, ({ name, slug, type, icon }) => Effect.gen(function* () {
+    const body = { name, slug };
+    const t = Option.getOrUndefined(type);
+    if (t)
+        body.type = t === 'tag' ? 1 : 0;
+    const ic = Option.getOrUndefined(icon);
+    if (ic)
+        body.icon = ic;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/categories', {
+        method: 'POST',
+        body,
+    });
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/category/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/category/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');
+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 api = yield* Api;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveCategoryId(slugOrId);
+    yield* api.request(`/categories/${id}`, { method: 'DELETE' });
+    yield* renderer.emitSuccess({ deleted: id });
+}));

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

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

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

@@ -0,0 +1,11 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+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 res = yield* api.request(`/categories/${encodeURIComponent(slugOrId)}`);
+    yield* renderer.emitSuccess(res);
+}));