@mx-space/cli 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,338 @@
+import { a as emitSuccess, i as emitInfo, n as defaultOutputOptions, o as emitWarn, r as emitError, s as renderTable, t as OutputOptions } from "./output-CTnO1lYt.mjs";
+
+//#region src/core/config-store.d.ts
+interface ConfigShape {
+  api_url?: string;
+  api_base?: string;
+  auth_base?: string;
+  api_version?: number;
+  client_id?: string;
+}
+interface CredentialsShape {
+  access_token: string;
+  refresh_token?: string;
+  expires_at: number;
+  user?: {
+    id?: string;
+    email?: string;
+    name?: string;
+  };
+}
+interface ResolvedConfig {
+  apiUrl: string;
+  apiBase: string;
+  authBase: string;
+  apiVersion: number;
+  clientId: string;
+  token?: string;
+  apiKey?: string;
+  configPath: string;
+  credentialsPath: string;
+}
+interface StoreOverrides {
+  apiUrl?: string;
+  token?: string;
+  apiKey?: string;
+}
+declare function getConfigDir(): string;
+declare function getConfigPath(): string;
+declare function getCredentialsPath(): string;
+declare function readConfig(): Promise<ConfigShape>;
+declare function writeConfig(cfg: ConfigShape): Promise<void>;
+declare function readCredentials(): Promise<CredentialsShape | null>;
+declare function writeCredentials(cred: CredentialsShape): Promise<void>;
+declare function deleteCredentials(): Promise<void>;
+declare function enforceCredentialsMode(p?: string): Promise<boolean>;
+declare function normalizeApiUrl(input: string): string;
+declare function resolveConfig(overrides?: StoreOverrides): Promise<ResolvedConfig>;
+//#endregion
+//#region src/core/auth.d.ts
+declare const SUPPORTED_API_VERSIONS: readonly [2];
+interface DeviceCodeResponse {
+  device_code: string;
+  user_code: string;
+  verification_uri: string;
+  verification_uri_complete?: string;
+  expires_in: number;
+  interval: number;
+}
+interface DeviceTokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+  refresh_token?: string;
+  scope?: string;
+  user?: {
+    id?: string;
+    email?: string;
+    name?: string;
+  };
+}
+interface ProbeResult {
+  apiUrl: string;
+  apiBase: string;
+  authBase: string;
+  apiVersion: number;
+}
+interface AuthHttp {
+  fetch: typeof fetch;
+}
+declare function probeAuthEndpoint(apiUrl: string, http?: AuthHttp): Promise<ProbeResult>;
+declare function requestDeviceCode(authBase: string, clientId: string, scope?: string, http?: AuthHttp): Promise<DeviceCodeResponse>;
+interface PollOptions {
+  intervalSec: number;
+  expiresInSec: number;
+  signal?: AbortSignal;
+  onTick?: (state: 'pending' | 'slow_down') => void;
+  http?: AuthHttp;
+}
+declare function pollDeviceToken(authBase: string, clientId: string, deviceCode: string, opts: PollOptions): Promise<DeviceTokenResponse>;
+declare function toCredentials(resp: DeviceTokenResponse): CredentialsShape;
+declare function isExpiringSoon(cred: CredentialsShape, bufferMs?: number): boolean;
+declare function refreshAccessToken(authBase: string, clientId: string, cred: CredentialsShape, http?: AuthHttp): Promise<CredentialsShape | null>;
+declare function loadCredentialsOrThrow(): Promise<CredentialsShape>;
+declare function ensureFreshToken(authBase: string, clientId: string, http?: AuthHttp): Promise<CredentialsShape>;
+//#endregion
+//#region src/core/api-client.d.ts
+interface ApiClientContext {
+  apiBase: string;
+  authBase: string;
+  clientId: string;
+  token?: string;
+  apiKey?: string;
+  autoRefresh?: boolean;
+  verbose?: boolean;
+  http?: AuthHttp;
+}
+interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+  body?: unknown;
+  query?: Record<string, unknown>;
+  headers?: Record<string, string>;
+  signal?: AbortSignal;
+}
+interface ApiResponse<T> {
+  ok: boolean;
+  status: number;
+  data: T;
+}
+declare class ApiClient {
+  private ctx;
+  private http;
+  private token?;
+  private refreshed;
+  constructor(ctx: ApiClientContext);
+  get apiBase(): string;
+  request<T = unknown>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+  private tryRefresh;
+}
+declare function createApiClient(ctx: ApiClientContext): Promise<ApiClient>;
+//#endregion
+//#region src/core/content-spec.d.ts
+interface ContentSource {
+  text: string;
+  origin: 'inline' | 'file' | 'stdin';
+  path?: string;
+}
+declare function readContentSpec(spec: string | undefined, {
+  cwd
+}?: {
+  cwd?: string;
+}): Promise<ContentSource | null>;
+declare function readJsonSpec(spec: string | undefined): Promise<unknown>;
+//#endregion
+//#region src/core/editor.d.ts
+interface EditorOptions {
+  filename: string;
+  initialContent: string;
+  editor?: string;
+}
+declare function runEditorRoundTrip(opts: EditorOptions): Promise<string>;
+//#endregion
+//#region src/core/document-output.d.ts
+type DocumentKind = 'post' | 'note' | 'page';
+declare function emitDocument(kind: DocumentKind, data: unknown, opts: OutputOptions): void;
+declare function renderReadableDocument(kind: DocumentKind, data: unknown): string;
+declare function renderDocumentEnvelope(kind: DocumentKind, data: unknown): string;
+//#endregion
+//#region src/core/envelope.d.ts
+type EnvelopeKind = 'post' | 'note';
+interface ParsedEnvelope {
+  kind: EnvelopeKind;
+  meta: Record<string, unknown>;
+  contentXml: string;
+  sourceMap: Record<string, number>;
+}
+declare function flagToTag(flag: string): string;
+declare function tagToFlag(tag: string): string;
+declare function parseEnvelope(xml: string, kind: EnvelopeKind): ParsedEnvelope;
+interface EnvelopeMeta {
+  title?: string;
+  slug?: string;
+  category?: string;
+  topic?: string;
+  state?: 'publish' | 'draft';
+  summary?: string;
+  copyright?: boolean;
+  pin?: string;
+  pinOrder?: number;
+  related?: string[];
+  tags?: string[];
+  mood?: string;
+  weather?: string;
+  publicAt?: string;
+  password?: string;
+  bookmark?: boolean;
+  location?: string;
+  subtitle?: string;
+  order?: number;
+  format?: 'lexical' | 'markdown';
+}
+declare function coerceMeta(raw: Record<string, unknown>): EnvelopeMeta;
+//#endregion
+//#region src/core/errors.d.ts
+type MxsErrorCode = 'generic' | 'argv.parse' | 'auth.missing' | 'auth.expired' | 'auth.denied' | 'auth.probe' | 'network.timeout' | 'network.dns' | 'network.refused' | 'validation.failed' | 'validation.xml' | 'server.error' | 'resource.not_found' | 'config.missing.api_url' | 'config.missing.token' | (string & {});
+interface MxsErrorOptions {
+  code: MxsErrorCode;
+  message: string;
+  details?: unknown;
+  hint?: string;
+  cause?: unknown;
+}
+declare class MxsError extends Error {
+  readonly code: MxsErrorCode;
+  readonly details?: unknown;
+  readonly hint?: string;
+  constructor(options: MxsErrorOptions);
+  toJSON(): {
+    hint?: string | undefined;
+    details?: {} | null | undefined;
+    ok: false;
+    code: MxsErrorCode;
+    message: string;
+  };
+}
+declare function exitCodeForError(err: unknown): number;
+//#endregion
+//#region src/core/litexml-codec.d.ts
+interface LexicalState {
+  root: {
+    type: 'root';
+    children: unknown[];
+    direction?: 'ltr' | 'rtl' | null;
+    format?: string;
+    indent?: number;
+    version?: number;
+  };
+}
+declare function parseToLexical(xml: string): LexicalState;
+declare function serializeFromLexical(state: LexicalState): string;
+declare function deriveTextFromLexical(state: LexicalState): string;
+declare function emptyLexicalState(): LexicalState;
+//#endregion
+//#region src/core/onboarding.d.ts
+interface OnboardingResult {
+  apiUrl: string;
+  apiBase: string;
+  authBase: string;
+  apiVersion: number;
+}
+interface OnboardingOptions {
+  http?: AuthHttp;
+  initialApiUrl?: string;
+  isTTY?: boolean;
+  prompt?: (question: string) => Promise<string>;
+}
+declare function runOnboarding(opts?: OnboardingOptions): Promise<OnboardingResult>;
+//#endregion
+//#region src/core/payload.d.ts
+type ContentFormat = 'lexical' | 'markdown';
+interface PostFlagInputs {
+  title?: string;
+  slug?: string;
+  category?: string;
+  content?: string;
+  format?: ContentFormat;
+  summary?: string;
+  state?: 'publish' | 'draft';
+  tags?: string[];
+  copyright?: boolean;
+  pin?: string;
+  pinOrder?: number;
+  related?: string[];
+  meta?: string;
+  file?: string;
+}
+interface NoteFlagInputs {
+  title?: string;
+  slug?: string;
+  topic?: string;
+  content?: string;
+  format?: ContentFormat;
+  state?: 'publish' | 'draft';
+  mood?: string;
+  weather?: string;
+  publicAt?: string;
+  password?: string;
+  bookmark?: boolean;
+  coords?: string;
+  location?: string;
+  images?: string;
+  meta?: string;
+  file?: string;
+}
+interface PageFlagInputs {
+  title?: string;
+  slug?: string;
+  subtitle?: string;
+  order?: number;
+  content?: string;
+  format?: ContentFormat;
+  meta?: string;
+  file?: string;
+}
+interface BuiltPayload {
+  payload: Record<string, unknown>;
+  envelopeMeta?: EnvelopeMeta;
+  contentSource?: 'flag' | 'envelope' | 'none';
+}
+declare function buildPostPayload(flags: PostFlagInputs): Promise<BuiltPayload>;
+declare function buildNotePayload(flags: NoteFlagInputs): Promise<BuiltPayload>;
+declare function buildPagePayload(flags: PageFlagInputs): Promise<BuiltPayload>;
+declare function emptyPayload(format: ContentFormat): {
+  content: string;
+  text: string;
+};
+//#endregion
+//#region src/core/resolve.d.ts
+interface ResolvableItem {
+  id: string;
+  slug?: string;
+  name?: string;
+}
+interface ResolverFetchers {
+  fetchCategories?: () => Promise<ResolvableItem[]>;
+  fetchTopics?: () => Promise<ResolvableItem[]>;
+}
+declare function isSnowflakeId(value: string): boolean;
+declare class NameResolver {
+  private fetchers;
+  private cache;
+  private ttlMs;
+  constructor(fetchers: ResolverFetchers, {
+    ttlMs
+  }?: {
+    ttlMs?: number;
+  });
+  resolveCategory(value: string): Promise<string>;
+  resolveTopic(value: string): Promise<string>;
+  invalidate(kind?: string): void;
+  private resolveWith;
+  private load;
+}
+declare function matchItem(items: ReadonlyArray<ResolvableItem>, value: string): ResolvableItem | null;
+declare function levenshtein(a: string, b: string): number;
+declare function fuzzySuggest(items: ReadonlyArray<ResolvableItem>, value: string, maxDistance?: number): string[];
+//#endregion
+export { ApiClient, type ApiClientContext, type ApiResponse, type AuthHttp, type BuiltPayload, type ConfigShape, type ContentFormat, type ContentSource, type CredentialsShape, type DeviceCodeResponse, type DeviceTokenResponse, type DocumentKind, type EnvelopeKind, type EnvelopeMeta, type LexicalState, MxsError, type MxsErrorCode, type MxsErrorOptions, NameResolver, type NoteFlagInputs, type OnboardingResult, type OutputOptions, type PageFlagInputs, type ParsedEnvelope, type PostFlagInputs, type ProbeResult, type RequestOptions, type ResolvableItem, type ResolvedConfig, type ResolverFetchers, SUPPORTED_API_VERSIONS, buildNotePayload, buildPagePayload, buildPostPayload, coerceMeta, createApiClient, defaultOutputOptions, deleteCredentials, deriveTextFromLexical, emitDocument, emitError, emitInfo, emitSuccess, emitWarn, emptyLexicalState, emptyPayload, enforceCredentialsMode, ensureFreshToken, exitCodeForError, flagToTag, fuzzySuggest, getConfigDir, getConfigPath, getCredentialsPath, isExpiringSoon, isSnowflakeId, levenshtein, loadCredentialsOrThrow, matchItem, normalizeApiUrl, parseEnvelope, parseToLexical, pollDeviceToken, probeAuthEndpoint, readConfig, readContentSpec, readCredentials, readJsonSpec, refreshAccessToken, renderDocumentEnvelope, renderReadableDocument, renderTable, requestDeviceCode, resolveConfig, runEditorRoundTrip, runOnboarding, serializeFromLexical, tagToFlag, toCredentials, writeConfig, writeCredentials };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,10 @@
+import { a as emitWarn, c as exitCodeForError, i as emitSuccess, n as emitError, o as renderTable, r as emitInfo, s as MxsError, t as defaultOutputOptions } from "./output-BM7aBFwt.mjs";
+import { a as getCredentialsPath, c as readCredentials, d as writeCredentials, i as getConfigPath, l as resolveConfig, n as enforceCredentialsMode, o as normalizeApiUrl, r as getConfigDir, s as readConfig, t as deleteCredentials, u as writeConfig } from "./config-store-DIu7x0ao.mjs";
+import { a as loadCredentialsOrThrow, c as refreshAccessToken, i as isExpiringSoon, l as requestDeviceCode, o as pollDeviceToken, r as ensureFreshToken, s as probeAuthEndpoint, t as SUPPORTED_API_VERSIONS, u as toCredentials } from "./auth-DIFZzoMm.mjs";
+import { n as ApiClient, r as createApiClient, t as runOnboarding } from "./onboarding-640IldLz.mjs";
+import { a as coerceMeta, c as tagToFlag, i as emptyPayload, l as readContentSpec, n as buildPagePayload, o as flagToTag, r as buildPostPayload, s as parseEnvelope, t as buildNotePayload, u as readJsonSpec } from "./payload-CN11pUto.mjs";
+import { t as runEditorRoundTrip } from "./editor-xrF-j3UE.mjs";
+import { i as serializeFromLexical, n as emptyLexicalState, r as parseToLexical, t as deriveTextFromLexical } from "./litexml-codec-CDoRloiR.mjs";
+import { n as renderDocumentEnvelope, r as renderReadableDocument, t as emitDocument } from "./document-output-BVB8emLt.mjs";
+import { a as matchItem, i as levenshtein, n as fuzzySuggest, r as isSnowflakeId, t as NameResolver } from "./resolve-BogJOR7R.mjs";
+export { ApiClient, MxsError, NameResolver, SUPPORTED_API_VERSIONS, buildNotePayload, buildPagePayload, buildPostPayload, coerceMeta, createApiClient, defaultOutputOptions, deleteCredentials, deriveTextFromLexical, emitDocument, emitError, emitInfo, emitSuccess, emitWarn, emptyLexicalState, emptyPayload, enforceCredentialsMode, ensureFreshToken, exitCodeForError, flagToTag, fuzzySuggest, getConfigDir, getConfigPath, getCredentialsPath, isExpiringSoon, isSnowflakeId, levenshtein, loadCredentialsOrThrow, matchItem, normalizeApiUrl, parseEnvelope, parseToLexical, pollDeviceToken, probeAuthEndpoint, readConfig, readContentSpec, readCredentials, readJsonSpec, refreshAccessToken, renderDocumentEnvelope, renderReadableDocument, renderTable, requestDeviceCode, resolveConfig, runEditorRoundTrip, runOnboarding, serializeFromLexical, tagToFlag, toCredentials, writeConfig, writeCredentials };

