@vellumai/assistant 0.5.16 → 0.6.0

package/src/agent/image-optimize.ts

@@ -0,0 +1,165 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { parseImageDimensions } from "../context/image-dimensions.js";
+
+// Anthropic's documented max dimension — images larger than this are scaled
+// down server-side anyway, so pre-scaling is zero quality loss.
+const MAX_DIMENSION = 1568;
+
+// Threshold below which we skip optimization — small images don't need it.
+const OPTIMIZE_THRESHOLD_BYTES = 300 * 1024; // 300 KB
+
+const JPEG_QUALITY = 80;
+
+// Content-addressed disk cache to avoid re-running sips on the same image.
+const CACHE_MAX_ENTRIES = 500;
+
+function getCacheDir(): string {
+  return join(tmpdir(), "vellum-optimized-images");
+}
+
+function readFromCache(
+  key: string,
+): { data: string; mediaType: string } | null {
+  try {
+    const cachePath = join(getCacheDir(), `${key}.jpg`);
+    if (!existsSync(cachePath)) return null;
+    const buf = readFileSync(cachePath) as Buffer;
+    return { data: buf.toString("base64"), mediaType: "image/jpeg" };
+  } catch {
+    return null;
+  }
+}
+
+function writeToCache(key: string, optimizedBytes: Buffer): void {
+  try {
+    const dir = getCacheDir();
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `${key}.jpg`), optimizedBytes);
+    evictIfNeeded(dir);
+  } catch {
+    // Cache write failure is non-fatal.
+  }
+}
+
+function evictIfNeeded(dir: string): void {
+  try {
+    const entries = readdirSync(dir)
+      .filter((f) => f.endsWith(".jpg"))
+      .map((f) => {
+        const full = join(dir, f);
+        return { path: full, mtimeMs: statSync(full).mtimeMs };
+      })
+      .sort((a, b) => a.mtimeMs - b.mtimeMs);
+    const excess = entries.length - CACHE_MAX_ENTRIES;
+    for (let i = 0; i < excess; i++) {
+      try {
+        unlinkSync(entries[i]!.path);
+      } catch {
+        /* ignore */
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+function runSips(inputBytes: Buffer): Buffer | null {
+  const srcPath = join(tmpdir(), `vellum-img-opt-${Date.now()}-src`);
+  const outPath = join(tmpdir(), `vellum-img-opt-${Date.now()}-out.jpg`);
+  try {
+    writeFileSync(srcPath, inputBytes);
+    execFileSync(
+      "sips",
+      [
+        "--resampleHeightWidthMax",
+        String(MAX_DIMENSION),
+        "-s",
+        "format",
+        "jpeg",
+        "-s",
+        "formatOptions",
+        String(JPEG_QUALITY),
+        srcPath,
+        "--out",
+        outPath,
+      ],
+      { stdio: "pipe", timeout: 15_000 },
+    );
+    return readFileSync(outPath) as Buffer;
+  } catch {
+    return null;
+  } finally {
+    try {
+      unlinkSync(srcPath);
+    } catch {
+      /* ignore */
+    }
+    try {
+      unlinkSync(outPath);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * Downscale a base64 image to fit within Anthropic's recommended dimensions
+ * (1568px max side). Returns the original data unchanged if the image is
+ * already small enough or if optimization fails.
+ *
+ * Anthropic applies the same scaling server-side, so this is zero quality
+ * loss — we just do it pre-flight to keep request payloads small and avoid
+ * 413 "request too large" errors when many images accumulate in context.
+ *
+ * Results are cached on disk by content hash so repeated sends of the same
+ * image (or daemon restarts) skip the sips call entirely.
+ */
+export function optimizeImageForTransport(
+  base64Data: string,
+  mediaType: string,
+): { data: string; mediaType: string } {
+  const rawBytes = Buffer.from(base64Data, "base64");
+
+  // Small images don't need optimization.
+  if (rawBytes.length <= OPTIMIZE_THRESHOLD_BYTES) {
+    return { data: base64Data, mediaType };
+  }
+
+  // If dimensions are already within limits, skip.
+  const dims = parseImageDimensions(base64Data, mediaType);
+  if (
+    dims &&
+    dims.width <= MAX_DIMENSION &&
+    dims.height <= MAX_DIMENSION
+  ) {
+    return { data: base64Data, mediaType };
+  }
+
+  // Content-addressed cache lookup.
+  const hash = createHash("sha256").update(rawBytes).digest("hex");
+  const cacheKey = hash.slice(0, 16);
+  const cached = readFromCache(cacheKey);
+  if (cached) return cached;
+
+  // Run sips (macOS). On other platforms this gracefully returns null.
+  const optimized = runSips(rawBytes);
+  if (!optimized) {
+    return { data: base64Data, mediaType };
+  }
+
+  writeToCache(cacheKey, optimized);
+  return { data: optimized.toString("base64"), mediaType: "image/jpeg" };
+}

package/src/agent/loop.ts

@@ -101,10 +101,7 @@ const DEFAULT_CONFIG: AgentLoopConfig = {
   minTurnIntervalMs: 150,
 };
 
-const PROGRESS_CHECK_INTERVAL = 5;
 const MAX_CONSECUTIVE_ERROR_NUDGES = 3;
-const PROGRESS_CHECK_REMINDER =
-  "You have been using tools for several turns. Check whether you are making meaningful progress toward the user's goal. If you are stuck in a loop or not making progress, summarize what you have tried and ask the user for guidance instead of continuing.";
 
 export interface ResolvedSystemPrompt {
   systemPrompt: string;
@@ -573,21 +570,11 @@ export class AgentLoop {
           break;
         }
 
-        // Track tool-use turns and inject progress reminder every N turns
         toolUseTurns++;
-        const isProgressCheckTurn =
-          toolUseTurns % PROGRESS_CHECK_INTERVAL === 0;
-        if (isProgressCheckTurn) {
-          resultBlocks.push({
-            type: "text",
-            text: `<system_notice>${PROGRESS_CHECK_REMINDER}</system_notice>`,
-          });
-        }
 
         // When any tool returned an error, nudge the LLM to retry with
         // corrected parameters instead of ending its turn. Skip the nudge
-        // when the progress check fires (to avoid contradictory instructions)
-        // and after MAX_CONSECUTIVE_ERROR_NUDGES consecutive error turns
+        // after MAX_CONSECUTIVE_ERROR_NUDGES consecutive error turns
         // (the error is likely unrecoverable at that point).
         const hasToolError = toolResults.some(({ result }) => result.isError);
         if (hasToolError) {
@@ -597,7 +584,6 @@ export class AgentLoop {
         }
         if (
           hasToolError &&
-          !isProgressCheckTurn &&
           consecutiveErrorTurns <= MAX_CONSECUTIVE_ERROR_NUDGES
         ) {
           resultBlocks.push({

package/src/bundler/app-compiler.ts

@@ -11,7 +11,7 @@
 
 import { existsSync, rmSync } from "node:fs";
 import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 
 import { getLogger } from "../util/logger.js";
 import { ensureCompilerTools } from "./compiler-tools.js";
@@ -79,6 +79,161 @@ function parseEsbuildStderr(stderr: string): {
   return { errors, warnings };
 }
 
+/**
+ * Decode JS string escape sequences (\xHH, \uHHHH, \u{H+}, standard
+ * escapes) so that obfuscated specifiers like `"\x2e\x2e/etc/passwd"` are
+ * normalised before the path-containment check.
+ */
+function decodeJsEscapes(raw: string): string {
+  return raw.replace(
+    /\\(?:x([0-9a-fA-F]{2})|u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|([nrtbfv0'"\\]))/g,
+    (_, hex2, codePoint, hex4, std) => {
+      if (hex2) return String.fromCharCode(parseInt(hex2, 16));
+      if (codePoint) return String.fromCodePoint(parseInt(codePoint, 16));
+      if (hex4) return String.fromCharCode(parseInt(hex4, 16));
+      const map: Record<string, string> = {
+        n: "\n",
+        r: "\r",
+        t: "\t",
+        b: "\b",
+        f: "\f",
+        v: "\v",
+        "0": "\0",
+        "'": "'",
+        '"': '"',
+        "\\": "\\",
+      };
+      return map[std] ?? std;
+    },
+  );
+}
+
+/**
+ * Strip JS block comments and line comments from source, replacing them
+ * with same-length whitespace so character offsets (used for line-number
+ * calculation) are preserved.  String literals are left intact.
+ */
+function stripJsComments(source: string): string {
+  let out = "";
+  for (let i = 0; i < source.length; ) {
+    const c = source[i];
+    const next = source[i + 1];
+
+    // String literal — pass through unchanged
+    if (c === '"' || c === "'" || c === "`") {
+      const q = c;
+      out += source[i++];
+      while (i < source.length && source[i] !== q) {
+        if (source[i] === "\\") {
+          out += source[i++]; // backslash
+        }
+        if (i < source.length) out += source[i++]; // char or escaped char
+      }
+      if (i < source.length) out += source[i++]; // closing quote
+      continue;
+    }
+
+    // Block comment → replace with spaces (keep newlines for line counting)
+    if (c === "/" && next === "*") {
+      out += "  "; // replace /*
+      i += 2;
+      while (
+        i < source.length &&
+        !(source[i] === "*" && source[i + 1] === "/")
+      ) {
+        out += source[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      if (i < source.length) {
+        out += "  "; // replace */
+        i += 2;
+      }
+      continue;
+    }
+
+    // Line comment → replace with spaces
+    if (c === "/" && next === "/") {
+      out += "  "; // replace //
+      i += 2;
+      while (i < source.length && source[i] !== "\n") {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+
+    out += source[i++];
+  }
+  return out;
+}
+
+/**
+ * Validate that all relative/absolute import paths in source files resolve
+ * within the app directory. This prevents crafted apps from importing
+ * arbitrary host files (e.g. `import data from '../../../../etc/passwd'`).
+ */
+async function validateImportPaths(
+  srcDir: string,
+  appDir: string,
+): Promise<CompileDiagnostic[]> {
+  const resolvedAppDir = resolve(appDir);
+  const errors: CompileDiagnostic[] = [];
+
+  const files = await readdir(srcDir, { recursive: true });
+  for (const file of files) {
+    const fileName = String(file);
+    const isJs = /\.[jt]sx?$/.test(fileName);
+    const isCss = /\.css$/.test(fileName);
+    if (!isJs && !isCss) continue;
+
+    const filePath = join(srcDir, fileName);
+    const content = await readFile(filePath, "utf-8");
+    const fileDir = dirname(filePath);
+
+    // Strip JS comments so patterns like `from /* */ "path"` are detected
+    const scannable = isJs ? stripJsComments(content) : content;
+
+    const specifiers: Array<{ specifier: string; index: number }> = [];
+
+    if (isJs) {
+      // Match: from "x", import "x", import("x"), require("x")
+      const re = /(?:from|import|require)\s*\(?\s*["']([^"']+)["']/g;
+      for (const m of scannable.matchAll(re)) {
+        specifiers.push({ specifier: m[1], index: m.index! });
+      }
+    } else {
+      // CSS: @import "x", @import url("x"), url("x")
+      const re =
+        /(?:@import\s+(?:url\s*\(\s*)?|url\s*\(\s*)["']?([^"')\s;]+)["']?/g;
+      for (const m of content.matchAll(re)) {
+        if (m[1]) specifiers.push({ specifier: m[1], index: m.index! });
+      }
+    }
+
+    for (const { specifier, index } of specifiers) {
+      // Decode JS string escapes so \x2e\x2e/… is normalised to ../../…
+      const decoded = isJs ? decodeJsEscapes(specifier) : specifier;
+
+      // Only validate path-based imports (starting with . or /)
+      if (!decoded.startsWith(".") && !decoded.startsWith("/")) continue;
+
+      const resolved = resolve(fileDir, decoded);
+      if (
+        !resolved.startsWith(resolvedAppDir + "/") &&
+        resolved !== resolvedAppDir
+      ) {
+        const line = content.substring(0, index).split("\n").length;
+        errors.push({
+          text: `Import "${specifier}" resolves outside the app directory`,
+          location: { file: fileName, line, column: 0 },
+        });
+      }
+    }
+  }
+
+  return errors;
+}
+
 /**
  * Scan source files for bare import specifiers and pre-install any
  * allowlisted packages into the shared cache so esbuild can resolve them.
@@ -86,6 +241,7 @@ function parseEsbuildStderr(stderr: string): {
 async function resolveAppImports(srcDir: string): Promise<void> {
   const importRe = /(?:import|from)\s+["']([^"'.][^"']*)["']/g;
   const seen = new Set<string>();
+  const failed: string[] = [];
 
   const files = await readdir(srcDir, { recursive: true });
   for (const file of files) {
@@ -97,9 +253,19 @@ async function resolveAppImports(srcDir: string): Promise<void> {
       const pkg = packageName(specifier);
       if (seen.has(pkg)) continue;
       seen.add(pkg);
-      await resolvePackage(pkg);
+      const result = await resolvePackage(pkg);
+      if (result === null) {
+        failed.push(pkg);
+      }
     }
   }
+
+  if (failed.length > 0) {
+    log.warn(
+      { failed },
+      "Some imported packages could not be resolved — esbuild may fail",
+    );
+  }
 }
 
 /**
@@ -137,6 +303,17 @@ export async function compileApp(appDir: string): Promise<CompileResult> {
     };
   }
 
+  // Validate that path-based imports don't escape the app directory
+  const pathErrors = await validateImportPaths(srcDir, appDir);
+  if (pathErrors.length > 0) {
+    const durationMs = Math.round(performance.now() - start);
+    log.info(
+      { durationMs, errorCount: pathErrors.length },
+      "Build blocked: imports resolve outside app directory",
+    );
+    return { ok: false, errors: pathErrors, warnings: [], durationMs };
+  }
+
   // Scan source files for bare imports and JIT-install allowed packages
   await resolveAppImports(srcDir);
 

package/src/bundler/package-resolver.ts

@@ -10,6 +10,7 @@ import { mkdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+import { ensureBun } from "../util/bun-runtime.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("package-resolver");
@@ -117,14 +118,11 @@ async function installPackage(
   log.info({ pkg }, "Installing package into shared cache");
 
   try {
-    const proc = Bun.spawn(["bun", "install", "--no-save", pkg], {
+    const bunPath = await ensureBun();
+    const proc = Bun.spawn([bunPath, "install", "--no-save", pkg], {
       cwd: cacheDir,
       stdout: "pipe",
       stderr: "pipe",
-      env: {
-        ...process.env,
-        PATH: `${homedir()}/.bun/bin:${process.env.PATH}`,
-      },
     });
 
     // Race against timeout

package/src/cli/__tests__/notifications.test.ts

@@ -55,7 +55,7 @@ mock.module("../../channels/config.js", () => ({
 
 import { Command } from "commander";
 
-import { getDb, initializeDb, resetDb } from "../../memory/db.js";
+import { getDb, initializeDb } from "../../memory/db.js";
 import { createEvent } from "../../notifications/events-store.js";
 import { registerNotificationsCommand } from "../commands/notifications.js";
 
@@ -129,7 +129,6 @@ beforeEach(() => {
 });
 
 afterAll(() => {
-  resetDb();
   process.exitCode = 0;
 });
 

package/src/cli/cli-memory.ts

@@ -1,10 +1,9 @@
-import { and, eq } from "drizzle-orm";
+import { and, eq, like, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "../memory/db.js";
-import { computeMemoryFingerprint } from "../memory/fingerprint.js";
 import { enqueueMemoryJob } from "../memory/jobs-store.js";
-import { memoryItems } from "../memory/schema.js";
+import { memoryGraphNodes } from "../memory/schema.js";
 import { getLogger } from "../util/logger.js";
 import { buildCliProgram } from "./program.js";
 
@@ -28,8 +27,17 @@ export function buildCliCapabilityStatement(
   return statement;
 }
 
+/** Default emotional charge for capability graph nodes. */
+const DEFAULT_EMOTIONAL_CHARGE = JSON.stringify({
+  valence: 0,
+  intensity: 0.1,
+  decayCurve: "linear",
+  decayRate: 0.05,
+  originalIntensity: 0.1,
+});
+
 /**
- * Upsert a capability memory item for a CLI command.
+ * Upsert a capability memory graph node for a CLI command.
  * Best-effort: errors are logged but never thrown.
  */
 export function upsertCliCapabilityMemory(
@@ -38,100 +46,95 @@ export function upsertCliCapabilityMemory(
 ): void {
   try {
     const db = getDb();
-    const subject = `cli:${commandName}`;
     const statement = buildCliCapabilityStatement(commandName, description);
-    const kind = "capability";
+    const content = `cli:${commandName}\n${statement}`;
     const scopeId = "default";
-    const confidence = 1.0;
-    const importance = 0.7;
-    const fingerprint = computeMemoryFingerprint(
-      scopeId,
-      kind,
-      subject,
-      statement,
-    );
     const now = Date.now();
 
     const existing = db
       .select()
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, kind),
-          eq(memoryItems.subject, subject),
-          eq(memoryItems.scopeId, scopeId),
+          eq(memoryGraphNodes.type, "procedural"),
+          like(memoryGraphNodes.content, `cli:${commandName}\n%`),
+          eq(memoryGraphNodes.scopeId, scopeId),
         ),
       )
       .get();
 
     if (existing) {
       if (
-        existing.status === "active" &&
-        existing.fingerprint === fingerprint
+        existing.content === content &&
+        existing.fidelity !== "gone"
       ) {
-        // Same content — just touch lastSeenAt
-        db.update(memoryItems)
-          .set({ lastSeenAt: now })
-          .where(eq(memoryItems.id, existing.id))
+        // Same content — just touch lastAccessed
+        db.update(memoryGraphNodes)
+          .set({ lastAccessed: now })
+          .where(eq(memoryGraphNodes.id, existing.id))
           .run();
         return;
       }
 
-      if (existing.status === "active") {
-        // Content changed — update statement and fingerprint
-        db.update(memoryItems)
+      if (existing.fidelity !== "gone") {
+        // Content changed — update content
+        db.update(memoryGraphNodes)
           .set({
-            statement,
-            fingerprint,
-            lastSeenAt: now,
+            content,
+            lastAccessed: now,
           })
-          .where(eq(memoryItems.id, existing.id))
+          .where(eq(memoryGraphNodes.id, existing.id))
           .run();
-        enqueueMemoryJob("embed_item", { itemId: existing.id });
+        enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
         return;
       }
 
-      // status === "deleted" or other — reactivate
-      db.update(memoryItems)
+      // fidelity === "gone" — reactivate
+      db.update(memoryGraphNodes)
         .set({
-          status: "active",
-          statement,
-          fingerprint,
-          lastSeenAt: now,
-          firstSeenAt: now,
+          fidelity: "vivid",
+          content,
+          created: now,
+          lastAccessed: now,
         })
-        .where(eq(memoryItems.id, existing.id))
+        .where(eq(memoryGraphNodes.id, existing.id))
         .run();
-      enqueueMemoryJob("embed_item", { itemId: existing.id });
+      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
       return;
     }
 
-    // No existing — insert new row
+    // No existing — insert new graph node
     const id = uuid();
-    db.insert(memoryItems)
+    db.insert(memoryGraphNodes)
       .values({
         id,
-        kind,
-        subject,
-        statement,
-        status: "active",
-        confidence,
-        importance,
-        fingerprint,
-        sourceType: "extraction",
+        content,
+        type: "procedural",
+        created: now,
+        lastAccessed: now,
+        lastConsolidated: now,
+        emotionalCharge: DEFAULT_EMOTIONAL_CHARGE,
+        fidelity: "vivid",
+        confidence: 1.0,
+        significance: 0.7,
+        stability: 14,
+        reinforcementCount: 0,
+        lastReinforced: now,
+        sourceConversations: JSON.stringify([]),
+        sourceType: "inferred",
+        narrativeRole: null,
+        partOfStory: null,
         scopeId,
-        firstSeenAt: now,
-        lastSeenAt: now,
       })
       .run();
-    enqueueMemoryJob("embed_item", { itemId: id });
+    enqueueMemoryJob("embed_graph_node", { nodeId: id });
   } catch (err) {
     log.warn({ err, commandName }, "Failed to upsert CLI capability memory");
   }
 }
 
 /**
- * Seed capability memory items for all CLI commands.
+ * Seed capability memory graph nodes for all CLI commands.
  * Prunes stale entries whose commands are no longer registered.
  * Best-effort: errors are logged but never thrown.
  */
@@ -149,24 +152,24 @@ export function seedCliCommandMemories(): void {
     const db = getDb();
     const allCapabilities = db
       .select()
-      .from(memoryItems)
+      .from(memoryGraphNodes)
       .where(
         and(
-          eq(memoryItems.kind, "capability"),
-          eq(memoryItems.scopeId, "default"),
-          eq(memoryItems.status, "active"),
+          eq(memoryGraphNodes.type, "procedural"),
+          eq(memoryGraphNodes.scopeId, "default"),
+          sql`${memoryGraphNodes.fidelity} != 'gone'`,
         ),
       )
       .all();
 
     const now = Date.now();
     for (const item of allCapabilities) {
-      if (!item.subject.startsWith("cli:")) continue;
-      const itemCommandName = item.subject.replace("cli:", "");
+      if (!item.content.startsWith("cli:")) continue;
+      const itemCommandName = item.content.split("\n")[0].replace("cli:", "");
       if (!commandNames.has(itemCommandName)) {
-        db.update(memoryItems)
-          .set({ status: "deleted", lastSeenAt: now })
-          .where(eq(memoryItems.id, item.id))
+        db.update(memoryGraphNodes)
+          .set({ fidelity: "gone", lastAccessed: now })
+          .where(eq(memoryGraphNodes.id, item.id))
           .run();
       }
     }