@qoder-ai/qmind-cli 2.0.0 → 3.1.0

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": "2.0.0",
+  "version": "3.1.0",
   "description": "QMind command line interface",
   "bin": {
     "qmind": "bin/cli.js"
@@ -11,7 +11,9 @@
     "bin",
     "dist",
     "CHANGELOG.md",
-    "README.md"
+    "CHANGELOG.zh-CN.md",
+    "README.md",
+    "README.zh-CN.md"
   ],
   "engines": {
     "node": ">=20.18.1"
@@ -31,20 +33,12 @@
     "undici": "7.29.0",
     "zod": "4.3.6"
   },
-  "optionalDependencies": {
-    "@napi-rs/keyring": "1.3.0"
-  },
   "devDependencies": {
     "@types/node": "24.13.3",
     "@types/picomatch": "4.0.3",
     "@types/proper-lockfile": "4.1.4",
-    "@ali/qmind-node-host": "^2.0.0",
-    "@ali/qmind-sdk": "^0.2.0"
+    "@ali/qmind-node-host": "^2.2.8",
+    "@ali/qmind-sdk": "^0.14.0"
   },
-  "license": "UNLICENSED",
-  "scripts": {
-    "build": "tsdown",
-    "check:package": "publint",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  }
+  "license": "UNLICENSED"
 }