@vellumai/assistant 0.8.0 → 0.8.1

package/src/daemon/handlers/skills.ts

@@ -691,6 +691,65 @@ export async function getSkill(
   return { skill: detail };
 }
 
+export function getSkillLocalDetail(
+  skillId: string,
+): {
+  ok: true;
+  id: string;
+  name: string;
+  description: string;
+  emoji: string | null;
+  source: string;
+  state: string;
+  directoryPath: string;
+  featureFlag: string | null;
+  includes: string[] | null;
+  activationHints: string[] | null;
+  avoidWhen: string[] | null;
+  toolManifest: { valid: boolean; toolCount: number; toolNames: string[] } | null;
+  installMeta: Record<string, unknown> | null;
+  config: { enabled: boolean; envKeys: string[]; configKeys: string[] } | null;
+} | { ok: false; error: string; status: 404 | 500 } {
+  try {
+    const catalog = loadSkillCatalog();
+    const config = getConfig();
+    const resolved = resolveSkillStates(catalog, config);
+    const match = resolved.find((r) => r.summary.id === skillId);
+    if (!match) {
+      return { ok: false, error: `Skill "${skillId}" not found. Run 'assistant skills list' to see available skills.`, status: 404 };
+    }
+    const { summary, state, configEntry } = match;
+    const installMeta = readInstallMeta(summary.directoryPath);
+    return {
+      ok: true,
+      id: summary.id,
+      name: summary.displayName,
+      description: summary.description,
+      emoji: summary.emoji ?? null,
+      source: summary.source,
+      state,
+      directoryPath: summary.directoryPath,
+      featureFlag: summary.featureFlag ?? null,
+      includes: summary.includes ?? null,
+      activationHints: summary.activationHints ?? null,
+      avoidWhen: summary.avoidWhen ?? null,
+      toolManifest: summary.toolManifest
+        ? { valid: summary.toolManifest.valid, toolCount: summary.toolManifest.toolCount, toolNames: summary.toolManifest.toolNames }
+        : null,
+      installMeta: installMeta ? (installMeta as unknown as Record<string, unknown>) : null,
+      config: configEntry
+        ? {
+            enabled: configEntry.enabled !== false,
+            envKeys: configEntry.env ? Object.keys(configEntry.env) : [],
+            configKeys: configEntry.config ? Object.keys(configEntry.config) : [],
+          }
+        : null,
+    };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err), status: 500 };
+  }
+}
+
 // ─── Skill file listing ──────────────────────────────────────────────────────
 
 // `SkillFileEntry` lives in `../../skills/catalog-files.ts` to keep a single
@@ -1017,6 +1076,8 @@ export async function installSkill(spec: {
   slug: string;
   version?: string;
   origin?: "clawhub" | "skillssh";
+  catalogOnly?: boolean;
+  overwrite?: boolean;
   contactId?: string;
 }): Promise<
   { success: true; skillId: string } | { success: false; error: string }
