@controlflow-ai/daemon 0.1.2 → 0.1.4

package/src/local-auth.ts

@@ -9,7 +9,21 @@ function hostName(value: string | null): string {
   return withoutPort.toLowerCase();
 }
 
-export function assertLocalRequest(request: Request, token: string | string[] | undefined): void {
+export interface LocalApiAgentPrincipal {
+  kind: 'agent';
+  agent: string;
+  runId: string;
+  chatId: string;
+}
+
+export interface LocalApiDaemonPrincipal {
+  kind: 'daemon';
+}
+
+export type LocalApiPrincipal = LocalApiAgentPrincipal | LocalApiDaemonPrincipal;
+export type RuntimeTokenLookup = (token: string) => LocalApiAgentPrincipal | null | undefined;
+
+function assertLocalRequestBasics(request: Request): void {
   const host = hostName(request.headers.get('host'));
   if (!ALLOWED_HOSTS.has(host)) {
     throw new HttpError(403, 'BAD_HOST', 'local daemon host is not allowed');
@@ -23,7 +37,10 @@ export function assertLocalRequest(request: Request, token: string | string[] |
   if (request.method === 'OPTIONS') {
     throw new HttpError(403, 'CORS_DENIED', 'CORS preflight is not allowed');
   }
+}
 
+export function assertLocalRequest(request: Request, token: string | string[] | undefined): void {
+  assertLocalRequestBasics(request);
   const tokens = Array.isArray(token) ? token.filter(Boolean) : token ? [token] : [];
   if (tokens.length === 0) {
     throw new HttpError(401, 'UNAUTHORIZED', 'local daemon token is required');
@@ -35,6 +52,21 @@ export function assertLocalRequest(request: Request, token: string | string[] |
   }
 }
 
+export function authenticateLocalRequest(
+  request: Request,
+  token: string | string[] | undefined,
+  runtimeTokenLookup?: RuntimeTokenLookup,
+): LocalApiPrincipal {
+  assertLocalRequestBasics(request);
+  const header = request.headers.get('authorization');
+  const bearer = header?.startsWith('Bearer ') ? header.slice('Bearer '.length) : '';
+  const tokens = Array.isArray(token) ? token.filter(Boolean) : token ? [token] : [];
+  if (tokens.some((item) => header === `Bearer ${item}`)) return { kind: 'daemon' };
+  const runtimePrincipal = bearer ? runtimeTokenLookup?.(bearer) : null;
+  if (runtimePrincipal) return runtimePrincipal;
+  throw new HttpError(401, 'UNAUTHORIZED', 'invalid local daemon token');
+}
+
 export function assertLoopbackBindHost(host: string): void {
   if (!LOOPBACK_BIND_HOSTS.has(host.toLowerCase())) {
     throw new Error('local daemon API must bind to a loopback host');

package/src/message-attachments.ts

@@ -0,0 +1,71 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { extname, join } from 'node:path';
+import { HttpError } from './http.js';
+
+export const MAX_MESSAGE_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+
+const ALLOWED_IMAGE_MIME_TYPES = new Set([
+  'image/png',
+  'image/jpeg',
+  'image/webp',
+  'image/gif',
+]);
+
+const EXTENSION_BY_MIME = new Map([
+  ['image/png', '.png'],
+  ['image/jpeg', '.jpg'],
+  ['image/webp', '.webp'],
+  ['image/gif', '.gif'],
+  ['text/plain', '.txt'],
+  ['text/markdown', '.md'],
+  ['application/json', '.json'],
+  ['text/html', '.html'],
+  ['application/pdf', '.pdf'],
+  ['application/zip', '.zip'],
+]);
+
+export function validateMessageAttachment(input: { kind: string; mimeType: string; content: Uint8Array }): void {
+  if (input.kind !== 'image' && input.kind !== 'file') throw new HttpError(400, 'UNSUPPORTED_ATTACHMENT_KIND', 'attachment kind must be image or file');
+  if (!input.mimeType.trim()) throw new HttpError(400, 'MISSING_ATTACHMENT_MIME', 'attachment mime_type is required');
+  if (input.kind === 'image' && !ALLOWED_IMAGE_MIME_TYPES.has(input.mimeType)) throw new HttpError(400, 'UNSUPPORTED_ATTACHMENT_MIME', 'unsupported image MIME type');
+  if (input.content.length === 0) throw new HttpError(400, 'EMPTY_ATTACHMENT', 'attachment content is required');
+  if (input.content.length > MAX_MESSAGE_ATTACHMENT_BYTES) throw new HttpError(400, 'ATTACHMENT_TOO_LARGE', 'attachment exceeds size limit');
+}
+
+export function safeAttachmentFilename(input: { id: string; filename?: string | null; mimeType: string }): string {
+  const raw = input.filename?.trim() || input.id;
+  const sanitized = raw.replace(/[/\\\0]+/g, '-').replace(/[^a-zA-Z0-9._ -]+/g, '-').trim().slice(0, 120) || input.id;
+  if (extname(sanitized)) return sanitized;
+  return `${sanitized}${EXTENSION_BY_MIME.get(input.mimeType) ?? '.bin'}`;
+}
+
+function safePathSegment(value: string): string {
+  return value.replace(/[/\\\0]+/g, '-').replace(/[^a-zA-Z0-9._-]+/g, '-').trim().slice(0, 160) || 'unknown';
+}
+
+export function storeMessageAttachmentFile(input: {
+  palHome: string;
+  roomId: string;
+  messageId: number;
+  attachmentId: string;
+  filename?: string | null;
+  mimeType: string;
+  content: Uint8Array;
+}): { path: string; filename: string } {
+  const filename = safeAttachmentFilename({
+    id: input.attachmentId,
+    filename: input.filename,
+    mimeType: input.mimeType,
+  });
+  const dir = join(
+    input.palHome,
+    'rooms',
+    safePathSegment(input.roomId),
+    'attachments',
+    `message-${input.messageId}`,
+  );
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const path = join(dir, `${safePathSegment(input.attachmentId)}-${filename}`);
+  writeFileSync(path, input.content, { mode: 0o600 });
+  return { path, filename };
+}