wtt-connect 0.1.0

package/src/adapters/generic-cli.js

@@ -0,0 +1,258 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { log } from '../logger.js';
+
+const PROFILE_ALIASES = {
+  claude: 'claude-code',
+  'cursor-agent': 'cursor',
+  opencode: 'opencode',
+  crush: 'crush',
+  devin: 'devin',
+};
+
+export const CLI_PROFILES = {
+  cursor: {
+    binKey: 'cursorBin',
+    defaultBin: 'agent',
+    sessionKey: 'cursorSessionId',
+    buildArgs: ({ prompt, config, sessionId }) => {
+      const args = ['--print', '--output-format', 'stream-json', '--trust'];
+      if (['yolo', 'full-auto', 'force', 'auto'].includes(normalizeMode(config.mode))) args.push('--force');
+      else if (['plan', 'suggest'].includes(normalizeMode(config.mode))) args.push('--mode', 'plan');
+      else if (normalizeMode(config.mode) === 'ask') args.push('--mode', 'ask');
+      if (sessionId) args.push('--resume', sessionId);
+      if (config.model) args.push('--model', config.model);
+      args.push('--workspace', config.workDir, '--', prompt);
+      return { args };
+    },
+  },
+  gemini: {
+    binKey: 'geminiBin',
+    defaultBin: 'gemini',
+    sessionKey: 'geminiSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = ['--output-format', 'stream-json'];
+      if (['yolo', 'full-auto', 'force'].includes(normalizeMode(config.mode))) args.push('-y');
+      else if (['auto-edit', 'auto_edit', 'auto'].includes(normalizeMode(config.mode))) args.push('--approval-mode', 'auto_edit');
+      else if (['plan', 'suggest'].includes(normalizeMode(config.mode))) args.push('--approval-mode', 'plan');
+      if (sessionId) args.push('--resume', sessionId);
+      if (config.model) args.push('-m', config.model);
+      args.push('-p', '-');
+      return { args, stdin: appendAttachmentRefs(prompt, context) };
+    },
+  },
+  qoder: {
+    binKey: 'qoderBin',
+    defaultBin: 'qodercli',
+    sessionKey: 'qoderSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = ['-p', appendAttachmentRefs(prompt, context), '-f', 'stream-json', '-q', '-w', config.workDir];
+      if (sessionId) args.push('-r', sessionId);
+      if (['yolo', 'full-auto', 'force'].includes(normalizeMode(config.mode))) args.push('--dangerously-skip-permissions');
+      if (config.model) args.push('--model', config.model);
+      return { args };
+    },
+  },
+  opencode: {
+    binKey: 'opencodeBin',
+    defaultBin: 'opencode',
+    sessionKey: 'opencodeSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = ['run', '--format', 'json'];
+      if (sessionId) args.push('--session', sessionId);
+      if (config.model) args.push('--model', config.model);
+      args.push('--dir', config.workDir, '--thinking');
+      for (const img of context.images || []) args.push('--file', img);
+      args.push('--', prompt);
+      return { args };
+    },
+  },
+  crush: {
+    binKey: 'crushBin',
+    defaultBin: 'crush',
+    sessionKey: 'crushSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => CLI_PROFILES.opencode.buildArgs({ prompt, config, sessionId, context }),
+  },
+  iflow: {
+    binKey: 'iflowBin',
+    defaultBin: 'iflow',
+    sessionKey: 'iflowSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = [];
+      if (config.model) args.push('-m', config.model);
+      const mode = normalizeMode(config.mode);
+      if (['yolo', 'full-auto', 'force'].includes(mode)) args.push('--yolo');
+      else if (['plan', 'suggest'].includes(mode)) args.push('--plan');
+      else if (['auto-edit', 'auto_edit', 'auto'].includes(mode)) args.push('--autoEdit');
+      else args.push('--default');
+      if (sessionId) args.push('-r', sessionId);
+      args.push('-i', appendAttachmentRefs(prompt, context));
+      return { args };
+    },
+  },
+  kimi: {
+    binKey: 'kimiBin',
+    defaultBin: 'kimi',
+    sessionKey: 'kimiSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = ['--print', '--output-format', 'stream-json'];
+      if (['plan', 'suggest'].includes(normalizeMode(config.mode))) args.push('--plan');
+      else if (normalizeMode(config.mode) === 'quiet') args.push('--quiet');
+      if (sessionId) args.push('--resume', sessionId);
+      if (config.model) args.push('--model', config.model);
+      args.push('--work-dir', config.workDir, '--prompt', appendAttachmentRefs(prompt, context));
+      return { args };
+    },
+  },
+  pi: {
+    binKey: 'piBin',
+    defaultBin: 'pi',
+    sessionKey: 'piSessionId',
+    buildArgs: ({ prompt, config, sessionId, context }) => {
+      const args = ['--mode', 'json', '-p'];
+      if (sessionId) args.push('--session', sessionId);
+      if (config.model) args.push('--model', config.model);
+      if (['yolo', 'full-auto', 'force', 'auto'].includes(normalizeMode(config.mode))) args.push('--auto-approve');
+      if (config.reasoningEffort) args.push('--thinking', config.reasoningEffort);
+      for (const img of context.images || []) args.push(`@${img}`);
+      args.push(prompt);
+      return { args };
+    },
+  },
+};
+
+export class GenericCliAdapter {
+  constructor(name, config, deps = {}) {
+    this.name = normalizeProfileName(name);
+    this.config = config;
+    this.store = deps.store;
+    this.profile = CLI_PROFILES[this.name];
+    if (!this.profile) throw new Error(`unsupported generic CLI adapter: ${name}`);
+  }
+
+  async run(prompt, context = {}) {
+    const sessionKey = context.sessionKey || 'default';
+    const stored = this.store?.getSession(sessionKey) || {};
+    const storedKey = this.profile.sessionKey || `${this.name}SessionId`;
+    const sessionId = stored[storedKey];
+    const bin = this.config[this.profile.binKey] || this.profile.defaultBin;
+    const built = this.profile.buildArgs({ prompt, config: this.config, sessionId, context });
+    log('info', `${this.name} launch`, { sessionKey, resume: Boolean(sessionId), mode: this.config.mode });
+    const result = await runCli(bin, built.args, built.stdin, this.config.workDir, (event) => {
+      const eventSessionId = extractSessionId(event);
+      if (eventSessionId) this.store?.patchSession(sessionKey, { [storedKey]: eventSessionId, adapter: this.name });
+      if (this.config.publishProgress && context.onProgress) context.onProgress(event).catch(() => {});
+    }, this.config.taskTimeoutSeconds * 1000);
+    if (result.sessionId) this.store?.patchSession(sessionKey, { [storedKey]: result.sessionId, adapter: this.name });
+    return result.text.trim();
+  }
+}
+
+export function normalizeProfileName(name) {
+  const raw = String(name || '').trim().toLowerCase();
+  return PROFILE_ALIASES[raw] || raw;
+}
+
+export function adapterBin(config, adapter) {
+  const name = normalizeProfileName(adapter);
+  const profile = CLI_PROFILES[name];
+  if (!profile) return '';
+  return config[profile.binKey] || profile.defaultBin;
+}
+
+function runCli(bin, args, stdinText, cwd, onEvent, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: [stdinText == null ? 'ignore' : 'pipe', 'pipe', 'pipe'], env: { ...process.env } });
+    let stderr = '';
+    let plainStdout = '';
+    let sessionId = '';
+    const texts = [];
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      let event;
+      try { event = JSON.parse(line); } catch {
+        plainStdout += `${line}\n`;
+        return;
+      }
+      const eventSessionId = extractSessionId(event);
+      if (eventSessionId) sessionId = eventSessionId;
+      const text = extractText(event);
+      if (text) texts.push(text);
+      onEvent?.(event);
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) reject(new Error(`${bin} exited ${code}: ${stderr.trim()}`));
+      else resolve({ text: collapseText(texts, plainStdout), sessionId });
+    });
+    if (stdinText != null) child.stdin.end(stdinText);
+  });
+}
+
+function collapseText(texts, plainStdout) {
+  const filtered = texts.map((x) => String(x || '').trim()).filter(Boolean);
+  if (filtered.length) return filtered.join('\n').trim();
+  return String(plainStdout || '').trim();
+}
+
+function extractSessionId(event) {
+  return event.session_id
+    || event.sessionId
+    || event.thread_id
+    || event.threadId
+    || event.conversation_id
+    || event.conversationId
+    || event.chat_id
+    || event.chatId
+    || (event.id && isSessionEvent(event) ? event.id : '');
+}
+
+function isSessionEvent(event) {
+  const type = String(event.type || event.event || '').toLowerCase();
+  return type.includes('session') && (type.includes('start') || type.includes('created') || type.includes('new'));
+}
+
+function extractText(event) {
+  if (typeof event === 'string') return event;
+  for (const key of ['result', 'text', 'content', 'message', 'output', 'output_text', 'final', 'response']) {
+    const value = event[key];
+    const text = valueToText(value);
+    if (text) return text;
+  }
+  if (event.type === 'item.completed' && event.item) return valueToText(event.item);
+  if (event.type === 'assistant' || event.role === 'assistant') return valueToText(event.content || event.message);
+  if (event.type === 'result' || event.event === 'result') return valueToText(event.result || event.data || event.payload);
+  return '';
+}
+
+function valueToText(value) {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(valueToText).filter(Boolean).join('\n');
+  if (typeof value === 'object') {
+    if (value.type && !['text', 'message', 'assistant', 'agent_message'].includes(String(value.type))) return '';
+    for (const key of ['text', 'content', 'message', 'result', 'output_text']) {
+      const text = valueToText(value[key]);
+      if (text) return text;
+    }
+  }
+  return '';
+}
+
+function appendAttachmentRefs(prompt, context = {}) {
+  const refs = [];
+  if (context.images?.length) refs.push(`Attached images: ${context.images.join(', ')}`);
+  if (context.files?.length) refs.push(`Attached files: ${context.files.join(', ')}`);
+  return refs.length ? `${prompt}\n\n${refs.join('\n')}` : prompt;
+}
+
+function normalizeMode(mode) {
+  return String(mode || '').trim().toLowerCase().replace(/_/g, '-');
+}

