feat: media upload by URL and base64 with whitelist and size limit
MediaImporter streams URL imports via wp_safe_remote_get with limit_response_size, checks Content-Length, intersects the MIME whitelist with get_allowed_mime_types and validates real content; base64 is size-checked before decoding. Server-side failures are write_failed; a failed alt text deletes the new attachment again (or partial_write). MediaUploads is the shared permission/result helper of both upload abilities. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01At3V6SjwbMe6eMzVGW3Hs7
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,279 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace LIT\MCP\Integrations\Media;
|
||||
|
||||
use LIT\MCP\Abilities\Errors;
|
||||
use LIT\MCP\Abilities\WriteFailed;
|
||||
use LIT\MCP\Limits;
|
||||
use Throwable;
|
||||
use WP_Error;
|
||||
|
||||
/**
|
||||
* Imports files into the media library (spec §6.3, §10).
|
||||
*
|
||||
* - URL: only http(s), checked with wp_http_validate_url() before any request and fetched
|
||||
* with wp_safe_remote_get() (rejects internal addresses, also after redirects), streamed
|
||||
* into a temp file and cut off one byte above the upload limit.
|
||||
* - Base64: decoded strictly; the size is checked before anything is decoded or written.
|
||||
* - Type: whitelist (filter lit_mcp_upload_mimes) intersected with what WordPress allows the
|
||||
* current user (SVG etc. only if WordPress itself allows it), checked against the real
|
||||
* file content with wp_check_filetype_and_ext() – disguised files fail.
|
||||
*
|
||||
* Input problems (URL, size, type) are validation errors; server-side failures are
|
||||
* write_failed. If the alt text cannot be saved after the attachment exists, the brand-new
|
||||
* attachment is deleted again (WriteFailed, rolled back) or – if that fails too – a partial
|
||||
* WriteFailed names the attachment. The temp file is removed on every path.
|
||||
* Not final so abilities can be tested with a mock.
|
||||
*/
|
||||
class MediaImporter
|
||||
{
|
||||
public const MIMES = [
|
||||
'jpg|jpeg|jpe' => 'image/jpeg',
|
||||
'png' => 'image/png',
|
||||
'gif' => 'image/gif',
|
||||
'webp' => 'image/webp',
|
||||
'avif' => 'image/avif',
|
||||
'pdf' => 'application/pdf',
|
||||
'mp4|m4v' => 'video/mp4',
|
||||
'mp3' => 'audio/mpeg',
|
||||
];
|
||||
|
||||
private const TIMEOUT = 30;
|
||||
private const ALT_KEY = '_wp_attachment_image_alt';
|
||||
|
||||
public function __construct(private Limits $limits)
|
||||
{
|
||||
}
|
||||
|
||||
/** @param array{title?: string, alt?: string, post_id?: int} $meta */
|
||||
public function fromUrl(string $url, ?string $filename, array $meta): int|WP_Error
|
||||
{
|
||||
$scheme = strtolower((string) wp_parse_url($url, PHP_URL_SCHEME));
|
||||
if (! in_array($scheme, ['http', 'https'], true) || ! wp_http_validate_url($url)) {
|
||||
return Errors::invalidInput(
|
||||
'Die URL ist nicht erlaubt.',
|
||||
['url' => 'nur öffentlich erreichbare http(s)-Adressen'],
|
||||
'Eine öffentlich erreichbare Datei-URL angeben (keine internen oder lokalen Adressen).'
|
||||
);
|
||||
}
|
||||
|
||||
AdminIncludes::load();
|
||||
$tmp = (string) wp_tempnam('lit-mcp-import');
|
||||
try {
|
||||
$response = $this->download($url, $tmp);
|
||||
if ($response instanceof WP_Error) {
|
||||
return $response;
|
||||
}
|
||||
|
||||
$name = $filename ?? wp_basename((string) wp_parse_url($url, PHP_URL_PATH));
|
||||
|
||||
return $this->import($tmp, $this->withExtension($name, $response), $meta);
|
||||
} finally {
|
||||
$this->removeTemp($tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/** @param array{title?: string, alt?: string, post_id?: int} $meta */
|
||||
public function fromBase64(string $data, string $filename, array $meta): int|WP_Error
|
||||
{
|
||||
$estimated = intdiv(strlen($data) * 3, 4);
|
||||
if ($estimated > $this->limits->uploadBytes() + 2) {
|
||||
return $this->tooLarge($estimated);
|
||||
}
|
||||
|
||||
$bytes = base64_decode($data, true);
|
||||
if ($bytes === false || $bytes === '') {
|
||||
return Errors::invalidInput(
|
||||
'data ist kein gültiges Base64.',
|
||||
['data' => 'Base64-kodierter Dateiinhalt erwartet (ohne data:-Präfix)']
|
||||
);
|
||||
}
|
||||
|
||||
if (strlen($bytes) > $this->limits->uploadBytes()) {
|
||||
return $this->tooLarge(strlen($bytes));
|
||||
}
|
||||
|
||||
AdminIncludes::load();
|
||||
$tmp = (string) wp_tempnam('lit-mcp-upload');
|
||||
try {
|
||||
// phpcs:ignore WordPress.WP.AlternativeFunctions.file_system_operations_file_put_contents -- temp file.
|
||||
if ($tmp === '' || file_put_contents($tmp, $bytes) === false) {
|
||||
return Errors::writeFailed('Die temporäre Datei konnte nicht geschrieben werden.');
|
||||
}
|
||||
|
||||
return $this->import($tmp, $filename, $meta);
|
||||
} finally {
|
||||
$this->removeTemp($tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/** @return array<string, mixed>|WP_Error The response (body streamed into $tmp). */
|
||||
private function download(string $url, string $tmp): array|WP_Error
|
||||
{
|
||||
$response = wp_safe_remote_get($url, [
|
||||
'timeout' => self::TIMEOUT,
|
||||
'stream' => true,
|
||||
'filename' => $tmp,
|
||||
'limit_response_size' => $this->limits->uploadBytes() + 1,
|
||||
]);
|
||||
if ($response instanceof WP_Error) {
|
||||
return $this->downloadFailed($response->get_error_message());
|
||||
}
|
||||
|
||||
$status = (int) wp_remote_retrieve_response_code($response);
|
||||
if ($status !== 200) {
|
||||
return $this->downloadFailed(sprintf('HTTP-Status %d', $status));
|
||||
}
|
||||
|
||||
$length = (string) wp_remote_retrieve_header($response, 'content-length');
|
||||
if (ctype_digit($length) && (int) $length > $this->limits->uploadBytes()) {
|
||||
return $this->tooLarge((int) $length, 'url');
|
||||
}
|
||||
|
||||
return $response;
|
||||
}
|
||||
|
||||
/** @param array{title?: string, alt?: string, post_id?: int} $meta */
|
||||
private function import(string $tmp, string $filename, array $meta): int|WP_Error
|
||||
{
|
||||
clearstatcache(true, $tmp);
|
||||
$size = (int) filesize($tmp);
|
||||
if ($size > $this->limits->uploadBytes()) {
|
||||
return $this->tooLarge($size);
|
||||
}
|
||||
|
||||
$mimes = $this->allowedMimes();
|
||||
$name = sanitize_file_name($filename !== '' ? $filename : 'datei');
|
||||
$check = wp_check_filetype_and_ext($tmp, $name, $mimes);
|
||||
if (empty($check['type']) || empty($check['ext'])) {
|
||||
return Errors::invalidInput(
|
||||
'Dateityp nicht erlaubt oder Inhalt passt nicht zur Endung.',
|
||||
['filename' => 'erlaubt: ' . str_replace('|', ', ', implode(', ', array_keys($mimes)))],
|
||||
'Nur erlaubte Dateitypen hochladen (Bilder, PDF, MP4, MP3) und die passende Endung verwenden.'
|
||||
);
|
||||
}
|
||||
|
||||
if (! empty($check['proper_filename'])) {
|
||||
$name = (string) $check['proper_filename'];
|
||||
}
|
||||
|
||||
$title = isset($meta['title']) ? sanitize_text_field((string) $meta['title']) : null;
|
||||
$attachmentId = media_handle_sideload(
|
||||
['name' => $name, 'tmp_name' => $tmp],
|
||||
(int) ($meta['post_id'] ?? 0),
|
||||
$title
|
||||
);
|
||||
if ($attachmentId instanceof WP_Error) {
|
||||
$reason = 'WordPress hat die Datei nicht übernommen: ' . $attachmentId->get_error_message();
|
||||
|
||||
return Errors::writeFailed($reason);
|
||||
}
|
||||
|
||||
$attachmentId = (int) $attachmentId;
|
||||
if (isset($meta['alt']) && $meta['alt'] !== '') {
|
||||
$this->saveAlt($attachmentId, sanitize_text_field((string) $meta['alt']));
|
||||
}
|
||||
|
||||
return $attachmentId;
|
||||
}
|
||||
|
||||
/** @throws WriteFailed When the alt text cannot be saved (attachment deleted again if possible). */
|
||||
private function saveAlt(int $attachmentId, string $alt): void
|
||||
{
|
||||
// update_post_meta() is also false when the value is already stored (alt from IPTC data).
|
||||
$stored = update_post_meta($attachmentId, self::ALT_KEY, $alt) !== false
|
||||
|| (string) get_post_meta($attachmentId, self::ALT_KEY, true) === $alt;
|
||||
if ($stored) {
|
||||
return;
|
||||
}
|
||||
|
||||
$reason = 'Der Alt-Text konnte nicht gespeichert werden.';
|
||||
$detail = sprintf('alt text of new attachment %d could not be saved', $attachmentId);
|
||||
try {
|
||||
$deleted = (bool) wp_delete_attachment($attachmentId, true);
|
||||
} catch (Throwable $e) {
|
||||
$deleted = false;
|
||||
$detail .= '; delete failed: ' . $e->getMessage();
|
||||
}
|
||||
|
||||
if ($deleted) {
|
||||
throw new WriteFailed($reason, true, null, null, null, $detail);
|
||||
}
|
||||
|
||||
throw new WriteFailed(
|
||||
$reason,
|
||||
false,
|
||||
$attachmentId,
|
||||
null,
|
||||
null,
|
||||
$detail . '; attachment could not be deleted',
|
||||
sprintf('Medium %d wurde trotzdem angelegt, aber ohne Alt-Text.', $attachmentId),
|
||||
'Den Aufruf nicht wiederholen (sonst liegt die Datei doppelt vor). Medium mit lit/media-get prüfen, den '
|
||||
. 'Alt-Text in der Mediathek nachtragen und dem Nutzer Bescheid geben.',
|
||||
['attachment_id' => $attachmentId]
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Whitelist (filterable) restricted to what WordPress allows the current user.
|
||||
*
|
||||
* @return array<string, string>
|
||||
*/
|
||||
private function allowedMimes(): array
|
||||
{
|
||||
$mimes = apply_filters('lit_mcp_upload_mimes', self::MIMES);
|
||||
$mimes = is_array($mimes) ? $mimes : self::MIMES;
|
||||
$allowed = get_allowed_mime_types();
|
||||
|
||||
return array_intersect_key($mimes, is_array($allowed) ? $allowed : []);
|
||||
}
|
||||
|
||||
/**
|
||||
* URLs without an extension (CDNs, image services): take it from the Content-Type
|
||||
* header, if that type is allowed. The real content is checked afterwards anyway.
|
||||
*
|
||||
* @param array<string, mixed> $response
|
||||
*/
|
||||
private function withExtension(string $name, array $response): string
|
||||
{
|
||||
if ($name !== '' && pathinfo($name, PATHINFO_EXTENSION) !== '') {
|
||||
return $name;
|
||||
}
|
||||
|
||||
$type = strtolower(trim(explode(';', (string) wp_remote_retrieve_header($response, 'content-type'))[0]));
|
||||
foreach ($this->allowedMimes() as $extensions => $mime) {
|
||||
if ($mime === $type) {
|
||||
return ($name !== '' ? $name : 'datei') . '.' . explode('|', $extensions)[0];
|
||||
}
|
||||
}
|
||||
|
||||
return $name;
|
||||
}
|
||||
|
||||
private function removeTemp(string $tmp): void
|
||||
{
|
||||
if ($tmp !== '' && file_exists($tmp)) {
|
||||
wp_delete_file($tmp);
|
||||
}
|
||||
}
|
||||
|
||||
private function downloadFailed(string $reason): WP_Error
|
||||
{
|
||||
return Errors::invalidInput(
|
||||
'Download fehlgeschlagen: ' . $reason,
|
||||
['url' => 'nicht abrufbar'],
|
||||
'URL prüfen; nur öffentlich erreichbare Dateien können importiert werden.'
|
||||
);
|
||||
}
|
||||
|
||||
private function tooLarge(int $bytes, string $field = 'data'): WP_Error
|
||||
{
|
||||
return Errors::invalidInput(
|
||||
sprintf('Datei zu groß (%.1f MB, Limit %d MB).', $bytes / 1048576, $this->limits->uploadMegabytes()),
|
||||
[$field => 'über dem Upload-Limit'],
|
||||
'Kleinere Datei verwenden oder das Limit unter Einstellungen → LIT MCP → Limits erhöhen lassen.'
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -10,8 +10,8 @@ use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
|
||||
use LIT\MCP\Limits;
|
||||
|
||||
/**
|
||||
* Media library tools (spec §6.3). Always available. $log and $limits are used by the
|
||||
* write tools that follow (upload, update, delete).
|
||||
* Media library tools (spec §6.3). Always available. $log and $limits serve the write
|
||||
* tools (upload now, update and delete to follow).
|
||||
*/
|
||||
final class MediaIntegration implements Integration
|
||||
{
|
||||
@@ -33,11 +33,15 @@ final class MediaIntegration implements Integration
|
||||
{
|
||||
$presenter = new MediaPresenter();
|
||||
$finder = new MediaUsageFinder(fn (): array => $this->schema->mediaFieldKeys());
|
||||
$importer = new MediaImporter($this->limits);
|
||||
$uploads = new MediaUploads($presenter, $this->log, $this->schema);
|
||||
|
||||
return [
|
||||
new MediaSearchAbility($presenter, $finder),
|
||||
new MediaGetAbility($presenter, $finder),
|
||||
new MediaPreviewAbility(),
|
||||
new MediaUploadFromUrlAbility($importer, $uploads),
|
||||
new MediaUploadAbility($importer, $uploads, $this->limits),
|
||||
new MediaDownloadAbility($this->limits),
|
||||
];
|
||||
}
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace LIT\MCP\Integrations\Media;
|
||||
|
||||
use LIT\MCP\Abilities\Ability;
|
||||
use LIT\MCP\Limits;
|
||||
use WP_Error;
|
||||
|
||||
/**
|
||||
* Uploads a Base64-encoded file into the media library (spec §6.3), up to the configured
|
||||
* upload limit. Checks and cleanup: MediaImporter; permission and result: MediaUploads.
|
||||
*/
|
||||
final class MediaUploadAbility implements Ability
|
||||
{
|
||||
public function __construct(
|
||||
private MediaImporter $importer,
|
||||
private MediaUploads $uploads,
|
||||
private Limits $limits
|
||||
) {
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'lit/media-upload';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Medium hochladen';
|
||||
}
|
||||
|
||||
public function description(): string
|
||||
{
|
||||
return sprintf(
|
||||
'Lädt eine Datei (Bild, PDF, MP4, MP3) als Base64 in die Mediathek, höchstens %d MB; optional mit '
|
||||
. 'Titel, Alt-Text und Zuordnung zu einem Eintrag (post_id). Nicht idempotent: jeder Aufruf legt '
|
||||
. 'ein neues Medium an.',
|
||||
$this->limits->uploadMegabytes()
|
||||
);
|
||||
}
|
||||
|
||||
public function inputSchema(): array
|
||||
{
|
||||
return [
|
||||
'type' => 'object',
|
||||
'properties' => array_merge(
|
||||
[
|
||||
'filename' => ['type' => 'string', 'minLength' => 1, 'description' => 'Dateiname mit Endung.'],
|
||||
'data' => [
|
||||
'type' => 'string',
|
||||
'minLength' => 1,
|
||||
'description' => 'Dateiinhalt als Base64 (ohne data:-Präfix).',
|
||||
],
|
||||
],
|
||||
MediaUploads::metaProperties()
|
||||
),
|
||||
'required' => ['filename', 'data'],
|
||||
'additionalProperties' => false,
|
||||
];
|
||||
}
|
||||
|
||||
public function outputSchema(): ?array
|
||||
{
|
||||
return MediaUploads::outputSchema();
|
||||
}
|
||||
|
||||
public function annotations(): array
|
||||
{
|
||||
return ['readonly' => false, 'destructive' => false, 'idempotent' => false];
|
||||
}
|
||||
|
||||
public function isDirect(): bool
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function permission(array $input): bool|WP_Error
|
||||
{
|
||||
return $this->uploads->permission($input);
|
||||
}
|
||||
|
||||
public function execute(array $input): mixed
|
||||
{
|
||||
return $this->uploads->run(
|
||||
$this->name(),
|
||||
fn (): int|WP_Error => $this->importer->fromBase64(
|
||||
(string) $input['data'],
|
||||
(string) $input['filename'],
|
||||
MediaUploads::meta($input)
|
||||
),
|
||||
'Datei "%s" hochgeladen (ID %d)'
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace LIT\MCP\Integrations\Media;
|
||||
|
||||
use LIT\MCP\Abilities\Ability;
|
||||
use WP_Error;
|
||||
|
||||
/**
|
||||
* Imports a publicly reachable file into the media library (spec §6.3). Direct tool.
|
||||
* Download, checks and cleanup: MediaImporter; permission and result: MediaUploads.
|
||||
*/
|
||||
final class MediaUploadFromUrlAbility implements Ability
|
||||
{
|
||||
public function __construct(private MediaImporter $importer, private MediaUploads $uploads)
|
||||
{
|
||||
}
|
||||
|
||||
public function name(): string
|
||||
{
|
||||
return 'lit/media-upload-from-url';
|
||||
}
|
||||
|
||||
public function label(): string
|
||||
{
|
||||
return 'Medium von URL importieren';
|
||||
}
|
||||
|
||||
public function description(): string
|
||||
{
|
||||
return 'Lädt eine öffentlich erreichbare Datei (Bild, PDF, MP4, MP3) von einer http(s)-URL in die '
|
||||
. 'Mediathek; optional mit Titel, Alt-Text und Zuordnung zu einem Eintrag (post_id). Interne Adressen '
|
||||
. 'und Dateien über dem Upload-Limit werden abgelehnt. Nicht idempotent: jeder Aufruf legt ein neues '
|
||||
. 'Medium an.';
|
||||
}
|
||||
|
||||
public function inputSchema(): array
|
||||
{
|
||||
return [
|
||||
'type' => 'object',
|
||||
'properties' => array_merge(
|
||||
[
|
||||
'url' => ['type' => 'string', 'minLength' => 1, 'description' => 'http(s)-URL der Datei.'],
|
||||
'filename' => [
|
||||
'type' => 'string',
|
||||
'description' => 'Optional: Dateiname mit Endung (Standard: aus der URL).',
|
||||
],
|
||||
],
|
||||
MediaUploads::metaProperties()
|
||||
),
|
||||
'required' => ['url'],
|
||||
'additionalProperties' => false,
|
||||
];
|
||||
}
|
||||
|
||||
public function outputSchema(): ?array
|
||||
{
|
||||
return MediaUploads::outputSchema();
|
||||
}
|
||||
|
||||
public function annotations(): array
|
||||
{
|
||||
return ['readonly' => false, 'destructive' => false, 'idempotent' => false];
|
||||
}
|
||||
|
||||
public function isDirect(): bool
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
public function permission(array $input): bool|WP_Error
|
||||
{
|
||||
return $this->uploads->permission($input);
|
||||
}
|
||||
|
||||
public function execute(array $input): mixed
|
||||
{
|
||||
$filename = isset($input['filename']) && $input['filename'] !== '' ? (string) $input['filename'] : null;
|
||||
$url = (string) $input['url'];
|
||||
|
||||
return $this->uploads->run(
|
||||
$this->name(),
|
||||
fn (): int|WP_Error => $this->importer->fromUrl($url, $filename, MediaUploads::meta($input)),
|
||||
'Datei "%s" von URL importiert (ID %d)'
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace LIT\MCP\Integrations\Media;
|
||||
|
||||
use LIT\MCP\Abilities\Errors;
|
||||
use LIT\MCP\Abilities\FollowUp;
|
||||
use LIT\MCP\Abilities\ToolResult;
|
||||
use LIT\MCP\Abilities\WriteFailed;
|
||||
use LIT\MCP\ChangeLog\ChangeLog;
|
||||
use LIT\MCP\Integrations\WordPress\PostGuard;
|
||||
use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
|
||||
use WP_Error;
|
||||
use WP_Post;
|
||||
|
||||
/**
|
||||
* What both upload abilities share (lit/media-upload-from-url, lit/media-upload): the
|
||||
* permission check, running the import and building the result for the new attachment.
|
||||
* Once the attachment is saved, a failure of the change log or of reading it back is only a
|
||||
* warning – the upload itself must not turn into an error.
|
||||
*/
|
||||
final class MediaUploads
|
||||
{
|
||||
public function __construct(
|
||||
private MediaPresenter $presenter,
|
||||
private ChangeLog $log,
|
||||
private ContentSchema $schema
|
||||
) {
|
||||
}
|
||||
|
||||
/**
|
||||
* upload_files, and for post_id the right to edit that entry (it becomes the parent).
|
||||
*
|
||||
* @param array<string, mixed> $input
|
||||
*/
|
||||
public function permission(array $input): bool|WP_Error
|
||||
{
|
||||
if (! current_user_can('upload_files')) {
|
||||
return Errors::forbidden('Keine Berechtigung zum Hochladen (upload_files).');
|
||||
}
|
||||
|
||||
if (! isset($input['post_id'])) {
|
||||
return true;
|
||||
}
|
||||
|
||||
$parent = PostGuard::editable($input['post_id'], $this->schema);
|
||||
|
||||
return $parent instanceof WP_Error ? $parent : true;
|
||||
}
|
||||
|
||||
/** The meta fields the importer takes from the input. */
|
||||
public static function meta(array $input): array
|
||||
{
|
||||
return array_intersect_key($input, ['title' => true, 'alt' => true, 'post_id' => true]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs $import (returns the new attachment id or an error) and builds the result.
|
||||
*
|
||||
* @param callable(): (int|WP_Error) $import
|
||||
* @param string $done Summary with "%s" = title and "%d" = id,
|
||||
* e.g. 'Datei "%s" hochgeladen (ID %d)'.
|
||||
* @return array<string, mixed>|WP_Error
|
||||
* @throws WriteFailed From the importer; a partial one is logged as partial first.
|
||||
*/
|
||||
public function run(string $ability, callable $import, string $done): array|WP_Error
|
||||
{
|
||||
try {
|
||||
$attachmentId = $import();
|
||||
} catch (WriteFailed $e) {
|
||||
if (! $e->rolledBack && $e->postId !== null) {
|
||||
$summary = sprintf('Medium %d: Upload nur teilweise gespeichert', $e->postId);
|
||||
$this->log->recordPartial($ability, 'attachment', (string) $e->postId, $summary);
|
||||
}
|
||||
throw $e;
|
||||
}
|
||||
|
||||
if ($attachmentId instanceof WP_Error) {
|
||||
return $attachmentId;
|
||||
}
|
||||
|
||||
return $this->result($ability, (int) $attachmentId, $done);
|
||||
}
|
||||
|
||||
/** @return array<string, mixed> */
|
||||
private function result(string $ability, int $attachmentId, string $done): array
|
||||
{
|
||||
$warnings = [];
|
||||
$saved = sprintf('Medium %d ist gespeichert.', $attachmentId);
|
||||
$attachment = get_post($attachmentId);
|
||||
$title = $attachment instanceof WP_Post ? (string) $attachment->post_title : '';
|
||||
$details = $attachment instanceof WP_Post
|
||||
? FollowUp::run(
|
||||
fn (): array => $this->presenter->summary($attachment),
|
||||
$ability . ' summary',
|
||||
'Die Angaben zum Medium konnten nicht gelesen werden; ' . $saved,
|
||||
$warnings
|
||||
)
|
||||
: null;
|
||||
|
||||
$summary = sprintf($done, $title, $attachmentId);
|
||||
$logId = FollowUp::run(
|
||||
fn (): ?int => $this->log->record($ability, 'attachment', (string) $attachmentId, $summary),
|
||||
$ability . ' change log',
|
||||
'Änderungsprotokoll konnte nicht geschrieben werden; ' . $saved,
|
||||
$warnings
|
||||
);
|
||||
|
||||
return ToolResult::ok($summary . '.')
|
||||
->changed((string) $attachmentId, 'attachment', 'created', $title)
|
||||
->logId(is_int($logId) ? $logId : null)
|
||||
->warnings($warnings)
|
||||
->urls(null, (string) get_edit_post_link($attachmentId, 'raw'))
|
||||
->with('attachment', is_array($details) ? $details : $this->fallback($attachmentId, $title))
|
||||
->toArray();
|
||||
}
|
||||
|
||||
/** @return array<string, mixed> The required summary fields when the attachment cannot be read. */
|
||||
private function fallback(int $attachmentId, string $title): array
|
||||
{
|
||||
return [
|
||||
'id' => $attachmentId,
|
||||
'title' => $title,
|
||||
'mime_type' => '',
|
||||
'url' => (string) wp_get_attachment_url($attachmentId),
|
||||
'alt' => '',
|
||||
];
|
||||
}
|
||||
|
||||
/** @return array<string, mixed> */
|
||||
public static function outputSchema(): array
|
||||
{
|
||||
return ToolResult::schema(['attachment' => MediaPresenter::summarySchema()], ['attachment']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Input properties both abilities share.
|
||||
*
|
||||
* @return array<string, array<string, mixed>>
|
||||
*/
|
||||
public static function metaProperties(): array
|
||||
{
|
||||
return [
|
||||
'title' => ['type' => 'string', 'description' => 'Optional: Titel in der Mediathek.'],
|
||||
'alt' => ['type' => 'string', 'description' => 'Optional: Alt-Text (bei Bildern empfohlen).'],
|
||||
'post_id' => [
|
||||
'type' => 'integer',
|
||||
'minimum' => 1,
|
||||
'description' => 'Optional: Eintrag, dem das Medium zugeordnet wird (braucht Bearbeitungsrecht).',
|
||||
],
|
||||
];
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user