@qoder-ai/qmind-cli 3.0.0 → 3.1.0

package/dist/{shared-DwycozMA.js → shared-BkQJzIZF.js}

@@ -566,6 +566,7 @@ const sourceListSchema = z.object({
 });
 const sourceTreeNodeSchema = z.lazy(() => z.object({
 	files: z.array(sourceTreeNodeSchema).default([]),
+	hasChildren: z.boolean().optional(),
 	id: z.string().min(1),
 	name: z.string().default(""),
 	path: z.string().default(""),
@@ -666,11 +667,12 @@ const sourcePreviewSchema = z.preprocess((value) => isRecord(value) ? {
 	url: httpsUrlSchema
 }));
 /** proto3 JSON serializes the token timeout and version as int64, so both arrive either way. */
+const officeTokenIntegerSchema = z.union([z.number(), z.string().regex(/^\d+$/).transform(Number)]).pipe(z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER));
 const webOfficeTokenFields = {
 	accessToken: z.string().min(1),
 	accessTokenExpiresAt: timestampSchema.optional(),
-	tokenTimeoutMs: wireInt64Schema,
-	tokenVersion: wireInt64Schema
+	tokenTimeoutMs: officeTokenIntegerSchema.refine((value) => value > 0),
+	tokenVersion: officeTokenIntegerSchema
 };
 function webOfficeTokenAliases(value) {
 	return isRecord(value) ? {
@@ -693,11 +695,11 @@ const sourceWebOfficeSessionSchema = z.preprocess((value) => {
 	} : aliased;
 }, z.object({
 	...webOfficeTokenFields,
-	readOnly: z.boolean().default(true),
+	readOnly: z.literal(true),
 	reused: z.boolean().default(false),
 	sessionId: z.string().min(1),
-	sourceFormat: z.string().default(""),
-	sourceId: z.string().default(""),
+	sourceFormat: z.string().min(1).transform((value) => value.trim().toLowerCase().replace(/^\./, "")).pipe(z.string().min(1)),
+	sourceId: z.string().min(1),
 	webOfficeUrl: httpsUrlSchema
 }));
 const sourceWebOfficeTokenSchema = z.preprocess(webOfficeTokenAliases, z.object(webOfficeTokenFields));
@@ -1038,6 +1040,12 @@ function optionalString(value, field) {
 	if (typeof value !== "string") throw invalidArgument(`${field} must be a string`, field);
 	return value;
 }
+/** Validate body text without trimming meaningful Markdown indentation or trailing newlines. */
+function requiredText(value, field) {
+	const text = optionalString(value, field);
+	if (text === void 0 || text.trim().length === 0) throw invalidArgument(`${field} must be a non-empty string`, field);
+	return text;
+}
 function optionalTrimmedString(value, field) {
 	const string = optionalString(value, field)?.trim();
 	return string === "" ? void 0 : string;
@@ -1144,4 +1152,4 @@ function call(context, options) {
 	});
 }
 //#endregion
-export { executeStream as $, retrieveResultSchema as A, sourceTreeSchema as B, chatSessionListSchema as C, importProvidersSchema as D, imageUrlsSchema as E, sourceImportResultsSchema as F, streamWireEventSchema as G, sourceUploadTicketSchema as H, sourceListSchema as I, voidResponseSchema as J, taskRunListSchema as K, sourcePreviewSchema as L, sourceActionAccessSchema as M, sourceChildrenCountsSchema as N, notebookListSchema as O, sourceContentSchema as P, assertCapability as Q, sourceRawContentSchema as R, chatMessageListSchema as S, imageUploadTicketSchema as T, sourceWebOfficeSessionSchema as U, sourceUploadCapabilitiesSchema as V, sourceWebOfficeTokenSchema as W, QMIND_MULTIPART_UPLOAD_MAX_BYTES as X, wikiBranchListSchema as Y, QMIND_SOURCE_UPLOAD_MAX_BYTES as Z, aliDingImportRunSchema as _, invalidArgument as a, cardListSchema as b, optionalRecord as c, pagination as d, executeUnary as et, positiveInteger as f, aliDingImportRunItemListSchema as g, stringList as h, httpUrl as i, sharedNotebookListSchema as j, notebookSchema as k, optionalString as l, requiredString as m, call as n, nonNegativeInteger as o, queryPath as p, taskRunSchema as q, compactUndefined as r, optionalBoolean as s, assertNonEmptyPatch as t, QMindError as tt, optionalTrimmedString as u, batchMutationResultSchema as v, chatSessionSchema as w, cardSchema as x, cancelQuestionResultSchema as y, sourceSchema as z };
+export { QMIND_SOURCE_UPLOAD_MAX_BYTES as $, notebookSchema as A, sourceSchema as B, chatMessageListSchema as C, imageUrlsSchema as D, imageUploadTicketSchema as E, sourceContentSchema as F, sourceWebOfficeTokenSchema as G, sourceUploadCapabilitiesSchema as H, sourceImportResultsSchema as I, taskRunSchema as J, streamWireEventSchema as K, sourceListSchema as L, sharedNotebookListSchema as M, sourceActionAccessSchema as N, importProvidersSchema as O, sourceChildrenCountsSchema as P, QMIND_MULTIPART_UPLOAD_MAX_BYTES as Q, sourcePreviewSchema as R, cardSchema as S, chatSessionSchema as T, sourceUploadTicketSchema as U, sourceTreeSchema as V, sourceWebOfficeSessionSchema as W, voidResponseSchema as X, timestampSchema as Y, wikiBranchListSchema as Z, aliDingImportRunItemListSchema as _, invalidArgument as a, cancelQuestionResultSchema as b, optionalRecord as c, pagination as d, assertCapability as et, positiveInteger as f, stringList as g, requiredText as h, httpUrl as i, retrieveResultSchema as j, notebookListSchema as k, optionalString as l, requiredString as m, call as n, executeUnary as nt, nonNegativeInteger as o, queryPath as p, taskRunListSchema as q, compactUndefined as r, QMindError as rt, optionalBoolean as s, assertNonEmptyPatch as t, executeStream as tt, optionalTrimmedString as u, aliDingImportRunSchema as v, chatSessionListSchema as w, cardListSchema as x, batchMutationResultSchema as y, sourceRawContentSchema as z };

package/dist/source-upload-DBm1Hyki.js

@@ -0,0 +1,17 @@
+import { H as sourceUploadCapabilitiesSchema, m as requiredString, n as call } from "./shared-BkQJzIZF.js";
+//#region ../sdk/src/operations/source-upload.ts
+/** Notebook-scoped edit preflight, not the deployment-level capabilities lookup. */
+async function preflightSourceUpload(context, notebookId, options) {
+	const notebook = requiredString(notebookId, "notebookId");
+	return call(context, {
+		callOptions: options,
+		capability: "transfers",
+		idempotent: true,
+		method: "GET",
+		operation: "sources.uploadPreflight",
+		path: context.profile.apiPath("notebooks", notebook, "sources", "upload", "capabilities"),
+		schema: sourceUploadCapabilitiesSchema
+	});
+}
+//#endregion
+export { preflightSourceUpload as t };

package/dist/transfers-F1ZLLBdU.js

@@ -0,0 +1,237 @@
+import { $ as QMIND_SOURCE_UPLOAD_MAX_BYTES, B as sourceSchema, E as imageUploadTicketSchema, Q as QMIND_MULTIPART_UPLOAD_MAX_BYTES, U as sourceUploadTicketSchema, X as voidResponseSchema, a as invalidArgument, l as optionalString, m as requiredString, nt as executeUnary, p as queryPath, r as compactUndefined, rt as QMindError, u as optionalTrimmedString } from "./shared-BkQJzIZF.js";
+import { t as preflightSourceUpload } from "./source-upload-DBm1Hyki.js";
+//#region ../sdk/src/operations/transfers.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function binarySource(value) {
+	if (!isRecord(value)) throw invalidArgument("source must be a QMindBinarySource", "source");
+	const filename = requiredString(value.filename, "source.filename");
+	const mimeType = requiredString(value.mimeType, "source.mimeType");
+	const size = value.size;
+	if (typeof size !== "number" || !Number.isSafeInteger(size) || size <= 0) throw invalidArgument("source.size must be a positive safe integer", "source.size");
+	if (typeof value.open !== "function") throw invalidArgument("source.open must be a function", "source.open");
+	const source = value;
+	return {
+		filename,
+		mimeType,
+		open: () => source.open(),
+		size
+	};
+}
+function transferOptions(options) {
+	if (options === void 0) return {};
+	if (!isRecord(options)) throw invalidArgument("options must be an object", "options");
+	if (options.onProgress !== void 0 && typeof options.onProgress !== "function") throw invalidArgument("onProgress must be a function", "onProgress");
+	return options;
+}
+function uploadMetadata(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw invalidArgument("metadata must be an object", "metadata");
+	return {
+		parentSourceId: optionalString(value.parentSourceId, "parentSourceId"),
+		path: optionalString(value.path, "path"),
+		sha256: optionalTrimmedString(value.sha256, "sha256"),
+		sourceType: optionalTrimmedString(value.sourceType, "sourceType"),
+		title: optionalTrimmedString(value.title, "title")
+	};
+}
+function progressReporter(context, operation, strategy, totalBytes, options) {
+	let lastUploadedBytes = 0;
+	const notify = (phase, uploadedBytes) => {
+		if (!Number.isSafeInteger(uploadedBytes) || uploadedBytes < lastUploadedBytes) throw new QMindError("HOST_POLICY_ERROR", "upload progress must be a monotonic integer", {
+			access: context.profile.access,
+			details: {
+				lastUploadedBytes,
+				totalBytes,
+				uploadedBytes
+			},
+			operation
+		});
+		if (uploadedBytes > totalBytes) throw new QMindError("HOST_POLICY_ERROR", "upload progress exceeds source size", {
+			access: context.profile.access,
+			details: {
+				totalBytes,
+				uploadedBytes
+			},
+			operation
+		});
+		lastUploadedBytes = uploadedBytes;
+		const progress = {
+			phase,
+			strategy,
+			totalBytes,
+			uploadedBytes
+		};
+		options.onProgress?.(progress);
+	};
+	return {
+		complete: () => notify("uploading", totalBytes),
+		registering: () => notify("registering", totalBytes),
+		start: () => notify("uploading", 0),
+		update: (uploadedBytes) => notify("uploading", uploadedBytes)
+	};
+}
+function requestOptions(options) {
+	return {
+		...options.signal === void 0 ? {} : { signal: options.signal },
+		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
+	};
+}
+function transferCall(context, operation, request, schema) {
+	return executeUnary({
+		capability: operation.startsWith("images.") ? "images.presignUpload" : "transfers",
+		operation,
+		profile: context.profile,
+		request,
+		schema,
+		transport: context.transport
+	});
+}
+function hostRequest(path, method, idempotent, options, body) {
+	const authorization = options.authorization?.trim();
+	return {
+		body,
+		destination: {
+			kind: "host",
+			path
+		},
+		...authorization === void 0 || authorization.length === 0 ? {} : { headers: { authorization: `Bearer ${authorization}` } },
+		idempotent,
+		method,
+		...requestOptions(options)
+	};
+}
+function signedUploadRequest(ticket, source, progress, options) {
+	return {
+		body: {
+			kind: "binary",
+			onProgress: progress.update,
+			source
+		},
+		destination: {
+			kind: "signed",
+			url: ticket.uploadUrl
+		},
+		headers: ticket.headers,
+		idempotent: true,
+		method: "PUT",
+		...requestOptions(options)
+	};
+}
+function selectSourceUploadStrategy(source, capabilities) {
+	const methods = capabilities.uploadMethods.filter(({ available, method, maxSizeBytes }) => available && maxSizeBytes > 0 && (method === "multipart" || method === "presign"));
+	if (methods.length === 0) throw new QMindError("UNSUPPORTED_OPERATION", "source upload is unavailable", {
+		details: { reason: "upload-unavailable" },
+		operation: "sources.uploadPreflight"
+	});
+	const filename = source.filename.toLowerCase();
+	const matching = methods.filter(({ supportedExtensions }) => supportedExtensions.some((extension) => filename.endsWith(extension.toLowerCase())));
+	if (matching.length === 0) throw new QMindError("INVALID_ARGUMENT", "file extension is not supported for upload", {
+		details: { reason: "unsupported-extension" },
+		operation: "sources.uploadPreflight"
+	});
+	const limit = (method) => Math.min(method.maxSizeBytes, method.method === "multipart" ? QMIND_MULTIPART_UPLOAD_MAX_BYTES : QMIND_SOURCE_UPLOAD_MAX_BYTES);
+	if (matching.find((method) => method.method === "multipart" && source.size <= limit(method))) return "multipart";
+	if (matching.some((method) => method.method === "presign" && source.size <= limit(method))) return "presigned";
+	throw new QMindError("FILE_TOO_LARGE", "file exceeds the available upload size limit", {
+		details: {
+			limitBytes: Math.max(...matching.map(limit)),
+			size: source.size
+		},
+		operation: "sources.uploadPreflight"
+	});
+}
+function createTransferOperations(context) {
+	return {
+		async uploadImage(notebookId, sourceId, rawSource, rawOptions) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const sourceIdValue = requiredString(sourceId, "sourceId");
+			const source = binarySource(rawSource);
+			const options = transferOptions(rawOptions);
+			if (source.size > 52428800) throw new QMindError("FILE_TOO_LARGE", "image exceeds the 50 MiB upload limit", {
+				access: context.profile.access,
+				details: {
+					limitBytes: QMIND_MULTIPART_UPLOAD_MAX_BYTES,
+					size: source.size
+				},
+				operation: "images.upload"
+			});
+			const ticket = await transferCall(context, "images.presignUpload", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", sourceIdValue, "images", "presign"), "POST", false, options, {
+				kind: "json",
+				value: {
+					filename: source.filename,
+					mimeType: source.mimeType,
+					size: source.size
+				}
+			}), imageUploadTicketSchema);
+			const progress = progressReporter(context, "images.upload", "presigned", source.size, options);
+			progress.start();
+			await transferCall(context, "images.upload", signedUploadRequest(ticket, source, progress, options), voidResponseSchema);
+			progress.complete();
+			return ticket;
+		},
+		async uploadSource(notebookId, rawSource, rawMetadata, rawOptions) {
+			const notebook = requiredString(notebookId, "notebookId");
+			const source = binarySource(rawSource);
+			const metadata = uploadMetadata(rawMetadata);
+			const options = transferOptions(rawOptions);
+			if (source.size > 524288e3) throw new QMindError("FILE_TOO_LARGE", "file exceeds the 500 MiB upload limit", {
+				access: context.profile.access,
+				details: {
+					limitBytes: QMIND_SOURCE_UPLOAD_MAX_BYTES,
+					size: source.size
+				},
+				operation: "transfers.source.multipart"
+			});
+			if (selectSourceUploadStrategy(source, await preflightSourceUpload(context, notebook, options)) === "multipart") {
+				const progress = progressReporter(context, "transfers.source.multipart", "multipart", source.size, options);
+				progress.start();
+				const fields = compactUndefined({
+					parent_source_id: metadata.parentSourceId,
+					path: metadata.path,
+					retain_original_file: "true",
+					source_type: metadata.sourceType,
+					title: metadata.title
+				});
+				const result = await transferCall(context, "transfers.source.multipart", hostRequest(queryPath(context.profile.apiPath("notebooks", notebook, "sources", "upload"), [["client", context.client]]), "POST", false, options, {
+					file: source,
+					fields,
+					kind: "multipart",
+					onProgress: progress.update
+				}), sourceSchema);
+				progress.complete();
+				return result;
+			}
+			const ticket = await transferCall(context, "transfers.source.presign", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", "presign"), "POST", false, options, {
+				kind: "json",
+				value: {
+					filename: source.filename,
+					mimeType: source.mimeType,
+					size: source.size
+				}
+			}), sourceUploadTicketSchema);
+			const progress = progressReporter(context, "transfers.source.upload", "presigned", source.size, options);
+			progress.start();
+			await transferCall(context, "transfers.source.upload", signedUploadRequest(ticket, source, progress, options), voidResponseSchema);
+			progress.complete();
+			progress.registering();
+			return transferCall(context, "transfers.source.register", hostRequest(context.profile.apiPath("notebooks", notebook, "sources", "register"), "POST", false, options, {
+				kind: "json",
+				value: compactUndefined({
+					filename: source.filename,
+					mimeType: source.mimeType,
+					parentSourceId: metadata.parentSourceId,
+					path: metadata.path,
+					sha256: metadata.sha256,
+					size: source.size,
+					sourceType: metadata.sourceType,
+					title: metadata.title,
+					uri: ticket.uri
+				})
+			}), sourceSchema);
+		}
+	};
+}
+//#endregion
+export { createTransferOperations };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qoder-ai/qmind-cli",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "QMind command line interface",
   "bin": {
     "qmind": "bin/cli.js"
@@ -37,8 +37,8 @@
     "@types/node": "24.13.3",
     "@types/picomatch": "4.0.3",
     "@types/proper-lockfile": "4.1.4",
-    "@ali/qmind-node-host": "^2.2.7",
-    "@ali/qmind-sdk": "^0.13.0"
+    "@ali/qmind-node-host": "^2.2.8",
+    "@ali/qmind-sdk": "^0.14.0"
   },
   "license": "UNLICENSED"
 }

