neoagent 2.3.1-beta.95 → 2.3.1-beta.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.3.1-beta.95",
+  "version": "2.3.1-beta.97",
   "description": "Proactive personal AI agent with no limits",
   "license": "MIT",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-e36f6379ecffed1205851d8afac54166
+e299764c07bc83e074bc914963bc6b6a

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"42d3d75a56efe1a2e9902f52dc8006099c45d9
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1191180070" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "818064985" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -129338,7 +129338,7 @@ r===$&&A.b()
 o.push(A.ii(p,A.iY(!1,new A.a3(B.tM,A.dT(new A.cI(B.he,new A.a5V(r,p),p),p,p),p),!1,B.I,!0),p,p,0,0,0,p))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.t("mp8lujhh-8aedfd7").length!==0&&r.b}if(r){r=s.d
+r=B.b.t("mp9vo0j5-aadf22e").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.ag&&!r.V?84:0
 q=s.e
@@ -134146,7 +134146,7 @@ $S:236}
 A.Ys.prototype={}
 A.Rr.prototype={
 mT(a){var s=this
-if(B.b.t("mp8lujhh-8aedfd7").length===0||s.a!=null)return
+if(B.b.t("mp9vo0j5-aadf22e").length===0||s.a!=null)return
 s.A5()
 s.a=A.q1(B.PP,new A.b58(s))},
 A5(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -134164,7 +134164,7 @@ if(!t.f.b(k)){s=1
 break}i=J.Z(k,"buildId")
 h=i==null?null:B.b.t(J.r(i))
 j=h==null?"":h
-if(J.bm(j)===0||J.d(j,"mp8lujhh-8aedfd7")){s=1
+if(J.bm(j)===0||J.d(j,"mp9vo0j5-aadf22e")){s=1
 break}n.b=!0
 n.D()
 p=2
@@ -134181,7 +134181,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$A5,r)},
 vb(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$vb=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mp8lujhh-8aedfd7").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("mp9vo0j5-aadf22e").length===0||n.c){s=1
 break}n.c=!0
 n.D()
 p=4

package/server/routes/browser.js

@@ -66,6 +66,19 @@ router.get('/status', async (req, res) => {
   }
 });
 