package/dist/list-BYzhflDg.mjs

@@ -0,0 +1,14 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/note/list.ts
+async function run(opts, flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/notes", { query: {
+		page: opts.page,
+		size: opts.size,
+		sortBy: opts.sort
+	} })).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-BYzhflDg.mjs.map

package/dist/list-BYzhflDg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-BYzhflDg.mjs","names":[],"sources":["../src/commands/note/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport interface NoteListFlags {\n  page?: number\n  size?: number\n  state?: string\n  sort?: string\n}\n\nexport async function run(\n  opts: NoteListFlags,\n  flags: GlobalFlags,\n  out: OutputOptions,\n) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request<{ data: unknown[] }>('/notes', {\n    query: {\n      page: opts.page,\n      size: opts.size,\n      sortBy: opts.sort,\n    },\n  })\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAUA,eAAsB,IACpB,MACA,OACA,KACA;CAUA,aAAY,MARG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QAA6B,UAAU,EAC9D,OAAO;EACL,MAAM,KAAK;EACX,MAAM,KAAK;EACX,QAAQ,KAAK;CACf,EACF,CAAC,GACe,MAAM,GAAG;AAC3B"}

package/dist/list-DY-tPNG-.mjs

@@ -0,0 +1,10 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/config/list.ts
+async function run(flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/options")).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-DY-tPNG-.mjs.map

package/dist/list-DY-tPNG-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-DY-tPNG-.mjs","names":[],"sources":["../src/commands/config/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport async function run(flags: GlobalFlags, out: OutputOptions) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request('/options')\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAGA,eAAsB,IAAI,OAAoB,KAAoB;CAIhE,aAAY,MAFG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QAAQ,UAAU,GAC3B,MAAM,GAAG;AAC3B"}

package/dist/list-DlQSkbqx.mjs

@@ -0,0 +1,10 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/page/list.ts
+async function run(_opts, flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/pages")).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-DlQSkbqx.mjs.map

package/dist/list-DlQSkbqx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-DlQSkbqx.mjs","names":[],"sources":["../src/commands/page/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport async function run(\n  _opts: unknown,\n  flags: GlobalFlags,\n  out: OutputOptions,\n) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request<{ data: unknown[] }>('/pages')\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAGA,eAAsB,IACpB,OACA,OACA,KACA;CAIA,aAAY,MAFG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QAA6B,QAAQ,GAC9C,MAAM,GAAG;AAC3B"}

package/dist/list-DsrA5wIz.mjs

@@ -0,0 +1,15 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/post/list.ts
+async function run(opts, flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/posts", { query: {
+		page: opts.page,
+		size: opts.size,
+		state: opts.state,
+		sortBy: opts.sort
+	} })).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-DsrA5wIz.mjs.map