@@ -1078,10 +1139,14 @@ export async function installSkill(spec: {
         const vellumCatalog = await getCatalog();
         const catalogEntry = vellumCatalog.find((s) => s.id === spec.slug);
         if (catalogEntry) {
+          // Default `overwrite` to true at the handler boundary to preserve
+          // pre-existing HTTP API behaviour. CLI callers always pass an
+          // explicit boolean (`opts.overwrite ?? false`) so the CLI surface
+          // still defaults to non-destructive installs.
           await installSkillLocally(
             spec.slug,
             catalogEntry,
-            true,
+            spec.overwrite ?? true,
             spec.contactId,
           );
 
@@ -1090,13 +1155,19 @@ export async function installSkill(spec: {
           return { success: true, skillId: spec.slug };
         }
       } catch (err) {
-        // If catalog lookup/install fails, fall through to community registries
+        if (spec.catalogOnly) {
+          return { success: false, error: `Failed to install catalog skill "${spec.slug}"` };
+        }
         log.warn(
           { err, skillId: spec.slug },
           "Vellum catalog install failed, falling back to community registry",
         );
       }
 
+    if (spec.catalogOnly) {
+      return { success: false, error: `Skill "${spec.slug}" not found in the Vellum catalog` };
+    }
+
     // skills.sh install path: route here when origin is explicitly "skillssh"
     // or when the slug looks like a skills.sh multi-segment format (owner/repo/skill)
     if (
@@ -1104,11 +1175,14 @@ export async function installSkill(spec: {
       (spec.origin !== "clawhub" && looksLikeSkillsShSlug(spec.slug))
     ) {
       const resolved = resolveSkillSource(spec.slug);
+      // Default `overwrite` to true at the handler boundary to preserve
+      // pre-existing HTTP API behaviour (same rationale as the catalog
+      // install path above).
       await installExternalSkill(
         resolved.owner,
         resolved.repo,
         resolved.skillSlug,
-        true /* overwrite */,
+        spec.overwrite ?? true,
         resolved.ref ?? spec.version,
         spec.contactId,
       );
@@ -1209,6 +1283,10 @@ export async function uninstallSkill(
       state: "uninstalled",
     });
 
+    // Without this, an uninstalled skill remains queryable in v2 until the
+    // next incidental seed event (enable/disable/install).
+    maybeSeedMemoryV2Skills(getConfig());
+
     return { success: true };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1250,6 +1328,7 @@ export async function checkSkillUpdates(): Promise<
 
 export async function searchSkills(
   query: string,
+  limit: number = 25,
 ): Promise<
   | { success: true; skills: SlimSkillResponse[] }
   | { success: false; error: string }
@@ -1290,8 +1369,8 @@ export async function searchSkills(
 
     // Search both community registries in parallel (non-fatal on failure)
     const [clawhubResult, skillsshResult] = await Promise.allSettled([
-      clawhubSearch(query),
-      searchSkillsRegistry(query, 25),
+      clawhubSearch(query, { limit }),
+      searchSkillsRegistry(query, limit),
     ]);
 
     let clawhubSkills: SlimSkillResponse[] = [];

package/src/daemon/history-repair.ts

@@ -68,11 +68,14 @@ export function repairHistory(messages: Message[]): RepairResult {
         }
       }
 
-      // Ensure every server_tool_use has a paired web_search_tool_result
-      // in the same assistant message (handles interrupted streams).
-      // Synthetic results are inserted IMMEDIATELY AFTER their corresponding
-      // server_tool_use block — not appended to the end — so that
-      // ensureToolPairing's split at tool_use boundaries cannot separate them.
+      // Pair server-side tool blocks within the same assistant message.
+      // Server tools (e.g. web_search) emit server_tool_use + matching
+      // web_search_tool_result. Either side can go missing — the synthetic
+      // result is inserted IMMEDIATELY AFTER the orphan server_tool_use (not
+      // appended to the end) so ensureToolPairing's split at tool_use
+      // boundaries cannot separate the pair. An orphan
+      // web_search_tool_result (no preceding server_tool_use) is downgraded
+      // to text — Anthropic rejects the request otherwise.
       const serverToolIds = new Set(
         cleanedContent
           .filter(
@@ -91,11 +94,35 @@ export function repairHistory(messages: Message[]): RepairResult {
           orphanedServerIds.add(id);
         }
       }
+      const orphanedWebSearchResultIds = new Set<string>();
+      for (const id of matchedServerIds) {
+        if (!serverToolIds.has(id)) {
+          orphanedWebSearchResultIds.add(id);
+        }
+      }
 
       let repairedContent: ContentBlock[];
-      if (orphanedServerIds.size > 0) {
+      if (orphanedServerIds.size > 0 || orphanedWebSearchResultIds.size > 0) {
         repairedContent = [];
         for (const block of cleanedContent) {
+          if (
+            block.type === "web_search_tool_result" &&
+            orphanedWebSearchResultIds.has(
+              (block as { tool_use_id: string }).tool_use_id,
+            )
+          ) {
+            repairedContent.push(
+              downgradeResult(
+                block as {
+                  type: "web_search_tool_result";
+                  tool_use_id: string;
+                  content: unknown;
+                },
+              ),
+            );
+            stats.orphanToolResultsDowngraded++;
+            continue;
+          }
           repairedContent.push(block);
           if (
             block.type === "server_tool_use" &&

package/src/daemon/host-app-control-proxy.ts

@@ -15,9 +15,11 @@
  * session at a time, and that session is bound to a specific target app.
  * The lock is module-level (`activeAppControlSession`) because the session
  * targets the user's actual desktop application, which is a host-wide
- * resource. It is acquired on a successful `app_control_start` (storing
- * `(conversationId, app)`) and released when the owning proxy's
- * `dispose()` fires.
+ * resource. It is acquired optimistically when `app_control_start` is
+ * dispatched (storing `(conversationId, app)`) so that the synchronous
+ * guard and the asynchronous host round-trip cannot race; it is released
+ * when the host returns a non-running state, the dispatch fails, or the
+ * owning proxy's `dispose()` fires.
  *
  * `app_control_start` is the only tool that can acquire the lock — the
  * user's medium-risk approval at start time is the consent boundary. All
@@ -144,12 +146,12 @@ function checkNonStartAuthorization(
   // except `stop`, and `stop` short-circuits in conversation-surfaces and
   // does not reach this method in production. A stop reaching here would
   // be a defensive bug — surface it explicitly rather than dispatch.
-  const requestedApp = (input as { app?: string }).app;
-  if (requestedApp == null) {
+  const requestedApp = (input as { app?: unknown }).app;
+  if (typeof requestedApp !== "string") {
     return {
       content:
-        "Tool input missing required 'app' field; cannot validate against " +
-        "the active app-control session.",
+        "Tool input missing required string 'app' field; cannot validate " +
+        "against the active app-control session.",
       isError: true,
     };
   }
@@ -222,6 +224,8 @@ export class HostAppControlProxy extends HostProxyBase<
     input: HostAppControlInput,
     conversationId: string,
     signal: AbortSignal,
+    sourceActorPrincipalId?: string,
+    targetClientId?: string,
   ): Promise<ToolExecutionResult> {
     if (signal.aborted) {
       return { content: "Aborted", isError: true };
@@ -235,7 +239,7 @@ export class HostAppControlProxy extends HostProxyBase<
     if (input.tool === "start") {
       if (
         activeAppControlSession != null &&
-        activeAppControlSession.conversationId !== conversationId
+        activeAppControlSession.conversationId !== this.conversationId
       ) {
         return {
           content:
@@ -245,8 +249,21 @@ export class HostAppControlProxy extends HostProxyBase<
           isError: true,
         };
       }
+      // Acquire optimistically to close the TOCTOU window between this
+      // synchronous guard and the asynchronous `dispatchRequest` below. Two
+      // concurrent starts from different conversations would otherwise both
+      // see `activeAppControlSession == null` and both pass the guard. The
+      // lock is released below if dispatch fails or the host returns a
+      // non-running state.
+      activeAppControlSession = {
+        conversationId: this.conversationId,
+        app: input.app,
+      };
     } else {
-      const sessionError = checkNonStartAuthorization(input, conversationId);
+      const sessionError = checkNonStartAuthorization(
+        input,
+        this.conversationId,
+      );
       if (sessionError != null) {
         return sessionError;
       }
@@ -258,9 +275,14 @@ export class HostAppControlProxy extends HostProxyBase<
         input,
         conversationId,
         signal,
+        undefined,
+        targetClientId,
       );
       return this.handleSuccess(input, payload);
     } catch (err) {
+      if (input.tool === "start") {
+        this.releaseSessionIfHeld();
+      }
       if (err instanceof HostProxyRequestError) {
         if (err.reason === "timeout") {
           log.warn({ toolName }, "Host app-control proxy request timed out");
@@ -279,6 +301,12 @@ export class HostAppControlProxy extends HostProxyBase<
     }
   }
 
+  private releaseSessionIfHeld(): void {
+    if (activeAppControlSession?.conversationId === this.conversationId) {
+      activeAppControlSession = undefined;
+    }
+  }
+
   // ---------------------------------------------------------------------------
   // Result handling
   // ---------------------------------------------------------------------------
@@ -304,13 +332,12 @@ export class HostAppControlProxy extends HostProxyBase<
       }
     }
 
-    // Store the exact `app` form for validation against subsequent
-    // non-start tool calls.
-    if (input.tool === "start" && payload.state === "running") {
-      activeAppControlSession = {
-        conversationId: this.conversationId,
-        app: input.app,
-      };
+    // The optimistic lock acquired in `request()` for `start` stays held
+    // only when the host confirms the session is running. Non-running
+    // outcomes (missing/minimized) release it so a retry or another
+    // conversation can acquire.
+    if (input.tool === "start" && payload.state !== "running") {
+      this.releaseSessionIfHeld();
     }
 
     return this.formatResult(payload, stuck);
@@ -382,8 +409,6 @@ export class HostAppControlProxy extends HostProxyBase<
    */
   override dispose(): void {
     super.dispose();
-    if (activeAppControlSession?.conversationId === this.conversationId) {
-      activeAppControlSession = undefined;
-    }
+    this.releaseSessionIfHeld();
   }
 }

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

@@ -1,10 +1,5 @@
-import { v4 as uuid } from "uuid";
-
 import { getConfig } from "../config/loader.js";
-import {
-  assistantEventHub,
-  broadcastMessage,
-} from "../runtime/assistant-event-hub.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import {
   ambiguousSameUserError,
   enforceSameActorOrErrorResult,
@@ -13,14 +8,42 @@ import {
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { formatShellOutput } from "../tools/shared/shell-output.js";
 import type { ToolExecutionResult } from "../tools/types.js";
-import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
+import { HostProxyBase, HostProxyRequestError } from "./host-proxy-base.js";
 
 const log = getLogger("host-bash-proxy");
 
-export class HostBashProxy {
+export type HostBashInput = {
+  command: string;
+  working_dir?: string;
+  timeout_seconds?: number;
+  env?: Record<string, string>;
+  targetClientId?: string;
+};
+
+type HostBashResultPayload = {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  timedOut: boolean;
+};
+
+export class HostBashProxy extends HostProxyBase<
+  Record<string, unknown>,
+  HostBashResultPayload
+> {
   private static _instance: HostBashProxy | null = null;
 
+  constructor() {
+    super({
+      capabilityName: "host_bash",
+      requestEventName: "host_bash_request",
+      cancelEventName: "host_bash_cancel",
+      resultPendingKind: "host_bash",
+      disposedMessage: "Host bash proxy disposed",
+    });
+  }
+
   /**
    * Lazily-initialized singleton. Availability of an actual desktop
    * connection is checked at send time via the assistant event hub,
@@ -47,31 +70,15 @@ export class HostBashProxy {
     HostBashProxy._instance = null;
   }
 
-  /**
-   * Whether a client with `host_bash` capability is connected.
-   */
-  isAvailable(): boolean {
-    return (
-      assistantEventHub.getMostRecentClientByCapability("host_bash") != null
-    );
-  }
-
-  request(
-    input: {
-      command: string;
-      working_dir?: string;
-      timeout_seconds?: number;
-      env?: Record<string, string>;
-      targetClientId?: string;
-    },
+  async request(
+    input: HostBashInput,
     conversationId: string,
     signal?: AbortSignal,
     // Principal ID of the actor on whose behalf this request is initiated.
     sourceActorPrincipalId?: string,
   ): Promise<ToolExecutionResult> {
     if (signal?.aborted) {
-      const result = formatShellOutput("", "Aborted", null, false, 0);
-      return Promise.resolve(result);
+      return formatShellOutput("", "Aborted", null, false, 0);
     }
 
     let resolvedTargetClientId: string | undefined;
@@ -79,10 +86,10 @@ export class HostBashProxy {
     if (input.targetClientId) {
       const target = assistantEventHub.getClientById(input.targetClientId);
       if (!target || !target.capabilities.includes("host_bash")) {
-        return Promise.resolve({
+        return {
           content: `Error: client "${input.targetClientId}" is not connected or does not support host_bash. Run \`assistant clients list --capability host_bash\` to see available clients.`,
           isError: true,
-        });
+        };
       }
       resolvedTargetClientId = input.targetClientId;
     } else {
@@ -97,7 +104,7 @@ export class HostBashProxy {
         sourceActorPrincipalId,
       });
       if (resolved.kind === "ambiguous") {
-        return Promise.resolve(ambiguousSameUserError("host_bash"));
+        return ambiguousSameUserError("host_bash");
       }
       resolvedTargetClientId =
         resolved.kind === "match" ? resolved.clientId : undefined;
@@ -114,98 +121,56 @@ export class HostBashProxy {
         targetClientId: resolvedTargetClientId,
         op: "host_bash",
       });
-      if (rejection) return Promise.resolve(rejection);
+      if (rejection) return rejection;
     }
 
-    const requestId = uuid();
-
-    return new Promise<ToolExecutionResult>((resolve, reject) => {
-      const shellMaxTimeoutSec = getConfig().timeouts.shellMaxTimeoutSec;
-      const timeoutSec = input.timeout_seconds ?? shellMaxTimeoutSec;
-      const proxyTimeoutSec = timeoutSec + 3;
-
-      let detachAbort: () => void = () => {};
-
-      const timer = setTimeout(() => {
-        pendingInteractions.resolve(requestId);
-        log.warn(
-          { requestId, command: input.command },
-          "Host bash proxy request timed out",
-        );
-        const timeoutMessage = resolvedTargetClientId
-          ? `Host bash proxy timed out waiting for response from client ${resolvedTargetClientId}`
-          : "Host bash proxy timed out waiting for client response";
-        resolve(formatShellOutput("", timeoutMessage, null, true, timeoutSec));
-      }, proxyTimeoutSec * 1000);
-
-      if (signal) {
-        const onAbort = () => {
-          if (pendingInteractions.get(requestId)) {
-            pendingInteractions.resolve(requestId);
-            try {
-              broadcastMessage(
-                {
-                  type: "host_bash_cancel",
-                  requestId,
-                  conversationId,
-                  targetClientId: resolvedTargetClientId,
-                },
-                conversationId,
-                { targetClientId: resolvedTargetClientId },
-              );
-            } catch {
-              // Best-effort cancel notification
-            }
-            resolve(formatShellOutput("", "Aborted", null, false, 0));
-          }
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-        detachAbort = () => signal.removeEventListener("abort", onAbort);
-      }
-
-      pendingInteractions.register(requestId, {
+    const shellMaxTimeoutSec = getConfig().timeouts.shellMaxTimeoutSec;
+    const timeoutSec = input.timeout_seconds ?? shellMaxTimeoutSec;
+    const proxyTimeoutMs = (timeoutSec + 3) * 1000;
+
+    // Spread command fields at the top level of the envelope so the desktop
+    // client receives the same flat message shape it has always expected.
+    const extraFields: Record<string, unknown> = { command: input.command };
+    if (input.working_dir !== undefined) extraFields.working_dir = input.working_dir;
+    if (input.timeout_seconds !== undefined)
+      extraFields.timeout_seconds = input.timeout_seconds;
+    if (input.env && Object.keys(input.env).length > 0) extraFields.env = input.env;
+
+    try {
+      const payload = await this.dispatchRequest(
+        "host_bash",
+        {},
         conversationId,
-        kind: "host_bash",
-        rpcResolve: resolve as (v: unknown) => void,
-        rpcReject: reject,
-        timer,
-        detachAbort,
-        targetClientId: resolvedTargetClientId,
-        targetActorPrincipalId:
-          resolvedTargetClientId != null
-            ? assistantEventHub.getActorPrincipalIdForClient(
-                resolvedTargetClientId,
-              )
-            : undefined,
-        metadata: { timeoutSec },
-      });
-
-      try {
-        broadcastMessage(
-          {
-            type: "host_bash_request",
-            requestId,
-            conversationId,
-            command: input.command,
-            working_dir: input.working_dir,
-            timeout_seconds: input.timeout_seconds,
-            targetClientId: resolvedTargetClientId,
-            ...(input.env && Object.keys(input.env).length > 0
-              ? { env: input.env }
-              : {}),
-          },
-          conversationId,
-          { targetClientId: resolvedTargetClientId },
-        );
-      } catch (err) {
-        pendingInteractions.resolve(requestId);
-        log.warn(
-          { requestId, command: input.command, err },
-          "Host bash proxy send failed",
-        );
-        reject(err instanceof Error ? err : new Error(String(err)));
+        signal,
+        extraFields,
+        resolvedTargetClientId,
+        proxyTimeoutMs,
+      );
+      return formatShellOutput(
+        payload.stdout,
+        payload.stderr,
+        payload.exitCode,
+        payload.timedOut,
+        timeoutSec,
+      );
+    } catch (err) {
+      if (err instanceof HostProxyRequestError) {
+        if (err.reason === "timeout") {
+          log.warn(
+            { command: input.command },
+            "Host bash proxy request timed out",
+          );
+          const msg = resolvedTargetClientId
+            ? `Host bash proxy timed out waiting for response from client ${resolvedTargetClientId}`
+            : "Host bash proxy timed out waiting for client response";
+          return formatShellOutput("", msg, null, true, timeoutSec);
+        }
+        if (err.reason === "aborted") {
+          return formatShellOutput("", "Aborted", null, false, 0);
+        }
       }
-    });
+      throw err;
+    }
   }
 
   /**
@@ -220,45 +185,7 @@ export class HostBashProxy {
       timedOut: boolean;
     },
   ): void {
-    const interaction = pendingInteractions.resolve(requestId);
-    if (!interaction?.rpcResolve) {
-      log.warn({ requestId }, "No pending host bash request for response");
-      return;
-    }
-    const timeoutSec = (interaction.metadata?.timeoutSec as number) ?? 0;
-    const result = formatShellOutput(
-      response.stdout,
-      response.stderr,
-      response.exitCode,
-      response.timedOut,
-      timeoutSec,
-    );
-    interaction.rpcResolve(result);
-  }
-
-  dispose(): void {
-    for (const entry of pendingInteractions.getByKind("host_bash")) {
-      pendingInteractions.resolve(entry.requestId);
-      try {
-        broadcastMessage(
-          {
-            type: "host_bash_cancel",
-            requestId: entry.requestId,
-            conversationId: entry.conversationId,
-            targetClientId: entry.targetClientId,
-          },
-          entry.conversationId,
-          { targetClientId: entry.targetClientId },
-        );
-      } catch {
-        // Best-effort cancel notification — connection may already be closed.
-      }
-      entry.rpcReject?.(
-        new AssistantError(
-          "Host bash proxy disposed",
-          ErrorCode.INTERNAL_ERROR,
-        ),
-      );
-    }
+    pendingInteractions.resolve(requestId);
+    this.resolve(requestId, response);
   }
 }