@vellumai/assistant 0.7.0 → 0.7.2

package/src/security/token-manager.ts

@@ -14,7 +14,6 @@
 import {
   isCredentialError,
   isTokenExpired,
-  oauthConnectionAccessTokenPath,
   oauthConnectionRefreshTokenPath,
   persistRefreshedTokens,
   RefreshCircuitBreaker,
@@ -22,6 +21,7 @@ import {
   type SecureKeyBackend,
 } from "@vellumai/credential-storage";
 
+import { getConnectionAccessTokenResult } from "../oauth/credential-token-resolver.js";
 import {
   getApp,
   getConnection,
@@ -321,9 +321,13 @@ export async function withValidToken<T>(
     opts && typeof opts === "object"
       ? getConnection(opts.connectionId)
       : getConnectionByProvider(service, opts);
-  let token = conn
-    ? await getSecureKeyAsync(oauthConnectionAccessTokenPath(conn.id))
+  const tokenResult = conn
+    ? await getConnectionAccessTokenResult({
+        provider: conn.provider,
+        connectionId: conn.id,
+      })
     : undefined;
+  let token = tokenResult?.value;
   if (!token || !conn) {
     throw new TokenExpiredError(
       service,

package/src/sequence/analytics.ts

@@ -15,7 +15,7 @@ import type { Sequence } from "./types.js";
 
 // ── Event tracking ──────────────────────────────────────────────────
 
-export type SequenceEventType =
+type SequenceEventType =
   | "send"
   | "reply"
   | "complete"
@@ -24,7 +24,7 @@ export type SequenceEventType =
   | "pause"
   | "resume";
 
-export interface SequenceEvent {
+interface SequenceEvent {
   id: string;
   sequenceId: string;
   enrollmentId: string;
@@ -74,7 +74,7 @@ function getRecentEvents(limit = 20): SequenceEvent[] {
 
 // ── Metrics ─────────────────────────────────────────────────────────
 
-export interface SequenceMetrics {
+interface SequenceMetrics {
   sequenceId: string;
   sequenceName: string;
   status: string;
@@ -90,7 +90,7 @@ export interface SequenceMetrics {
   avgTimeToReplyMs: number | null;
 }
 
-export interface StepMetrics {
+interface StepMetrics {
   stepIndex: number;
   subject: string;
   sends: number;
@@ -98,7 +98,7 @@ export interface StepMetrics {
   dropOff: number;
 }
 
-export interface DashboardData {
+interface DashboardData {
   summary: {
     totalSequences: number;
     activeSequences: number;

package/src/sequence/engine.ts

@@ -9,7 +9,7 @@
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
 import { getMessages } from "../memory/conversation-crud.js";
-import type { ScheduleMessageProcessor } from "../schedule/scheduler.js";
+import type { ScheduleMessageProcessor } from "../schedule/scheduler-types.js";
 import { getLogger } from "../util/logger.js";
 import { recordEvent } from "./analytics.js";
 import { checkAllPreSend, recordSend } from "./guardrails.js";

package/src/signals/cancel.ts

@@ -5,34 +5,23 @@
  * HTTP POST to `/v1/conversations/:id/cancel`. The daemon's ConfigWatcher
  * detects the file change and invokes {@link handleCancelSignal}, which
  * reads the payload and aborts the target conversation.
- *
- * Because the signal handler needs access to the daemon's conversation map, the
- * daemon registers a callback at startup via {@link registerCancelCallback}.
  */
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
+import {
+  findConversation,
+  touchConversation,
+} from "../daemon/conversation-store.js";
+import { getSubagentManager } from "../subagent/index.js";
+import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import { getSignalsDir } from "../util/platform.js";
 
 const log = getLogger("signal:cancel");
 
-// ── Daemon callback registry ─────────────────────────────────────────
-
-type CancelCallback = (conversationId: string) => boolean;
-
-let _cancelGeneration: CancelCallback | null = null;
-
-/**
- * Register the cancel-generation callback. Called once by the daemon
- * server at startup so the signal handler can reach the conversation map.
- */
-export function registerCancelCallback(cb: CancelCallback): void {
-  _cancelGeneration = cb;
-}
-
 // ── Signal handler ───────────────────────────────────────────────────
 
 /**
@@ -52,17 +41,19 @@ export function handleCancelSignal(): void {
       return;
     }
 
-    if (!_cancelGeneration) {
-      log.warn("Cancel callback not registered; daemon may not be ready");
+    const conversation = findConversation(conversationId);
+    if (!conversation) {
+      log.warn({ conversationId }, "No active conversation for cancel signal");
       return;
     }
 
-    const found = _cancelGeneration(conversationId);
-    if (found) {
-      log.info({ conversationId }, "Generation cancelled via signal file");
-    } else {
-      log.warn({ conversationId }, "No active conversation for cancel signal");
-    }
+    touchConversation(conversationId);
+    conversation.abort(
+      createAbortReason("signal_cancel", "handleCancelSignal", conversationId),
+    );
+    getSubagentManager().abortAllForParent(conversationId);
+
+    log.info({ conversationId }, "Generation cancelled via signal file");
   } catch (err) {
     log.error({ err }, "Failed to handle cancel signal");
   }

package/src/signals/conversation-undo.ts

@@ -7,37 +7,18 @@
  * {@link handleConversationUndoSignal}, which reads the payload, performs
  * the undo, and writes `signals/conversation-undo.result` so the CLI
  * receives feedback.
- *
- * Because the signal handler needs access to the daemon's conversation map, the
- * daemon registers a callback at startup via
- * {@link registerConversationUndoCallback}.
  */
 
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import { getIsContainerized } from "../config/env-registry.js";
+import { undoLastMessage } from "../daemon/handlers/conversations.js";
 import { getLogger } from "../util/logger.js";
 import { getSignalsDir } from "../util/platform.js";
 
 const log = getLogger("signal:conversation-undo");
 
-// ── Daemon callback registry ─────────────────────────────────────────
-
-type UndoCallback = (
-  conversationId: string,
-) => Promise<{ removedCount: number } | null>;
-
-let _undoLastMessage: UndoCallback | null = null;
-
-/**
- * Register the undo callback. Called once by the daemon server at startup
- * so the signal handler can reach the conversation map.
- */
-export function registerConversationUndoCallback(cb: UndoCallback): void {
-  _undoLastMessage = cb;
-}
-
 // ── Signal handler ───────────────────────────────────────────────────
 
 /**
@@ -93,13 +74,7 @@ export async function handleConversationUndoSignal(): Promise<void> {
       return;
     }
 
-    if (!_undoLastMessage) {
-      log.warn("Undo callback not registered; daemon may not be ready");
-      writeResult({ ok: false, error: "Assistant not ready", requestId });
-      return;
-    }
-
-    const result = await _undoLastMessage(conversationId);
+    const result = await undoLastMessage(conversationId);
     if (!result) {
       log.warn({ conversationId }, "No active conversation for undo signal");
       writeResult({ ok: false, error: "No active conversation", requestId });

package/src/signals/emit-event.ts

@@ -18,7 +18,6 @@ import { join } from "node:path";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
 import { getLogger } from "../util/logger.js";
 import { getSignalsDir } from "../util/platform.js";
 
@@ -30,7 +29,7 @@ export function handleEmitEventSignal(): void {
     const message = JSON.parse(content) as ServerMessage;
 
     assistantEventHub
-      .publish(buildAssistantEvent(DAEMON_INTERNAL_ASSISTANT_ID, message))
+      .publish(buildAssistantEvent(message))
       .catch((err: unknown) => {
         log.error({ err }, "Failed to publish event from signal");
       });

package/src/signals/user-message.ts

@@ -9,15 +9,24 @@
  *
  * Per-request filenames avoid dropped messages when overlapping invocations
  * race on the same signal file.
- *
- * Because the signal handler needs access to the daemon's conversation map and
- * event hub, the daemon registers a callback at startup via
- * {@link registerUserMessageCallback}.
  */
 
-import { readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
+import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
+import {
+  processMessageInBackground,
+  resolveTurnChannel,
+  resolveTurnInterface,
+} from "../daemon/process-message.js";
+import {
+  uploadFileBackedAttachment,
+  validateAttachmentUpload,
+} from "../memory/attachments-store.js";
+import { getOrCreateConversation as getOrCreateConversationKey } from "../memory/conversation-key-store.js";
+import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { getLogger } from "../util/logger.js";
 import { getSignalsDir } from "../util/platform.js";
 
@@ -35,25 +44,108 @@ export interface SignalAttachment {
   mimeType: string;
 }
 
-// ── Daemon callback registry ─────────────────────────────────────────
+// ── Dispatch helper ──────────────────────────────────────────────────
 
-type UserMessageCallback = (params: {
+async function dispatchUserMessage(params: {
   conversationKey: string;
   content: string;
   sourceChannel: string;
   sourceInterface: string;
   bypassSecretCheck?: boolean;
   attachments?: SignalAttachment[];
-}) => Promise<{ accepted: boolean; error?: string; message?: string }>;
+}): Promise<{ accepted: boolean; error?: string; message?: string }> {
+  if (!params.bypassSecretCheck) {
+    const ingressResult = checkIngressForSecrets(params.content);
+    if (ingressResult.blocked) {
+      return {
+        accepted: false,
+        error: "secret_blocked" as const,
+        message: ingressResult.userNotice,
+      };
+    }
+  }
 
-let _sendUserMessage: UserMessageCallback | null = null;
+  const { conversationId } = getOrCreateConversationKey(params.conversationKey);
+  const conversation = await getOrCreateConversation(conversationId);
 
-/**
- * Register the user-message callback. Called once by the daemon server at
- * startup so the signal handler can reach the conversation map and event hub.
- */
-export function registerUserMessageCallback(cb: UserMessageCallback): void {
-  _sendUserMessage = cb;
+  const attachmentIds: string[] = [];
+  const resolvedAttachments: UserMessageAttachment[] = [];
+  if (params.attachments && params.attachments.length > 0) {
+    for (const a of params.attachments) {
+      try {
+        const validation = validateAttachmentUpload(a.filename, a.mimeType);
+        if (!validation.ok) {
+          log.warn(
+            { error: validation.error, path: a.path },
+            "Signal attachment rejected by validation",
+          );
+          continue;
+        }
+        const size = statSync(a.path).size;
+        const stored = uploadFileBackedAttachment(
+          a.filename,
+          a.mimeType,
+          a.path,
+          size,
+        );
+        attachmentIds.push(stored.id);
+        resolvedAttachments.push({
+          id: stored.id,
+          filename: a.filename,
+          mimeType: a.mimeType,
+          data: "",
+          filePath: a.path,
+        });
+      } catch (err) {
+        log.warn({ err, path: a.path }, "Failed to register signal attachment");
+      }
+    }
+  }
+
+  if (conversation.isProcessing()) {
+    for (let i = resolvedAttachments.length - 1; i >= 0; i--) {
+      const att = resolvedAttachments[i];
+      if (att.filePath && !att.data) {
+        try {
+          att.data = readFileSync(att.filePath).toString("base64");
+        } catch (err) {
+          log.warn(
+            { err, path: att.filePath },
+            "Failed to read queued signal attachment, skipping",
+          );
+          resolvedAttachments.splice(i, 1);
+        }
+      }
+    }
+    const requestId = crypto.randomUUID();
+    const resolvedChannel = resolveTurnChannel(params.sourceChannel);
+    const resolvedInterface = resolveTurnInterface(params.sourceInterface);
+    const result = conversation.enqueueMessage(
+      params.content,
+      resolvedAttachments,
+      undefined,
+      requestId,
+      undefined,
+      undefined,
+      {
+        userMessageChannel: resolvedChannel,
+        assistantMessageChannel: resolvedChannel,
+        userMessageInterface: resolvedInterface,
+        assistantMessageInterface: resolvedInterface,
+      },
+    );
+    return { accepted: !result.rejected };
+  }
+
+  await processMessageInBackground(
+    conversationId,
+    params.content,
+    attachmentIds.length > 0 ? attachmentIds : undefined,
+    undefined,
+    params.sourceChannel,
+    params.sourceInterface,
+  );
+  return { accepted: true };
 }
 
 // ── Signal handler ───────────────────────────────────────────────────
@@ -143,12 +235,6 @@ export async function handleUserMessageSignal(filename: string): Promise<void> {
       return;
     }
 
-    if (!_sendUserMessage) {
-      log.warn("User-message callback not registered; daemon may not be ready");
-      writeResult({ ok: false, error: "Assistant not ready", requestId });
-      return;
-    }
-
     // Validate and normalize attachments
     const attachments: SignalAttachment[] = [];
     if (Array.isArray(parsed.attachments)) {
@@ -167,7 +253,7 @@ export async function handleUserMessageSignal(filename: string): Promise<void> {
       }
     }
 
-    const result = await _sendUserMessage({
+    const result = await dispatchUserMessage({
       conversationKey: parsed.conversationKey,
       content: parsed.content,
       sourceChannel: parsed.sourceChannel ?? "vellum",

package/src/skills/catalog-files.ts

@@ -64,14 +64,8 @@ function classifyByName(name: string): boolean {
  * depends on `catalog-cache.ts`, which would otherwise be reachable via
  * the handler module.
  */
-export interface SkillFileEntry {
-  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
-  name: string; // basename
-  size: number;
-  mimeType: string;
-  isBinary: boolean;
-  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
-}
+import type { SkillFileEntry } from "./skill-file-types.js";
+export type { SkillFileEntry } from "./skill-file-types.js";
 
 // ─── Platform response contracts ─────────────────────────────────────────────
 //

package/src/skills/catalog-install.ts

@@ -30,6 +30,7 @@ export interface CatalogSkill {
   emoji?: string;
   includes?: string[];
   version?: string;
+  updatedAt?: string;
   metadata?: {
     vellum?: {
       "display-name"?: string;

package/src/skills/clawhub.ts

@@ -181,7 +181,7 @@ async function runClawhub(
   const { mkdirSync } = await import("node:fs");
   mkdirSync(cwd, { recursive: true });
 
-  log.info({ args, cwd }, "Running clawhub command");
+  log.debug({ args, cwd }, "Running clawhub command");
 
   const proc = Bun.spawn(["npx", "clawhub", ...args], {
     cwd,
@@ -211,7 +211,7 @@ async function runClawhub(
 
   const exitCode = await proc.exited;
 
-  log.info(
+  log.debug(
     { exitCode, stdoutLen: stdout.length, stderrLen: stderr.length },
     "clawhub command completed",
   );

package/src/skills/include-graph.ts

@@ -1,6 +1,6 @@
 import type { SkillSummary } from "../config/skills.js";
 
-export interface IncludeGraphResult {
+interface IncludeGraphResult {
   /** Ordered list of all skill IDs visited during traversal (including the root). */
   visited: string[];
 }
@@ -37,12 +37,12 @@ export function getImmediateChildren(
   return children;
 }
 
-export interface IncludeValidationSuccess {
+interface IncludeValidationSuccess {
   ok: true;
   visited: string[];
 }
 
-export interface IncludeValidationError {
+interface IncludeValidationError {
   ok: false;
   error: "missing";
   missingChildId: string;
@@ -50,13 +50,13 @@ export interface IncludeValidationError {
   path: string[]; // full path from root to the parent that referenced the missing child
 }
 
-export interface IncludeValidationCycleError {
+interface IncludeValidationCycleError {
   ok: false;
   error: "cycle";
   cyclePath: string[]; // the IDs forming the cycle, e.g. ['a', 'b', 'c', 'a']
 }
 
-export type IncludeValidationResult =
+type IncludeValidationResult =
   | IncludeValidationSuccess
   | IncludeValidationError
   | IncludeValidationCycleError;

package/src/skills/inline-command-runner.ts

@@ -24,7 +24,6 @@
 import { spawn } from "node:child_process";
 
 import { buildSanitizedEnv } from "../tools/terminal/safe-env.js";
-import { wrapCommand } from "../tools/terminal/sandbox.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("inline-command-runner");
@@ -105,12 +104,7 @@ export async function runInlineCommand(
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const maxChars = options?.maxOutputChars ?? MAX_OUTPUT_CHARS;
 
-  // Sandbox is disabled — the assistant runs in Docker or platform-managed
-  // environments where the container provides isolation. The networkMode
-  // option is a no-op when sandbox is disabled (wrapCommand returns a plain
-  // bash invocation); network isolation is handled at the container level.
-  const sandboxConfig = { enabled: false } as const;
-  const wrapped = wrapCommand(command, workingDir, sandboxConfig);
+  const wrapped = { command: "bash", args: ["-c", "--", command] };
 
   // Build a minimal, sanitized environment. Explicitly exclude gateway URL,
   // workspace dir, and data dir since inline commands have no business calling

package/src/skills/remote-skill-policy.ts

@@ -1,4 +1,4 @@
-export type RemoteSkillProvider = "clawhub" | "skillssh";
+type RemoteSkillProvider = "clawhub" | "skillssh";
 
 export type SkillsShRisk =
   | "safe"
@@ -26,12 +26,12 @@ export interface RemoteSkillPolicy {
   maxSkillsShRisk: SkillsShRiskThreshold;
 }
 
-export interface ClawhubModerationState {
+interface ClawhubModerationState {
   isSuspicious?: boolean;
   isMalwareBlocked?: boolean;
 }
 
-export interface SkillsShAuditState {
+interface SkillsShAuditState {
   risk?: SkillsShRisk | null;
 }
 
@@ -40,12 +40,12 @@ interface RemoteSkillCandidateBase {
   slug: string;
 }
 
-export interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "clawhub";
   moderation?: ClawhubModerationState | null;
 }
 
-export interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "skillssh";
   audit?: SkillsShAuditState | null;
 }

package/src/skills/skill-file-provider.ts

@@ -1,5 +1,5 @@
 import type { SlimSkillResponse } from "../daemon/message-types/skills.js";
-import type { SkillFileEntry } from "./catalog-files.js";
+import type { SkillFileEntry } from "./skill-file-types.js";
 
 /**
  * A file provider can resolve file listings and single-file content for

package/src/skills/skill-file-types.ts

@@ -0,0 +1,13 @@
+/**
+ * Types extracted from catalog-files.ts to break the
+ * catalog-files ↔ skill-file-provider cycle.
+ */
+
+export interface SkillFileEntry {
+  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
+  name: string; // basename
+  size: number;
+  mimeType: string;
+  isBinary: boolean;
+  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
+}

package/src/skills/skillssh-audit-types.ts

@@ -0,0 +1,28 @@
+/**
+ * Audit types for SkillSSH partner security analysis.
+ *
+ * Extracted as a leaf module so daemon message types can reference
+ * PartnerAudit without pulling in the full skillssh-registry module
+ * (which transitively imports cli/program and the entire CLI graph).
+ */
+
+export type RiskLevel =
+  | "safe"
+  | "low"
+  | "medium"
+  | "high"
+  | "critical"
+  | "unknown";
+
+export interface PartnerAudit {
+  risk: RiskLevel;
+  alerts?: number;
+  score?: number;
+  analyzedAt: string;
+}
+
+/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
+export type SkillAuditData = Record<string, PartnerAudit>;
+
+/** Map from skill slug to per-provider audit data */
+export type AuditResponse = Record<string, SkillAuditData>;

package/src/skills/skillssh-registry.ts

@@ -6,6 +6,14 @@ import { dirname, join, resolve, sep } from "node:path";
 import { getWorkspaceSkillsDir } from "../util/platform.js";
 import { upsertSkillsIndex } from "./catalog-install.js";
 import { computeSkillHash, writeInstallMeta } from "./install-meta.js";
+import type {
+  AuditResponse,
+  PartnerAudit,
+  RiskLevel,
+  SkillAuditData,
+} from "./skillssh-audit-types.js";
+
+export type { AuditResponse, PartnerAudit, RiskLevel, SkillAuditData };
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -17,27 +25,6 @@ export interface SkillsShSearchResult {
   source: string; // e.g. "vercel-labs/agent-skills"
 }
 
-export type RiskLevel =
-  | "safe"
-  | "low"
-  | "medium"
-  | "high"
-  | "critical"
-  | "unknown";
-
-export interface PartnerAudit {
-  risk: RiskLevel;
-  alerts?: number;
-  score?: number;
-  analyzedAt: string;
-}
-
-/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
-export type SkillAuditData = Record<string, PartnerAudit>;
-
-/** Map from skill slug to per-provider audit data */
-export type AuditResponse = Record<string, SkillAuditData>;
-
 export interface ResolvedSkillSource {
   owner: string;
   repo: string;