@yeaft/webchat-agent 1.0.522 → 1.0.523

package/connection/buffer.js

@@ -59,7 +59,7 @@ function bufferMessage(msg, reason) {
 
 const FILE_CHUNK_SEND_TIMEOUT_MS = 10_000;
 
-function sendFileChunk(socket, data) {
+function sendTransferChunk(socket, data) {
   // Production uses Node ws; retain compatibility with synchronous, one-argument
   // transport stubs without treating a real ws.send() return as a flushed write.
   if (!(socket instanceof WebSocket) && socket.send.length < 2) {
@@ -104,14 +104,14 @@ async function sendNow(msg, queuedSocket) {
   const socket = ctx.ws;
   if (!socket || socket.readyState !== WebSocket.OPEN) return bufferMessage(msg, 'Disconnected');
   // File transfers are request/connection scoped, unlike replayable chat output.
-  if (msg.type === 'file_content_chunk' && queuedSocket !== socket) return 'dropped';
+  if (['file_content_chunk', 'video_chunk'].includes(msg.type) && queuedSocket !== socket) return 'dropped';
   const payload = ctx.serverEncryptionRequired && ctx.sessionKey
     ? await encrypt(msg, ctx.sessionKey) : msg;
   if (socket !== ctx.ws || socket.readyState !== WebSocket.OPEN) {
     return bufferMessage(msg, 'Connection changed');
   }
   const data = JSON.stringify(payload);
-  if (msg.type === 'file_content_chunk') return sendFileChunk(socket, data);
+  if (['file_content_chunk', 'video_chunk'].includes(msg.type)) return sendTransferChunk(socket, data);
   socket.send(data);
   return 'sent';
 }
@@ -161,7 +161,8 @@ export async function sendToServer(msg) {
     return 'dropped';
   }
   const promise = new Promise((resolve, reject) => {
-    ctx.outboundSendQueue.push({ msg, bytes, resolve, reject, socket: msg.type === 'file_content_chunk' ? ctx.ws : null });
+    const connectionScoped = ['file_content_chunk', 'video_chunk'].includes(msg.type);
+    ctx.outboundSendQueue.push({ msg, bytes, resolve, reject, socket: connectionScoped ? ctx.ws : null });
     ctx.outboundSendQueueBytes = Number(ctx.outboundSendQueueBytes || 0) + bytes;
   });
   scheduleOutboundDrain();

package/connection/message-router.js

@@ -10,7 +10,7 @@ import { decodeKey } from '../encryption.js';
 import { handleTerminalCreate, handleTerminalInput, handleTerminalResize, handleTerminalClose } from '../terminal.js';
 import { handleProxyHttpRequest, handleProxyWsOpen, handleProxyWsMessage, handleProxyWsClose } from '../proxy.js';
 import {
-  handleReadFile, handleWriteFile, handleListDirectory,
+  handleReadFile, handleVideoMetadata, handleVideoChunk, handleWriteFile, handleListDirectory,
   handleGitStatus, handleGitDiff, handleGitAdd, handleGitReset, handleGitRestore, handleGitCommit, handleGitPush,
   handleFileSearch, handleResolveFileReferences, handleCreateFile, handleDeleteFiles, handleMoveFiles, handleCopyFiles, handleUploadToDir, handleTransferFiles
 } from '../workbench.js';
@@ -251,6 +251,14 @@ export async function handleMessage(msg) {
       await handleReadFile(msg);
       break;
 
+    case 'video_metadata':
+      await handleVideoMetadata(msg);
+      break;
+
+    case 'video_chunk':
+      await handleVideoChunk(msg);
+      break;
+
     case 'write_file':
       await handleWriteFile(msg);
       break;

package/index.js

@@ -177,7 +177,7 @@ async function detectCapabilities() {
   // agent build can speak plaintext WS frames. New servers see this and
   // flip `agent.encryptOutbound = false`, stopping outbound encryption
   // to this peer. Old servers ignore the unknown capability token.
-  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', 'workbench_session_routes', 'workbench_request_correlation', 'workbench_terminal_cleanup_fence', 'workbench_file_content_chunks', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch', 'file_reference_resolution', 'response_image_preview', 'yeaft_plugins', 'yeaft_managed_skills', 'settings_request_correlation'];
+  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', 'workbench_session_routes', 'workbench_request_correlation', 'workbench_terminal_cleanup_fence', 'workbench_file_content_chunks', 'workbench_video_stream', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch', 'file_reference_resolution', 'response_image_preview', 'yeaft_plugins', 'yeaft_managed_skills', 'settings_request_correlation'];
   capabilities.push(getAgentUpgradeCapability());
   if (isWorkCenterEnabled()) {
     capabilities.push('work_center', 'work_center_message_v2');

package/local-runtime/server/handlers/agent-file-terminal.js

@@ -26,7 +26,7 @@ import {
 } from '../workbench-correlation.js';
 import { appendFileContentChunk, discardFileContentAssembly } from '../file-content-assembly.js';
 import { cachePreviewFile, MAX_PREVIEW_FILE_BYTES } from '../preview-files.js';
-import { createWorkbenchPreview } from '../workbench-preview.js';
+import { createWorkbenchPreview, createWorkbenchVideo } from '../workbench-preview.js';
 
 function stripAgentRouting(msg) {
   const {
@@ -286,9 +286,27 @@ async function handleOneShotResponse(agentId, agent, msg, routeKey) {
     await pending.onResponse?.({ error: 'Preview workspace is no longer available' });
     return;
   }
-  const projected = msg.type === 'file_content' && msg.binary && !pending.onResponse
-    ? cacheBinaryPreview(msg, null, pending)
-    : msg;
+  let projected = msg;
+  if (msg.type === 'file_content' && msg.binary && !pending.onResponse) {
+    projected = cacheBinaryPreview(msg, null, pending);
+  } else if (msg.type === 'video_metadata' && !msg.error && !pending.onResponse) {
+    const fileId = randomUUID();
+    const token = createWorkbenchVideo(fileId, pending, msg);
+    const { mtimeMs: _mtimeMs, ...publicMetadata } = msg;
+    projected = token ? {
+      ...publicMetadata,
+      filePath: msg.requestedFilePath || msg.filePath,
+      videoStream: true,
+      fileId,
+      previewToken: token,
+      previewUrl: `/api/preview/${fileId}?token=${encodeURIComponent(token)}`,
+    } : {
+      ...publicMetadata,
+      filePath: msg.requestedFilePath || msg.filePath,
+      error: 'Video stream is unavailable for this Session.',
+      errorCode: 'VIDEO_STREAM_UNAVAILABLE',
+    };
+  }
   await sendToPendingClient(agentId, projected, pending);
 }
 
@@ -304,7 +322,7 @@ export async function handleAgentFileTerminal(agentId, agent, rawMsg) {
     'terminal_created', 'terminal_output', 'terminal_closed', 'terminal_error',
   ]);
   const oneShotTypes = new Set([
-    'file_content', 'file_content_chunk', 'file_references_resolved', 'file_saved', 'directory_listing', 'file_op_result',
+    'file_content', 'file_content_chunk', 'video_metadata', 'video_chunk', 'file_references_resolved', 'file_saved', 'directory_listing', 'file_op_result',
     'git_status_result', 'git_diff_result', 'git_op_result', 'file_search_result',
   ]);
   if (!terminalTypes.has(msg.type) && !oneShotTypes.has(msg.type)) return false;

package/local-runtime/server/handlers/client-workbench.js

@@ -62,6 +62,7 @@ const AGENT_DIRECTORY_PICKER_CONVERSATION = '_workdir_picker';
 const RESPONSE_TYPES = Object.freeze({
   terminal_create: ['terminal_created', 'terminal_error'],
   read_file: ['file_content'],
+  video_metadata: ['video_metadata'],
   resolve_file_references: ['file_references_resolved'],
   write_file: ['file_saved'],
   list_directory: ['directory_listing'],
@@ -83,6 +84,7 @@ const RESPONSE_TYPES = Object.freeze({
 const TIMEOUT_RESPONSE_TYPES = Object.freeze({
   terminal_create: 'terminal_error',
   read_file: 'file_content',
+  video_metadata: 'video_metadata',
   resolve_file_references: 'file_references_resolved',
   write_file: 'file_saved',
   list_directory: 'directory_listing',
@@ -124,8 +126,8 @@ function workbenchFailureResponse({ agentId, msg, resolved, error }) {
   if (msg.type === 'terminal_create') {
     return { ...response, terminalId: msg.terminalId || null, message: error };
   }
-  if (msg.type === 'read_file') {
-    return { ...response, filePath: msg.filePath };
+  if (msg.type === 'read_file' || msg.type === 'video_metadata') {
+    return { ...response, filePath: msg.filePath, requestedFilePath: msg.filePath };
   }
   if (msg.type === 'resolve_file_references') {
     return { ...response, references: [] };
@@ -308,7 +310,8 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
     }
 
     case 'resolve_file_references':
-    case 'read_file': {
+    case 'read_file':
+    case 'video_metadata': {
       const fileAgentId = msg.agentId || client.currentAgent;
       if (!fileAgentId) { console.warn('[Server] read_file: no agentId'); return; }
       if (!await checkAgentAccess(fileAgentId)) return;
@@ -318,6 +321,17 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
         return;
       }
       const fileConvId = resolved.conversationId || msg.conversationId || client.currentConversation || '_explorer';
+      if (msg.type === 'video_metadata'
+          && (!agents.get(fileAgentId)?.capabilities?.includes?.('workbench_video_stream')
+            || !agentSupportsWorkbenchRequestCorrelation(agents.get(fileAgentId)))) {
+        await sendToWebClient(client, workbenchFailureResponse({
+          agentId: fileAgentId,
+          msg,
+          resolved: { ...resolved, conversationId: fileConvId },
+          error: 'Video streaming is not supported by this Agent',
+        }));
+        return;
+      }
       if (msg.responseImagePreview
           && !agents.get(fileAgentId)?.capabilities?.includes?.('response_image_preview')) {
         await sendToWebClient(client, workbenchFailureResponse({
@@ -336,7 +350,8 @@ export async function handleClientWorkbench(clientId, client, msg, checkAgentAcc
         msg,
         resolved,
         canonical: canonicalWorkbenchMessage(msg, { ...resolved, conversationId: fileConvId }, {
-          canonicalWorkDir: !resolved.legacy && msg.type === 'resolve_file_references',
+          canonicalWorkDir: !resolved.legacy
+            && (msg.type === 'resolve_file_references' || msg.type === 'video_metadata'),
         }),
       });
       break;

package/local-runtime/server/routes/upload-routes.js

@@ -5,7 +5,7 @@ import { userDb } from '../database.js';
 import { pendingFiles, previewFiles } from '../context.js';
 import { PREVIEW_FILE_TTL_MS, prunePreviewFiles } from '../preview-files.js';
 import { yeaftAssetStore } from '../yeaft-asset-store.js';
-import { readWorkbenchPreview } from '../workbench-preview.js';
+import { openWorkbenchVideo, readWorkbenchPreview, WORKBENCH_VIDEO_CHUNK_BYTES } from '../workbench-preview.js';
 
 // 文件上传配置 (存储在内存中)
 const upload = multer({
@@ -13,6 +13,93 @@ const upload = multer({
   limits: { fileSize: CONFIG.maxFileSize }
 });
 
+export function parseByteRange(header, size) {
+  if (!header) return null;
+  const match = /^bytes=(\d*)-(\d*)$/.exec(String(header).trim());
+  if (!match || (!match[1] && !match[2]) || !Number.isSafeInteger(size) || size <= 0) return false;
+  let start;
+  let end;
+  if (!match[1]) {
+    const suffix = Number(match[2]);
+    if (!/^\d+$/.test(match[2]) || !Number.isSafeInteger(suffix) || suffix <= 0) return false;
+    start = Math.max(0, size - suffix);
+    end = size - 1;
+  } else {
+    if (!/^\d+$/.test(match[1]) || (match[2] && !/^\d+$/.test(match[2]))) return false;
+    start = Number(match[1]);
+    end = match[2] ? Number(match[2]) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start >= size || end < start) return false;
+    end = Math.min(end, size - 1);
+  }
+  return { start, end };
+}
+
+async function writeResponseChunk(res, chunk) {
+  if (res.destroyed || res.writableEnded) return false;
+  if (res.write(chunk)) return true;
+  await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      res.off?.('drain', onDrain);
+      res.off?.('close', onClose);
+      res.off?.('error', onError);
+    };
+    const onDrain = () => { cleanup(); resolve(); };
+    const onClose = () => { cleanup(); resolve(); };
+    const onError = error => { cleanup(); reject(error); };
+    res.once('drain', onDrain);
+    res.once('close', onClose);
+    res.once('error', onError);
+  });
+  return !res.destroyed && !res.writableEnded;
+}
+
+export async function streamWorkbenchVideo(req, res, video) {
+  const abortController = new AbortController();
+  const abort = () => abortController.abort();
+  req.once?.('aborted', abort);
+  res.once?.('close', abort);
+  try {
+    const requested = parseByteRange(req.headers?.range, video.size);
+    if (requested === false) {
+      res.setHeader('Content-Range', `bytes */${video.size}`);
+      return res.status(416).end();
+    }
+    if (video.size === 0 && requested) {
+      res.setHeader('Content-Range', 'bytes */0');
+      return res.status(416).end();
+    }
+    const range = requested || { start: 0, end: video.size - 1 };
+    const partial = requested !== null;
+    const isHead = req.method === 'HEAD';
+    const firstEnd = video.size === 0 ? -1 : Math.min(range.end, range.start + WORKBENCH_VIDEO_CHUNK_BYTES - 1);
+    const firstChunk = isHead || firstEnd < range.start
+      ? null
+      : await video.read(range.start, firstEnd, abortController.signal);
+    res.status(partial ? 206 : 200);
+    res.setHeader('Content-Type', video.mimeType);
+    res.setHeader('Accept-Ranges', 'bytes');
+    res.setHeader('Content-Length', String(video.size === 0 ? 0 : range.end - range.start + 1));
+    if (partial) res.setHeader('Content-Range', `bytes ${range.start}-${range.end}/${video.size}`);
+    const disposition = req.query.download === '1' ? 'attachment' : 'inline';
+    res.setHeader('Content-Disposition', `${disposition}; filename="${encodeURIComponent(video.filename)}"`);
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Cache-Control', 'no-store');
+    if (isHead || video.size === 0) return res.end();
+    if (!await writeResponseChunk(res, firstChunk)) return;
+    for (let start = firstEnd + 1; start <= range.end;) {
+      const end = Math.min(range.end, start + WORKBENCH_VIDEO_CHUNK_BYTES - 1);
+      const chunk = await video.read(start, end, abortController.signal);
+      if (!await writeResponseChunk(res, chunk)) return;
+      start = end + 1;
+    }
+    res.end();
+  } finally {
+    req.off?.('aborted', abort);
+    res.off?.('close', abort);
+  }
+}
+
 export function extensionForMimeType(mimeType) {
   const type = String(mimeType || '').toLowerCase();
   if (type === 'image/png') return '.png';
@@ -82,10 +169,18 @@ export function registerUploadRoutes(app, { requireAuth }) {
   app.get('/api/preview/:fileId', async (req, res) => {
     let file;
     try {
+      if (typeof req.query.token === 'string' && req.query.token.startsWith('wbv1.')) {
+        const video = openWorkbenchVideo(req.params.fileId, req.query.token);
+        return await streamWorkbenchVideo(req, res, video);
+      }
       file = typeof req.query.token === 'string' && req.query.token.startsWith('wb1.')
         ? await readWorkbenchPreview(req.params.fileId, req.query.token)
         : previewFiles.get(req.params.fileId);
     } catch (error) {
+      if (res.headersSent) {
+        res.destroy(error);
+        return;
+      }
       res.setHeader('Cache-Control', 'no-store');
       return res.status(error.status || 502).send(error.status ? error.message : 'Preview read failed');
     }

package/local-runtime/server/workbench-preview.js

@@ -9,6 +9,9 @@ import { cachePreviewFile, MAX_PREVIEW_FILE_BYTES, prunePreviewFiles } from './p
 
 const inflight = new Map();
 const MAX_REFILLS = 16;
+const MAX_VIDEO_READS = 32;
+let activeVideoReads = 0;
+export const WORKBENCH_VIDEO_CHUNK_BYTES = 1024 * 1024;
 const key = () => createHash('sha256').update(`workbench-preview:${CONFIG.jwtSecret}`).digest();
 const failure = (status, message) => Object.assign(new Error(message), { status });
 
@@ -28,10 +31,25 @@ export function createWorkbenchPreview(fileId, pending, filePath) {
   return `wb1.${Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString('base64url')}`;
 }
 
-function decodeSource(fileId, token) {
+export function createWorkbenchVideo(fileId, pending, metadata) {
+  if (!pending?.route || !metadata?.filePath || !Number.isSafeInteger(metadata.size)
+      || metadata.size < 0 || !Number.isFinite(metadata.mtimeMs) || !metadata.mimeType?.startsWith('video/')) return null;
+  const source = {
+    fileId, filePath: metadata.filePath, size: metadata.size, mtimeMs: metadata.mtimeMs,
+    mimeType: metadata.mimeType, filename: metadata.filePath.split(/[\\/]/).pop(),
+    agentId: pending.agentId, userId: pending.userId,
+    route: pending.route, workspaceGeneration: pending.workspaceGeneration,
+  };
+  const iv = randomBytes(12);
+  const cipher = createCipheriv('aes-256-gcm', key(), iv);
+  const encrypted = Buffer.concat([cipher.update(JSON.stringify(source)), cipher.final()]);
+  return `wbv1.${Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString('base64url')}`;
+}
+
+function decodeSource(fileId, token, prefix = 'wb1.') {
   try {
-    if (typeof token !== 'string' || !token.startsWith('wb1.') || token.length > 24000) throw new Error();
-    const bytes = Buffer.from(token.slice(4), 'base64url');
+    if (typeof token !== 'string' || !token.startsWith(prefix) || token.length > 24000) throw new Error();
+    const bytes = Buffer.from(token.slice(prefix.length), 'base64url');
     const cipher = createDecipheriv('aes-256-gcm', key(), bytes.subarray(0, 12));
     cipher.setAuthTag(bytes.subarray(12, 28));
     const source = JSON.parse(Buffer.concat([cipher.update(bytes.subarray(28)), cipher.final()]).toString());
@@ -102,6 +120,79 @@ async function refill(source, token, { client, resolved }) {
   }
 }
 
+async function requestVideoChunk(source, start, end, signal) {
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start
+      || end >= source.size || (end - start + 1) > WORKBENCH_VIDEO_CHUNK_BYTES) {
+    throw failure(416, 'Invalid video byte range');
+  }
+  if (signal?.aborted) throw failure(499, 'Video request cancelled');
+  if (activeVideoReads >= MAX_VIDEO_READS) throw failure(503, 'Video stream capacity exceeded; retry shortly');
+  activeVideoReads += 1;
+  const clientId = `video:${randomUUID()}`;
+  const publicRequestId = randomUUID();
+  let requestId;
+  let onAbort;
+  try {
+    const { client, resolved } = authorize(source);
+    const result = await new Promise((resolve, reject) => {
+      onAbort = () => reject(failure(499, 'Video request cancelled'));
+      signal?.addEventListener('abort', onAbort, { once: true });
+      requestId = registerWorkbenchRequest({
+        agentId: source.agentId, clientId, publicRequestId, userId: source.userId,
+        allowLegacyCorrelation: false, route: source.route, routeKey: resolved.routeKey,
+        conversationId: resolved.conversationId, workspaceGeneration: source.workspaceGeneration,
+        role: client.role, requestType: 'video_chunk', expectedResponseTypes: ['video_chunk'],
+        onTimeout: (_pending, reason) => reject(failure(reason === 'timeout' ? 504 : 503, 'Video read timed out or disconnected')),
+        onResponse: msg => {
+          if (msg.error) return reject(failure(msg.errorCode === 'ENOENT' ? 404 : msg.errorCode === 'VIDEO_FILE_CHANGED' ? 409 : 502, msg.error));
+          const buffer = Buffer.from(msg.content || '', 'base64');
+          if (msg.filePath !== source.filePath || msg.start !== start || msg.end !== end
+              || msg.size !== source.size || msg.mtimeMs !== source.mtimeMs
+              || msg.mimeType !== source.mimeType || buffer.length !== end - start + 1) {
+            return reject(failure(502, 'Invalid video stream response'));
+          }
+          resolve(buffer);
+        },
+      });
+      if (!requestId) return reject(failure(503, 'Video stream unavailable'));
+      Promise.resolve(forwardToAgent(source.agentId, {
+        type: 'video_chunk', filePath: source.filePath, workDir: resolved.workDir,
+        conversationId: resolved.conversationId, workbenchRoute: source.route,
+        workbenchRouteKey: resolved.routeKey, workbenchWorkspaceGeneration: source.workspaceGeneration,
+        _workbenchRequestId: requestId, _requestUserId: source.userId,
+        _requestClientId: clientId, requestId: publicRequestId,
+        start, end, expectedSize: source.size, expectedMtimeMs: source.mtimeMs,
+      })).then(sent => {
+        if (sent === false) reject(failure(503, 'Agent is offline'));
+      }, () => reject(failure(503, 'Video read failed')));
+    });
+    authorize(source);
+    return result;
+  } finally {
+    signal?.removeEventListener('abort', onAbort);
+    if (requestId) deleteWorkbenchRequest({ agentId: source.agentId, requestId });
+    activeVideoReads -= 1;
+  }
+}
+
+export function openWorkbenchVideo(fileId, token) {
+  const source = decodeSource(fileId, token, 'wbv1.');
+  if (!Number.isSafeInteger(source.size) || source.size < 0 || !Number.isFinite(source.mtimeMs)
+      || !source.mimeType?.startsWith('video/')) throw failure(403, 'Forbidden');
+  const agent = agents.get(source.agentId);
+  if (!agent?.capabilities?.includes?.('workbench_video_stream')
+      || !agentSupportsWorkbenchRequestCorrelation(agent)) {
+    throw failure(410, 'Video streaming is no longer available');
+  }
+  authorize(source);
+  return {
+    size: source.size,
+    mimeType: source.mimeType,
+    filename: source.filename || source.filePath.split(/[\\/]/).pop() || 'video',
+    read: (start, end, signal) => requestVideoChunk(source, start, end, signal),
+  };
+}
+
 /** Resolve an HTTP capability independently of the browser's active Session or socket. */
 export async function readWorkbenchPreview(fileId, token) {
   const source = decodeSource(fileId, token);

package/local-runtime/server/ws-agent.js

@@ -454,7 +454,7 @@ async function handleAgentMessage(agentId, msg, ws) {
     'proxy_ws_closed', 'proxy_ws_error', 'restart_agent_ack', 'upgrade_agent_ack',
     'directory_listing', 'folders_list', 'models_list', 'yeaft_output', 'yeaft_session_output', 'session_output', 'yeaft_asset_put',
     'yeaft_history_chunk', 'yeaft_history_outline', 'yeaft_history_search_result', 'yeaft_history_window', 'slash_commands_update', 'agent_metrics',
-    'file_content', 'file_content_chunk', 'file_saved', 'file_op_result', 'file_search_result',
+    'file_content', 'file_content_chunk', 'video_metadata', 'video_chunk', 'file_saved', 'file_op_result', 'file_search_result',
     'git_status_result', 'git_diff_result', 'git_op_result',
     'terminal_created', 'terminal_output', 'terminal_closed', 'terminal_error',
     'agent_capabilities_updated', 'browser_runtime_status_result', 'browser_runtime_install_progress', 'browser_runtime_error',

package/local-runtime/server/ws-client.js

@@ -232,7 +232,7 @@ export function handleWebConnection(ws, url, req = {}) {
 const WORKBENCH_TYPES = new Set([
   ...CLIENT_BROWSER_TYPES,
   'terminal_create', 'terminal_input', 'terminal_resize', 'terminal_close',
-  'read_file', 'resolve_file_references', 'write_file', 'create_file', 'delete_files', 'move_files', 'copy_files', 'upload_to_dir', 'file_search',
+  'read_file', 'video_metadata', 'resolve_file_references', 'write_file', 'create_file', 'delete_files', 'move_files', 'copy_files', 'upload_to_dir', 'file_search',
   'git_status', 'git_diff', 'git_add', 'git_reset', 'git_restore', 'git_commit', 'git_push',
   'proxy_update_ports', 'update_file_tabs', 'restore_file_tabs'
 ]);

package/local-runtime/version.json

@@ -1 +1 @@
-{"version":"1.0.522"}
+{"version":"1.0.523"}