@vellumai/assistant 0.4.26 → 0.4.29

package/src/daemon/handlers/avatar.ts

@@ -1,10 +1,10 @@
-import * as net from 'node:net';
-import { join } from 'node:path';
+import * as net from "node:net";
+import { join } from "node:path";
 
-import { setAvatarTool } from '../../tools/system/avatar-generator.js';
-import { getWorkspaceDir } from '../../util/platform.js';
-import type { GenerateAvatarRequest } from '../ipc-contract/settings.js';
-import { defineHandlers, type HandlerContext, log } from './shared.js';
+import { setAvatarTool } from "../../tools/system/avatar-generator.js";
+import { getWorkspaceDir } from "../../util/platform.js";
+import type { GenerateAvatarRequest } from "../ipc-contract/settings.js";
+import { defineHandlers, type HandlerContext, log } from "./shared.js";
 
 /**
  * Handle a client request to generate a custom avatar via Gemini.
@@ -19,14 +19,14 @@ async function handleGenerateAvatar(
   const description = msg.description?.trim();
   if (!description) {
     ctx.send(socket, {
-      type: 'generate_avatar_response',
+      type: "generate_avatar_response",
       success: false,
-      error: 'Description is required.',
+      error: "Description is required.",
     });
     return;
   }
 
-  log.info({ description }, 'Generating avatar via IPC request');
+  log.info({ description }, "Generating avatar via IPC request");
 
   try {
     const result = await setAvatarTool.execute(
@@ -37,7 +37,7 @@ async function handleGenerateAvatar(
 
     if (result.isError) {
       ctx.send(socket, {
-        type: 'generate_avatar_response',
+        type: "generate_avatar_response",
         success: false,
         error: result.content,
       });
@@ -45,18 +45,23 @@ async function handleGenerateAvatar(
     }
 
     // Broadcast avatar change to all connected clients
-    const avatarPath = join(getWorkspaceDir(), 'data', 'avatar', 'custom-avatar.png');
-    ctx.broadcast({ type: 'avatar_updated', avatarPath });
+    const avatarPath = join(
+      getWorkspaceDir(),
+      "data",
+      "avatar",
+      "custom-avatar.png",
+    );
+    ctx.broadcast({ type: "avatar_updated", avatarPath });
 
     ctx.send(socket, {
-      type: 'generate_avatar_response',
+      type: "generate_avatar_response",
       success: true,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ error: message }, 'Avatar generation failed unexpectedly');
+    log.error({ error: message }, "Avatar generation failed unexpectedly");
     ctx.send(socket, {
-      type: 'generate_avatar_response',
+      type: "generate_avatar_response",
       success: false,
       error: message,
     });

package/src/daemon/handlers/computer-use.ts

@@ -1,17 +1,21 @@
-import * as net from 'node:net';
-
-import { getConfig } from '../../config/loader.js';
-import { RateLimitProvider } from '../../providers/ratelimit.js';
-import { getFailoverProvider } from '../../providers/registry.js';
-import { ComputerUseSession } from '../computer-use-session.js';
-import { deleteBlob, readBlob, validateBlobKindEncoding } from '../ipc-blob-store.js';
+import * as net from "node:net";
+
+import { getConfig } from "../../config/loader.js";
+import { RateLimitProvider } from "../../providers/ratelimit.js";
+import { getFailoverProvider } from "../../providers/registry.js";
+import { ComputerUseSession } from "../computer-use-session.js";
+import {
+  deleteBlob,
+  readBlob,
+  validateBlobKindEncoding,
+} from "../ipc-blob-store.js";
 import type {
   CuObservation,
   CuSessionAbort,
   CuSessionCreate,
   ServerMessage,
-} from '../ipc-protocol.js';
-import { defineHandlers, type HandlerContext,log } from './shared.js';
+} from "../ipc-protocol.js";
+import { defineHandlers, type HandlerContext, log } from "./shared.js";
 
 const cuObservationSequenceBySession = new Map<string, number>();
 
@@ -52,7 +56,11 @@ export function handleCuSessionCreate(
   let provider = getFailoverProvider(config.provider, config.providerOrder);
   const { rateLimit } = config;
   if (rateLimit.maxRequestsPerMinute > 0 || rateLimit.maxTokensPerSession > 0) {
-    provider = new RateLimitProvider(provider, rateLimit, ctx.sharedRequestTimestamps);
+    provider = new RateLimitProvider(
+      provider,
+      rateLimit,
+      ctx.sharedRequestTimestamps,
+    );
   }
 
   const sendToClient = (serverMsg: ServerMessage) => {
@@ -62,7 +70,10 @@ export function handleCuSessionCreate(
   const sessionRef: { current?: ComputerUseSession } = {};
   const onTerminal = (sessionId: string) => {
     removeCuSessionReferences(ctx, sessionId, sessionRef.current);
-    log.info({ sessionId }, 'Computer-use session cleaned up after terminal state');
+    log.info(
+      { sessionId },
+      "Computer-use session cleaned up after terminal state",
+    );
   };
 
   const session = new ComputerUseSession(
@@ -87,7 +98,10 @@ export function handleCuSessionCreate(
   }
   sessionIds.add(msg.sessionId);
 
-  log.info({ sessionId: msg.sessionId, taskLength: msg.task.length }, 'Computer-use session created');
+  log.info(
+    { sessionId: msg.sessionId, taskLength: msg.task.length },
+    "Computer-use session created",
+  );
 }
 
 export function handleCuSessionAbort(
@@ -97,12 +111,18 @@ export function handleCuSessionAbort(
 ): void {
   const session = ctx.cuSessions.get(msg.sessionId);
   if (!session) {
-    log.debug({ sessionId: msg.sessionId }, 'CU session abort: session not found (already finished?)');
+    log.debug(
+      { sessionId: msg.sessionId },
+      "CU session abort: session not found (already finished?)",
+    );
     return;
   }
   session.abort();
   removeCuSessionReferences(ctx, msg.sessionId, session);
-  log.info({ sessionId: msg.sessionId }, 'Computer-use session aborted by client');
+  log.info(
+    { sessionId: msg.sessionId },
+    "Computer-use session aborted by client",
+  );
 }
 
 export async function handleCuObservation(
@@ -116,59 +136,79 @@ export async function handleCuObservation(
   // Strategy: blob-first, inline-fallback, cu_error if neither available.
   if (msg.axTreeBlob) {
     try {
-      validateBlobKindEncoding(msg.axTreeBlob, 'axTreeBlob');
+      validateBlobKindEncoding(msg.axTreeBlob, "axTreeBlob");
       const buf = await readBlob(msg.axTreeBlob);
-      msg.axTree = buf.toString('utf8');
+      msg.axTree = buf.toString("utf8");
       deleteBlob(msg.axTreeBlob.id);
     } catch (err) {
-      log.warn({ err, blobId: msg.axTreeBlob.id }, 'Failed to hydrate axTreeBlob, checking inline fallback');
+      log.warn(
+        { err, blobId: msg.axTreeBlob.id },
+        "Failed to hydrate axTreeBlob, checking inline fallback",
+      );
       deleteBlob(msg.axTreeBlob.id);
       if (!msg.axTree) {
-        log.warn({ blobId: msg.axTreeBlob.id }, 'No inline axTree fallback; continuing with partial observation');
+        log.warn(
+          { blobId: msg.axTreeBlob.id },
+          "No inline axTree fallback; continuing with partial observation",
+        );
       }
     }
   }
 
   if (msg.screenshotBlob) {
     try {
-      validateBlobKindEncoding(msg.screenshotBlob, 'screenshotBlob');
+      validateBlobKindEncoding(msg.screenshotBlob, "screenshotBlob");
       const buf = await readBlob(msg.screenshotBlob);
-      msg.screenshot = buf.toString('base64');
+      msg.screenshot = buf.toString("base64");
       deleteBlob(msg.screenshotBlob.id);
     } catch (err) {
-      log.warn({ err, blobId: msg.screenshotBlob.id }, 'Failed to hydrate screenshotBlob, checking inline fallback');
+      log.warn(
+        { err, blobId: msg.screenshotBlob.id },
+        "Failed to hydrate screenshotBlob, checking inline fallback",
+      );
       deleteBlob(msg.screenshotBlob.id);
       if (!msg.screenshot) {
-        log.warn({ blobId: msg.screenshotBlob.id }, 'No inline screenshot fallback; continuing with partial observation');
+        log.warn(
+          { blobId: msg.screenshotBlob.id },
+          "No inline screenshot fallback; continuing with partial observation",
+        );
       }
     }
   }
 
-  const previousSequence = cuObservationSequenceBySession.get(msg.sessionId) ?? 0;
+  const previousSequence =
+    cuObservationSequenceBySession.get(msg.sessionId) ?? 0;
   const sequence = previousSequence + 1;
   cuObservationSequenceBySession.set(msg.sessionId, sequence);
-  const axTreeBytes = msg.axTree ? Buffer.byteLength(msg.axTree, 'utf8') : 0;
-  const axDiffBytes = msg.axDiff ? Buffer.byteLength(msg.axDiff, 'utf8') : 0;
-  const secondaryWindowsBytes = msg.secondaryWindows ? Buffer.byteLength(msg.secondaryWindows, 'utf8') : 0;
-  const screenshotBase64Bytes = msg.screenshot ? Buffer.byteLength(msg.screenshot, 'utf8') : 0;
+  const axTreeBytes = msg.axTree ? Buffer.byteLength(msg.axTree, "utf8") : 0;
+  const axDiffBytes = msg.axDiff ? Buffer.byteLength(msg.axDiff, "utf8") : 0;
+  const secondaryWindowsBytes = msg.secondaryWindows
+    ? Buffer.byteLength(msg.secondaryWindows, "utf8")
+    : 0;
+  const screenshotBase64Bytes = msg.screenshot
+    ? Buffer.byteLength(msg.screenshot, "utf8")
+    : 0;
   const screenshotApproxRawBytes = msg.screenshot
     ? Math.floor((msg.screenshot.length / 4) * 3)
     : 0;
-  log.info({
-    sessionId: msg.sessionId,
-    sequence,
-    receiveTimestampMs,
-    axTreeBytes,
-    axDiffBytes,
-    secondaryWindowsBytes,
-    screenshotBase64Bytes,
-    screenshotApproxRawBytes,
-  }, 'IPC_METRIC cu_observation_daemon_receive');
+  log.info(
+    {
+      sessionId: msg.sessionId,
+      sequence,
+      receiveTimestampMs,
+      axTreeBytes,
+      axDiffBytes,
+      secondaryWindowsBytes,
+      screenshotBase64Bytes,
+      screenshotApproxRawBytes,
+    },
+    "IPC_METRIC cu_observation_daemon_receive",
+  );
 
   const session = ctx.cuSessions.get(msg.sessionId);
   if (!session) {
     ctx.send(socket, {
-      type: 'cu_error',
+      type: "cu_error",
       sessionId: msg.sessionId,
       message: `No computer-use session found for id ${msg.sessionId}`,
     });
@@ -177,7 +217,10 @@ export async function handleCuObservation(
 
   // Fire-and-forget: the session sends messages via its sendToClient callback
   session.handleObservation(msg).catch((err) => {
-    log.error({ err, sessionId: msg.sessionId }, 'Error handling CU observation');
+    log.error(
+      { err, sessionId: msg.sessionId },
+      "Error handling CU observation",
+    );
   });
 }
 

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

@@ -1,32 +1,40 @@
-import * as net from 'node:net';
+import * as net from "node:net";
 
-import type { ChannelId } from '../../channels/types.js';
-import * as externalConversationStore from '../../memory/external-conversation-store.js';
-import { findMember, revokeMember } from '../../memory/ingress-member-store.js';
-import { DAEMON_INTERNAL_ASSISTANT_ID } from '../../runtime/assistant-scope.js';
+import type { ChannelId } from "../../channels/types.js";
+import { findContactChannel } from "../../contacts/contact-store.js";
+import { revokeMember } from "../../contacts/contacts-write.js";
+import type { ChannelStatus } from "../../contacts/types.js";
+import * as externalConversationStore from "../../memory/external-conversation-store.js";
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
 import {
   createVerificationChallenge,
   findActiveSession,
   getGuardianBinding,
   getPendingChallenge,
-  revokeBinding as revokeGuardianBinding,
+  revokeBinding,
   revokePendingChallenges,
-} from '../../runtime/channel-guardian-service.js';
-import { type ChannelReadinessService, createReadinessService } from '../../runtime/channel-readiness-service.js';
+} from "../../runtime/channel-guardian-service.js";
+import {
+  type ChannelReadinessService,
+  createReadinessService,
+} from "../../runtime/channel-readiness-service.js";
 import {
   cancelOutbound,
   resendOutbound,
   startOutbound,
-} from '../../runtime/guardian-outbound-actions.js';
+} from "../../runtime/guardian-outbound-actions.js";
 import type {
   GuardianVerificationRequest,
   GuardianVerificationResponse,
-} from '../ipc-protocol.js';
-import { defineHandlers, type HandlerContext, log } from './shared.js';
+} from "../ipc-protocol.js";
+import { defineHandlers, type HandlerContext, log } from "./shared.js";
 
 // -- Transport-agnostic result type (omits the IPC `type` discriminant) --
 
-export type GuardianVerificationResult = Omit<GuardianVerificationResponse, 'type'>;
+export type GuardianVerificationResult = Omit<
+  GuardianVerificationResponse,
+  "type"
+>;
 
 // ---------------------------------------------------------------------------
 // Re-export rate limit constants from the shared outbound actions module
@@ -38,7 +46,7 @@ export {
   MAX_SENDS_PER_DESTINATION_WINDOW,
   MAX_SENDS_PER_SESSION,
   RESEND_COOLDOWN_MS,
-} from '../../runtime/guardian-outbound-actions.js';
+} from "../../runtime/guardian-outbound-actions.js";
 
 // ---------------------------------------------------------------------------
 // Readiness service singleton
@@ -63,19 +71,27 @@ export function createGuardianChallenge(
   sessionId?: string,
 ): GuardianVerificationResult {
   const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
-  const resolvedChannel = channel ?? 'telegram';
+  const resolvedChannel = channel ?? "telegram";
 
-  const existingBinding = getGuardianBinding(resolvedAssistantId, resolvedChannel);
+  const existingBinding = getGuardianBinding(
+    resolvedAssistantId,
+    resolvedChannel,
+  );
   if (existingBinding && !rebind) {
     return {
       success: false,
-      error: 'already_bound',
-      message: 'A guardian is already bound for this channel. Revoke the existing binding first, or set rebind: true to replace.',
+      error: "already_bound",
+      message:
+        "A guardian is already bound for this channel. Revoke the existing binding first, or set rebind: true to replace.",
       channel: resolvedChannel,
     };
   }
 
-  const result = createVerificationChallenge(resolvedAssistantId, resolvedChannel, sessionId);
+  const result = createVerificationChallenge(
+    resolvedAssistantId,
+    resolvedChannel,
+    sessionId,
+  );
 
   return {
     success: true,
@@ -89,25 +105,37 @@ export function getGuardianStatus(
   channel?: ChannelId,
 ): GuardianVerificationResult {
   const resolvedAssistantId = DAEMON_INTERNAL_ASSISTANT_ID;
-  const resolvedChannel = channel ?? 'telegram';
+  const resolvedChannel = channel ?? "telegram";
 
   const binding = getGuardianBinding(resolvedAssistantId, resolvedChannel);
   let guardianUsername: string | undefined;
   let guardianDisplayName: string | undefined;
   if (binding?.metadataJson) {
     try {
-      const parsed = JSON.parse(binding.metadataJson) as Record<string, unknown>;
-      if (typeof parsed.username === 'string' && parsed.username.trim().length > 0) {
+      const parsed = JSON.parse(binding.metadataJson) as Record<
+        string,
+        unknown
+      >;
+      if (
+        typeof parsed.username === "string" &&
+        parsed.username.trim().length > 0
+      ) {
         guardianUsername = parsed.username.trim();
       }
-      if (typeof parsed.displayName === 'string' && parsed.displayName.trim().length > 0) {
+      if (
+        typeof parsed.displayName === "string" &&
+        parsed.displayName.trim().length > 0
+      ) {
         guardianDisplayName = parsed.displayName.trim();
       }
     } catch {
       // ignore malformed metadata
     }
   }
-  if (binding?.guardianDeliveryChatId && (!guardianUsername || !guardianDisplayName)) {
+  if (
+    binding?.guardianDeliveryChatId &&
+    (!guardianUsername || !guardianDisplayName)
+  ) {
     const ext = externalConversationStore.getBindingByChannelChat(
       resolvedChannel,
       binding.guardianDeliveryChatId,
@@ -119,18 +147,22 @@ export function getGuardianStatus(
       guardianDisplayName = ext.displayName;
     }
   }
-  const hasPendingChallenge = getPendingChallenge(resolvedAssistantId, resolvedChannel) != null;
+  const hasPendingChallenge =
+    getPendingChallenge(resolvedAssistantId, resolvedChannel) != null;
 
   // Include active outbound session state so the UI can resume
   // after app restart and detect bootstrap completion.
-  const activeOutboundSession = findActiveSession(resolvedAssistantId, resolvedChannel);
+  const activeOutboundSession = findActiveSession(
+    resolvedAssistantId,
+    resolvedChannel,
+  );
   const outboundFields: Record<string, unknown> = {};
   if (activeOutboundSession) {
     outboundFields.verificationSessionId = activeOutboundSession.id;
     outboundFields.expiresAt = activeOutboundSession.expiresAt;
     outboundFields.nextResendAt = activeOutboundSession.nextResendAt;
     outboundFields.sendCount = activeOutboundSession.sendCount;
-    if (activeOutboundSession.status === 'pending_bootstrap') {
+    if (activeOutboundSession.status === "pending_bootstrap") {
       outboundFields.pendingBootstrap = true;
     }
   }
@@ -149,6 +181,64 @@ export function getGuardianStatus(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Revoke guardian binding
+// ---------------------------------------------------------------------------
+
+export function revokeGuardianForChannel(
+  channel?: ChannelId,
+): GuardianVerificationResult {
+  const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
+  const resolvedChannel = channel ?? "telegram";
+
+  // Always revoke pending challenges first — the macOS app uses
+  // action: "revoke" to cancel an in-flight challenge even before
+  // a binding exists (e.g. during verification setup).
+  revokePendingChallenges(assistantId, resolvedChannel);
+
+  // Capture binding before revoking so we can revoke the guardian's
+  // contact record — without this, the guardian would still pass
+  // the ACL check after unbinding.
+  const bindingBeforeRevoke = getGuardianBinding(assistantId, resolvedChannel);
+  if (!bindingBeforeRevoke) {
+    return {
+      success: true,
+      bound: false,
+      channel: resolvedChannel,
+    };
+  }
+
+  // Revoke the member BEFORE the guardian binding so that
+  // revokeMember sees the channel as active/pending and sets the
+  // correct revokedReason ("guardian_binding_revoked"). If the guardian binding
+  // is revoked first, the channel is already marked revoked and the member
+  // revocation becomes a no-op (wrong reason or skipped entirely).
+  const contactResult = findContactChannel({
+    channelType: resolvedChannel,
+    externalUserId: bindingBeforeRevoke.guardianExternalUserId,
+    externalChatId: bindingBeforeRevoke.guardianDeliveryChatId,
+  });
+
+  if (contactResult) {
+    const channelStatus: ChannelStatus = contactResult.channel.status;
+    if (
+      channelStatus === "active" ||
+      channelStatus === "pending" ||
+      channelStatus === "unverified"
+    ) {
+      revokeMember(contactResult.channel.id, "guardian_binding_revoked");
+    }
+  }
+
+  revokeBinding(assistantId, resolvedChannel);
+
+  return {
+    success: true,
+    bound: false,
+    channel: resolvedChannel,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Guardian verification handler
 // ---------------------------------------------------------------------------
@@ -158,54 +248,42 @@ export function handleGuardianVerification(
   socket: net.Socket,
   ctx: HandlerContext,
 ): void {
-  const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
-  const channel = msg.channel ?? 'telegram';
+  const channel = msg.channel ?? "telegram";
 
   try {
-    if (msg.action === 'create_challenge') {
-      const result = createGuardianChallenge(channel, msg.rebind, msg.sessionId);
-      ctx.send(socket, { type: 'guardian_verification_response', ...result });
-    } else if (msg.action === 'status') {
+    if (msg.action === "create_challenge") {
+      const result = createGuardianChallenge(
+        channel,
+        msg.rebind,
+        msg.sessionId,
+      );
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
+    } else if (msg.action === "status") {
       const result = getGuardianStatus(channel);
-      ctx.send(socket, { type: 'guardian_verification_response', ...result });
-    } else if (msg.action === 'revoke') {
-      // Capture binding before revoking so we can revoke the guardian's
-      // ingress member record — without this, the guardian would still pass
-      // the ACL check after unbinding.
-      const bindingBeforeRevoke = getGuardianBinding(assistantId, channel);
-      revokeGuardianBinding(assistantId, channel);
-      revokePendingChallenges(assistantId, channel);
-
-      if (bindingBeforeRevoke) {
-        const member = findMember({
-          assistantId,
-          sourceChannel: channel,
-          externalUserId: bindingBeforeRevoke.guardianExternalUserId,
-          externalChatId: bindingBeforeRevoke.guardianDeliveryChatId,
-        });
-        if (member) {
-          revokeMember(member.id, 'guardian_binding_revoked');
-        }
-      }
-
-      ctx.send(socket, {
-        type: 'guardian_verification_response',
-        success: true,
-        bound: false,
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
+    } else if (msg.action === "revoke") {
+      const result = revokeGuardianForChannel(channel);
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
+    } else if (msg.action === "start_outbound") {
+      const result = startOutbound({
+        channel,
+        destination: msg.destination,
+        rebind: msg.rebind,
+        originConversationId: msg.originConversationId,
+      });
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
+    } else if (msg.action === "resend_outbound") {
+      const result = resendOutbound({
         channel,
+        originConversationId: msg.originConversationId,
       });
-    } else if (msg.action === 'start_outbound') {
-      const result = startOutbound({ channel, destination: msg.destination, rebind: msg.rebind, originConversationId: msg.originConversationId });
-      ctx.send(socket, { type: 'guardian_verification_response', ...result });
-    } else if (msg.action === 'resend_outbound') {
-      const result = resendOutbound({ channel, originConversationId: msg.originConversationId });
-      ctx.send(socket, { type: 'guardian_verification_response', ...result });
-    } else if (msg.action === 'cancel_outbound') {
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
+    } else if (msg.action === "cancel_outbound") {
       const result = cancelOutbound({ channel });
-      ctx.send(socket, { type: 'guardian_verification_response', ...result });
+      ctx.send(socket, { type: "guardian_verification_response", ...result });
     } else {
       ctx.send(socket, {
-        type: 'guardian_verification_response',
+        type: "guardian_verification_response",
         success: false,
         error: `Unknown action: ${String(msg.action)}`,
         channel,
@@ -213,9 +291,9 @@ export function handleGuardianVerification(
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log.error({ err }, 'Failed to handle guardian verification');
+    log.error({ err }, "Failed to handle guardian verification");
     ctx.send(socket, {
-      type: 'guardian_verification_response',
+      type: "guardian_verification_response",
       success: false,
       error: message,
       channel,
@@ -223,7 +301,6 @@ export function handleGuardianVerification(
   }
 }
 
-
 export const channelHandlers = defineHandlers({
   guardian_verification: handleGuardianVerification,
 });