package/src/adapters/index.js

@@ -0,0 +1,28 @@
+import { CodexAdapter } from './codex.js';
+import { ClaudeCodeAdapter } from './claude-code.js';
+import { OpenClawAdapter } from './openclaw.js';
+import { AcpAdapter } from './acp.js';
+import { GenericCliAdapter, normalizeProfileName } from './generic-cli.js';
+
+const GENERIC_CLI_ADAPTERS = new Set(['cursor', 'gemini', 'qoder', 'opencode', 'crush', 'iflow', 'kimi', 'pi']);
+
+export function createAdapter(config, deps = {}) {
+  const adapter = normalizeAdapterName(config.adapter);
+  switch (adapter) {
+    case 'codex': return new CodexAdapter({ ...config, adapter }, deps);
+    case 'claude-code': return new ClaudeCodeAdapter({ ...config, adapter }, deps);
+    case 'acp': return new AcpAdapter({ ...config, adapter }, deps);
+    case 'devin': return new AcpAdapter({ ...config, adapter, acpCommand: config.devinBin || 'devin', acpArgs: config.devinArgs?.length ? config.devinArgs : ['acp'], acpDisplayName: 'Devin' }, deps);
+    case 'openclaw': return new OpenClawAdapter({ ...config, adapter }, deps); // legacy/manual only; wtt-plugin is preferred.
+    default:
+      if (GENERIC_CLI_ADAPTERS.has(adapter)) return new GenericCliAdapter(adapter, { ...config, adapter }, deps);
+      throw new Error(`unsupported adapter: ${config.adapter}`);
+  }
+}
+
+export function normalizeAdapterName(name) {
+  const normalized = normalizeProfileName(name);
+  if (normalized === 'claude') return 'claude-code';
+  if (normalized === 'cc-connect') return 'codex';
+  return normalized;
+}