package/dist/list-DsrA5wIz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-DsrA5wIz.mjs","names":[],"sources":["../src/commands/post/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport interface PostListFlags {\n  page?: number\n  size?: number\n  state?: string\n  sort?: string\n}\n\nexport async function run(\n  opts: PostListFlags,\n  flags: GlobalFlags,\n  out: OutputOptions,\n) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request<{\n    data: unknown[]\n    pagination?: unknown\n  }>('/posts', {\n    query: {\n      page: opts.page,\n      size: opts.size,\n      state: opts.state,\n      sortBy: opts.sort,\n    },\n  })\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAUA,eAAsB,IACpB,MACA,OACA,KACA;CAcA,aAAY,MAZG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QAGtB,UAAU,EACX,OAAO;EACL,MAAM,KAAK;EACX,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,QAAQ,KAAK;CACf,EACF,CAAC,GACe,MAAM,GAAG;AAC3B"}

package/dist/list-Fp4nKfQb.mjs

@@ -0,0 +1,10 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/category/list.ts
+async function run(flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/categories")).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-Fp4nKfQb.mjs.map

package/dist/list-Fp4nKfQb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-Fp4nKfQb.mjs","names":[],"sources":["../src/commands/category/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport async function run(flags: GlobalFlags, out: OutputOptions) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request<{ data: unknown[] }>('/categories')\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAGA,eAAsB,IAAI,OAAoB,KAAoB;CAIhE,aAAY,MAFG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QAA6B,aAAa,GACnD,MAAM,GAAG;AAC3B"}

package/dist/list-s_tloiEX.mjs

@@ -0,0 +1,10 @@
+import { i as emitSuccess } from "./output-BM7aBFwt.mjs";
+import { n as resolveContext, t as buildApiClient } from "./shared-D0HVBDHI.mjs";
+//#region src/commands/topic/list.ts
+async function run(flags, out) {
+	emitSuccess((await buildApiClient(await resolveContext(flags, out), flags).request("/topics/all")).data, out);
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=list-s_tloiEX.mjs.map

package/dist/list-s_tloiEX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-s_tloiEX.mjs","names":[],"sources":["../src/commands/topic/list.ts"],"sourcesContent":["import { emitSuccess, type OutputOptions } from '../../core/output'\nimport { buildApiClient, type GlobalFlags, resolveContext } from '../internal/shared'\n\nexport async function run(flags: GlobalFlags, out: OutputOptions) {\n  const ctx = await resolveContext(flags, out)\n  const client = buildApiClient(ctx, flags)\n  const res = await client.request<{ data: unknown[] } | unknown[]>(\n    '/topics/all',\n  )\n  emitSuccess(res.data, out)\n}\n"],"mappings":";;;AAGA,eAAsB,IAAI,OAAoB,KAAoB;CAMhE,aAAY,MAJG,eAAe,MADZ,eAAe,OAAO,GAAG,GACR,KACZ,EAAE,QACvB,aACF,GACgB,MAAM,GAAG;AAC3B"}