package/dist/cards-2J6ebaI0.js

@@ -1,75 +0,0 @@
-import { b as cardListSchema, d as pagination, h as stringList, m as requiredString, n as call, p as queryPath, u as optionalTrimmedString, v as batchMutationResultSchema, x as cardSchema } from "./shared-DwycozMA.js";
-//#region ../sdk/src/operations/cards.ts
-function createCardOperations(context) {
-	const listCards = async (notebookId, input = {}, options, featured = false) => {
-		const notebook = requiredString(notebookId, "notebookId");
-		const normalizedPage = pagination({
-			page: input.page ?? 1,
-			pageSize: input.pageSize ?? 20
-		});
-		const category = optionalTrimmedString(input.category, "category");
-		const query = optionalTrimmedString(input.query, "query");
-		const root = context.profile.apiPath(featured ? "featured-notebooks" : "notebooks", notebook, "cards");
-		const path = queryPath(root, [
-			["category", category],
-			["query", query],
-			["page", normalizedPage.page],
-			["page_size", normalizedPage.pageSize]
-		]);
-		return call(context, {
-			callOptions: options,
-			capability: featured ? "featuredNotebooks.read" : "cards.read",
-			idempotent: true,
-			method: "GET",
-			operation: featured ? "featuredCards.list" : "cards.list",
-			path,
-			schema: cardListSchema
-		});
-	};
-	return {
-		async batchDeleteCards(notebookId, cardIds, options) {
-			const notebook = requiredString(notebookId, "notebookId");
-			const ids = stringList(cardIds, "cardIds", { min: 1 });
-			return call(context, {
-				body: { cardIds: ids },
-				callOptions: options,
-				capability: "cards.write",
-				idempotent: false,
-				method: "POST",
-				operation: "cards.batchDelete",
-				path: context.profile.apiPath("notebooks", notebook, "cards", "batch-delete"),
-				schema: batchMutationResultSchema
-			});
-		},
-		async deleteCard(notebookId, cardId, options) {
-			const notebook = requiredString(notebookId, "notebookId");
-			const card = requiredString(cardId, "cardId");
-			return call(context, {
-				callOptions: options,
-				capability: "cards.write",
-				idempotent: false,
-				method: "DELETE",
-				operation: "cards.delete",
-				path: context.profile.apiPath("notebooks", notebook, "cards", card),
-				schema: batchMutationResultSchema
-			});
-		},
-		async getCard(notebookId, cardId, options) {
-			const notebook = requiredString(notebookId, "notebookId");
-			const card = requiredString(cardId, "cardId");
-			return call(context, {
-				callOptions: options,
-				capability: "cards.read",
-				idempotent: true,
-				method: "GET",
-				operation: "cards.get",
-				path: context.profile.apiPath("notebooks", notebook, "cards", card),
-				schema: cardSchema
-			});
-		},
-		listCards: (notebookId, input, options) => listCards(notebookId, input, options),
-		listFeaturedCards: (notebookId, input, options) => listCards(notebookId, input, options, true)
-	};
-}
-//#endregion
-export { createCardOperations };