package/src/adapters/openclaw.js

@@ -0,0 +1,32 @@
+import { spawn } from 'node:child_process';
+
+export class OpenClawAdapter {
+  constructor(config) {
+    this.config = config;
+    this.name = 'openclaw';
+  }
+
+  async run(prompt, context = {}) {
+    // First implementation uses the OpenClaw CLI as an external agent surface.
+    // Future versions should prefer OpenClaw's native session API when exposed
+    // outside the OpenClaw runtime.
+    const args = ['run', prompt];
+    return runText(this.config.openclawBin, args, this.config.workDir, this.config.taskTimeoutSeconds * 1000);
+  }
+}
+
+function runText(bin, args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+    let stdout = '';
+    let stderr = '';
+    const timer = setTimeout(() => { child.kill('SIGTERM'); reject(new Error(`${bin} timed out`)); }, timeoutMs);
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => { clearTimeout(timer); reject(err); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      code === 0 ? resolve(stdout.trim()) : reject(new Error(`${bin} exited ${code}: ${stderr.trim()}`));
+    });
+  });
+}

package/src/artifacts.js

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { lookupMime } from './mime.js';
+import { log } from './logger.js';
+
+export class ArtifactManager {
+  constructor(config, store) {
+    this.config = config;
+    this.store = store;
+  }
+
+  async writeTextArtifact(name, text) {
+    const dir = this.config.artifactDir;
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, safeName(name));
+    await fs.writeFile(file, text, 'utf8');
+    return file;
+  }
+
+  async uploadFile(filePath) {
+    if (!this.config.uploadArtifacts) return null;
+    const stat = await fs.stat(filePath);
+    if (!stat.isFile()) return null;
+    const mimeType = lookupMime(filePath);
+    const name = path.basename(filePath);
+    const sign = await this.fetchJson('/media/sign', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.authHeaders() },
+      body: JSON.stringify({ filename: name, mime_type: mimeType, size: stat.size }),
+    });
+    const uploadUrl = absoluteUrl(this.config.wttBaseUrl, sign.upload_url);
+    const bytes = await fs.readFile(filePath);
+    const put = await fetch(uploadUrl, { method: 'PUT', body: bytes, headers: this.authHeaders() });
+    if (!put.ok) throw new Error(`artifact upload failed: ${put.status} ${await put.text()}`);
+    const asset = await this.fetchJson('/media/commit', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.authHeaders() },
+      body: JSON.stringify({ upload_token: sign.upload_token }),
+    });
+    this.store?.addArtifact({ filePath, asset });
+    log('info', 'artifact uploaded', { file: filePath, url: asset.url || asset.public_url });
+    return asset;
+  }
+
+  async uploadText(name, text) {
+    const file = await this.writeTextArtifact(name, text);
+    return { file, asset: await this.uploadFile(file) };
+  }
+
+  async fetchJson(url, options) {
+    const r = await fetch(absoluteUrl(this.config.wttBaseUrl, url), options);
+    if (!r.ok) throw new Error(`WTT media API failed: ${r.status} ${await r.text()}`);
+    return r.json();
+  }
+
+  authHeaders() {
+    return this.config.httpToken ? { Authorization: `Bearer ${this.config.httpToken}` } : {};
+  }
+}
+
+function absoluteUrl(base, maybeRelative) {
+  if (/^https?:\/\//.test(maybeRelative)) return maybeRelative;
+  return `${String(base).replace(/\/$/, '')}${maybeRelative.startsWith('/') ? '' : '/'}${maybeRelative}`;
+}
+
+function safeName(name) {
+  return String(name || 'artifact.txt').replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 120) || 'artifact.txt';
+}

