@pablopunk/webr 0.3.8 → 0.3.10

package/src/server/host.ts

@@ -14,11 +14,13 @@ import { isTrustedHost } from './auth/access';
 import { registerDevHmrProxy } from './dev-hmr-proxy';
 import { registerVoiceRoutes } from './voice/routes';
 import type { Transcriber } from './voice/transcriber';
-import { MAX_IMAGE_BYTES, UploadStore, uploadContentTypes } from './uploads';
+import { MAX_IMAGE_BYTES, UploadStore, uploadContentTypes, uploadFileName } from './uploads';
 
 const localOwner = 'local';
 type SsrHandler = (request: FastifyRequest['raw'], response: import('node:http').ServerResponse, next: (error?: unknown) => void, locals: Record<string, unknown>) => void;
 
+const MAX_PROJECT_ICON_BYTES = 512 * 1024;
+
 export async function createHost(manager: RuntimeManager, origin: string, ssr?: SsrHandler, tls?: { key: Buffer; cert: Buffer }, uploads = new UploadStore(), authOptions: AuthOptions = {}, { devHmrPort, transcriber }: { devHmrPort?: number; transcriber?: Transcriber } = {}) {
   const app = Fastify({ logger: false, bodyLimit: 16 * 1024, ...(tls ? { https: tls } : {}), requestTimeout: 10_000 });
   const configuredOrigin = new URL(origin);
@@ -37,6 +39,9 @@ export async function createHost(manager: RuntimeManager, origin: string, ssr?:
     if (error instanceof z.ZodError) return reply.code(400).send({ error: 'invalid_request' });
     const status = (error as { statusCode?: number }).statusCode;
     if (status === 413) return reply.code(413).send({ error: 'image_too_large' });
+    if (message === 'file_too_large') return reply.code(413).send({ error: message });
+    if (message === 'empty_file') return reply.code(400).send({ error: message });
+    if (message === 'upload_failed') return reply.code(502).send({ error: message });
     if (status === 415 || message === 'unsupported_image') return reply.code(415).send({ error: 'unsupported_image' });
     if (status && status >= 400 && status < 500) return reply.code(status).send({ error: 'invalid_request' });
     if (message === 'thread_not_found') return reply.code(404).send({ error: message });
@@ -57,12 +62,13 @@ export async function createHost(manager: RuntimeManager, origin: string, ssr?:
   app.get('/api/runtime', async () => manager.bootstrap());
   app.addContentTypeParser(uploadContentTypes, { parseAs: 'buffer', bodyLimit: MAX_IMAGE_BYTES }, (_request, body, done) => done(null, body));
   app.post('/api/uploads', { bodyLimit: MAX_IMAGE_BYTES }, async (request, reply) => {
-    const { machineId } = z.object({ machineId: opaqueId }).strict().parse(request.query);
+    const { machineId, name } = z.object({ machineId: opaqueId, name: z.string().max(255).optional() }).strict().parse(request.query);
     const supervisor = manager.supervisors.get(machineId);
     if (!supervisor?.connected) return reply.code(409).send({ error: 'machine_disconnected' });
-    if (!supervisor.target.acceptsLocalFiles) return reply.code(409).send({ error: 'uploads_unsupported_target' });
+    if (!supervisor.target.acceptsUploads) return reply.code(409).send({ error: 'uploads_unsupported_target' });
     if (!Buffer.isBuffer(request.body)) return reply.code(415).send({ error: 'unsupported_image' });
-    return { path: await uploads.save(request.headers['content-type'], request.body) };
+    const fileName = uploadFileName(request.headers['content-type'], name, request.body);
+    return { path: supervisor.target.storeUpload ? await supervisor.target.storeUpload(fileName, request.body) : await uploads.saveAs(fileName, request.body) };
   });
   app.get('/api/directories', async (request, reply) => {
     const { machineId, prefix } = z.object({ machineId: opaqueId, prefix: z.string().max(1000).refine((path) => !/[\x00-\x1f]/.test(path)) }).strict().parse(request.query);
@@ -87,10 +93,20 @@ export async function createHost(manager: RuntimeManager, origin: string, ssr?:
     supervisor.invalidate();
     return reply.code(result.state === 'unknown' ? 202 : 201).send(result);
   });
+  const projectIconTarget = z.object({ machineId: opaqueId, logicalId: z.string().min(1).max(1000) }).strict();
+  app.put('/api/projects/icon', { bodyLimit: MAX_PROJECT_ICON_BYTES }, async (request, reply) => {
+    const { machineId, logicalId } = projectIconTarget.parse(request.query);
+    if (!Buffer.isBuffer(request.body)) return reply.code(415).send({ error: 'unsupported_image' });
+    manager.setProjectIcon(machineId, logicalId, request.headers['content-type'], request.body); return { saved: true };
+  });
+  app.delete('/api/projects/icon', async (request) => {
+    const { machineId, logicalId } = projectIconTarget.parse(request.query);
+    manager.resetProjectIcon(machineId, logicalId); return { reset: true };
+  });
   app.get('/api/projects/:machineId/:projectId/icon', async (request, reply) => {
     const { machineId, projectId } = z.object({ machineId: opaqueId, projectId: opaqueId }).parse(request.params);
     const target = manager.supervisors.get(machineId)?.target;
-    const icon = await target?.icon?.(projectId);
+    const icon = manager.customProjectIcon(machineId, projectId) ?? await target?.icon?.(projectId);
     if (!icon) return reply.code(404).send();
     if (icon.contentType === 'image/svg+xml') reply.header('Content-Security-Policy', "sandbox; default-src 'none'; style-src 'unsafe-inline'");
     return reply.type(icon.contentType).send(icon.bytes);

package/src/server/runtime/manager.ts

@@ -3,7 +3,9 @@ import type { TargetAdapter } from './target';
 import type { Thread } from '../../lib/models';
 import { canClosePane, insertAfter } from '../../lib/pane-strip';
 import { TargetSupervisor } from './supervisor';
-import { projectNameKey, reconcile } from './reconcile';
+import { projectIconKey, projectNameKey, reconcile } from './reconcile';
+import { imageExtension } from '../uploads';
+import type { Icon } from '../transport/icons';
 import type { MetadataDatabase } from '../storage/database';
 import type { Bootstrap, Projection } from '../../shared/runtime';
 import type { Machine } from '../../lib/machines';
@@ -39,9 +41,9 @@ export class RuntimeManager extends EventEmitter {
   async close() { this.closed = true; for (const supervisor of this.supervisors.values()) supervisor.stop(); await this.journal.stop(); this.removeAllListeners(); }
   bootstrap(): Bootstrap {
     const projections = [...this.projections.values()];
-    return { projections, projects: projections.flatMap((projection) => projection.projects), threads: projections.flatMap((projection) => projection.threads), machines: [...this.supervisors.values()].map((supervisor) => ({ id: supervisor.target.id, name: supervisor.target.name, session: supervisor.target.session, connected: supervisor.connected, projectPaths: Object.fromEntries(supervisor.target.locations.map((location) => [location.projectId, location.path])), harnesses: [], error: supervisor.error, writable: supervisor.target.writable, configVersion: this.configVersions.get(supervisor.target.id) })) };
+    return { projections, projects: projections.flatMap((projection) => projection.projects), threads: projections.flatMap((projection) => projection.threads), machines: [...this.supervisors.values()].map((supervisor) => ({ id: supervisor.target.id, name: supervisor.target.name, session: supervisor.target.session, connected: supervisor.connected, projectPaths: Object.fromEntries(supervisor.target.locations.map((location) => [location.projectId, location.path])), harnesses: [], error: supervisor.error, writable: supervisor.target.writable, os: supervisor.target.os, configVersion: this.configVersions.get(supervisor.target.id) })) };
   }
-  private machine(supervisor: TargetSupervisor): Machine { return { id: supervisor.target.id, name: supervisor.target.name, session: supervisor.target.session, connected: supervisor.connected, configVersion: supervisor.target.configVersion, writable: supervisor.target.writable, error: supervisor.error, projectPaths: Object.fromEntries(supervisor.target.locations.map((location) => [location.projectId, location.path])), harnesses: [] }; }
+  private machine(supervisor: TargetSupervisor): Machine { return { id: supervisor.target.id, name: supervisor.target.name, session: supervisor.target.session, connected: supervisor.connected, configVersion: supervisor.target.configVersion, writable: supervisor.target.writable, os: supervisor.target.os, error: supervisor.error, projectPaths: Object.fromEntries(supervisor.target.locations.map((location) => [location.projectId, location.path])), harnesses: [] }; }
   async catalog(machineId: string, projectId?: string) {
     const supervisor = this.supervisors.get(machineId);
     if (!supervisor?.connected) throw new Error('machine_disconnected');
@@ -125,6 +127,26 @@ export class RuntimeManager extends EventEmitter {
     this.database.setSetting(projectNameKey(machineId, logicalId), name);
     this.publish(supervisor);
   }
+  setProjectIcon(machineId: string, logicalId: string, contentType: string | undefined, bytes: Buffer) {
+    const supervisor = this.supervisors.get(machineId);
+    if (!supervisor) throw new Error('machine_disconnected');
+    imageExtension(contentType, bytes);
+    this.database.setSetting(projectIconKey(machineId, logicalId), `${contentType!.split(';')[0].trim()}|${bytes.toString('base64')}`);
+    this.publish(supervisor);
+  }
+  resetProjectIcon(machineId: string, logicalId: string) {
+    const supervisor = this.supervisors.get(machineId);
+    if (!supervisor) throw new Error('machine_disconnected');
+    this.database.deleteSetting(projectIconKey(machineId, logicalId));
+    this.publish(supervisor);
+  }
+  customProjectIcon(machineId: string, projectId: string): Icon | undefined {
+    const logicalId = this.projections.get(machineId)?.projects.find((project) => project.id === projectId)?.logicalId;
+    const stored = logicalId && this.database.getSetting(projectIconKey(machineId, logicalId));
+    if (!stored) return;
+    const [contentType, data] = stored.split('|');
+    return { contentType, bytes: Buffer.from(data, 'base64') };
+  }
   async renameThread(machineId: string, threadId: string, title: string) {
     const supervisor = this.supervisors.get(machineId);
     const thread = this.projections.get(machineId)?.threads.find((thread) => thread.id === threadId);

package/src/server/runtime/reconcile.ts

@@ -5,6 +5,9 @@ import type { Project, Thread } from '../../lib/models';
 import type { TargetAdapter } from './target';
 import { orderPanes } from '../../lib/pane-strip';
 
+export const projectIconKey = (machineId: string, logicalId: string) => `project-icon:${machineId}:${logicalId}`;
+const iconRoute = (machineId: string, id: string, version = '') => `/api/projects/${encodeURIComponent(machineId)}/${encodeURIComponent(id)}/icon${version}`;
+const customIconVersion = (value?: string) => value ? `?v=${createHash('sha1').update(value).digest('hex').slice(0, 8)}` : undefined;
 export const projectNameKey = (machineId: string, logicalId: string) => `project-name:${machineId}:${logicalId}`;
 export const projectIdentity = (machineId: string, repository: string) => createHash('sha256').update(machineId + '\0' + repository).digest('hex').slice(0, 32);
 const sameBinding = (thread: Thread, target: TargetAdapter) => thread.session === target.session && thread.bindingFingerprint === target.fingerprint && thread.bindingConfigVersion === target.configVersion;
@@ -17,6 +20,12 @@ const threadTitle = (label: string | null | undefined, panes: NativeSnapshot['pa
   return agent?.title?.trim() || agent?.terminal_title_stripped?.trim() || namedTab || fallback;
 };
 
+function projectIconUrl(database: MetadataDatabase, target: TargetAdapter, id: string, logicalId: string, located: boolean) {
+  const custom = customIconVersion(database.getSetting(projectIconKey(target.id, logicalId)));
+  if (custom) return iconRoute(target.id, id, custom);
+  return target.icon && located ? iconRoute(target.id, id) : undefined;
+}
+
 export function reconcile(database: MetadataDatabase, target: TargetAdapter, snapshot: NativeSnapshot): { threads: Thread[]; projects: Project[] } {
   const saved = database.threadRows(target.id);
   const projects: Project[] = [];
@@ -26,7 +35,7 @@ export function reconcile(database: MetadataDatabase, target: TargetAdapter, sna
     const location = target.locations.find((location) => location.workspaceId === workspace.workspace_id || location.path === cwd);
     const id = location?.projectId ?? projectIdentity(target.id, workspace.worktree?.repo_key ?? (cwd || workspace.workspace_id));
     const logicalId = location?.logicalId ?? workspace.worktree?.repo_key ?? id;
-    if (!projects.some((project) => project.id === id)) projects.push({ id, machineId: target.id, localId: location?.localId, logicalId, name: database.getSetting(projectNameKey(target.id, logicalId)) ?? workspace.worktree?.repo_name ?? workspace.label, path: location?.path ?? cwd, color: '#9b83df', initial: (workspace.label[0] ?? 'P').toUpperCase(), iconUrl: target.icon && location ? `/api/projects/${encodeURIComponent(target.id)}/${encodeURIComponent(id)}/icon` : undefined });
+    if (!projects.some((project) => project.id === id)) projects.push({ id, machineId: target.id, localId: location?.localId, logicalId, name: database.getSetting(projectNameKey(target.id, logicalId)) ?? workspace.worktree?.repo_name ?? workspace.label, path: location?.path ?? cwd, color: '#9b83df', initial: (workspace.label[0] ?? 'P').toUpperCase(), iconUrl: projectIconUrl(database, target, id, logicalId, !!location) });
     for (const tab of snapshot.tabs.filter((tab) => tab.workspace_id === workspace.workspace_id)) tabProjects.set(tab.tab_id, id);
   }
   const launching = database.operations().some((operation) => operation.input.machineId === target.id && ['pending', 'running'].includes(operation.state));

package/src/server/runtime/target.ts

@@ -1,4 +1,4 @@
-import type { Machine } from '../../lib/machines';
+import type { Machine, MachineOs } from '../../lib/machines';
 import type { NativeSnapshot } from '../protocol/native';
 import type { TerminalFrame, TerminalStream } from '../terminal/cli';
 import type { LaunchInput } from '../../shared/runtime';
@@ -14,7 +14,9 @@ export type TargetAdapter = {
   enabled?: boolean;
   locations: LaunchLocation[];
   writable: boolean;
-  acceptsLocalFiles?: boolean;
+  os?: MachineOs;
+  acceptsUploads?: boolean;
+  storeUpload?(fileName: string, bytes: Buffer): Promise<string>;
   subscribe(onEvent: () => void, onClose: (reason: string) => void, paneIds?: string[]): Promise<() => void>;
   snapshot(): Promise<NativeSnapshot>;
   catalog(projectId?: string): Promise<Machine>;

package/src/server/storage/database.ts

@@ -25,6 +25,7 @@ export class MetadataDatabase {
   }
   close() { this.sqlite.close(); }
   getSetting(key: string) { return this.db.select().from(schema.settings).where(eq(schema.settings.key, key)).get()?.value; }
+  deleteSetting(key: string) { this.db.delete(schema.settings).where(eq(schema.settings.key, key)).run(); }
   setSetting(key: string, value: string) { this.db.insert(schema.settings).values({ key, value }).onConflictDoUpdate({ target: schema.settings.key, set: { value } }).run(); }
   threadRows(machineId?: string, session?: string) {
     return this.db.select().from(schema.threads).where(machineId ? and(eq(schema.threads.machineId, machineId), session ? eq(schema.threads.session, session) : undefined) : undefined).all();

package/src/server/transport/herdr-target.ts

@@ -5,9 +5,10 @@ import { SocketApi } from '../protocol/socket';
 import { nativeSnapshot, nativeWorkspace, nativeTab, nativePane } from '../protocol/native';
 import { openCliStream } from '../terminal/cli';
 import { boundedProcess } from './process';
+import { uploadOverSsh } from './remote-upload';
 import { SshForward, sshOptions, remoteCommand, quoteShell } from './ssh';
 import type { LaunchInput } from '../../shared/runtime';
-import type { Machine } from '../../lib/machines';
+import type { Machine, MachineOs } from '../../lib/machines';
 import { harnessName } from '../../lib/models';
 import { acceptsModelFlag, herdrAgentKinds, isHerdrAgentKind } from '../../shared/agent-kinds';
 import { modelListings, parseModelListing } from './model-discovery';
@@ -23,20 +24,25 @@ import { expandHome, listLocalDirectories, suggestDirectories } from '../directo
 const MODEL_LISTING_TIMEOUT_MS = 15_000;
 const MODEL_CACHE_TTL_MS = 10 * 60_000;
 const MODEL_LISTING_LIMIT = 4 * 1024 * 1024;
+const osFromPlatform = (platform: string): MachineOs | undefined => platform === 'darwin' || platform === 'Darwin' ? 'macos' : platform === 'win32' || /^(MINGW|MSYS|CYGWIN)/i.test(platform) ? 'windows' : platform.toLowerCase() === 'linux' ? 'linux' : undefined;
 type Dependencies = { process: typeof boundedProcess; cli: typeof openCliStream };
 export class HerdrTarget implements TargetAdapter {
   readonly id; readonly name; readonly session; readonly locations: LaunchLocation[];
   readonly fingerprint; configVersion = 1;
   get enabled() { return this.profile.enabled; }
   get writable() { return this.compatible; }
-  get acceptsLocalFiles() { return this.profile.transport === 'local'; }
+  get os() { return this.profile.transport === 'local' ? osFromPlatform(process.platform) : this.remoteOs; }
+  get acceptsUploads() { return this.profile.transport === 'local' || this.remoteOs !== 'windows'; }
+  storeUpload?: (fileName: string, bytes: Buffer) => Promise<string>;
   private api?: SocketApi;
   private forwarding?: SshForward;
   private compatible = false;
+  private remoteOs?: MachineOs;
   private connecting?: Promise<SocketApi>;
   private streams = new Set<ReturnType<typeof openCliStream>>();
   private icons = new Map<string, { expires: number; value: Promise<Icon | undefined> }>();
   constructor(private profile: TargetProfile, private dependencies: Dependencies = { process: boundedProcess, cli: openCliStream }) {
+    if (profile.transport === 'ssh') this.storeUpload = (fileName, bytes) => uploadOverSsh(profile.host!, fileName, bytes);
     this.id = profile.id; this.name = profile.name; this.session = profile.session;
     this.fingerprint = targetFingerprint(profile);
     this.locations = profile.locations.map((location) => ({ ...location, localId: location.projectId, logicalId: location.logicalId ?? location.projectId, projectId: scopedProjectId(profile.id, location.projectId) }));
@@ -67,6 +73,7 @@ export class HerdrTarget implements TargetAdapter {
       const schema = JSON.parse(await this.dependencies.process(schemaCommand.command, schemaCommand.args, schemaCommand.env, 5000, 2 * 1024 * 1024));
       if (validateInstalledSchema(schema).length) { this.compatible = false; throw new Error('unsupported_herdr_schema'); }
       this.compatible = true;
+      if (this.profile.transport === 'ssh') void this.detectRemoteOs();
       return this.api;
     })();
     try { return await this.connecting; }
@@ -89,7 +96,7 @@ export class HerdrTarget implements TargetAdapter {
     if (tab.workspace_id !== workspace.workspace_id || pane.workspace_id !== workspace.workspace_id || pane.tab_id !== tab.tab_id) throw new Error('workspace_identity_mismatch');
     return { workspaceId: workspace.workspace_id, tabId: tab.tab_id, terminalId: pane.terminal_id };
   }
-  async catalog(_projectId?: string): Promise<Machine> {
+  async catalog(projectId?: string): Promise<Machine> {
     const api = await this.connect();
     await api.request('ping');
     const run = (command: string, args: string[]) => this.runOnTarget(command, args);
@@ -97,7 +104,16 @@ export class HerdrTarget implements TargetAdapter {
     const present = (await Promise.all(herdrAgentKinds.map(async (kind) => (await isPresent(kind)) ? kind : undefined))).filter((kind): kind is string => !!kind);
     present.forEach((kind) => this.discoverModels(kind));
     const modelsPending = present.some((kind) => this.pendingModels.has(kind));
-    return { id: this.id, name: this.name, session: this.session, connected: true, writable: this.writable, configVersion: this.configVersion, modelsPending, projectPaths: Object.fromEntries(this.locations.map((location) => [location.projectId, location.path])), harnesses: present.map((id) => ({ id, name: harnessName(id), models: ['Default', ...(this.discoveredModels.get(id)?.models ?? [])], customModels: acceptsModelFlag(id), launchEnabled: true })) };
+    const isGitRepo = await this.isGitRepo(projectId);
+    return { id: this.id, name: this.name, session: this.session, connected: true, writable: this.writable, configVersion: this.configVersion, modelsPending, isGitRepo, projectPaths: Object.fromEntries(this.locations.map((location) => [location.projectId, location.path])), harnesses: present.map((id) => ({ id, name: harnessName(id), models: ['Default', ...(this.discoveredModels.get(id)?.models ?? [])], customModels: acceptsModelFlag(id), launchEnabled: true })) };
+  }
+  private async detectRemoteOs() {
+    this.remoteOs = await this.runOnTarget('uname', ['-s']).then((output) => osFromPlatform(output.trim()), () => undefined);
+  }
+  private async isGitRepo(projectId?: string) {
+    const location = this.locations.find((location) => location.projectId === projectId);
+    if (!location) return true;
+    return this.runOnTarget('git', ['-C', await this.expandHome(location.path), 'rev-parse', '--is-inside-work-tree']).then(() => true, () => false);
   }
   private discoveredModels = new Map<string, { models: string[]; expires: number }>();
   private pendingModels = new Set<string>();

package/src/server/transport/icons.ts

@@ -2,7 +2,8 @@ import { readdir, realpath, stat, readFile } from 'node:fs/promises';
 import { basename, dirname, extname, isAbsolute, join, relative, sep } from 'node:path';
 
 const contentTypes: Record<string, string> = { '.ico': 'image/x-icon', '.png': 'image/png', '.svg': 'image/svg+xml', '.webp': 'image/webp' };
-const directories = ['', 'public', 'static', 'assets', 'web', 'web/public', 'app/public', 'src/assets', 'src/app', 'frontend/public'];
+const maxBytes = 2 * 1024 * 1024;
+const directories = ['build/Icon.icon/Assets', '', 'public', 'static', 'assets', 'web', 'web/public', 'app/public', 'src/assets', 'src/app', 'frontend/public'];
 export type Icon = { bytes: Buffer; contentType: string };
 
 function withinRoot(root: string, path: string) {
@@ -37,9 +38,9 @@ async function iconInDirectory(root: string, directory: string): Promise<Icon |
       const file = await realpath(join(actual, entry.name));
       if (!withinRoot(root, file)) continue;
       const info = await stat(file);
-      if (!info.isFile() || info.size <= 0 || info.size > 1024 * 1024) continue;
+      if (!info.isFile() || info.size <= 0 || info.size > maxBytes) continue;
       const bytes = await readFile(file);
-      if (bytes.length <= 1024 * 1024) return { bytes, contentType: contentTypes[extname(entry.name).toLowerCase()] };
+      if (bytes.length <= maxBytes) return { bytes, contentType: contentTypes[extname(entry.name).toLowerCase()] };
     } catch {}
   }
 }
@@ -55,10 +56,17 @@ async function appDirectories(root: string) {
     .slice(0, 32).flatMap((entry) => ['public', 'static', 'assets', 'src/assets', 'src/app'].map((part) => join(apps, entry.name, part)));
 }
 
+async function sourceDirectories(root: string) {
+  try {
+    return (await readdir(join(root, 'src'), { withFileTypes: true })).filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name).sort().slice(0, 8).map((name) => join(root, 'src', name, 'public'));
+  } catch { return []; }
+}
+
 export async function readApprovedIcon(path: string): Promise<Icon | undefined> {
   let root: string;
   try { root = await realpath(path); } catch { return; }
-  for (const directory of [...directories.map((part) => join(root, part)), ...await appDirectories(root)]) {
+  for (const directory of [...directories.map((part) => join(root, part)), ...await sourceDirectories(root), ...await appDirectories(root)]) {
     const icon = await iconInDirectory(root, directory);
     if (icon) return icon;
   }

package/src/server/transport/remote-upload.ts

@@ -0,0 +1,40 @@
+import { spawn } from 'node:child_process';
+import { quoteShell, sshOptions } from './ssh';
+
+const UPLOAD_TIMEOUT_MS = 60_000;
+const EXPIRY_DAYS = 7;
+const OUTPUT_LIMIT = 4096;
+const hostPattern = /^[A-Za-z0-9_][A-Za-z0-9_.@-]{0,200}$/;
+const fileNamePattern = /^(image|file)-[0-9a-f-]{36}(\.[a-z0-9]{1,10})?$/;
+const absolutePath = /^\/[^\0\r\n]+$/;
+
+export const remoteUploadScript = (fileName: string) => {
+  if (!fileNamePattern.test(fileName)) throw new Error('invalid_upload_name');
+  return [
+    'set -e', 'umask 077',
+    'dir="${XDG_CACHE_HOME:-$HOME/.cache}/webr-uploads"', 'mkdir -p "$dir"',
+    `target="$dir/${fileName}"`,
+    'cat > "$target.part"', 'mv "$target.part" "$target"',
+    `find "$dir" -type f \\( -name 'image-*' -o -name 'file-*' \\) -mtime +${EXPIRY_DAYS} -exec rm -f {} + >/dev/null 2>&1 || true`,
+    'printf \'%s\\n\' "$target"',
+  ].join('\n');
+};
+
+export function uploadOverSsh(host: string, fileName: string, bytes: Buffer, spawnProcess: typeof spawn = spawn, timeoutMs = UPLOAD_TIMEOUT_MS): Promise<string> {
+  if (!hostPattern.test(host)) throw new Error('invalid_ssh_target');
+  const command = 'sh -c ' + quoteShell(remoteUploadScript(fileName));
+  return new Promise((resolve, reject) => {
+    const child = spawnProcess('ssh', [...sshOptions, host, command], { stdio: ['pipe', 'pipe', 'ignore'] });
+    let output = ''; let settled = false;
+    const settle = (error?: Error, path?: string) => {
+      if (settled) return; settled = true; clearTimeout(timer);
+      if (error) { child.kill('SIGTERM'); reject(error); } else resolve(path!);
+    };
+    const timer = setTimeout(() => settle(new Error('upload_failed')), timeoutMs);
+    child.stdout!.on('data', (chunk: Buffer) => { output += chunk; if (output.length > OUTPUT_LIMIT) settle(new Error('upload_failed')); });
+    child.stdin!.on('error', () => {});
+    child.on('error', () => settle(new Error('upload_failed')));
+    child.on('close', (code) => { const path = output.trim().split('\n').at(-1) ?? ''; if (code === 0 && absolutePath.test(path)) settle(undefined, path); else settle(new Error('upload_failed')); });
+    child.stdin!.end(bytes);
+  });
+}

package/src/server/uploads.ts

@@ -3,6 +3,8 @@ import { mkdir, readdir, rm, stat, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 
 export const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+export const MAX_FILE_BYTES = 5 * 1024 * 1024;
+export const FILE_CONTENT_TYPE = 'application/octet-stream';
 const UPLOAD_LIFETIME_MS = 7 * 24 * 60 * 60 * 1000;
 const startsWith = (bytes: Buffer, signature: number[], offset = 0) => signature.every((byte, index) => bytes[offset + index] === byte);
 const ascii = (text: string) => [...text].map((character) => character.charCodeAt(0));
@@ -12,7 +14,9 @@ const imageTypes: Record<string, { extension: string; matches: (bytes: Buffer) =
   'image/gif': { extension: 'gif', matches: (bytes) => startsWith(bytes, ascii('GIF87a')) || startsWith(bytes, ascii('GIF89a')) },
   'image/webp': { extension: 'webp', matches: (bytes) => startsWith(bytes, ascii('RIFF')) && startsWith(bytes, ascii('WEBP'), 8) },
 };
-export const uploadContentTypes = Object.keys(imageTypes);
+export const uploadContentTypes = [...Object.keys(imageTypes), FILE_CONTENT_TYPE];
+export const isFileUpload = (contentType: string | undefined) => contentType?.split(';')[0].trim().toLowerCase() === FILE_CONTENT_TYPE;
+const extensionOf = (name: string | undefined) => /\.[A-Za-z0-9]{1,10}$/.exec(name ?? '')?.[0].toLowerCase() ?? '';
 
 export function imageExtension(contentType: string | undefined, bytes: Buffer) {
   const type = imageTypes[contentType?.split(';')[0].trim().toLowerCase() ?? ''];
@@ -20,19 +24,26 @@ export function imageExtension(contentType: string | undefined, bytes: Buffer) {
   return type.extension;
 }
 
+export function uploadFileName(contentType: string | undefined, name: string | undefined, bytes: Buffer) {
+  if (!isFileUpload(contentType)) return `image-${randomUUID()}.${imageExtension(contentType, bytes)}`;
+  if (!bytes.length) throw new Error('empty_file');
+  if (bytes.length > MAX_FILE_BYTES) throw new Error('file_too_large');
+  return `file-${randomUUID()}${extensionOf(name)}`;
+}
+
 export class UploadStore {
   constructor(readonly directory = resolve(process.env.WEBR_UPLOADS ?? '.data/uploads'), private lifetimeMs = UPLOAD_LIFETIME_MS) {}
-  async save(contentType: string | undefined, bytes: Buffer) {
-    const extension = imageExtension(contentType, bytes);
+  save(contentType: string | undefined, bytes: Buffer, name?: string) { return this.saveAs(uploadFileName(contentType, name, bytes), bytes); }
+  async saveAs(fileName: string, bytes: Buffer) {
     await mkdir(this.directory, { recursive: true, mode: 0o700 });
-    const path = join(this.directory, `image-${randomUUID()}.${extension}`);
+    const path = join(this.directory, fileName);
     await writeFile(path, bytes, { mode: 0o600, flag: 'wx' });
     void this.removeExpired().catch(() => {});
     return path;
   }
   async removeExpired(now = Date.now()) {
     for (const name of await readdir(this.directory).catch(() => [] as string[])) {
-      if (!/^image-[0-9a-f-]{36}\.(png|jpg|gif|webp)$/.test(name)) continue;
+      if (!/^(image-[0-9a-f-]{36}\.(png|jpg|gif|webp)|file-[0-9a-f-]{36}(\.[a-z0-9]{1,10})?)$/.test(name)) continue;
       const path = join(this.directory, name);
       if (now - (await stat(path)).mtimeMs > this.lifetimeMs) await rm(path, { force: true });
     }