@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/daemon/install-assistant-command.ts

@@ -0,0 +1,322 @@
+/**
+ * Installs the `assistant` command onto PATH on every daemon start.
+ *
+ * Skills and the agent's own bash tool invoke `assistant …` (e.g. `assistant
+ * browser navigate`), and the daemon's PATH is inherited from a GUI app launch
+ * that carries none of the install's bin directories. Without this the command
+ * is simply missing and every such tool call exits 127.
+ */
+
+import { execFileSync } from "node:child_process";
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  renameSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, sep } from "node:path";
+
+import {
+  findAssistantCommand,
+  isRepoCheckoutPath,
+} from "@vellumai/environments";
+
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("install-assistant-command");
+
+/** Ownership marker embedded in every wrapper this module writes. */
+const WRAPPER_MARKER = "# vellum-assistant-command v1";
+
+/**
+ * What to install as `assistant`:
+ *   - `binary`: a compiled executable, installed as a symlink.
+ *   - `bun-entry`: a script bun must interpret, installed as a wrapper that
+ *     pins an absolute bun so the command works from any PATH.
+ */
+export type AssistantCommandTarget =
+  | { kind: "binary"; binary: string }
+  | { kind: "bun-entry"; bun: string; entry: string };
+
+/** Whether `execPath` is a bun runtime rather than a compiled product binary. */
+function isBunRuntime(execPath: string): boolean {
+  const base = basename(execPath);
+  return base === "bun" || base === "bunx" || base.startsWith("bun-");
+}
+
+/**
+ * The entrypoint bun should run for `assistant` in an npm-installed runtime:
+ * the command the install ships, or the assistant package's own CLI
+ * entrypoint when the dependency graph omits the package declaring that bin.
+ * Null for a repo checkout, where developers manage their own PATH.
+ */
+function resolveInstalledEntry(moduleDir: string): string | null {
+  if (isRepoCheckoutPath(moduleDir)) {
+    return null;
+  }
+
+  const command = findAssistantCommand(moduleDir);
+  if (command !== null) {
+    return command;
+  }
+
+  // `<pkg>/src/daemon` sits one level below `<pkg>/src/index.ts`.
+  const packageEntry = join(moduleDir, "..", "index.ts");
+  return existsSync(packageEntry) ? packageEntry : null;
+}
+
+/**
+ * Resolve what `assistant` should point at, or null when this runtime layout
+ * has nothing installable.
+ *
+ * `execPath` and `moduleDir` are overridable so the layouts can be tested
+ * without a real install; both default to this process.
+ */
+export function resolveAssistantCommandTarget(overrides?: {
+  execPath?: string;
+  moduleDir?: string;
+}): AssistantCommandTarget | null {
+  const execPath = overrides?.execPath ?? process.execPath;
+  const moduleDir = overrides?.moduleDir ?? dirname(__filename);
+
+  // Compiled desktop build: the `assistant` binary sits beside the daemon
+  // binary inside the app bundle.
+  if (execPath.includes(`${sep}Contents${sep}MacOS${sep}`)) {
+    const binary = join(dirname(execPath), "vellum-assistant");
+    if (existsSync(binary)) {
+      return { kind: "binary", binary };
+    }
+    log.warn(
+      { expected: binary },
+      "Bundled vellum-assistant binary not found alongside daemon",
+    );
+    return null;
+  }
+
+  // Installed npm runtime, run under bun. The entry needs an interpreter, so
+  // the bun running this daemon is what the wrapper pins.
+  if (!isBunRuntime(execPath)) {
+    return null;
+  }
+  const entry = resolveInstalledEntry(moduleDir);
+  return entry === null ? null : { kind: "bun-entry", bun: execPath, entry };
+}
+
+/** Single-quote a value for safe interpolation into a shell script. */
+function shQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+function wrapperScript(bun: string, entry: string): string {
+  return [
+    "#!/bin/sh",
+    WRAPPER_MARKER,
+    "# Installed by the Vellum assistant daemon. Safe to delete.",
+    `exec ${shQuote(bun)} ${shQuote(entry)} "$@"`,
+    "",
+  ].join("\n");
+}
+
+/** Atomically write `content` via tmp-file + rename, mode 0755. */
+function writeExecutableAtomic(path: string, content: string): void {
+  const tmpPath = `${path}.tmp`;
+  writeFileSync(tmpPath, content);
+  chmodSync(tmpPath, 0o755);
+  renameSync(tmpPath, path);
+}
+
+/**
+ * Whether anything already at `commandPath` may be replaced. A symlink or a
+ * wrapper this module wrote is ours; any other real file belongs to someone
+ * else (a developer's own build) and is never clobbered.
+ */
+function claimCommandPath(commandPath: string): boolean {
+  let stats;
+  try {
+    stats = lstatSync(commandPath);
+  } catch (err) {
+    // Nothing there, so this is free to create.
+    return (err as NodeJS.ErrnoException)?.code === "ENOENT";
+  }
+
+  if (stats.isSymbolicLink()) {
+    return true;
+  }
+  if (!stats.isFile()) {
+    return false;
+  }
+  try {
+    return readFileSync(commandPath, "utf-8").includes(WRAPPER_MARKER);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install `target` at `commandPath`. Returns true when the command is in
+ * place (including when it already was), false when the path is unusable or
+ * belongs to someone else.
+ */
+export function installCommandAt(
+  commandPath: string,
+  target: AssistantCommandTarget,
+): boolean {
+  try {
+    // Already correct? Leave it alone: this runs on every daemon start.
+    try {
+      const stats = lstatSync(commandPath);
+      if (target.kind === "binary" && stats.isSymbolicLink()) {
+        if (readlinkSync(commandPath) === target.binary) {
+          return true;
+        }
+      } else if (target.kind === "bun-entry" && stats.isFile()) {
+        if (
+          readFileSync(commandPath, "utf-8") ===
+          wrapperScript(target.bun, target.entry)
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      // Missing or unreadable, so fall through to the write below.
+    }
+
+    if (!claimCommandPath(commandPath)) {
+      return false;
+    }
+
+    const dir = dirname(commandPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    if (target.kind === "binary") {
+      try {
+        unlinkSync(commandPath);
+      } catch {
+        // Nothing to remove.
+      }
+      symlinkSync(target.binary, commandPath);
+      return true;
+    }
+
+    writeExecutableAtomic(commandPath, wrapperScript(target.bun, target.entry));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ensures ~/.local/bin is present in the user's shell profile so that
+ * commands placed there are on PATH in new terminal sessions.
+ */
+function ensureLocalBinInShellProfile(localBinDir: string): void {
+  const shell = process.env.SHELL ?? "";
+  const home = homedir();
+  const profilePath = shell.endsWith("/zsh")
+    ? join(home, ".zshrc")
+    : shell.endsWith("/bash")
+      ? join(home, ".bash_profile")
+      : null;
+  if (!profilePath) {
+    return;
+  }
+
+  try {
+    const contents = existsSync(profilePath)
+      ? readFileSync(profilePath, "utf-8")
+      : "";
+    if (contents.includes(localBinDir)) {
+      return;
+    }
+    const line = `\nexport PATH="${localBinDir}:$PATH"\n`;
+    appendFileSync(profilePath, line);
+    log.info(
+      { profilePath, localBinDir },
+      "Added ~/.local/bin to shell profile",
+    );
+  } catch {
+    // Not critical: the user can add it manually
+  }
+}
+
+/**
+ * Checks whether `assistant` already resolves on PATH to something other than
+ * our candidate locations. If so, we skip installing to avoid shadowing a
+ * developer's local build.
+ */
+function commandResolvesElsewhere(
+  commandName: string,
+  candidatePaths: Set<string>,
+): boolean {
+  try {
+    const resolved = execFileSync("/usr/bin/which", [commandName], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return resolved !== "" && !candidatePaths.has(resolved);
+  } catch {
+    // `which` exited non-zero: command not found, safe to proceed
+    return false;
+  }
+}
+
+/**
+ * Idempotent: installs (or verifies) the `assistant` command. Called on every
+ * daemon startup, best-effort and self-contained: every step swallows its own
+ * errors, so a failure never affects startup.
+ *
+ * Tries `/usr/local/bin/assistant` first, then falls back to
+ * `~/.local/bin/assistant` (and patches the shell profile if needed).
+ *
+ * Skipped when VELLUM_DEV=1 (developers manage their own PATH).
+ */
+export function installAssistantCommand(): void {
+  if (process.env.VELLUM_DEV === "1") {
+    return;
+  }
+
+  const target = resolveAssistantCommandTarget();
+  if (!target) {
+    return;
+  }
+
+  const localBinDir = join(homedir(), ".local", "bin");
+  const candidateDirs = ["/usr/local/bin", localBinDir];
+  const candidatePaths = new Set(
+    candidateDirs.map((dir) => `${dir}/assistant`),
+  );
+
+  if (commandResolvesElsewhere("assistant", candidatePaths)) {
+    log.info(
+      "`assistant` already resolves to a non-managed path, skipping install",
+    );
+    return;
+  }
+
+  for (const dir of candidateDirs) {
+    const commandPath = join(dir, "assistant");
+    if (installCommandAt(commandPath, target)) {
+      log.info({ commandPath, target }, "Installed assistant command");
+      if (dir === localBinDir) {
+        ensureLocalBinInShellProfile(localBinDir);
+      }
+      return;
+    }
+    log.info(
+      { commandPath },
+      "Could not install assistant command at candidate, trying next",
+    );
+  }
+
+  log.warn("Could not install assistant command in any candidate directory");
+}

package/src/daemon/lifecycle.ts

@@ -49,6 +49,7 @@ import { warmLocalGuardianPrincipalCache } from "../runtime/local-actor-identity
 import { recoverInterruptedImport } from "../runtime/migrations/vbundle-streaming-importer.js";
 import { markCurrentProcessAsMainDaemon } from "../runtime/process-role.js";
 import { publishConfigChanged } from "../runtime/sync/resource-sync-events.js";
+import { reconcilePluginSchedules } from "../schedule/plugin-schedule-reconciler.js";
 import { recoverStaleSchedules } from "../schedule/schedule-recovery.js";
 import { startScheduler } from "../schedule/scheduler.js";
 import { getSubagentManager } from "../subagent/index.js";
@@ -82,7 +83,7 @@ import { startDiskPressureGuardForLifecycle } from "./disk-pressure-guard-lifecy
 import { startEventLoopWatchdog } from "./event-loop-watchdog.js";
 import { initializePlugins } from "./external-plugins-bootstrap.js";
 import { backfillSlackInjectionTemplates } from "./handlers/config-slack-channel.js";
-import { installAssistantSymlink } from "./install-symlink.js";
+import { installAssistantCommand } from "./install-assistant-command.js";
 import {
   type InterruptedResumeTarget,
   MAX_RESUME_ATTEMPTS,
@@ -698,6 +699,16 @@ export async function runDaemon(): Promise<void> {
     log.error({ err }, "Schedule recovery failed — continuing startup");
   }
 
+  // Converge plugin-declared schedules into cron_jobs rows before the
+  // scheduler starts claiming. The reconciler contains its own failures and
+  // checks DB migration readiness itself; the catch is startup insurance in
+  // the same shape as schedule recovery above.
+  try {
+    await reconcilePluginSchedules();
+  } catch (err) {
+    log.error({ err }, "Plugin schedule reconcile failed, continuing startup");
+  }
+
   // Reconcile workflow runs orphaned by a crash: any row still `running` was
   // in flight when the process died (the engine always finishes its row on
   // exit), so flip it to `interrupted` to make it eligible for an explicit
@@ -774,10 +785,10 @@ export async function runDaemon(): Promise<void> {
 
   writePid(process.pid);
 
-  // Install the `assistant` CLI symlink idempotently on every daemon start.
+  // Install the `assistant` CLI command idempotently on every daemon start.
   // Best-effort and self-contained: every step swallows its own errors, so a
   // failure never affects startup.
-  installAssistantSymlink();
+  installAssistantCommand();
 
   void startEmbeddingRuntimeManager();
 

package/src/daemon/message-types/conversations.ts

@@ -29,13 +29,12 @@ interface BaseTransportMetadata {
   /** IANA timezone reported by the active client for the current turn. */
   clientTimezone?: string;
   /**
-   * The client's operating-system surface ("web" | "ios" | "macos"),
-   * reported independently of {@link interfaceId}. The web bundle ships to a
-   * browser, the Capacitor iOS shell, and the Electron macOS app, all on the
-   * same `"web"` transport interface — `clientOs` is what tells the assistant
-   * which OS it is actually talking to (rendered as the `client_os:` line in
-   * the per-turn context) WITHOUT perturbing transport/host-proxy capability
-   * inference, which keys off `interfaceId`.
+   * The client's operating-system surface, reported independently of
+   * {@link interfaceId}. The web bundle ships to browsers, mobile shells, and
+   * Electron desktop apps on the same `"web"` transport interface. `clientOs`
+   * tells the assistant which OS it is actually talking to, rendered as the
+   * `client_os:` line in the per-turn context, without perturbing
+   * transport/host-proxy capability inference, which keys off `interfaceId`.
    */
   clientOs?: string;
   /**

package/src/daemon/message-types/sync.ts

@@ -15,6 +15,7 @@ export const SYNC_TAGS = {
   assistantSchedules: "assistant:self:schedules",
   assistantTheme: "assistant:self:theme",
   appsList: "apps:list",
+  documentsList: "documents:list",
   pluginsList: "plugins:list",
   conversationsList: "conversations:list",
   featureFlagsClient: "feature-flags:client",

package/src/daemon/persist-media-references.ts

@@ -43,11 +43,11 @@ function imageFilename(mediaType: string): string {
  * transport-optimized image (`resolveMediaReferences` applies the same
  * optimization at send time), so hint the optimized dimensions.
  */
-function optimizedImageDimensions(
+async function optimizedImageDimensions(
   dataBase64: string,
   mediaType: string,
-): { width: number; height: number } | null {
-  const optimized = optimizeImageForTransport(dataBase64, mediaType);
+): Promise<{ width: number; height: number } | null> {
+  const optimized = await optimizeImageForTransport(dataBase64, mediaType);
   return parseImageDimensions(optimized.data, optimized.mediaType);
 }
 
@@ -56,13 +56,13 @@ function optimizedImageDimensions(
  * `messageId`, returning the block with a `workspace_ref` source — or null when
  * the store write fails (caller keeps the inline base64 block).
  */
-function referenceMediaBlock(
+async function referenceMediaBlock(
   conversationId: string,
   conversationCreatedAt: number,
   messageId: string,
   block: ImageContent | FileContent,
   position: number,
-): ContentBlock | null {
+): Promise<ContentBlock | null> {
   if (block.source.type !== "base64") {
     return block;
   }
@@ -73,7 +73,7 @@ function referenceMediaBlock(
 
   let stored: { id: string; sizeBytes: number };
   try {
-    stored = createInlineAttachment(
+    stored = await createInlineAttachment(
       conversationId,
       conversationCreatedAt,
       filename,
@@ -99,7 +99,7 @@ function referenceMediaBlock(
       : {}),
   };
   if (block.type === "image") {
-    const dims = optimizedImageDimensions(data, media_type);
+    const dims = await optimizedImageDimensions(data, media_type);
     if (dims) {
       source.width = dims.width;
       source.height = dims.height;
@@ -122,34 +122,43 @@ function referenceMediaBlock(
  * `workspace_ref`. Blocks that are already references, carry no media, or fail
  * to store are returned unchanged.
  */
-export function referenceMediaBlocksForPersist(
+export async function referenceMediaBlocksForPersist(
   conversationId: string,
   conversationCreatedAt: number,
   messageId: string,
   blocks: ContentBlock[],
-): ContentBlock[] {
+): Promise<ContentBlock[]> {
   // A single link position counter across all attachments in the message so
   // their `message_attachments` rows keep content order.
   let position = 0;
-  const convert = (block: ContentBlock): ContentBlock => {
+  const convert = async (block: ContentBlock): Promise<ContentBlock> => {
     if (block.type === "image" || block.type === "file") {
       if (block.source.type !== "base64") {
         return block;
       }
       return (
-        referenceMediaBlock(
+        (await referenceMediaBlock(
           conversationId,
           conversationCreatedAt,
           messageId,
           block,
           position++,
-        ) ?? block
+        )) ?? block
       );
     }
     if (block.type === "tool_result" && block.contentBlocks?.length) {
-      return { ...block, contentBlocks: block.contentBlocks.map(convert) };
+      const contentBlocks: ContentBlock[] = [];
+      for (const cb of block.contentBlocks) {
+        contentBlocks.push(await convert(cb));
+      }
+      return { ...block, contentBlocks };
     }
     return block;
   };
-  return blocks.map(convert);
+  // Sequential so the shared position counter keeps content order.
+  const result: ContentBlock[] = [];
+  for (const block of blocks) {
+    result.push(await convert(block));
+  }
+  return result;
 }

package/src/daemon/process-message.ts

@@ -484,12 +484,12 @@ export async function processMessage(
     const userMetaWithSlack = slackMeta
       ? { ...serverChannelMeta, slackMeta }
       : serverChannelMeta;
-    const cleanMsg = createUserMessage(content, attachments);
+    const cleanMsg = await createUserMessage(content, attachments);
     const llmMsg = enrichMessageWithSourcePaths(cleanMsg, attachments);
     const persisted = await addMessage(
       conversationId,
       "user",
-      serializePersistedUserMessageContent(
+      await serializePersistedUserMessageContent(
         content,
         options?.displayContent,
         attachments,
@@ -578,11 +578,11 @@ export async function processMessage(
     const compactUserMeta = slackMeta
       ? { ...compactChannelMeta, slackMeta }
       : compactChannelMeta;
-    const cleanMsg = createUserMessage(content, attachments);
+    const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
       "user",
-      serializePersistedUserMessageContent(
+      await serializePersistedUserMessageContent(
         content,
         options?.displayContent,
         attachments,
@@ -633,11 +633,11 @@ export async function processMessage(
     const cleanUserMeta = slackMeta
       ? { ...cleanChannelMeta, slackMeta }
       : cleanChannelMeta;
-    const cleanMsg = createUserMessage(content, attachments);
+    const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
       "user",
-      serializePersistedUserMessageContent(
+      await serializePersistedUserMessageContent(
         content,
         options?.displayContent,
         attachments,