@vellumai/assistant 0.5.6 → 0.5.7

package/src/daemon/conversation-tool-setup.ts

@@ -23,7 +23,6 @@ import {
 import { isAllowDecision } from "../permissions/types.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
-import { getEffectiveMode } from "../runtime/conversation-approval-overrides.js";
 import { coreAppProxyTools } from "../tools/apps/definitions.js";
 import { registerConversationSender } from "../tools/browser/browser-screencast.js";
 import type { ToolExecutor } from "../tools/executor.js";
@@ -234,110 +233,6 @@ export function createToolExecutor(
           params.allowedDomains,
         );
       },
-      requestConfirmation: async (req) => {
-        // Check trust store before prompting
-        const existingRule = findHighestPriorityRule(
-          "cc:" + req.toolName,
-          [req.toolName, `cc:${req.toolName}`, "cc:*"],
-          ctx.workingDir,
-        );
-        if (existingRule && existingRule.decision !== "ask") {
-          return {
-            decision:
-              existingRule.decision === "allow"
-                ? ("allow" as const)
-                : ("deny" as const),
-          };
-        }
-        // Auto-approve sub-tool confirmations when a temporary approval
-        // override is active for this conversation (guardian only).
-        const guardianTrust = ctx.trustContext?.trustClass ?? "unknown";
-        if (
-          guardianTrust === "guardian" &&
-          getEffectiveMode(ctx.conversationId) !== undefined
-        ) {
-          return { decision: "allow" as const };
-        }
-        const allowlistOptions = [
-          {
-            label: `cc:${req.toolName}`,
-            description: `Claude Code ${req.toolName}`,
-            pattern: `cc:${req.toolName}`,
-          },
-          {
-            label: "cc:*",
-            description: "All Claude Code sub-tools",
-            pattern: "cc:*",
-          },
-        ];
-        const scopeOptions = generateScopeOptions(ctx.workingDir);
-        const response = await prompter.prompt(
-          `cc:${req.toolName}`,
-          req.input,
-          req.riskLevel,
-          allowlistOptions,
-          scopeOptions,
-          undefined,
-          undefined,
-          ctx.conversationId,
-          req.executionTarget,
-          undefined,
-          undefined,
-          undefined,
-          toolUseId,
-        );
-        if (
-          (response.decision === "always_allow" ||
-            response.decision === "always_allow_high_risk") &&
-          response.selectedPattern &&
-          response.selectedScope
-        ) {
-          log.info(
-            {
-              toolName: "cc:" + req.toolName,
-              pattern: response.selectedPattern,
-              scope: response.selectedScope,
-              highRisk: response.decision === "always_allow_high_risk",
-            },
-            "Persisting always-allow trust rule",
-          );
-          addRule(
-            "cc:" + req.toolName,
-            response.selectedPattern,
-            response.selectedScope,
-            "allow",
-            100,
-            response.decision === "always_allow_high_risk"
-              ? { allowHighRisk: true }
-              : undefined,
-          );
-        }
-        if (
-          response.decision === "always_deny" &&
-          response.selectedPattern &&
-          response.selectedScope
-        ) {
-          log.info(
-            {
-              toolName: "cc:" + req.toolName,
-              pattern: response.selectedPattern,
-              scope: response.selectedScope,
-            },
-            "Persisting always-deny trust rule",
-          );
-          addRule(
-            "cc:" + req.toolName,
-            response.selectedPattern,
-            response.selectedScope,
-            "deny",
-          );
-        }
-        return {
-          decision: isAllowDecision(response.decision)
-            ? ("allow" as const)
-            : ("deny" as const),
-        };
-      },
     };
 
     // Intercept skill_execute: extract the real tool name and input, then

package/src/daemon/conversation.ts

@@ -42,6 +42,7 @@ import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import { patternMatchesCandidate } from "../permissions/trust-store.js";
 import type { UserDecision } from "../permissions/types.js";
+import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
@@ -353,10 +354,18 @@ export class Conversation {
     const resolveSystemPromptCallback = (
       _history: import("../providers/types.js").Message[],
     ): ResolvedSystemPrompt => {
+      const persona = resolvePersonaContext(
+        this.trustContext,
+        this.channelCapabilities,
+      );
       const resolved = {
         systemPrompt: hasSystemPromptOverride
           ? systemPrompt
-          : buildSystemPrompt({ hasNoClient: this.hasNoClient }),
+          : buildSystemPrompt({
+              hasNoClient: this.hasNoClient,
+              userPersona: persona.userPersona,
+              channelPersona: persona.channelPersona,
+            }),
         maxTokens: configuredMaxTokens,
       };
       return resolved;

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/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");
+}