687 lines
22 KiB
TypeScript
687 lines
22 KiB
TypeScript
import {
|
|
AbortMultipartUploadCommand,
|
|
CompleteMultipartUploadCommand,
|
|
CreateMultipartUploadCommand,
|
|
HeadObjectCommand,
|
|
ListPartsCommand,
|
|
PutObjectCommand,
|
|
UploadPartCommand,
|
|
} from "@aws-sdk/client-s3";
|
|
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
|
|
import { NextResponse } from "next/server";
|
|
import { z } from "zod";
|
|
|
|
import { auth } from "@/app/(auth)/auth";
|
|
import { upsertMediaAsset } from "@/lib/db/queries";
|
|
import {
|
|
IMAGE_UPLOAD_MAX_BYTES,
|
|
IMAGE_UPLOAD_TOO_LARGE_MESSAGE,
|
|
} from "@/lib/image-upload-limits";
|
|
import { createLogger } from "@/lib/observability/logger";
|
|
import {
|
|
buildS3PublicUrl,
|
|
buildStorageObjectKey,
|
|
createS3Client,
|
|
getContentType,
|
|
maybeEnqueueStorageMigrationTask,
|
|
resolveS3UploadTarget,
|
|
} from "@/lib/storage/service";
|
|
import {
|
|
getOpenClawChatFileContentType,
|
|
isOpenClawChatFolderFileAllowed,
|
|
OPENCLAW_CHAT_FILE_MAX_BYTES,
|
|
OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE,
|
|
OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE,
|
|
OPENCLAW_CHAT_VIDEO_MAX_BYTES,
|
|
OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE,
|
|
} from "@/lib/openclaw-chat/media-attachments";
|
|
|
|
const logger = createLogger("direct-upload-api");
|
|
const DIRECT_UPLOAD_MAX_BYTES = OPENCLAW_CHAT_FILE_MAX_BYTES;
|
|
const DIRECT_UPLOAD_MEDIA_MAX_BYTES = 500 * 1024 * 1024;
|
|
const MULTIPART_THRESHOLD_BYTES = 50 * 1024 * 1024;
|
|
const DEFAULT_PART_SIZE_BYTES = 8 * 1024 * 1024;
|
|
const PRESIGNED_URL_EXPIRES_SECONDS = 6 * 60 * 60;
|
|
const DIRECT_UPLOAD_PREFIX = "uploads/direct";
|
|
|
|
function elapsedMs(startedAt: number) {
|
|
return Date.now() - startedAt;
|
|
}
|
|
|
|
const allowedDirectUploadTypes = new Set([
|
|
"image/jpeg",
|
|
"image/jpg",
|
|
"image/png",
|
|
"image/webp",
|
|
]);
|
|
const allowedOpenClawVideoUploadTypes = new Set([
|
|
"video/mp4",
|
|
"video/quicktime",
|
|
"video/webm",
|
|
"video/x-m4v",
|
|
"video/x-matroska",
|
|
]);
|
|
|
|
const InitiateSchema = z.object({
|
|
action: z.literal("initiate"),
|
|
filename: z.string().min(1).max(256),
|
|
contentType: z.string().min(1).max(128),
|
|
size: z.number().int().positive().max(DIRECT_UPLOAD_MAX_BYTES),
|
|
purpose: z.string().max(64).optional(),
|
|
clientUploadId: z.string().max(128).optional(),
|
|
});
|
|
|
|
const CompleteSchema = z.object({
|
|
action: z.literal("complete"),
|
|
key: z.string().min(1).max(512),
|
|
uploadId: z.string().min(1).max(512).optional(),
|
|
filename: z.string().min(1).max(256),
|
|
contentType: z.string().min(1).max(128),
|
|
size: z.number().int().positive().max(DIRECT_UPLOAD_MAX_BYTES),
|
|
parts: z
|
|
.array(
|
|
z.object({
|
|
ETag: z.string().min(1),
|
|
PartNumber: z.number().int().positive(),
|
|
})
|
|
)
|
|
.optional(),
|
|
purpose: z.string().max(64).optional(),
|
|
clientUploadId: z.string().max(128).optional(),
|
|
});
|
|
|
|
const ResumeSchema = z.object({
|
|
action: z.literal("resume"),
|
|
key: z.string().min(1).max(512),
|
|
uploadId: z.string().min(1).max(512),
|
|
filename: z.string().min(1).max(256),
|
|
contentType: z.string().min(1).max(128),
|
|
size: z.number().int().positive().max(DIRECT_UPLOAD_MAX_BYTES),
|
|
partSize: z.number().int().min(5 * 1024 * 1024).max(128 * 1024 * 1024),
|
|
purpose: z.string().max(64).optional(),
|
|
clientUploadId: z.string().max(128).optional(),
|
|
});
|
|
|
|
const AbortSchema = z.object({
|
|
action: z.literal("abort"),
|
|
key: z.string().min(1).max(512),
|
|
uploadId: z.string().min(1).max(512),
|
|
clientUploadId: z.string().max(128).optional(),
|
|
});
|
|
|
|
const RequestSchema = z.discriminatedUnion("action", [
|
|
InitiateSchema,
|
|
ResumeSchema,
|
|
CompleteSchema,
|
|
AbortSchema,
|
|
]);
|
|
|
|
function normalizeContentType(contentType: string, filename: string) {
|
|
const trimmed = contentType.trim().toLowerCase();
|
|
return trimmed || getContentType(filename);
|
|
}
|
|
|
|
function sanitizeDisplayName(filename: string) {
|
|
return (
|
|
filename
|
|
.trim()
|
|
.replace(/[^\u4e00-\u9fa5a-zA-Z0-9._-]+/g, "-")
|
|
.replace(/^-+|-+$/g, "")
|
|
.slice(0, 120) || `upload-${Date.now()}`
|
|
);
|
|
}
|
|
|
|
function userUploadPrefix(userId: string) {
|
|
return `${DIRECT_UPLOAD_PREFIX}/${userId}`;
|
|
}
|
|
|
|
function assertUserOwnedKey(key: string, userId: string) {
|
|
const normalized = String(key || "").replace(/^\/+/, "");
|
|
const prefix = `${userUploadPrefix(userId)}/`;
|
|
if (!normalized.startsWith(prefix)) {
|
|
const error = new Error("Invalid upload object key");
|
|
error.name = "InvalidUploadObjectKeyError";
|
|
throw error;
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
function isAllowedDirectUpload(
|
|
contentType: string,
|
|
purpose: string | undefined,
|
|
filename: string
|
|
) {
|
|
return (
|
|
allowedDirectUploadTypes.has(contentType) ||
|
|
(purpose === OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE &&
|
|
allowedOpenClawVideoUploadTypes.has(contentType)) ||
|
|
(purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE &&
|
|
Boolean(
|
|
getOpenClawChatFileContentType({ name: filename, type: contentType })
|
|
)) ||
|
|
(purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE &&
|
|
isOpenClawChatFolderFileAllowed({ name: filename, type: contentType }))
|
|
);
|
|
}
|
|
|
|
function getPurposeMaxBytes(purpose?: string, contentType?: string) {
|
|
if (String(contentType || "").toLowerCase().startsWith("image/")) {
|
|
return IMAGE_UPLOAD_MAX_BYTES;
|
|
}
|
|
if (purpose === OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE) {
|
|
return OPENCLAW_CHAT_VIDEO_MAX_BYTES;
|
|
}
|
|
if (
|
|
purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE ||
|
|
purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
) {
|
|
return DIRECT_UPLOAD_MAX_BYTES;
|
|
}
|
|
return DIRECT_UPLOAD_MEDIA_MAX_BYTES;
|
|
}
|
|
|
|
function computePartSize(size: number) {
|
|
if (size <= 100 * 1024 * 1024) return DEFAULT_PART_SIZE_BYTES;
|
|
if (size <= 500 * 1024 * 1024) return 16 * 1024 * 1024;
|
|
if (size <= 1024 * 1024 * 1024) return 32 * 1024 * 1024;
|
|
return 64 * 1024 * 1024;
|
|
}
|
|
|
|
async function createPartUrls(params: {
|
|
client: ReturnType<typeof createS3Client>;
|
|
bucket: string;
|
|
key: string;
|
|
uploadId: string;
|
|
partNumbers: number[];
|
|
}) {
|
|
return Promise.all(
|
|
params.partNumbers.map(async (partNumber) => {
|
|
const command = new UploadPartCommand({
|
|
Bucket: params.bucket,
|
|
Key: params.key,
|
|
UploadId: params.uploadId,
|
|
PartNumber: partNumber,
|
|
});
|
|
return {
|
|
partNumber,
|
|
url: await getSignedUrl(params.client, command, {
|
|
expiresIn: PRESIGNED_URL_EXPIRES_SECONDS,
|
|
}),
|
|
};
|
|
})
|
|
);
|
|
}
|
|
|
|
export async function POST(request: Request) {
|
|
const requestStartedAt = Date.now();
|
|
const session = await auth();
|
|
if (!session?.user?.id) {
|
|
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
|
|
}
|
|
|
|
let payload: z.infer<typeof RequestSchema>;
|
|
try {
|
|
payload = RequestSchema.parse(await request.json());
|
|
} catch (error) {
|
|
return NextResponse.json(
|
|
{
|
|
error: "Invalid direct upload request",
|
|
details: error instanceof Error ? error.message : String(error),
|
|
},
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
logger.info("direct_upload_request_start", {
|
|
action: payload.action,
|
|
size: "size" in payload ? payload.size : null,
|
|
contentType: "contentType" in payload ? payload.contentType : null,
|
|
purpose: "purpose" in payload ? payload.purpose || null : null,
|
|
clientUploadId:
|
|
"clientUploadId" in payload ? payload.clientUploadId || null : null,
|
|
});
|
|
|
|
const resolveStartedAt = Date.now();
|
|
const target = await resolveS3UploadTarget().catch((error) => {
|
|
logger.error("resolve_storage_target_failed", error);
|
|
return null;
|
|
});
|
|
|
|
if (!target) {
|
|
return NextResponse.json(
|
|
{ error: "Direct upload is not available for current storage backend" },
|
|
{ status: 409 }
|
|
);
|
|
}
|
|
logger.info("direct_upload_storage_target_resolved", {
|
|
action: payload.action,
|
|
elapsedMs: elapsedMs(resolveStartedAt),
|
|
provider: target.config.provider || "s3",
|
|
bucket: target.config.bucket,
|
|
hasPublicUrl: Boolean(target.config.publicUrl),
|
|
});
|
|
|
|
const client = createS3Client(target.config);
|
|
const bucket = target.config.bucket;
|
|
const usePublicReadAcl = target.config.provider !== "qiniu-kodo";
|
|
|
|
try {
|
|
if (payload.action === "initiate") {
|
|
const contentType = normalizeContentType(
|
|
payload.contentType,
|
|
payload.filename
|
|
);
|
|
|
|
if (!isAllowedDirectUpload(contentType, payload.purpose, payload.filename)) {
|
|
logger.warn("unsupported_direct_upload_type", {
|
|
contentType,
|
|
filenameExtension: payload.filename.toLowerCase().split(".").pop() || null,
|
|
size: payload.size,
|
|
purpose: payload.purpose || null,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
return NextResponse.json(
|
|
{
|
|
error:
|
|
"直传仅支持图片、Claw 视频、压缩包、表格和文件夹清单",
|
|
},
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
const maxBytes = getPurposeMaxBytes(payload.purpose, contentType);
|
|
if (payload.size > maxBytes) {
|
|
return NextResponse.json(
|
|
{
|
|
error: contentType.startsWith("image/")
|
|
? IMAGE_UPLOAD_TOO_LARGE_MESSAGE
|
|
: `文件不能超过 ${maxBytes / 1024 / 1024}MB`,
|
|
},
|
|
{ status: 413 }
|
|
);
|
|
}
|
|
|
|
const displayName = sanitizeDisplayName(payload.filename);
|
|
const key = buildStorageObjectKey(
|
|
displayName,
|
|
userUploadPrefix(session.user.id)
|
|
);
|
|
|
|
const multipartThreshold =
|
|
payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE ||
|
|
payload.purpose === OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE ||
|
|
payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? DEFAULT_PART_SIZE_BYTES
|
|
: MULTIPART_THRESHOLD_BYTES;
|
|
if (payload.size < multipartThreshold) {
|
|
const presignStartedAt = Date.now();
|
|
const command = new PutObjectCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
ContentType: contentType,
|
|
CacheControl: "public, max-age=31536000, immutable",
|
|
...(usePublicReadAcl ? { ACL: "public-read" as const } : {}),
|
|
});
|
|
const url = await getSignedUrl(client, command, {
|
|
expiresIn: PRESIGNED_URL_EXPIRES_SECONDS,
|
|
});
|
|
logger.info("direct_upload_single_presigned", {
|
|
elapsedMs: elapsedMs(presignStartedAt),
|
|
totalElapsedMs: elapsedMs(requestStartedAt),
|
|
size: payload.size,
|
|
contentType,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
const headers: Record<string, string> = {
|
|
"Content-Type": contentType,
|
|
"Cache-Control": "public, max-age=31536000, immutable",
|
|
};
|
|
if (usePublicReadAcl) {
|
|
headers["x-amz-acl"] = "public-read";
|
|
}
|
|
|
|
return NextResponse.json({
|
|
mode: "single",
|
|
key,
|
|
url,
|
|
headers,
|
|
expiresIn: PRESIGNED_URL_EXPIRES_SECONDS,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
}
|
|
|
|
const multipartStartedAt = Date.now();
|
|
const createResult = await client.send(
|
|
new CreateMultipartUploadCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
ContentType: contentType,
|
|
CacheControl: "public, max-age=31536000, immutable",
|
|
...(usePublicReadAcl ? { ACL: "public-read" as const } : {}),
|
|
})
|
|
);
|
|
|
|
const uploadId = createResult.UploadId;
|
|
if (!uploadId) {
|
|
throw new Error("Storage provider did not return uploadId");
|
|
}
|
|
|
|
const partSize = computePartSize(payload.size);
|
|
const partCount = Math.ceil(payload.size / partSize);
|
|
const parts = await createPartUrls({
|
|
client,
|
|
bucket,
|
|
key,
|
|
uploadId,
|
|
partNumbers: Array.from({ length: partCount }, (_, index) => index + 1),
|
|
});
|
|
logger.info("direct_upload_multipart_prepared", {
|
|
elapsedMs: elapsedMs(multipartStartedAt),
|
|
totalElapsedMs: elapsedMs(requestStartedAt),
|
|
size: payload.size,
|
|
partCount,
|
|
partSize,
|
|
contentType,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
|
|
return NextResponse.json({
|
|
mode: "multipart",
|
|
key,
|
|
uploadId,
|
|
partSize,
|
|
partCount,
|
|
parts,
|
|
expiresIn: PRESIGNED_URL_EXPIRES_SECONDS,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
}
|
|
|
|
if (payload.action === "resume") {
|
|
const key = assertUserOwnedKey(payload.key, session.user.id);
|
|
const contentType = normalizeContentType(payload.contentType, payload.filename);
|
|
if (!isAllowedDirectUpload(contentType, payload.purpose, payload.filename)) {
|
|
return NextResponse.json({ error: "不支持续传该文件类型" }, { status: 400 });
|
|
}
|
|
if (payload.size > getPurposeMaxBytes(payload.purpose, contentType)) {
|
|
return NextResponse.json(
|
|
{
|
|
error: contentType.startsWith("image/")
|
|
? IMAGE_UPLOAD_TOO_LARGE_MESSAGE
|
|
: "文件超过允许的上传大小",
|
|
},
|
|
{ status: 413 }
|
|
);
|
|
}
|
|
const expectedPartSize = computePartSize(payload.size);
|
|
if (payload.partSize !== expectedPartSize) {
|
|
return NextResponse.json(
|
|
{ error: "续传分片参数已失效，请重新开始上传", code: "RESUME_SESSION_EXPIRED" },
|
|
{ status: 409 }
|
|
);
|
|
}
|
|
|
|
try {
|
|
const listed = await client.send(
|
|
new ListPartsCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
UploadId: payload.uploadId,
|
|
MaxParts: 1000,
|
|
})
|
|
);
|
|
const uploadedParts = (listed.Parts || []).flatMap((part) => {
|
|
if (!part.ETag || typeof part.PartNumber !== "number") return [];
|
|
return [
|
|
{
|
|
ETag: part.ETag,
|
|
PartNumber: part.PartNumber,
|
|
size: Number(part.Size || 0),
|
|
},
|
|
];
|
|
});
|
|
const uploadedPartNumbers = new Set(
|
|
uploadedParts.map((part) => part.PartNumber)
|
|
);
|
|
const partCount = Math.ceil(payload.size / expectedPartSize);
|
|
const missingPartNumbers = Array.from(
|
|
{ length: partCount },
|
|
(_, index) => index + 1
|
|
).filter((partNumber) => !uploadedPartNumbers.has(partNumber));
|
|
const parts = await createPartUrls({
|
|
client,
|
|
bucket,
|
|
key,
|
|
uploadId: payload.uploadId,
|
|
partNumbers: missingPartNumbers,
|
|
});
|
|
|
|
logger.info("direct_upload_multipart_resumed", {
|
|
totalElapsedMs: elapsedMs(requestStartedAt),
|
|
size: payload.size,
|
|
uploadedPartCount: uploadedParts.length,
|
|
missingPartCount: missingPartNumbers.length,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
return NextResponse.json({
|
|
mode: "multipart",
|
|
key,
|
|
uploadId: payload.uploadId,
|
|
partSize: expectedPartSize,
|
|
partCount,
|
|
parts,
|
|
uploadedParts,
|
|
resumed: true,
|
|
expiresIn: PRESIGNED_URL_EXPIRES_SECONDS,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
} catch (error) {
|
|
const head = await client
|
|
.send(new HeadObjectCommand({ Bucket: bucket, Key: key }))
|
|
.catch(() => null);
|
|
if (head?.ContentLength === payload.size) {
|
|
return NextResponse.json({
|
|
mode: "completed",
|
|
key,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
}
|
|
logger.warn("direct_upload_resume_session_missing", error, {
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
return NextResponse.json(
|
|
{ error: "续传会话已失效，请重新开始上传", code: "RESUME_SESSION_EXPIRED" },
|
|
{ status: 409 }
|
|
);
|
|
}
|
|
}
|
|
|
|
if (payload.action === "abort") {
|
|
const key = assertUserOwnedKey(payload.key, session.user.id);
|
|
const abortStartedAt = Date.now();
|
|
await client.send(
|
|
new AbortMultipartUploadCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
UploadId: payload.uploadId,
|
|
})
|
|
);
|
|
logger.info("direct_upload_multipart_aborted", {
|
|
elapsedMs: elapsedMs(abortStartedAt),
|
|
totalElapsedMs: elapsedMs(requestStartedAt),
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
return NextResponse.json({ ok: true });
|
|
}
|
|
|
|
const key = assertUserOwnedKey(payload.key, session.user.id);
|
|
const contentType = normalizeContentType(payload.contentType, payload.filename);
|
|
if (!isAllowedDirectUpload(contentType, payload.purpose, payload.filename)) {
|
|
return NextResponse.json(
|
|
{
|
|
error:
|
|
"直传仅支持图片、Claw 视频、压缩包、表格和文件夹清单",
|
|
},
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
if (payload.size > getPurposeMaxBytes(payload.purpose, contentType)) {
|
|
return NextResponse.json(
|
|
{
|
|
error: contentType.startsWith("image/")
|
|
? IMAGE_UPLOAD_TOO_LARGE_MESSAGE
|
|
: "文件超过允许的上传大小",
|
|
},
|
|
{ status: 413 }
|
|
);
|
|
}
|
|
|
|
if (payload.uploadId) {
|
|
const completeMultipartStartedAt = Date.now();
|
|
const parts = [...(payload.parts || [])].sort(
|
|
(a, b) => a.PartNumber - b.PartNumber
|
|
);
|
|
if (parts.length === 0) {
|
|
return NextResponse.json(
|
|
{ error: "Missing multipart upload parts" },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
await client.send(
|
|
new CompleteMultipartUploadCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
UploadId: payload.uploadId,
|
|
MultipartUpload: {
|
|
Parts: parts,
|
|
},
|
|
})
|
|
);
|
|
logger.info("direct_upload_multipart_completed", {
|
|
elapsedMs: elapsedMs(completeMultipartStartedAt),
|
|
partCount: parts.length,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
}
|
|
|
|
const headStartedAt = Date.now();
|
|
const head = await client.send(
|
|
new HeadObjectCommand({
|
|
Bucket: bucket,
|
|
Key: key,
|
|
})
|
|
);
|
|
logger.info("direct_upload_head_object_completed", {
|
|
elapsedMs: elapsedMs(headStartedAt),
|
|
uploadMode: payload.uploadId ? "multipart" : "single",
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
|
|
const actualSize =
|
|
typeof head.ContentLength === "number" ? head.ContentLength : null;
|
|
if (actualSize !== null && actualSize !== payload.size) {
|
|
throw new Error(
|
|
`Uploaded object size mismatch: expected ${payload.size}, received ${actualSize}`
|
|
);
|
|
}
|
|
|
|
const url = buildS3PublicUrl(target.config, key);
|
|
const resolvedContentType =
|
|
head.ContentType || contentType || getContentType(payload.filename);
|
|
const assetStartedAt = Date.now();
|
|
const asset = await upsertMediaAsset({
|
|
userId: session.user.id,
|
|
mediaType:
|
|
payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE ||
|
|
payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? "file"
|
|
: resolvedContentType.startsWith("video/")
|
|
? "video"
|
|
: "image",
|
|
sourceType:
|
|
payload.purpose === OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE
|
|
? "openclaw_chat_video_upload"
|
|
: payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE
|
|
? "openclaw_chat_file_upload"
|
|
: payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? "openclaw_chat_folder_file_upload"
|
|
: "upload",
|
|
status: "ready",
|
|
originalUrl: url,
|
|
previewUrl:
|
|
payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE ||
|
|
payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? null
|
|
: url,
|
|
thumbnailUrl:
|
|
payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE ||
|
|
payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? null
|
|
: url,
|
|
mimeType: resolvedContentType,
|
|
displayName: payload.filename,
|
|
sourceTable:
|
|
payload.purpose === OPENCLAW_CHAT_VIDEO_UPLOAD_PURPOSE
|
|
? "openclaw_chat_video_upload"
|
|
: payload.purpose === OPENCLAW_CHAT_FILE_UPLOAD_PURPOSE
|
|
? "openclaw_chat_file_upload"
|
|
: payload.purpose === OPENCLAW_CHAT_FOLDER_UPLOAD_PURPOSE
|
|
? "openclaw_chat_folder_file_upload"
|
|
: "direct_upload",
|
|
metadata: {
|
|
pathname: key,
|
|
size: actualSize ?? payload.size,
|
|
expectedSize: payload.size,
|
|
uploadMode: payload.uploadId ? "multipart" : "single",
|
|
purpose: payload.purpose || null,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
},
|
|
});
|
|
logger.info("direct_upload_asset_registered", {
|
|
elapsedMs: elapsedMs(assetStartedAt),
|
|
totalElapsedMs: elapsedMs(requestStartedAt),
|
|
uploadMode: payload.uploadId ? "multipart" : "single",
|
|
assetId: asset?.id ?? null,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
|
|
await maybeEnqueueStorageMigrationTask({
|
|
uploaded: { url, pathname: key },
|
|
storageConfig: target.storageConfig,
|
|
migrationConfig: target.migrationConfig,
|
|
}).catch((error) => {
|
|
logger.warn("enqueue_storage_migration_failed", error);
|
|
});
|
|
|
|
return NextResponse.json({
|
|
url,
|
|
pathname: key,
|
|
contentType: resolvedContentType,
|
|
assetId: asset?.id ?? null,
|
|
clientUploadId: payload.clientUploadId || null,
|
|
});
|
|
} catch (error) {
|
|
logger.error("direct_upload_request_failed", error, {
|
|
action: payload.action,
|
|
size: "size" in payload ? payload.size : null,
|
|
contentType: "contentType" in payload ? payload.contentType : null,
|
|
purpose: "purpose" in payload ? payload.purpose || null : null,
|
|
clientUploadId:
|
|
"clientUploadId" in payload ? payload.clientUploadId || null : null,
|
|
});
|
|
return NextResponse.json(
|
|
{
|
|
error: "Direct upload failed",
|
|
details: error instanceof Error ? error.message : String(error),
|
|
},
|
|
{
|
|
status:
|
|
error instanceof Error &&
|
|
error.name === "InvalidUploadObjectKeyError"
|
|
? 403
|
|
: 500,
|
|
}
|
|
);
|
|
}
|
|
}
|