@controlflow-ai/daemon 0.1.2 → 0.1.3

package/src/agent-workspace.ts

@@ -0,0 +1,183 @@
+import { existsSync, lstatSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, extname, join, resolve, sep } from 'node:path';
+import { agentHomePath } from './config.js';
+import type { AgentDefinition, AgentWorkspaceFile, AgentWorkspaceFileKind } from './types.js';
+
+const maxWorkspaceFileBytes = 20_000;
+const maxWorkspaceWriteBytes = 64_000;
+const allowedTextExtensions = new Set(['.md', '.txt', '.json']);
+const rootFileSpecs = new Map<string, { kind: AgentWorkspaceFileKind; label: string }>([
+  ['MEMORY.md', { kind: 'memory', label: 'Memory' }],
+  ['SOUL.md', { kind: 'soul', label: 'Soul' }],
+]);
+
+type DirectorySpec = {
+  dir: 'state' | 'kb';
+  kind: AgentWorkspaceFileKind;
+};
+
+const directorySpecs: DirectorySpec[] = [
+  { dir: 'state', kind: 'state' },
+  { dir: 'kb', kind: 'knowledge' },
+];
+
+export type AgentWorkspaceFileErrorCode =
+  | 'WORKSPACE_FILE_NOT_ALLOWED'
+  | 'WORKSPACE_FILE_NOT_FOUND'
+  | 'WORKSPACE_FILE_TOO_LARGE';
+
+export class AgentWorkspaceFileError extends Error {
+  constructor(
+    public readonly code: AgentWorkspaceFileErrorCode,
+    public readonly status: number,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+function isInsideHome(home: string, path: string): boolean {
+  const resolvedHome = resolve(home);
+  const resolvedPath = resolve(path);
+  return resolvedPath === resolvedHome || resolvedPath.startsWith(`${resolvedHome}${sep}`);
+}
+
+function normalizeWorkspaceRelativePath(input: string): string | null {
+  const trimmed = input.trim();
+  if (!trimmed || trimmed.includes('\\') || trimmed.includes('\0') || trimmed.startsWith('/')) return null;
+  const segments = trimmed.split('/');
+  if (segments.some((segment) => !segment || segment === '.' || segment === '..' || segment.startsWith('.'))) return null;
+  return segments.join('/');
+}
+
+function workspaceFileSpec(relativePath: string): { kind: AgentWorkspaceFileKind; label: string } | null {
+  const rootSpec = rootFileSpecs.get(relativePath);
+  if (rootSpec) return rootSpec;
+
+  const [directory, ...rest] = relativePath.split('/');
+  if (!rest.length || rest.length > 3) return null;
+  const directorySpec = directorySpecs.find((spec) => spec.dir === directory);
+  if (!directorySpec) return null;
+  const fileName = rest[rest.length - 1]!;
+  if (!allowedTextExtensions.has(extname(fileName).toLowerCase())) return null;
+  return { kind: directorySpec.kind, label: basename(fileName) };
+}
+
+function readWorkspaceFile(home: string, path: string, relativePath: string, kind: AgentWorkspaceFileKind, label: string): AgentWorkspaceFile | null {
+  if (!isInsideHome(home, path)) return null;
+  let stats;
+  try {
+    stats = lstatSync(path);
+  } catch {
+    return null;
+  }
+  if (!stats.isFile()) return null;
+  const bytes = readFileSync(path);
+  if (bytes.includes(0)) return null;
+  const truncated = bytes.byteLength > maxWorkspaceFileBytes;
+  const content = bytes.subarray(0, maxWorkspaceFileBytes).toString('utf8');
+  return {
+    path: relativePath,
+    label,
+    kind,
+    size_bytes: stats.size,
+    updated_at: stats.mtime.toISOString(),
+    content,
+    truncated,
+  };
+}
+
+function collectDirectoryFiles(home: string, spec: DirectorySpec): AgentWorkspaceFile[] {
+  const root = join(home, spec.dir);
+  if (!existsSync(root) || !isInsideHome(home, root)) return [];
+  try {
+    if (!lstatSync(root).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+
+  const files: AgentWorkspaceFile[] = [];
+  const walk = (directory: string, relativeDirectory: string, depth: number) => {
+    if (depth > 2) return;
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.')) continue;
+      const absolutePath = join(directory, entry.name);
+      const relativePath = `${relativeDirectory}/${entry.name}`;
+      if (!isInsideHome(home, absolutePath)) continue;
+      if (entry.isDirectory()) {
+        walk(absolutePath, relativePath, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || !allowedTextExtensions.has(extname(entry.name).toLowerCase())) continue;
+      const file = readWorkspaceFile(home, absolutePath, relativePath, spec.kind, basename(entry.name));
+      if (file) files.push(file);
+    }
+  };
+  walk(root, spec.dir, 0);
+  return files;
+}
+
+export function listAgentWorkspaceFiles(agent: AgentDefinition): AgentWorkspaceFile[] {
+  const home = agentHomePath(agent.id);
+  const files: AgentWorkspaceFile[] = [];
+  const memory = readWorkspaceFile(home, join(home, 'MEMORY.md'), 'MEMORY.md', 'memory', 'Memory');
+  if (memory) files.push(memory);
+  const soul = readWorkspaceFile(home, join(home, 'SOUL.md'), 'SOUL.md', 'soul', 'Soul');
+  if (soul) files.push(soul);
+  for (const spec of directorySpecs) {
+    files.push(...collectDirectoryFiles(home, spec));
+  }
+  return files;
+}
+
+export function updateAgentWorkspaceFile(agent: AgentDefinition, inputPath: string, content: string): AgentWorkspaceFile {
+  if (Buffer.byteLength(content, 'utf8') > maxWorkspaceWriteBytes) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_TOO_LARGE', 400, `workspace file edits are limited to ${maxWorkspaceWriteBytes} bytes`);
+  }
+  if (content.includes('\0')) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file content must be text');
+  }
+
+  const relativePath = normalizeWorkspaceRelativePath(inputPath);
+  if (!relativePath) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+  const spec = workspaceFileSpec(relativePath);
+  if (!spec) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+
+  const home = agentHomePath(agent.id);
+  const absolutePath = join(home, relativePath);
+  if (!isInsideHome(home, absolutePath)) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+
+  let stats;
+  try {
+    stats = lstatSync(absolutePath);
+  } catch {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_FOUND', 404, 'workspace file not found');
+  }
+  if (!stats.isFile()) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+
+  const existing = readWorkspaceFile(home, absolutePath, relativePath, spec.kind, spec.label);
+  if (!existing) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+
+  writeFileSync(absolutePath, content, 'utf8');
+  const updated = readWorkspaceFile(home, absolutePath, relativePath, spec.kind, spec.label);
+  if (!updated) {
+    throw new AgentWorkspaceFileError('WORKSPACE_FILE_NOT_ALLOWED', 400, 'workspace file path is not allowed');
+  }
+  return updated;
+}