@vellumai/assistant 0.5.5 → 0.5.7

package/src/daemon/handlers/config-vercel.ts

@@ -0,0 +1,92 @@
+/**
+ * Business logic for Vercel API token management.
+ *
+ * The Vercel token is stored in the secure credential vault under
+ * `credential/vercel/api_token`. These functions provide get/set/delete
+ * operations that mirror the pattern used by Telegram config handlers.
+ */
+
+import { credentialKey } from "../../security/credential-key.js";
+import {
+  deleteSecureKeyAsync,
+  getSecureKeyAsync,
+  setSecureKeyAsync,
+} from "../../security/secure-keys.js";
+import {
+  deleteCredentialMetadata,
+  upsertCredentialMetadata,
+} from "../../tools/credentials/metadata-store.js";
+import { getLogger } from "../../util/logger.js";
+
+const log = getLogger("config-vercel");
+
+// -- Transport-agnostic result type --
+
+export interface VercelConfigResult {
+  hasToken: boolean;
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Check whether a Vercel API token is stored in the credential vault.
+ */
+export async function getVercelConfig(): Promise<VercelConfigResult> {
+  const token = await getSecureKeyAsync(credentialKey("vercel", "api_token"));
+  return { hasToken: !!token, success: true };
+}
+
+/**
+ * Store a Vercel API token in the credential vault.
+ */
+export async function setVercelConfig(
+  apiToken?: string,
+): Promise<VercelConfigResult> {
+  if (!apiToken) {
+    return { hasToken: false, success: false, error: "apiToken is required" };
+  }
+
+  const stored = await setSecureKeyAsync(
+    credentialKey("vercel", "api_token"),
+    apiToken,
+  );
+  if (!stored) {
+    return {
+      hasToken: false,
+      success: false,
+      error: "Failed to store Vercel API token in secure storage",
+    };
+  }
+
+  upsertCredentialMetadata("vercel", "api_token", {
+    allowedTools: ["deploy", "publish_page"],
+  });
+
+  log.info("Vercel API token stored successfully");
+  return { hasToken: true, success: true };
+}
+
+/**
+ * Delete the Vercel API token from the credential vault.
+ */
+export async function deleteVercelConfig(): Promise<VercelConfigResult> {
+  const result = await deleteSecureKeyAsync(
+    credentialKey("vercel", "api_token"),
+  );
+
+  if (result === "error") {
+    const stillPresent = !!(await getSecureKeyAsync(
+      credentialKey("vercel", "api_token"),
+    ));
+    return {
+      hasToken: stillPresent,
+      success: false,
+      error: "Failed to delete Vercel API token from secure storage",
+    };
+  }
+
+  deleteCredentialMetadata("vercel", "api_token");
+
+  log.info("Vercel API token deleted");
+  return { hasToken: false, success: true };
+}

package/src/daemon/handlers/conversations.ts

@@ -23,7 +23,6 @@ import {
   queueGenerateConversationTitle,
   UNTITLED_FALLBACK,
 } from "../../memory/conversation-title-service.js";
-import { reduceBeforeSwitch } from "../../memory/reducer-scheduler.js";
 import * as pendingInteractions from "../../runtime/pending-interactions.js";
 import { getSubagentManager } from "../../subagent/index.js";
 import { truncate } from "../../util/truncate.js";
@@ -234,12 +233,6 @@ export async function handleConversationCreate(
     conversationType: normalizeConversationType(conversation.conversationType),
   });
 