+router.get('/cookies', async (req, res) => {
+  try {
+    const bc = await getBrowserController(req);
+    if (typeof bc.getCookies !== 'function') {
+      return res.status(501).json({ error: 'Cookie export is unavailable for this browser provider.' });
+    }
+    const result = await bc.getCookies();
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: sanitizeError(err) });
+  }
+});
+
 // Launch browser
 router.post('/launch', async (req, res) => {
   try {

package/server/services/ai/capabilityHealth.js

@@ -310,8 +310,8 @@ function getCommandHealth(userId, app, engine) {
     configured: Boolean(runtimeManager),
     healthy: Boolean(runtimeManager),
     summary: runtimeManager
-      ? 'Shell command execution is available through the per-user runtime capsule.'
-      : 'Shell executor is not available.',
+      ? 'Shell command execution is available.'
+      : 'Shell command execution is not available in this environment.',
   });
 }
 

package/server/services/ai/models.js

@@ -31,14 +31,14 @@ const STATIC_MODELS = [
         purpose: 'coding'
     },
     {
-        id: 'gpt-5.3-codex',
-        label: 'GPT-5.3 (Codex Default)',
+        id: 'gpt-5.4',
+        label: 'GPT-5.4 (Codex Default)',
         provider: 'openai-codex',
         purpose: 'general'
     },
     {
-        id: 'gpt-4.1-codex',
-        label: 'GPT-4.1 (Codex Fast)',
+        id: 'gpt-5.4-mini',
+        label: 'GPT-5.4 mini (Codex Fast)',
         provider: 'openai-codex',
         purpose: 'coding'
     },

package/server/services/ai/providers/openaiCodex.js

@@ -1,31 +1,330 @@
-const { OpenAIProvider } = require('./openai');
+const OpenAI = require('openai');
+const { BaseProvider } = require('./base');
 
-class OpenAICodexProvider extends OpenAIProvider {
+const DEFAULT_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+
+function normalizeContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (!part) return '';
+      if (typeof part === 'string') return part;
+      if (part.type === 'text' && typeof part.text === 'string') return part.text;
+      if (part.type === 'input_text' && typeof part.text === 'string') return part.text;
+      return '';
+    }).join('');
+  }
+  return String(content);
+}
+
+function normalizeInputContent(content) {
+  if (content == null) return [];
+
+  if (typeof content === 'string') {
+    return [{ type: 'input_text', text: content }];
+  }
+
+  if (!Array.isArray(content)) {
+    const text = String(content);
+    return text ? [{ type: 'input_text', text }] : [];
+  }
+
+  const parts = [];
+  for (const part of content) {
+    if (!part) continue;
+    if (typeof part === 'string') {
+      if (part.trim()) parts.push({ type: 'input_text', text: part });
+      continue;
+    }
+    if (part.type === 'text' && typeof part.text === 'string') {
+      parts.push({ type: 'input_text', text: part.text });
+      continue;
+    }
+    if (part.type === 'input_text' && typeof part.text === 'string') {
+      parts.push({ type: 'input_text', text: part.text });
+      continue;
+    }
+    if (part.type === 'image_url') {
+      const imageUrl = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url;
+      if (imageUrl) {
+        parts.push({
+          type: 'input_image',
+          image_url: imageUrl,
+          detail: part.detail || 'auto',
+        });
+      }
+      continue;
+    }
+    if (part.type === 'input_image') {
+      parts.push({
+        type: 'input_image',
+        image_url: part.image_url || null,
+        file_id: part.file_id || null,
+        detail: part.detail || 'auto',
+      });
+    }
+  }
+
+  return parts;
+}
+
+function toFunctionCallOutput(toolCallId, content) {
+  return {
+    type: 'function_call_output',
+    call_id: toolCallId,
+    output: normalizeContent(content),
+  };
+}
+
+function extractResponseText(response) {
+  if (typeof response?.output_text === 'string' && response.output_text.length > 0) {
+    return response.output_text;
+  }
+
+  const parts = [];
+  for (const item of response?.output || []) {
+    if (item?.type !== 'message') continue;
+    for (const content of item.content || []) {
+      if (content?.type === 'output_text' && typeof content.text === 'string') {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join('');
+}
+
+function extractToolCalls(response) {
+  const toolCalls = [];
+  for (const item of response?.output || []) {
+    if (item?.type !== 'function_call') continue;
+    toolCalls.push({
+      id: item.call_id || item.id || '',
+      type: 'function',
+      function: {
+        name: item.name || '',
+        arguments: item.arguments || '',
+      },
+    });
+  }
+  return toolCalls.filter((toolCall) => toolCall.id && toolCall.function.name);
+}
+
+function formatOpenAIError(err) {
+  if (!err || typeof err !== 'object') return 'Unknown OpenAI error';
+  const parts = [];
+  if (typeof err.status === 'number') parts.push(`HTTP ${err.status}`);
+  if (err.type) parts.push(`type=${err.type}`);
+  if (err.code) parts.push(`code=${err.code}`);
+  if (err.param) parts.push(`param=${err.param}`);
+  if (err.request_id) parts.push(`request_id=${err.request_id}`);
+  const message = err.message || 'Unknown OpenAI error';
+  return parts.length > 0 ? `${message} (${parts.join(', ')})` : message;
+}
+
+class OpenAICodexProvider extends BaseProvider {
   constructor(config = {}) {
-    const officialBaseUrl = 'https://api.openai.com/v1';
-    const baseUrl = config.baseUrl || process.env.OPENAI_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
-    
-    if (!baseUrl.includes('api.openai.com') && !baseUrl.includes('chatgpt.com')) {
-      console.warn(`[OpenAICodex] Using non-official base URL: ${baseUrl}`);
-    } else if (baseUrl.includes('chatgpt.com')) {
-      console.info(`[OpenAICodex] Using ChatGPT subscription endpoint: ${baseUrl}`);
+    super(config);
+
+    const baseURL = config.baseUrl || process.env.OPENAI_CODEX_BASE_URL || DEFAULT_BASE_URL;
+
+    if (!baseURL.includes('chatgpt.com/backend-api/codex') && !baseURL.includes('api.openai.com')) {
+      console.warn(`[OpenAICodex] Using non-official base URL: ${baseURL}`);
+    } else if (baseURL.includes('chatgpt.com/backend-api/codex')) {
+      console.info(`[OpenAICodex] Using ChatGPT Codex endpoint: ${baseURL}`);
     }
 
-    super({
-      ...config,
+    this.name = 'openai-codex';
+    this.models = [
+      'gpt-5.4',
+      'gpt-5.4-mini',
+    ];
+    this.reasoningModels = new Set([
+      'gpt-5.4',
+      'gpt-5.4-mini',
+      'gpt-5.4-nano',
+    ]);
+    this.client = new OpenAI({
       apiKey: config.apiKey || process.env.OPENAI_CODEX_ACCESS_TOKEN,
-      baseUrl,
+      baseURL,
       defaultHeaders: {
         'Editor-Version': process.env.OPENAI_CODEX_EDITOR_VERSION || 'vscode/1.99.0',
         'Editor-Plugin-Version': process.env.OPENAI_CODEX_EDITOR_PLUGIN_VERSION || 'neoagent/1.0.0',
-        'User-Agent': process.env.OPENAI_CODEX_USER_AGENT || 'NeoAgent/1.0.0'
-      }
+        'User-Agent': process.env.OPENAI_CODEX_USER_AGENT || 'NeoAgent/1.0.0',
+      },
     });
-    this.name = 'openai-codex';
   }
 
-  // OpenAI Codex (subscription-based) uses the OAuth token directly as the API key.
-  // The base URL routes it through the ChatGPT backend-api.
+  _isReasoningModel(model) {
+    if (!model) return false;
+    for (const id of this.reasoningModels) {
+      if (model === id || model.startsWith(`${id}-`)) return true;
+    }
+    return false;
+  }
+
+  _buildRequest(messages = [], tools = [], options = {}, model = '') {
+    const instructions = [];
+    const input = [];
+
+    for (const msg of messages || []) {
+      if (!msg || !msg.role) continue;
+
+      if ((msg.role === 'system' || msg.role === 'developer') && msg.content != null) {
+        const text = normalizeContent(msg.content).trim();
+        if (text) instructions.push(text);
+        continue;
+      }
+
+      if (msg.role === 'tool') {
+        const toolCallId = String(msg.tool_call_id || '').trim();
+        if (!toolCallId) continue;
+        input.push(toFunctionCallOutput(toolCallId, msg.content));
+        continue;
+      }
+
+      const content = normalizeInputContent(msg.content);
+      if (content.length > 0) {
+        input.push({
+          type: 'message',
+          role: msg.role === 'assistant' ? 'assistant' : 'user',
+          content,
+        });
+      }
+
+      if (msg.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+        for (const toolCall of msg.tool_calls) {
+          const name = String(toolCall?.function?.name || '').trim();
+          const argumentsText = String(toolCall?.function?.arguments || '');
+          const callId = String(toolCall?.id || toolCall?.call_id || '').trim();
+          if (!name || !callId) continue;
+          input.push({
+            type: 'function_call',
+            id: callId,
+            call_id: callId,
+            name,
+            arguments: argumentsText,
+          });
+        }
+      }
+    }
+
+    const request = {
+      input,
+    };
+
+    if (instructions.length > 0) {
+      request.instructions = instructions.join('\n\n');
+    }
+
+    if (tools && tools.length > 0) {
+      request.tools = this.formatTools(tools);
+      request.tool_choice = options.toolChoice || 'auto';
+    }
+
+    request.max_output_tokens = options.maxTokens || 16384;
+
+    if (options.temperature !== undefined && options.temperature !== null) {
+      request.temperature = options.temperature;
+    }
+
+    const reasoningEffort = options.reasoningEffort || options.reasoning_effort;
+    if (reasoningEffort || this._isReasoningModel(model)) {
+      request.reasoning = {
+        effort: reasoningEffort || 'medium',
+      };
+    }
+
+    return request;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const request = this._buildRequest(messages, tools, options, model);
+    let response;
+    try {
+      response = await this.client.responses.create({
+        model,
+        ...request,
+      });
+    } catch (err) {
+      throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
+    }
+
+    const toolCalls = extractToolCalls(response);
+
+    return {
+      content: extractResponseText(response),
+      toolCalls,
+      finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+      usage: response.usage ? {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.total_tokens,
+      } : null,
+      model: response.model,
+    };
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const request = this._buildRequest(messages, tools, options, model);
+    let stream;
+    try {
+      stream = await this.client.responses.create({
+        model,
+        ...request,
+        stream: true,
+      });
+    } catch (err) {
+      throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
+    }
+
+    let content = '';
+    let finalResponse = null;
+
+    for await (const event of stream) {
+      if (event.type === 'response.output_text.delta' && typeof event.delta === 'string') {
+        content += event.delta;
+        yield { type: 'content', content: event.delta };
+        continue;
+      }
+
+      if (event.type === 'response.completed') {
+        finalResponse = event.response;
+      }
+    }
+
+    const response = finalResponse || {};
+    const toolCalls = extractToolCalls(response);
+    const finalContent = extractResponseText(response) || content;
+
+    if (toolCalls.length > 0) {
+      yield {
+        type: 'tool_calls',
+        content: finalContent,
+        toolCalls,
+        usage: response.usage ? {
+          promptTokens: response.usage.input_tokens,
+          completionTokens: response.usage.output_tokens,
+          totalTokens: response.usage.total_tokens,
+        } : null,
+      };
+      return;
+    }
+
+    yield {
+      type: 'done',
+      content: finalContent,
+      toolCalls: [],
+      finishReason: 'stop',
+      usage: response.usage ? {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.total_tokens,
+      } : null,
+    };
+  }
 }
 
 module.exports = { OpenAICodexProvider };

package/server/services/ai/settings.js

@@ -77,7 +77,7 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
     supportsApiKey: true,
     supportsBaseUrl: true,
     defaultEnabled: false,
-    defaultBaseUrl: 'https://api.openai.com/v1'
+    defaultBaseUrl: 'https://chatgpt.com/backend-api/codex'
   },
   ollama: {
     id: 'ollama',

package/server/services/browser/controller.js

@@ -779,6 +779,17 @@ class BrowserController {
     };
   }
 
+  async getCookies() {
+    await this.ensureBrowser();
+    if (!this.context || typeof this.context.cookies !== 'function') {
+      return { cookies: [] };
+    }
+    const cookies = await this.context.cookies().catch(() => []);
+    return {
+      cookies: Array.isArray(cookies) ? cookies : [],
+    };
+  }
+
   async close() {
     if (this.page && !this.page.isClosed()) {
       await this.page.close().catch(() => { });

package/server/services/runtime/backends/local-vm.js

@@ -272,6 +272,9 @@ class VmBrowserProvider {
     const status = await this.client.request('GET', '/browser/status');
     return Number(status?.pages || 0);
   }
+  async getCookies() {
+    return this.client.request('GET', '/browser/cookies');
+  }
   async setHeadless(value) {
     this.headless = true;
     return { success: true };

package/server/services/social_video/service.js

@@ -126,6 +126,35 @@ function resolveVoiceSttConfigFromSettings(settings = {}) {
   };
 }
 
+function serializeCookiesForNetscapeJar(cookies = []) {
+  const lines = ['# Netscape HTTP Cookie File'];
+  for (const cookie of Array.isArray(cookies) ? cookies : []) {
+    if (!cookie || typeof cookie !== 'object') continue;
+    const domain = String(cookie.domain || '').trim();
+    const name = String(cookie.name || '').trim();
+    const value = String(cookie.value || '').replace(/[\r\n\t]/g, ' ');
+    if (!domain || !name) continue;
+    const cookieDomain = domain.startsWith('.') ? domain : domain;
+    const includeSubdomains = domain.startsWith('.') ? 'TRUE' : 'FALSE';
+    const pathValue = String(cookie.path || '/').trim() || '/';
+    const secure = cookie.secure ? 'TRUE' : 'FALSE';
+    const expires = Number.isFinite(Number(cookie.expires)) && Number(cookie.expires) > 0
+      ? String(Math.floor(Number(cookie.expires)))
+      : '0';
+    const httpOnlyPrefix = cookie.httpOnly ? '#HttpOnly_' : '';
+    lines.push([
+      `${httpOnlyPrefix}${cookieDomain}`,
+      includeSubdomains,
+      pathValue,
+      secure,
+      expires,
+      name,
+      value,
+    ].join('\t'));
+  }
+  return `${lines.join('\n')}\n`;
+}
+
 function fileExists(filePath) {
   try {
     return fs.statSync(filePath).isFile();
@@ -240,8 +269,14 @@ class SocialVideoService {
 
       const pageMetadata = await this.#resolvePageMetadata(userId, normalizedUrl, warnings);
       jobDir = await fsp.mkdtemp(path.join(SOCIAL_VIDEO_TMP_DIR, `${platform}-${Date.now()}-`));
+      const cookieFilePath = await this.#resolveCookieFile({
+        userId,
+        platform,
+        jobDir,
+        warnings,
+      });
 
-      const mediaInfo = await this.#readMediaInfo(normalizedUrl, jobDir);
+      const mediaInfo = await this.#readMediaInfo(normalizedUrl, jobDir, cookieFilePath);
       const baseTitle = String(pageMetadata.title || mediaInfo.title || '').trim();
       const baseDescription = String(pageMetadata.description || mediaInfo.description || '').trim();
       const resolvedUrl = String(pageMetadata.resolvedUrl || mediaInfo.webpage_url || normalizedUrl).trim();
@@ -264,6 +299,7 @@ class SocialVideoService {
         captionTrack,
         transcriptDecision,
         jobDir,
+        cookieFilePath,
         userId,
         agentId,
         warnings,
@@ -276,6 +312,7 @@ class SocialVideoService {
           sourceUrl: normalizedUrl,
           mediaInfo,
           jobDir,
+          cookieFilePath,
           warnings,
         });
 
@@ -432,10 +469,11 @@ class SocialVideoService {
     };
   }
 
-  async #readMediaInfo(normalizedUrl, jobDir) {
+  async #readMediaInfo(normalizedUrl, jobDir, cookieFilePath = null) {
     const infoTemplate = path.join(jobDir, 'media.%(ext)s');
     const infoPath = path.join(jobDir, 'media.info.json');
-    const command = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist --skip-download --write-info-json --no-clean-infojson -o ${shellEscape(infoTemplate)} -- ${shellEscape(normalizedUrl)}`;
+    const cookieArg = cookieFilePath ? ` --cookies ${shellEscape(cookieFilePath)}` : '';
+    const command = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist --skip-download --write-info-json --no-clean-infojson${cookieArg} -o ${shellEscape(infoTemplate)} -- ${shellEscape(normalizedUrl)}`;
     await this.#runCommand(command, { cwd: jobDir, timeout: 4 * 60 * 1000 });
     if (!fileExists(infoPath)) {
       throw new Error('yt-dlp did not produce an info JSON artifact.');
@@ -486,7 +524,8 @@ class SocialVideoService {
 
   async #transcribeViaStt(context) {
     const template = path.join(context.jobDir, 'audio.%(ext)s');
-    const command = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist -o ${shellEscape(template)} -f bestaudio -- ${shellEscape(context.sourceUrl)}`;
+    const cookieArg = context.cookieFilePath ? ` --cookies ${shellEscape(context.cookieFilePath)}` : '';
+    const command = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist${cookieArg} -o ${shellEscape(template)} -f bestaudio -- ${shellEscape(context.sourceUrl)}`;
     await this.#runCommand(command, { cwd: context.jobDir, timeout: 10 * 60 * 1000 });
 
     const audioPath = firstFileMatching(context.jobDir, 'audio.');
@@ -521,6 +560,36 @@ class SocialVideoService {
     });
   }
 
+  async #resolveCookieFile(context) {
+    if (context.platform !== 'instagram') {
+      return null;
+    }
+    if (!this.runtimeManager || typeof this.runtimeManager.getBrowserProviderForUser !== 'function') {
+      return null;
+    }
+
+    const browser = await Promise.resolve(
+      this.runtimeManager.getBrowserProviderForUser(context.userId),
+    ).catch(() => null);
+    if (!browser || typeof browser.getCookies !== 'function') {
+      return null;
+    }
+
+    const payload = await browser.getCookies().catch((error) => {
+      context.warnings.push(`Browser cookie export failed: ${error.message}`);
+      return null;
+    });
+    const cookies = Array.isArray(payload?.cookies) ? payload.cookies : [];
+    if (cookies.length === 0) {
+      context.warnings.push('Browser cookie export returned no cookies for Instagram.');
+      return null;
+    }
+
+    const cookieFilePath = path.join(context.jobDir, 'browser.cookies.txt');
+    await fsp.writeFile(cookieFilePath, serializeCookiesForNetscapeJar(cookies), 'utf8');
+    return cookieFilePath;
+  }
+
   async #resolveFrameImage(context) {
     const downloadedFrame = await this.#extractFrameFromVideo(context).catch((error) => {
       context.warnings.push(`Frame extraction failed: ${error.message}`);
@@ -540,7 +609,8 @@ class SocialVideoService {
 
   async #extractFrameFromVideo(context) {
     const template = path.join(context.jobDir, 'video.%(ext)s');
-    const downloadCommand = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist -o ${shellEscape(template)} -f "bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best" --merge-output-format mp4 -- ${shellEscape(context.sourceUrl)}`;
+    const cookieArg = context.cookieFilePath ? ` --cookies ${shellEscape(context.cookieFilePath)}` : '';
+    const downloadCommand = `${shellEscape(this.ytDlpBin)} --quiet --no-warnings --no-playlist${cookieArg} -o ${shellEscape(template)} -f "bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best" --merge-output-format mp4 -- ${shellEscape(context.sourceUrl)}`;
     await this.#runCommand(downloadCommand, { cwd: context.jobDir, timeout: 14 * 60 * 1000 });
 
     const videoPath = firstFileMatching(context.jobDir, 'video.');