@vellumai/assistant 0.6.6 → 0.7.0

package/src/daemon/handlers/skills.ts

@@ -81,6 +81,7 @@ import {
   type SkillAuditData,
 } from "../../skills/skillssh-registry.js";
 import { getWorkspaceSkillsDir } from "../../util/platform.js";
+import { maybeSeedMemoryV2Skills } from "../memory-v2-startup.js";
 import type {
   SkillDetailResponse,
   SkillFileContentResponse,
@@ -295,7 +296,7 @@ function saveConfigWithSuppression(
  * NOT used for bundled skills — those have a simpler inline path in
  * `installSkill()` that only auto-enables, broadcasts, and seeds memories.
  */
-export function postInstallSkill(
+function postInstallSkill(
   skillId: string,
   _skillDir: string,
   ctx: SkillOperationContext,
@@ -319,6 +320,7 @@ export function postInstallSkill(
 
   // Seed skill memories
   seedSkillGraphNodes();
+  maybeSeedMemoryV2Skills(getConfig());
   void seedUninstalledCatalogSkillMemories().catch(() => {});
 }
 
@@ -352,13 +354,6 @@ function deriveOrigin(
   return meta?.origin ?? "custom";
 }
 
-/** Sort rank by kind: bundled first, then catalog, then installed. */
-function kindSortRank(kind: SlimSkillResponse["kind"]): number {
-  if (kind === "bundled") return 0;
-  if (kind === "catalog") return 1;
-  return 2; // installed
-}
-
 /** Convert a resolved skill to a SlimSkillResponse. */
 function toSlimSkillResponse(
   summary: SkillSummary,
@@ -425,12 +420,9 @@ export function listSkills(_ctx: SkillOperationContext): SlimSkillResponse[] {
 
   const items = resolved.map((r) => toSlimSkillResponse(r.summary, r.state));
 
-  // Sort by kind rank, then alphabetical by name within each tier.
-  items.sort((a, b) => {
-    const rankDiff = kindSortRank(a.kind) - kindSortRank(b.kind);
-    if (rankDiff !== 0) return rankDiff;
-    return a.name.localeCompare(b.name);
-  });
+  // Alphabetical by name — kind/source is a property on each skill, not a
+  // grouping axis. Keeps output stable as the catalog grows.
+  items.sort((a, b) => a.name.localeCompare(b.name));
 
   return items;
 }
@@ -439,7 +431,7 @@ export function listSkills(_ctx: SkillOperationContext): SlimSkillResponse[] {
  * List installed skills merged with available catalog skills.
  * Installed skills take precedence when deduplicating by ID.
  */
-export async function listSkillsWithCatalog(
+async function listSkillsWithCatalog(
   ctx: SkillOperationContext,
 ): Promise<SlimSkillResponse[]> {
   const installed = listSkills(ctx);
@@ -461,12 +453,8 @@ export async function listSkillsWithCatalog(
 
   const merged = [...installed, ...available];
 
-  // Sort by kind rank, then alphabetical by name
-  merged.sort((a, b) => {
-    const rankDiff = kindSortRank(a.kind) - kindSortRank(b.kind);
-    if (rankDiff !== 0) return rankDiff;
-    return a.name.localeCompare(b.name);
-  });
+  // Alphabetical by name — kind is a property on each skill, not a grouping axis.
+  merged.sort((a, b) => a.name.localeCompare(b.name));
 
   return merged;
 }
@@ -482,7 +470,7 @@ export interface SkillListFilter {
 }
 
 /** Human-readable labels matching Swift's `sourceLabel`. */
-export function originDisplayLabel(origin: string): string {
+function originDisplayLabel(origin: string): string {
   switch (origin) {
     case "vellum":
       return "Vellum";
@@ -498,7 +486,7 @@ export function originDisplayLabel(origin: string): string {
 }
 
 /** Check if a skill's origin matches a text query (matching Swift logic). */
-export function originMatchesQuery(origin: string, query: string): boolean {
+function originMatchesQuery(origin: string, query: string): boolean {
   const label = originDisplayLabel(origin).toLowerCase();
   if (label.includes(query)) return true;
   // "community" umbrella matches clawhub and skillssh
@@ -1000,6 +988,7 @@ export function enableSkill(
       state: "enabled",
     });
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {
@@ -1023,6 +1012,7 @@ export function disableSkill(
       state: "disabled",
     });
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {
@@ -1118,6 +1108,7 @@ export async function installSkill(
         );
       }
       seedSkillGraphNodes();
+      maybeSeedMemoryV2Skills(config);
       void seedUninstalledCatalogSkillMemories().catch(() => {});
       return { success: true, skillId: spec.slug };
     }
@@ -1692,6 +1683,7 @@ export async function createSkill(
     }
 
     seedSkillGraphNodes();
+    maybeSeedMemoryV2Skills(getConfig());
     void seedUninstalledCatalogSkillMemories().catch(() => {});
     return { success: true };
   } catch (err) {

package/src/daemon/host-transfer-proxy.ts

@@ -0,0 +1,500 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+import { v4 as uuid } from "uuid";
+
+import type { ToolExecutionResult } from "../tools/types.js";
+import { AssistantError, ErrorCode } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage } from "./message-protocol.js";
+
+const log = getLogger("host-transfer-proxy");
+
+interface PendingTransfer {
+  resolve: (result: ToolExecutionResult) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+  requestId: string;
+  transferId: string;
+  direction: "to_host" | "to_sandbox";
+  filePath: string;
+  overwrite?: boolean;
+  sizeBytes?: number;
+  sha256?: string;
+  fileBuffer?: Buffer;
+  /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
+  detachAbort: () => void;
+}
+
+/**
+ * Compute a size-adaptive timeout in milliseconds.
+ *
+ * Formula: max(120_000, (sizeBytes / (1024 * 1024)) * 1000 + 30_000)
+ * This gives 120s minimum, plus ~1s per MB + 30s buffer for larger files.
+ */
+function computeTimeoutMs(sizeBytes?: number): number {
+  if (sizeBytes == null) return 120_000;
+  const sizeBased = (sizeBytes / (1024 * 1024)) * 1000 + 30_000;
+  return Math.max(120_000, sizeBased);
+}
+
+export class HostTransferProxy {
+  /**
+   * Override for tests: when set, all timeout durations use this value instead
+   * of the size-adaptive computation.  Reset to `undefined` after tests.
+   * @internal
+   */
+  static _testTimeoutOverrideMs: number | undefined;
+
+  /** Pending transfers keyed by requestId (for resolution from client results). */
+  private pending = new Map<string, PendingTransfer>();
+  /** Pending transfers keyed by transferId (for content endpoint lookups). */
+  private transfers = new Map<string, PendingTransfer>();
+  private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
+  private clientConnected = false;
+
+  constructor(
+    sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
+  ) {
+    this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
+  }
+
+  updateSender(
+    sendToClient: (msg: ServerMessage) => void,
+    clientConnected: boolean,
+  ): void {
+    this.sendToClient = sendToClient;
+    this.clientConnected = clientConnected;
+  }
+
+  /**
+   * Request a file transfer from the sandbox to the host machine.
+   *
+   * Reads the source file, computes SHA-256, and sends a host_transfer_request
+   * message with direction "to_host". The file buffer is stored so the content
+   * endpoint can serve it to the client.
+   */
+  requestToHost(
+    input: {
+      sourcePath: string;
+      destPath: string;
+      overwrite: boolean;
+      conversationId: string;
+    },
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      return Promise.resolve({ content: "Aborted", isError: true });
+    }
+
+    const requestId = uuid();
+    const transferId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      readFile(input.sourcePath)
+        .then((fileBuffer) => {
+          // Check again after async read in case signal fired during I/O.
+          if (signal?.aborted) {
+            resolve({ content: "Aborted", isError: true });
+            return;
+          }
+
+          const sizeBytes = fileBuffer.length;
+          const sha256 = createHash("sha256").update(fileBuffer).digest("hex");
+          const timeoutMs =
+            HostTransferProxy._testTimeoutOverrideMs ??
+            computeTimeoutMs(sizeBytes);
+
+          let detachAbort: () => void = () => {};
+
+          const timer = setTimeout(() => {
+            this.pending.delete(requestId);
+            this.transfers.delete(transferId);
+            detachAbort();
+            this.onInternalResolve?.(requestId);
+            log.warn(
+              { requestId, transferId, direction: "to_host" },
+              "Host transfer proxy request timed out",
+            );
+            resolve({
+              content:
+                "Host transfer proxy timed out waiting for client response",
+              isError: true,
+            });
+          }, timeoutMs);
+
+          if (signal) {
+            const onAbort = () => {
+              if (this.pending.has(requestId)) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                this.transfers.delete(transferId);
+                detachAbort();
+                this.onInternalResolve?.(requestId);
+                try {
+                  this.sendToClient({
+                    type: "host_transfer_cancel",
+                    requestId,
+                  } as ServerMessage);
+                } catch {
+                  // Best-effort cancel notification — connection may already be closed.
+                }
+                resolve({ content: "Aborted", isError: true });
+              }
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            detachAbort = () => signal.removeEventListener("abort", onAbort);
+          }
+
+          const entry: PendingTransfer = {
+            resolve,
+            reject,
+            timer,
+            requestId,
+            transferId,
+            direction: "to_host",
+            filePath: input.destPath,
+            sizeBytes,
+            sha256,
+            fileBuffer,
+            detachAbort,
+          };
+          this.pending.set(requestId, entry);
+          this.transfers.set(transferId, entry);
+
+          try {
+            this.sendToClient({
+              type: "host_transfer_request",
+              requestId,
+              conversationId: input.conversationId,
+              direction: "to_host",
+              transferId,
+              destPath: input.destPath,
+              sizeBytes,
+              sha256,
+              overwrite: input.overwrite,
+            } as ServerMessage);
+          } catch (err) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.transfers.delete(transferId);
+            detachAbort();
+            this.onInternalResolve?.(requestId);
+            log.warn(
+              { requestId, transferId, err },
+              "Host transfer proxy send failed",
+            );
+            reject(err instanceof Error ? err : new Error(String(err)));
+          }
+        })
+        .catch((err) => {
+          log.warn(
+            { requestId, sourcePath: input.sourcePath, err },
+            "Failed to read source file for host transfer",
+          );
+          resolve({
+            content: `Failed to read source file: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true,
+          });
+        });
+    });
+  }
+
+  /**
+   * Request a file transfer from the host machine to the sandbox.
+   *
+   * Sends a host_transfer_request message with direction "to_sandbox".
+   * The Promise resolves when the client pushes the file content and it
+   * is written to the destination path with SHA-256 verification.
+   */
+  requestToSandbox(
+    input: {
+      sourcePath: string;
+      destPath: string;
+      overwrite?: boolean;
+      conversationId: string;
+    },
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      return Promise.resolve({ content: "Aborted", isError: true });
+    }
+
+    const requestId = uuid();
+    const transferId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      const timeoutMs = HostTransferProxy._testTimeoutOverrideMs ?? 120_000;
+
+      let detachAbort: () => void = () => {};
+
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.transfers.delete(transferId);
+        detachAbort();
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, transferId, direction: "to_sandbox" },
+          "Host transfer proxy request timed out",
+        );
+        resolve({
+          content: "Host transfer proxy timed out waiting for client response",
+          isError: true,
+        });
+      }, timeoutMs);
+
+      if (signal) {
+        const onAbort = () => {
+          if (this.pending.has(requestId)) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.transfers.delete(transferId);
+            detachAbort();
+            this.onInternalResolve?.(requestId);
+            try {
+              this.sendToClient({
+                type: "host_transfer_cancel",
+                requestId,
+              } as ServerMessage);
+            } catch {
+              // Best-effort cancel notification — connection may already be closed.
+            }
+            resolve({ content: "Aborted", isError: true });
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        detachAbort = () => signal.removeEventListener("abort", onAbort);
+      }
+
+      const entry: PendingTransfer = {
+        resolve,
+        reject,
+        timer,
+        requestId,
+        transferId,
+        direction: "to_sandbox",
+        filePath: input.destPath,
+        overwrite: input.overwrite,
+        detachAbort,
+      };
+      this.pending.set(requestId, entry);
+      this.transfers.set(transferId, entry);
+
+      try {
+        this.sendToClient({
+          type: "host_transfer_request",
+          requestId,
+          conversationId: input.conversationId,
+          direction: "to_sandbox",
+          transferId,
+          sourcePath: input.sourcePath,
+        } as ServerMessage);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pending.delete(requestId);
+        this.transfers.delete(transferId);
+        detachAbort();
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, transferId, err },
+          "Host transfer proxy send failed",
+        );
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+
+  /**
+   * Resolve a to_host transfer result from the client.
+   *
+   * Called when the client POSTs the result after downloading content
+   * and writing it to the host filesystem.
+   */
+  resolveTransferResult(
+    requestId: string,
+    result: {
+      isError: boolean;
+      bytesWritten?: number;
+      errorMessage?: string;
+    },
+  ): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) {
+      log.warn({ requestId }, "No pending host transfer request for response");
+      return;
+    }
+    clearTimeout(entry.timer);
+    entry.detachAbort();
+    this.pending.delete(requestId);
+    this.transfers.delete(entry.transferId);
+
+    if (result.isError) {
+      entry.resolve({
+        content: result.errorMessage ?? "Host transfer failed",
+        isError: true,
+      });
+    } else {
+      entry.resolve({
+        content: `File transferred successfully${result.bytesWritten != null ? ` (${result.bytesWritten} bytes)` : ""}`,
+        isError: false,
+      });
+    }
+  }
+
+  /**
+   * Get the content for a to_host transfer (the GET content endpoint).
+   *
+   * TransferIds are single-use: the entry is removed from the transfers
+   * map after the first access, so subsequent calls return null.
+   */
+  getTransferContent(
+    transferId: string,
+  ): { buffer: Buffer; sizeBytes: number; sha256: string } | null {
+    const entry = this.transfers.get(transferId);
+    if (
+      !entry ||
+      !entry.fileBuffer ||
+      entry.sizeBytes == null ||
+      !entry.sha256
+    ) {
+      return null;
+    }
+    // Single-use: consume the transfer from the transfers map.
+    // The pending map entry stays alive for the result resolution.
+    this.transfers.delete(transferId);
+    return {
+      buffer: entry.fileBuffer,
+      sizeBytes: entry.sizeBytes,
+      sha256: entry.sha256,
+    };
+  }
+
+  /**
+   * Receive file content from the client for a to_sandbox transfer (the PUT content endpoint).
+   *
+   * Writes the data to the sandbox destination path and verifies the SHA-256 hash.
+   * Resolves the pending request on success.
+   */
+  async receiveTransferContent(
+    transferId: string,
+    data: Buffer,
+    sha256Header: string,
+  ): Promise<{ accepted: boolean; error?: string }> {
+    const entry = this.transfers.get(transferId);
+    if (!entry) {
+      return { accepted: false, error: "Unknown or expired transfer ID" };
+    }
+
+    if (entry.direction !== "to_sandbox") {
+      return {
+        accepted: false,
+        error: "Transfer is not a to_sandbox transfer",
+      };
+    }
+
+    const computedHash = createHash("sha256").update(data).digest("hex");
+    if (computedHash !== sha256Header) {
+      return {
+        accepted: false,
+        error: `SHA-256 mismatch: expected ${sha256Header}, got ${computedHash}`,
+      };
+    }
+
+    const { requestId } = entry;
+
+    // Enforce overwrite policy before writing.
+    if (entry.overwrite !== true && existsSync(entry.filePath)) {
+      const errorMsg = `Destination file already exists: ${entry.filePath}. Set overwrite to true to replace it.`;
+      clearTimeout(entry.timer);
+      entry.detachAbort();
+      this.pending.delete(requestId);
+      this.transfers.delete(transferId);
+      entry.resolve({ content: errorMsg, isError: true });
+      return { accepted: false, error: errorMsg };
+    }
+
+    const cleanup = () => {
+      clearTimeout(entry.timer);
+      entry.detachAbort();
+      this.pending.delete(requestId);
+      this.transfers.delete(transferId);
+    };
+
+    try {
+      await mkdir(dirname(entry.filePath), { recursive: true });
+      await writeFile(entry.filePath, data);
+      cleanup();
+      entry.resolve({
+        content: `File received and written to ${entry.filePath} (${data.length} bytes)`,
+        isError: false,
+      });
+      return { accepted: true };
+    } catch (err) {
+      const errorMsg = `Failed to write file: ${err instanceof Error ? err.message : String(err)}`;
+      log.warn(
+        { transferId, filePath: entry.filePath, err },
+        "Failed to write received transfer content",
+      );
+      cleanup();
+      entry.resolve({ content: errorMsg, isError: true });
+      return { accepted: false, error: errorMsg };
+    }
+  }
+
+  /** Cancel a pending transfer by requestId. */
+  cancel(requestId: string): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    entry.detachAbort();
+    this.pending.delete(requestId);
+    this.transfers.delete(entry.transferId);
+    this.onInternalResolve?.(requestId);
+    try {
+      this.sendToClient({
+        type: "host_transfer_cancel",
+        requestId,
+      } as ServerMessage);
+    } catch {
+      // Best-effort cancel notification — connection may already be closed.
+    }
+    entry.resolve({ content: "Transfer cancelled", isError: true });
+  }
+
+  hasPendingTransfer(transferId: string): boolean {
+    return this.transfers.has(transferId);
+  }
+
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
+  dispose(): void {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      entry.detachAbort();
+      this.onInternalResolve?.(requestId);
+      try {
+        this.sendToClient({
+          type: "host_transfer_cancel",
+          requestId,
+        } as ServerMessage);
+      } catch {
+        // Best-effort cancel notification — connection may already be closed.
+      }
+      entry.reject(
+        new AssistantError(
+          "Host transfer proxy disposed",
+          ErrorCode.INTERNAL_ERROR,
+        ),
+      );
+    }
+    this.pending.clear();
+    this.transfers.clear();
+  }
+}