package/src/attachments.js

@@ -0,0 +1,181 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { lookupMime } from './mime.js';
+import { log } from './logger.js';
+
+export class AttachmentManager {
+  constructor(config) {
+    this.config = config;
+  }
+
+  async stageMessage(message) {
+    const refs = collectRefs(message);
+    if (!refs.length) return { files: [], images: [], promptBlock: '' };
+    await fs.mkdir(this.config.inboxDir, { recursive: true });
+    const files = [];
+    const images = [];
+    for (const ref of refs) {
+      try {
+        const staged = await this.stageRef(ref);
+        files.push(staged);
+        if (staged.mimeType.startsWith('image/')) images.push(staged.path);
+      } catch (err) {
+        log('warn', 'attachment stage failed', { name: ref.name || ref.url || ref.path, error: err.message });
+      }
+    }
+    return { files, images, promptBlock: renderPromptBlock(files) };
+  }
+
+  async stageRef(ref) {
+    if (ref.path) {
+      const resolved = path.resolve(ref.path);
+      const stat = await fs.stat(resolved);
+      if (!stat.isFile()) throw new Error('not a file');
+      return { ...ref, path: resolved, name: ref.name || path.basename(resolved), mimeType: ref.mimeType || lookupMime(resolved), size: stat.size };
+    }
+    if (!ref.url) throw new Error('missing attachment url/path');
+    const url = absoluteUrl(this.config.wttBaseUrl, ref.url);
+    const r = await fetch(url, { headers: this.authHeaders() });
+    if (!r.ok) throw new Error(`download failed: ${r.status}`);
+    const bytes = Buffer.from(await r.arrayBuffer());
+    const mimeType = ref.mimeType || r.headers.get('content-type')?.split(';')[0] || 'application/octet-stream';
+    const ext = extFromMime(mimeType) || path.extname(new URL(url).pathname) || '.bin';
+    const name = safeName(ref.name || path.basename(new URL(url).pathname) || `attachment${ext}`);
+    const file = path.resolve(this.config.inboxDir, `${Date.now()}-${crypto.randomUUID().slice(0, 8)}-${name.endsWith(ext) ? name : `${name}${ext}`}`);
+    await fs.writeFile(file, bytes);
+    return { ...ref, path: file, name, mimeType, size: bytes.length };
+  }
+
+  authHeaders() {
+    return this.config.httpToken ? { Authorization: `Bearer ${this.config.httpToken}` } : {};
+  }
+}
+
+export function collectRefs(message) {
+  const out = [];
+  const push = (x) => {
+    if (!x) return;
+    if (typeof x === 'string') out.push({ url: x });
+    else out.push({
+      url: x.url || x.public_url || x.download_url || x.href,
+      path: x.path || x.file_path,
+      name: x.name || x.filename || x.original_name,
+      mimeType: x.mime_type || x.mimeType || x.content_type,
+    });
+  };
+  for (const key of ['attachments', 'files', 'images', 'audio', 'media']) {
+    const value = message?.[key];
+    if (Array.isArray(value)) value.forEach(push);
+    else push(value);
+  }
+  for (const ref of refsFromMarkdown(String(message?.content || ''))) push(ref);
+  for (const ref of refsFromMetadata(message?.metadata)) push(ref);
+  return dedupeRefs(out.filter((x) => x.url || x.path));
+}
+
+function renderPromptBlock(files) {
+  if (!files.length) return '';
+  const lines = ['\nAttachments staged locally:'];
+  for (const f of files) lines.push(`- ${f.name || path.basename(f.path)} (${f.mimeType}, ${f.size} bytes): ${f.path}`);
+  lines.push('Use these local paths when relevant.');
+  return lines.join('\n');
+}
+
+function refsFromMarkdown(content) {
+  const out = [];
+  const imageRe = /!\[([^\]]*)\]\(([^\s)]+)(?:\s+"[^"]*")?\)/g;
+  for (const m of content.matchAll(imageRe)) {
+    out.push({ url: stripAngleBrackets(m[2]), name: m[1] || undefined });
+  }
+
+  const linkRe = /(?<!!)\[([^\]]+)\]\(([^\s)]+)(?:\s+"[^"]*")?\)/g;
+  for (const m of content.matchAll(linkRe)) {
+    const url = stripAngleBrackets(m[2]);
+    if (looksLikeMediaUrl(url)) out.push({ url, name: m[1] || undefined });
+  }
+
+  const bareUrlRe = /https?:\/\/[^\s)\]>"']+/g;
+  for (const m of content.matchAll(bareUrlRe)) {
+    const url = stripTrailingPunctuation(m[0]);
+    if (looksLikeMediaUrl(url)) out.push({ url });
+  }
+  return out;
+}
+
+function refsFromMetadata(metadata) {
+  if (!metadata) return [];
+  let obj = metadata;
+  if (typeof metadata === 'string') {
+    try { obj = JSON.parse(metadata); } catch { return refsFromMarkdown(metadata); }
+  }
+  const out = [];
+  const visit = (value) => {
+    if (!value) return;
+    if (Array.isArray(value)) return value.forEach(visit);
+    if (typeof value === 'string') {
+      if (looksLikeMediaUrl(value)) out.push({ url: value });
+      return;
+    }
+    if (typeof value !== 'object') return;
+    const url = value.url || value.public_url || value.download_url || value.href;
+    const pathValue = value.path || value.file_path;
+    if (url || pathValue) out.push({
+      url,
+      path: pathValue,
+      name: value.name || value.filename || value.original_name,
+      mimeType: value.mime_type || value.mimeType || value.content_type,
+    });
+    for (const key of ['attachments', 'files', 'images', 'audio', 'media']) visit(value[key]);
+  };
+  visit(obj);
+  return out;
+}
+
+function safeName(name) {
+  return String(name || 'attachment').replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 100) || 'attachment';
+}
+
+function looksLikeMediaUrl(url) {
+  try {
+    const u = new URL(stripAngleBrackets(url));
+    if (/\/media\//.test(u.pathname)) return true;
+    return /\.(png|jpe?g|gif|webp|bmp|svg|heic|mp3|wav|ogg|webm|mp4|mov|pdf|txt|md|json|zip)$/i.test(u.pathname);
+  } catch {
+    return false;
+  }
+}
+
+function stripAngleBrackets(value) {
+  return String(value || '').replace(/^</, '').replace(/>$/, '');
+}
+
+function stripTrailingPunctuation(value) {
+  return stripAngleBrackets(value).replace(/[.,;:!?，。；：！？]+$/, '');
+}
+
+function dedupeRefs(refs) {
+  const seen = new Set();
+  const out = [];
+  for (const ref of refs) {
+    const key = ref.path || ref.url;
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push(ref);
+  }
+  return out;
+}
+
+function extFromMime(mime) {
+  const m = {
+    'image/jpeg': '.jpg', 'image/png': '.png', 'image/gif': '.gif', 'image/webp': '.webp',
+    'audio/mpeg': '.mp3', 'audio/wav': '.wav', 'audio/ogg': '.ogg', 'audio/webm': '.webm',
+    'video/mp4': '.mp4', 'video/webm': '.webm', 'application/pdf': '.pdf',
+    'text/plain': '.txt', 'text/markdown': '.md', 'text/html': '.html', 'application/json': '.json', 'application/zip': '.zip',
+  };
+  return m[mime] || '';
+}
+
+function absoluteUrl(base, maybeRelative) {
+  if (/^https?:\/\//.test(String(maybeRelative))) return maybeRelative;
+  return `${String(base).replace(/\/$/, '')}${String(maybeRelative).startsWith('/') ? '' : '/'}${maybeRelative}`;
+}