-  // Reduce the previous dirty conversation before processing the initial
-  // message so its memory is fresh for the next read.
-  if (msg.initialMessage) {
-    await reduceBeforeSwitch(conversation.id);
-  }
-
   // Auto-send the initial message if provided, kick-starting the skill.
   if (msg.initialMessage) {
     // Queue title generation eagerly — some processMessage paths (guardian
@@ -350,10 +343,6 @@ export async function switchConversation(
     return null;
   }
 
-  // Reduce the previous dirty conversation before switching so its memory
-  // is fresh for the next read.
-  await reduceBeforeSwitch(conversationId);
-
   // If the target conversation is headless-locked (actively executing a task run),
   // skip rebinding so tool confirmations stay suppressed.
   const existingConversation = ctx.conversations.get(conversationId);

package/src/daemon/handlers/skills.ts

@@ -24,6 +24,7 @@ import {
   getConfiguredProvider,
   userMessage,
 } from "../../providers/provider-send-message.js";
+import { isTextMimeType as isTextMime } from "../../runtime/routes/workspace-utils.js";
 import {
   clawhubCheckUpdates,
   clawhubInspect,
@@ -49,20 +50,6 @@ import {
 
 // ─── MIME detection helpers ───────────────────────────────────────────────────
 
-const TEXT_MIME_PREFIXES = [
-  "text/",
-  "application/json",
-  "application/javascript",
-  "application/typescript",
-  "application/xml",
-  "application/yaml",
-  "application/x-yaml",
-  "application/toml",
-  "application/x-sh",
-];
-function isTextMime(mimeType: string): boolean {
-  return TEXT_MIME_PREFIXES.some((prefix) => mimeType.startsWith(prefix));
-}
 const MAX_INLINE_SIZE = 2 * 1024 * 1024; // 2 MB
 
 // ─── Shared context for standalone functions ─────────────────────────────────
@@ -380,7 +367,7 @@ function readDirRecursive(dir: string, rootDir: string): SkillFileEntry[] {
     try {
       const stat = statSync(fullPath);
       const mimeType = Bun.file(fullPath).type;
-      const isText = isTextMime(mimeType);
+      const isText = isTextMime(mimeType, dirent.name);
       let content: string | null = null;
       if (isText && stat.size <= MAX_INLINE_SIZE) {
         content = readFileSync(fullPath, "utf-8");

package/src/daemon/install-symlink.ts

@@ -0,0 +1,195 @@
+import { execFileSync } from "node:child_process";
+import {
+  appendFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  symlinkSync,
+  unlinkSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("install-symlink");
+
+/**
+ * Resolves the path to the `vellum-assistant` binary that should be symlinked
+ * as `assistant`.
+ *
+ * - **Bundled (desktop app):** The daemon runs from a compiled binary inside
+ *   `Vellum.app/Contents/MacOS/`. `process.execPath` is the daemon binary
+ *   itself — the `vellum-assistant` CLI binary lives alongside it in the same
+ *   directory.
+ *
+ * - **Dev (bun):** `process.execPath` is the bun runtime. We resolve the
+ *   assistant entrypoint relative to this file's location in the source tree
+ *   and return a wrapper script path that would need bun to run — so we skip
+ *   symlinking in dev mode since developers manage their own PATH.
+ */
+function resolveAssistantBinary(): string | null {
+  const execPath = process.execPath;
+  // Detect the bundled desktop app case by checking for the app bundle path.
+  const isBundled = execPath.includes("/Contents/MacOS/");
+
+  if (isBundled) {
+    // The assistant CLI binary is a sibling of the daemon binary in
+    // Contents/MacOS/.
+    const macosDir = dirname(execPath);
+    const assistantBinary = join(macosDir, "vellum-assistant");
+    if (existsSync(assistantBinary)) {
+      return assistantBinary;
+    }
+    log.warn(
+      { expected: assistantBinary },
+      "Bundled vellum-assistant binary not found alongside daemon",
+    );
+    return null;
+  }
+
+  // Dev mode: resolve the assistant entrypoint from the source tree.
+  // The daemon entry is at assistant/src/daemon/main.ts and the assistant
+  // CLI entry is at assistant/src/index.ts.
+  const assistantEntry = join(dirname(__filename), "..", "index.ts");
+  if (existsSync(assistantEntry)) {
+    return assistantEntry;
+  }
+  return null;
+}
+
+/**
+ * Attempts to place a symlink at `symlinkPath` pointing to `target`.
+ * Returns true if the symlink was created or already points to the target.
+ */
+function trySymlink(target: string, symlinkPath: string): boolean {
+  try {
+    try {
+      const stats = lstatSync(symlinkPath);
+      if (!stats.isSymbolicLink()) {
+        // Real file — don't overwrite (could be a developer's local install)
+        return false;
+      }
+      const dest = readlinkSync(symlinkPath);
+      if (dest === target) return true;
+      // Stale or dangling symlink — remove before creating new one
+      unlinkSync(symlinkPath);
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") return false;
+      // Path doesn't exist — proceed to create symlink
+    }
+
+    const dir = dirname(symlinkPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    symlinkSync(target, symlinkPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Ensures ~/.local/bin is present in the user's shell profile so that
+ * symlinks 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 — user can add it manually
+  }
+}
+
+/**
+ * Checks whether `assistant` already resolves on PATH to something other than
+ * our candidate symlink locations. If so, we skip symlinking to avoid
+ * overwriting 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) a symlink for the `assistant` command.
+ *
+ * Called on every daemon startup. Handles two runtime modes:
+ * - **Bundled binary** (desktop app): symlinks to the compiled
+ *   `vellum-assistant` binary in the app bundle.
+ * - **Bun dev mode**: symlinks to a small wrapper script that invokes
+ *   `bun run` on the assistant entrypoint.
+ *
+ * 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 installAssistantSymlink(): void {
+  if (process.env.VELLUM_DEV === "1") return;
+
+  const target = resolveAssistantBinary();
+  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 symlink",
+    );
+    return;
+  }
+
+  for (const dir of candidateDirs) {
+    const symlinkPath = join(dir, "assistant");
+    if (trySymlink(target, symlinkPath)) {
+      log.info({ symlinkPath, target }, "Installed assistant symlink");
+      if (dir === localBinDir) {
+        ensureLocalBinInShellProfile(localBinDir);
+      }
+      return;
+    }
+    log.info(
+      { symlinkPath },
+      "Could not install assistant symlink at candidate — trying next",
+    );
+  }
+
+  log.warn("Could not install assistant symlink in any candidate directory");
+}