@cloudglab/confluence-cli 0.0.1

package/dist/core/config.js

@@ -0,0 +1,108 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { isRecord } from "./value.js";
+const CONFIG_DIR = path.join(homedir(), ".confluence");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function normalizeRootUrl(url) {
+    const trimmed = url.trim();
+    const withProtocol = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    try {
+        const parsed = new URL(withProtocol);
+        return `${parsed.protocol}//${parsed.host}`.replace(/\/+$/, "");
+    }
+    catch {
+        return trimmed.replace(/\/+$/, "");
+    }
+}
+function normalizeApiBaseUrl(url) {
+    const trimmed = url.replace(/\/+$/, "");
+    return `${trimmed}/rest/api`;
+}
+export function normalizeConfig(raw) {
+    if (!raw.url?.trim())
+        throw new Error("缺少 Confluence 地址。");
+    const url = normalizeRootUrl(raw.url);
+    const apiBaseUrl = raw.apiBaseUrl ? raw.apiBaseUrl.replace(/\/+$/, "") : normalizeApiBaseUrl(url);
+    const personalToken = normalizeOptionalValue(raw.personalToken);
+    const username = normalizeOptionalValue(raw.username);
+    const password = normalizeOptionalValue(raw.password);
+    if (!personalToken && (!username || !password)) {
+        throw new Error("缺少凭证。需要 CONFLUENCE_PAT 或 CONFLUENCE_USERNAME + CONFLUENCE_PASSWORD。");
+    }
+    return {
+        url,
+        apiBaseUrl,
+        authType: personalToken ? "pat" : "basic",
+        username,
+        password: personalToken ? undefined : password,
+        personalToken,
+        source: "~/.confluence/config.json",
+    };
+}
+export function loadConfluenceConfig() {
+    const envConfig = {
+        url: normalizeOptionalValue(process.env.CONFLUENCE_URL),
+        apiBaseUrl: normalizeOptionalValue(process.env.CONFLUENCE_API_BASE_URL),
+        personalToken: normalizeOptionalValue(process.env.CONFLUENCE_PAT) ?? normalizeOptionalValue(process.env.CONFLUENCE_PERSONAL_TOKEN),
+        username: normalizeOptionalValue(process.env.CONFLUENCE_USERNAME),
+        password: normalizeOptionalValue(process.env.CONFLUENCE_PASSWORD) ?? normalizeOptionalValue(process.env.CONFLUENCE_API_TOKEN),
+    };
+    const envOverrides = removeEmptyValues(envConfig);
+    const hasAnyEnvOverride = Object.keys(envOverrides).length > 0;
+    if (envConfig.url && (envConfig.personalToken || (envConfig.username && envConfig.password))) {
+        return normalizeConfig(envOverrides);
+    }
+    if (!existsSync(CONFIG_FILE)) {
+        throw new Error("未找到 Confluence 配置。\n" +
+            "用法: confluence initConfluence --url https://cf.cloudglab.cn --pat YOUR_TOKEN --save true\n" +
+            "或设置环境变量: CONFLUENCE_URL + CONFLUENCE_PAT");
+    }
+    const raw = readConfigFile();
+    if (!hasAnyEnvOverride)
+        return normalizeConfig(raw);
+    return normalizeConfig({
+        ...raw,
+        ...envOverrides,
+    });
+}
+function readConfigFile() {
+    try {
+        const parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        if (!isRecord(parsed))
+            throw new Error("配置内容必须是 JSON 对象");
+        return parsed;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Confluence 配置文件损坏，请检查 ${CONFIG_FILE}：${message}`);
+    }
+}
+function removeEmptyValues(config) {
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => value !== undefined && value !== ""));
+}
+function normalizeOptionalValue(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}
+export function saveConfig(config) {
+    const normalized = normalizeConfig(config);
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(CONFIG_FILE, `${JSON.stringify(normalized, null, 2)}\n`, { mode: 0o600 });
+}
+export function maskConfig(config) {
+    return {
+        ...config,
+        password: config.password ? maskSecret(config.password) : undefined,
+        personalToken: config.personalToken ? maskSecret(config.personalToken) : undefined,
+    };
+}
+function maskSecret(secret) {
+    if (secret.length <= 8)
+        return "********";
+    return `${secret.slice(0, 3)}***${secret.slice(-3)}`;
+}
+//# sourceMappingURL=config.js.map

package/dist/core/http-error.d.ts

@@ -0,0 +1,2 @@
+import type { HttpError } from "./http.js";
+export declare function isHttpStatusError(error: unknown, statusCode: number): error is HttpError;

package/dist/core/http-error.js

@@ -0,0 +1,4 @@
+export function isHttpStatusError(error, statusCode) {
+    return error instanceof Error && "statusCode" in error && error.statusCode === statusCode;
+}
+//# sourceMappingURL=http-error.js.map

package/dist/core/http.d.ts

@@ -0,0 +1,28 @@
+import type { RestMethod } from "../api/endpoints.js";
+import type { ConfluenceConfig } from "../types/common.js";
+export interface MultipartFile {
+    fieldName: string;
+    filename: string;
+    contentType?: string;
+    data: Buffer;
+}
+export interface HttpError extends Error {
+    statusCode?: number;
+    responseBody?: unknown;
+}
+export declare class ConfluenceHttpClient {
+    private readonly client;
+    constructor(config: ConfluenceConfig);
+    get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+    post<T>(path: string, data: unknown): Promise<T>;
+    put<T>(path: string, data: unknown): Promise<T>;
+    delete<T>(path: string, params?: Record<string, unknown>): Promise<T>;
+    request<T>(method: RestMethod, path: string, params?: Record<string, unknown>, data?: unknown): Promise<T>;
+    postMultipart<T>(path: string, fields: Record<string, string | boolean | number | undefined>, files: MultipartFile[]): Promise<T>;
+    putMultipart<T>(path: string, fields: Record<string, string | boolean | number | undefined>, files: MultipartFile[]): Promise<T>;
+    getBuffer(path: string, params?: Record<string, unknown>): Promise<{
+        data: Buffer;
+        headers: Record<string, unknown>;
+    }>;
+    private multipart;
+}

package/dist/core/http.js

@@ -0,0 +1,124 @@
+import axios from "axios";
+export class ConfluenceHttpClient {
+    client;
+    constructor(config) {
+        this.client = axios.create({
+            baseURL: config.apiBaseUrl,
+            timeout: 30_000,
+            auth: config.authType === "basic" ? { username: config.username, password: config.password } : undefined,
+            headers: {
+                Accept: "application/json",
+                ...(config.authType === "pat" ? { Authorization: `Bearer ${config.personalToken}` } : {}),
+            },
+        });
+    }
+    async get(path, params) {
+        try {
+            const response = await this.client.get(path, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async post(path, data) {
+        try {
+            const response = await this.client.post(path, data, { headers: { "Content-Type": "application/json" } });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async put(path, data) {
+        try {
+            const response = await this.client.put(path, data, { headers: { "Content-Type": "application/json" } });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async delete(path, params) {
+        try {
+            const response = await this.client.delete(path, { params });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async request(method, path, params, data) {
+        try {
+            const response = await this.client.request({ method, url: path, params, data, headers: data === undefined ? undefined : { "Content-Type": "application/json" } });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async postMultipart(path, fields, files) {
+        return this.multipart("POST", path, fields, files);
+    }
+    async putMultipart(path, fields, files) {
+        return this.multipart("PUT", path, fields, files);
+    }
+    async getBuffer(path, params) {
+        try {
+            const response = await this.client.get(path, { params, responseType: "arraybuffer" });
+            return { data: Buffer.from(response.data), headers: response.headers };
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+    async multipart(method, path, fields, files) {
+        const boundary = `----confluence-cli-${Date.now().toString(16)}`;
+        const body = buildMultipartBody(boundary, fields, files);
+        try {
+            const response = await this.client.request({
+                method,
+                url: path,
+                data: body,
+                headers: {
+                    "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                    "Content-Length": body.length,
+                    "X-Atlassian-Token": "no-check",
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw normalizeHttpError(error);
+        }
+    }
+}
+function buildMultipartBody(boundary, fields, files) {
+    const chunks = [];
+    for (const [name, value] of Object.entries(fields)) {
+        if (value === undefined)
+            continue;
+        chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${escapeMultipartName(name)}"\r\n\r\n${String(value)}\r\n`));
+    }
+    for (const file of files) {
+        chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${escapeMultipartName(file.fieldName)}"; filename="${escapeMultipartName(file.filename)}"\r\nContent-Type: ${file.contentType ?? "application/octet-stream"}\r\n\r\n`), file.data, Buffer.from("\r\n"));
+    }
+    chunks.push(Buffer.from(`--${boundary}--\r\n`));
+    return Buffer.concat(chunks);
+}
+function escapeMultipartName(value) {
+    return value.replace(/["\\\r\n]/g, "_");
+}
+function normalizeHttpError(error) {
+    if (axios.isAxiosError(error)) {
+        const status = error.response?.status;
+        const responseBody = error.response?.data;
+        const body = typeof responseBody === "string" ? responseBody : JSON.stringify(responseBody ?? {});
+        const normalized = new Error(`Confluence request failed${status ? ` (${status})` : ""}: ${body || error.message}`);
+        normalized.statusCode = status;
+        normalized.responseBody = responseBody;
+        return normalized;
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+//# sourceMappingURL=http.js.map

package/dist/core/inline-comment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Inline comment marker format for Confluence 7.13.7 (Server/Data Center):
+ *
+ * The page body storage format uses:
+ *   <ac:inline-comment-marker ac:ref="ref-id">selected text</ac:inline-comment-marker>
+ *
+ * The comment is linked via `extensions.inlineProperties.inlineMarkerRef`.
+ *
+ * Known limitations:
+ * - Selection text must be contiguously present in the storage format body
+ * - Selection spanning XML element boundaries (e.g., across <strong>/</strong>) will fail
+ * - Selection within macros (ac:structured-macro) or links (ac:link) will fail
+ */
+export interface InlineAnnotationResult {
+    annotatedBody: string;
+    markerRef: string;
+}
+export declare function generateMarkerRef(): string;
+/**
+ * Find `selection` in the storage format body and wrap it with an inline-comment-marker.
+ * Returns null if the selection cannot be safely annotated.
+ */
+export declare function findAndAnnotateSelection(storageBody: string, selection: string, markerRef?: string): InlineAnnotationResult | null;

package/dist/core/inline-comment.js

@@ -0,0 +1,27 @@
+import { randomUUID } from "node:crypto";
+export function generateMarkerRef() {
+    return `ic-${randomUUID().slice(0, 8)}`;
+}
+/**
+ * Find `selection` in the storage format body and wrap it with an inline-comment-marker.
+ * Returns null if the selection cannot be safely annotated.
+ */
+export function findAndAnnotateSelection(storageBody, selection, markerRef) {
+    if (!selection || selection.trim().length === 0)
+        return null;
+    const index = storageBody.indexOf(selection);
+    if (index === -1)
+        return null;
+    // Safety: don't insert marker if it would split an XML tag
+    const charBefore = index > 0 ? storageBody[index - 1] : "";
+    const charAfter = index + selection.length < storageBody.length
+        ? storageBody[index + selection.length]
+        : "";
+    if (charBefore === "<" || charAfter === ">")
+        return null;
+    const ref = markerRef ?? generateMarkerRef();
+    const marker = `<ac:inline-comment-marker ac:ref="${ref}">${selection}</ac:inline-comment-marker>`;
+    const annotatedBody = storageBody.slice(0, index) + marker + storageBody.slice(index + selection.length);
+    return { annotatedBody, markerRef: ref };
+}
+//# sourceMappingURL=inline-comment.js.map

package/dist/core/list-result.d.ts

@@ -0,0 +1,14 @@
+import { type PaginationInput } from "./pagination.js";
+export interface ListResult<T = unknown> {
+    source: "server-paginated" | "server-full-list" | "client-paginated";
+    partial: boolean;
+    page: number;
+    limit: number;
+    total: number;
+    scanned?: number;
+    itemKey: string;
+    items: T[];
+}
+export declare function extractItems<T = unknown>(response: unknown, keys: string[]): T[];
+export declare function toServerListResult<T = unknown>(response: unknown, keys: string[], pagination?: PaginationInput): ListResult<T>;
+export declare function toClientPaginatedListResult<T = unknown>(response: unknown, keys: string[], pagination?: PaginationInput): ListResult<T>;

package/dist/core/list-result.js

@@ -0,0 +1,81 @@
+import { normalizePagination } from "./pagination.js";
+export function extractItems(response, keys) {
+    if (Array.isArray(response))
+        return response;
+    if (typeof response !== "object" || response === null)
+        return [];
+    const record = response;
+    for (const key of keys) {
+        const value = record[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+export function toServerListResult(response, keys, pagination = {}) {
+    const items = extractItems(response, keys);
+    const normalized = normalizePagination(pagination);
+    if (Array.isArray(response)) {
+        return {
+            source: "server-full-list",
+            partial: false,
+            page: 1,
+            limit: items.length,
+            total: items.length,
+            itemKey: keys[0] ?? "items",
+            items,
+        };
+    }
+    const record = typeof response === "object" && response !== null ? response : {};
+    const page = toPositiveInteger(record.page) ?? normalized.page;
+    const limit = toPositiveInteger(record.limit) ?? normalized.limit;
+    const total = toNonNegativeInteger(record.total) ?? items.length;
+    return {
+        source: "server-paginated",
+        partial: false,
+        page,
+        limit,
+        total,
+        itemKey: keys[0] ?? "items",
+        items,
+    };
+}
+export function toClientPaginatedListResult(response, keys, pagination = {}) {
+    const items = extractItems(response, keys);
+    const normalized = normalizePagination(pagination);
+    const start = (normalized.page - 1) * normalized.limit;
+    const window = items.slice(start, start + normalized.limit);
+    return {
+        source: "client-paginated",
+        partial: false,
+        page: normalized.page,
+        limit: normalized.limit,
+        total: items.length,
+        scanned: items.length,
+        itemKey: keys[0] ?? "items",
+        items: window,
+    };
+}
+function toFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function toPositiveInteger(value) {
+    const parsed = toFiniteNumber(value);
+    if (parsed === undefined || parsed <= 0)
+        return undefined;
+    return Math.floor(parsed);
+}
+function toNonNegativeInteger(value) {
+    const parsed = toFiniteNumber(value);
+    if (parsed === undefined || parsed < 0)
+        return undefined;
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=list-result.js.map

package/dist/core/manifest.d.ts

@@ -0,0 +1,11 @@
+import { InMemoryCliRegistry } from "./cli-registry.js";
+import type { Role } from "../types/common.js";
+export interface Manifest {
+    version: string;
+    commands: string[];
+    groups: Record<string, string[]>;
+    commandToGroup: Record<string, string>;
+}
+export declare function loadManifest(): Promise<Manifest | undefined>;
+export declare function getAvailableCommandNames(role: Role): Promise<string[]>;
+export declare function buildRegistryForCommand(role: Role, commandName: string): Promise<InMemoryCliRegistry>;

package/dist/core/manifest.js

@@ -0,0 +1,42 @@
+import { readFile } from "node:fs/promises";
+import { InMemoryCliRegistry } from "./cli-registry.js";
+import { registerTools } from "./tool-registry.js";
+import { hasToolGroup } from "./roles.js";
+let manifestCache = null;
+export async function loadManifest() {
+    if (manifestCache !== null)
+        return manifestCache ?? undefined;
+    try {
+        const manifestPath = new URL("../../dist/manifest.json", import.meta.url);
+        const content = await readFile(manifestPath, "utf8");
+        manifestCache = JSON.parse(content);
+        return manifestCache;
+    }
+    catch {
+        manifestCache = undefined;
+        return undefined;
+    }
+}
+export async function getAvailableCommandNames(role) {
+    const manifest = await loadManifest();
+    if (manifest) {
+        const names = new Set();
+        for (const [group, commands] of Object.entries(manifest.groups)) {
+            if (hasToolGroup(role, group)) {
+                for (const command of commands) {
+                    names.add(command);
+                }
+            }
+        }
+        return Array.from(names).sort((left, right) => left.localeCompare(right));
+    }
+    const registry = new InMemoryCliRegistry();
+    await registerTools(registry, role);
+    return registry.list().map((command) => command.name);
+}
+export async function buildRegistryForCommand(role, commandName) {
+    const registry = new InMemoryCliRegistry();
+    await registerTools(registry, role, { commandName });
+    return registry;
+}
+//# sourceMappingURL=manifest.js.map

package/dist/core/pagination.d.ts

@@ -0,0 +1,26 @@
+export interface PaginationInput {
+    page?: number;
+    limit?: number;
+}
+export interface PaginationParams {
+    page: number;
+    limit: number;
+}
+export declare function normalizePagination(input?: PaginationInput): PaginationParams;
+export declare function normalizeTotalPages(total: unknown, limit: number, fallbackItemCount?: number): number;
+export declare function fetchRemainingPagesConcurrently<T>(firstPage: {
+    items: T[];
+    total?: unknown;
+}, fetchPage: (page: number) => Promise<T[]>, options?: {
+    limit?: number;
+    concurrency?: number;
+}): Promise<T[]>;
+export interface FetchAllPagesOptions<T> {
+    fetchPage: (page: number) => Promise<{
+        items: T[];
+        total?: unknown;
+    }>;
+    pageSize?: number;
+    concurrency?: number;
+}
+export declare function fetchAllPages<T>(options: FetchAllPagesOptions<T>): Promise<T[]>;

package/dist/core/pagination.js

@@ -0,0 +1,45 @@
+const DEFAULT_PAGE = 1;
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+const MAX_TOTAL_PAGES = 1000;
+export function normalizePagination(input = {}) {
+    const pageCandidate = Number.isFinite(input.page) && input.page && input.page > 0 ? Math.floor(input.page) : DEFAULT_PAGE;
+    const page = Math.max(pageCandidate, DEFAULT_PAGE);
+    const rawLimitCandidate = Number.isFinite(input.limit) && input.limit && input.limit > 0 ? Math.floor(input.limit) : DEFAULT_LIMIT;
+    const rawLimit = Math.max(rawLimitCandidate, 1);
+    const limit = Math.min(rawLimit, MAX_LIMIT);
+    return { page, limit };
+}
+export function normalizeTotalPages(total, limit, fallbackItemCount = 0) {
+    const parsedTotal = typeof total === "number" && Number.isFinite(total)
+        ? total
+        : typeof total === "string" && total.trim() !== ""
+            ? Number(total)
+            : fallbackItemCount;
+    const safeTotal = Number.isFinite(parsedTotal) && parsedTotal > 0 ? parsedTotal : fallbackItemCount;
+    const safeLimit = Number.isFinite(limit) && limit > 0 ? limit : DEFAULT_LIMIT;
+    return Math.min(Math.ceil(safeTotal / safeLimit), MAX_TOTAL_PAGES);
+}
+export async function fetchRemainingPagesConcurrently(firstPage, fetchPage, options = {}) {
+    const limit = options.limit ?? DEFAULT_LIMIT;
+    const concurrency = options.concurrency ?? 3;
+    const totalPages = normalizeTotalPages(firstPage.total, limit, firstPage.items.length);
+    const allItems = [...firstPage.items];
+    if (totalPages <= 1)
+        return allItems;
+    for (let startPage = 2; startPage <= totalPages; startPage += concurrency) {
+        const endPage = Math.min(startPage + concurrency - 1, totalPages);
+        const pageIndexes = Array.from({ length: endPage - startPage + 1 }, (_, index) => startPage + index);
+        const pages = await Promise.all(pageIndexes.map((page) => fetchPage(page)));
+        for (const items of pages) {
+            allItems.push(...items);
+        }
+    }
+    return allItems;
+}
+export async function fetchAllPages(options) {
+    const pageSize = options.pageSize ?? 100;
+    const firstPage = await options.fetchPage(1);
+    return fetchRemainingPagesConcurrently({ items: firstPage.items, total: firstPage.total }, async (page) => (await options.fetchPage(page)).items, { limit: pageSize, concurrency: options.concurrency });
+}
+//# sourceMappingURL=pagination.js.map

package/dist/core/roles.d.ts

@@ -0,0 +1,4 @@
+import type { Role } from "../types/common.js";
+export type ToolGroup = "init" | "convert" | "metadata" | "rest" | "space" | "content" | "labels" | "attachments" | "transfer" | "install";
+export declare function hasToolGroup(role: Role, group: ToolGroup): boolean;
+export declare function getToolGroups(role: Role): ToolGroup[];

package/dist/core/roles.js

@@ -0,0 +1,12 @@
+const ROLE_TOOL_GROUPS = {
+    full: ["init", "install", "convert", "metadata", "rest", "space", "content", "labels", "attachments", "transfer"],
+    reader: ["init", "install", "convert", "metadata", "rest", "space", "content", "labels", "attachments"],
+    writer: ["init", "install", "convert", "metadata", "rest", "space", "content", "labels", "attachments", "transfer"],
+};
+export function hasToolGroup(role, group) {
+    return ROLE_TOOL_GROUPS[role].includes(group);
+}
+export function getToolGroups(role) {
+    return ROLE_TOOL_GROUPS[role];
+}
+//# sourceMappingURL=roles.js.map

package/dist/core/tool-registry.d.ts

@@ -0,0 +1,9 @@
+import type { CliRegistry } from "./cli-registry.js";
+import type { Role } from "../types/common.js";
+export interface RegisterToolsOptions {
+    commandName?: string;
+    onGroupRegister?: (group: ReturnType<typeof getToolGroupNames>[number], commands: string[]) => void;
+}
+export declare function registerTools(registry: CliRegistry, role: Role, options?: RegisterToolsOptions): Promise<void>;
+declare function getToolGroupNames(): readonly ["init", "install", "convert", "metadata", "rest", "space", "content", "labels", "attachments", "transfer"];
+export {};

package/dist/core/tool-registry.js

@@ -0,0 +1,60 @@
+import { hasToolGroup } from "./roles.js";
+import { registerAttachmentTools } from "../tools/attachments.js";
+import { registerConvertTools } from "../tools/convert.js";
+import { registerContentTools } from "../tools/content.js";
+import { registerInitTools } from "../tools/init.js";
+import { registerInstallTools } from "../tools/install.js";
+import { registerLabelTools } from "../tools/labels.js";
+import { registerMetadataTools } from "../tools/metadata.js";
+import { registerRestTools } from "../tools/rest.js";
+import { registerSpaceTools } from "../tools/spaces.js";
+import { registerTransferTools } from "../tools/transfer.js";
+const groupLoaders = {
+    init: () => registerInitTools,
+    install: () => registerInstallTools,
+    convert: () => registerConvertTools,
+    metadata: () => registerMetadataTools,
+    rest: () => registerRestTools,
+    space: () => registerSpaceTools,
+    content: () => registerContentTools,
+    labels: () => registerLabelTools,
+    attachments: () => registerAttachmentTools,
+    transfer: () => registerTransferTools,
+};
+export async function registerTools(registry, role, options = {}) {
+    const { commandName, onGroupRegister } = options;
+    if (commandName) {
+        const group = await resolveCommandGroup(commandName);
+        if (group && hasToolGroup(role, group)) {
+            registerGroup(registry, group, onGroupRegister);
+            return;
+        }
+    }
+    for (const group of getToolGroupNames()) {
+        if (!hasToolGroup(role, group))
+            continue;
+        registerGroup(registry, group, onGroupRegister);
+    }
+}
+function registerGroup(registry, group, onGroupRegister) {
+    const before = new Set(registry.list().map((command) => command.name));
+    const loader = groupLoaders[group];
+    const register = loader();
+    register(registry);
+    const added = registry.list().map((command) => command.name).filter((name) => !before.has(name));
+    onGroupRegister?.(group, added);
+}
+async function resolveCommandGroup(commandName) {
+    try {
+        const { commandToGroup } = await import("./command-groups.generated.js");
+        const group = commandToGroup[commandName];
+        return group;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getToolGroupNames() {
+    return ["init", "install", "convert", "metadata", "rest", "space", "content", "labels", "attachments", "transfer"];
+}
+//# sourceMappingURL=tool-registry.js.map

package/dist/core/validation.d.ts

@@ -0,0 +1,2 @@
+/** 必填字符串：去空白后空串抛错，否则返回裁剪后的值。 */
+export declare function requireNonBlank(value: string | undefined | null, message: string): string;

package/dist/core/validation.js

@@ -0,0 +1,10 @@
+/** 必填字符串：去空白后空串抛错，否则返回裁剪后的值。 */
+export function requireNonBlank(value, message) {
+    if (typeof value !== "string")
+        throw new Error(message);
+    const text = value.trim();
+    if (text === "")
+        throw new Error(message);
+    return text;
+}
+//# sourceMappingURL=validation.js.map

package/dist/core/value.d.ts

@@ -0,0 +1,2 @@
+export declare function firstString(...values: unknown[]): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;