@vellumai/assistant 0.7.2 → 0.7.3

package/src/oauth/connection-resolver.test.ts

@@ -62,7 +62,10 @@ mock.module("../platform/client.js", () => ({
 // ---------------------------------------------------------------------------
 
 import { BYOOAuthConnection } from "./byo-connection.js";
-import { resolveOAuthConnection } from "./connection-resolver.js";
+import {
+  resolveEffectiveBaseUrl,
+  resolveOAuthConnection,
+} from "./connection-resolver.js";
 import { PlatformOAuthConnection } from "./platform-connection.js";
 
 // ---------------------------------------------------------------------------
@@ -214,3 +217,65 @@ describe("resolveOAuthConnection", () => {
     ).rejects.toThrow(/No active OAuth connection found/);
   });
 });
+
+describe("resolveEffectiveBaseUrl", () => {
+  const fallback = "https://login.salesforce.com";
+
+  test("uses instance_url from JSON-string metadata for Salesforce", () => {
+    const metadata = JSON.stringify({
+      instance_url: "https://acme.my.salesforce.com",
+      issued_at: "1714000000000",
+    });
+    expect(resolveEffectiveBaseUrl("salesforce", fallback, metadata)).toBe(
+      "https://acme.my.salesforce.com",
+    );
+  });
+
+  test("uses instance_url from already-parsed object metadata", () => {
+    const metadata = { instance_url: "https://na162.salesforce.com" };
+    expect(resolveEffectiveBaseUrl("salesforce", fallback, metadata)).toBe(
+      "https://na162.salesforce.com",
+    );
+  });
+
+  test("falls back to seed baseUrl when metadata is null", () => {
+    expect(resolveEffectiveBaseUrl("salesforce", fallback, null)).toBe(
+      fallback,
+    );
+  });
+
+  test("falls back to seed baseUrl when instance_url is empty string", () => {
+    const metadata = JSON.stringify({ instance_url: "" });
+    expect(resolveEffectiveBaseUrl("salesforce", fallback, metadata)).toBe(
+      fallback,
+    );
+  });
+
+  test("falls back to seed baseUrl when metadata is unparseable JSON", () => {
+    expect(
+      resolveEffectiveBaseUrl("salesforce", fallback, "{ not valid json"),
+    ).toBe(fallback);
+  });
+
+  test("falls back to seed baseUrl when instance_url is the wrong type", () => {
+    const metadata = JSON.stringify({ instance_url: 12345 });
+    expect(resolveEffectiveBaseUrl("salesforce", fallback, metadata)).toBe(
+      fallback,
+    );
+  });
+
+  test("ignores instance_url for non-Salesforce providers", () => {
+    // A different provider whose token response happens to include an
+    // instance_url-shaped field MUST NOT have its baseUrl rewritten.
+    const metadata = JSON.stringify({
+      instance_url: "https://attacker.example.com",
+    });
+    expect(
+      resolveEffectiveBaseUrl(
+        "google",
+        "https://gmail.googleapis.com/gmail/v1/users/me",
+        metadata,
+      ),
+    ).toBe("https://gmail.googleapis.com/gmail/v1/users/me");
+  });
+});

package/src/oauth/connection-resolver.ts

@@ -116,11 +116,65 @@ export async function resolveOAuthConnection(
   return new BYOOAuthConnection({
     id: conn.id,
     provider: conn.provider,
-    baseUrl,
+    baseUrl: resolveEffectiveBaseUrl(conn.provider, baseUrl, conn.metadata),
     accountInfo: conn.accountInfo,
   });
 }
 
+/**
+ * Resolve the effective API base URL for a connection, preferring per-tenant
+ * values stored on the connection's `metadata` over the provider's static
+ * seed value when applicable.
+ *
+ * Salesforce is the only provider that needs this: every org has its own
+ * API instance host (``acme.my.salesforce.com``, ``na162.salesforce.com``)
+ * which is returned in the OAuth token response as ``instance_url`` and
+ * captured into ``oauth_connection.metadata`` by ``storeOAuth2Tokens``.
+ * The seed's ``baseUrl`` for Salesforce is the login domain
+ * (``https://login.salesforce.com``) — correct for the OAuth handshake but
+ * wrong for REST API calls. Pulling the per-connection ``instance_url``
+ * here avoids forcing every caller to override ``baseUrl`` per-request.
+ *
+ * For all other providers the seed value is correct (single API domain),
+ * so we return it unchanged.
+ *
+ * If a future provider needs the same treatment, generalize via a
+ * declarative ``baseUrlMetadataKey`` field on the seed entry rather than
+ * adding more provider-name branches here.
+ */
+export function resolveEffectiveBaseUrl(
+  provider: string,
+  fallbackBaseUrl: string,
+  rawMetadata: unknown,
+): string {
+  if (provider !== "salesforce") return fallbackBaseUrl;
+
+  const metadata = parseConnectionMetadata(rawMetadata);
+  const instanceUrl = metadata?.instance_url;
+  if (typeof instanceUrl === "string" && instanceUrl.length > 0) {
+    return instanceUrl;
+  }
+  return fallbackBaseUrl;
+}
+
+function parseConnectionMetadata(
+  raw: unknown,
+): Record<string, unknown> | undefined {
+  if (raw == null) return undefined;
+  if (typeof raw === "object") {
+    return raw as Record<string, unknown>;
+  }
+  if (typeof raw !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null
+      ? (parsed as Record<string, unknown>)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Platform connection ID resolution
 // ---------------------------------------------------------------------------

package/src/oauth/oauth-connect-state.ts

@@ -0,0 +1,77 @@
+/**
+ * In-memory OAuth connect flow status map.
+ *
+ * Tracks the current state of daemon-owned OAuth connect flows so the CLI
+ * can poll for completion via the IPC route.
+ */
+type OAuthConnectState =
+  | { status: "pending"; service: string; expiresAt: number }
+  | { status: "complete"; service: string; accountInfo?: string; grantedScopes?: string[]; completedAt: number }
+  | { status: "error"; service: string; error: string; failedAt: number };
+
+const activeOAuthConnectFlows = new Map<string, OAuthConnectState>();
+
+const PENDING_TTL_MS = 5 * 60 * 1000; // 5 min — matches oauth-callback-registry.ts:14
+const COMPLETION_GRACE_MS = 60 * 1000; // 60s so the polling CLI gets one final read
+
+export function setOAuthConnectPending(state: string, service: string): void {
+  clearExpiredOAuthConnectStates();
+  activeOAuthConnectFlows.set(state, {
+    status: "pending",
+    service,
+    expiresAt: Date.now() + PENDING_TTL_MS,
+  });
+}
+
+export function setOAuthConnectComplete(
+  state: string,
+  service: string,
+  accountInfo?: string,
+  grantedScopes?: string[],
+): void {
+  clearExpiredOAuthConnectStates();
+  activeOAuthConnectFlows.set(state, {
+    status: "complete",
+    service,
+    accountInfo,
+    grantedScopes,
+    completedAt: Date.now(),
+  });
+}
+
+export function setOAuthConnectError(
+  state: string,
+  service: string,
+  error: string,
+): void {
+  clearExpiredOAuthConnectStates();
+  activeOAuthConnectFlows.set(state, {
+    status: "error",
+    service,
+    error,
+    failedAt: Date.now(),
+  });
+}
+
+export function getOAuthConnectState(state: string): OAuthConnectState | null {
+  clearExpiredOAuthConnectStates();
+  return activeOAuthConnectFlows.get(state) ?? null;
+}
+
+export function clearExpiredOAuthConnectStates(): void {
+  const now = Date.now();
+  for (const [key, state] of activeOAuthConnectFlows) {
+    if (state.status === "pending" && now > state.expiresAt) {
+      activeOAuthConnectFlows.delete(key);
+    } else if (state.status === "complete" && now > state.completedAt + COMPLETION_GRACE_MS) {
+      activeOAuthConnectFlows.delete(key);
+    } else if (state.status === "error" && now > state.failedAt + COMPLETION_GRACE_MS) {
+      activeOAuthConnectFlows.delete(key);
+    }
+  }
+}
+
+/** Test-only helper — clears all state for test isolation. */
+export function _clearAllOAuthConnectStates(): void {
+  activeOAuthConnectFlows.clear();
+}

package/src/oauth/seed-providers.ts

@@ -393,6 +393,7 @@ export const PROVIDER_SEED_DATA: Record<
       { scope: "project:delete", description: "Delete entire projects" },
     ],
     loopbackPort: 17325,
+    managedServiceConfigKey: "todoist-oauth",
     injectionTemplates: [
       {
         hostPattern: "api.todoist.com",
@@ -402,7 +403,7 @@ export const PROVIDER_SEED_DATA: Record<
       },
     ],
     appType: "App",
-    identityUrl: "https://api.todoist.com/sync/v9/sync",
+    identityUrl: "https://api.todoist.com/api/v1/sync",
     identityMethod: "POST",
     identityHeaders: { "Content-Type": "application/x-www-form-urlencoded" },
     identityBody: "sync_token=*&resource_types=[%22user%22]",
@@ -429,6 +430,7 @@ export const PROVIDER_SEED_DATA: Record<
     availableScopes:
       "https://discord.com/developers/docs/topics/oauth2#shared-resources-oauth2-scopes",
     loopbackPort: 17326,
+    managedServiceConfigKey: "discord-oauth",
     injectionTemplates: [
       {
         hostPattern: "discord.com",
@@ -497,6 +499,7 @@ export const PROVIDER_SEED_DATA: Record<
     defaultScopes: ["default"],
     availableScopes: "https://developers.asana.com/docs/oauth-scopes",
     loopbackPort: 17328,
+    managedServiceConfigKey: "asana-oauth",
     injectionTemplates: [
       {
         hostPattern: "app.asana.com",
@@ -563,6 +566,7 @@ export const PROVIDER_SEED_DATA: Record<
     availableScopes:
       "https://developers.hubspot.com/docs/guides/apps/authentication/scopes",
     loopbackPort: 17330,
+    managedServiceConfigKey: "hubspot-oauth",
     injectionTemplates: [
       {
         hostPattern: "api.hubapi.com",
@@ -576,6 +580,59 @@ export const PROVIDER_SEED_DATA: Record<
     identityResponsePaths: ["user", "hub_domain"],
   },
 
+  salesforce: {
+    provider: "salesforce",
+    authorizeUrl: "https://login.salesforce.com/services/oauth2/authorize",
+    tokenExchangeUrl: "https://login.salesforce.com/services/oauth2/token",
+    refreshUrl: "https://login.salesforce.com/services/oauth2/token",
+    pingUrl: "https://login.salesforce.com/services/oauth2/userinfo",
+    // baseUrl points at the login domain — correct for the OAuth handshake
+    // and for ``/services/oauth2/userinfo``/``revoke`` calls. REST API calls
+    // to ``/services/data/...`` go to the per-org instance host returned in
+    // the token response as ``instance_url`` and stored on
+    // ``oauth_connection.metadata``. ``connection-resolver.ts`` substitutes
+    // that instance URL when constructing the BYO connection so callers
+    // don't need to override ``baseUrl`` per request.
+    baseUrl: "https://login.salesforce.com",
+    displayLabel: "Salesforce",
+    description: "CRM contacts, leads, and opportunities",
+    dashboardUrl:
+      "https://help.salesforce.com/s/articleView?id=sf.connected_app_create.htm&type=5",
+    clientIdPlaceholder: null,
+    logoUrl:
+      "https://cdn.jsdelivr.net/gh/glincker/thesvg@main/public/icons/salesforce/default.svg",
+    defaultScopes: ["api", "refresh_token", "openid", "email", "profile"],
+    availableScopes:
+      "https://help.salesforce.com/s/articleView?id=sf.remoteaccess_oauth_tokens_scopes.htm",
+    authorizeParams: { prompt: "consent" },
+    tokenEndpointAuthMethod: "client_secret_post",
+    loopbackPort: 17336,
+    // Salesforce REST traffic goes to per-org instance hosts like
+    // ``acme.my.salesforce.com`` and ``acme.lightning.force.com``.
+    // ``matchHostPattern`` only treats ``*.<domain>`` as a wildcard match —
+    // bare ``salesforce.com`` would only match the apex. Use wildcards so
+    // ``Authorization: Bearer`` injection actually fires on tenant hosts.
+    injectionTemplates: [
+      {
+        hostPattern: "*.salesforce.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+      {
+        hostPattern: "*.force.com",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ],
+    revokeUrl: "https://login.salesforce.com/services/oauth2/revoke",
+    revokeBodyTemplate: { token: "{access_token}" },
+    appType: "Connected App",
+    identityUrl: "https://login.salesforce.com/services/oauth2/userinfo",
+    identityResponsePaths: ["email", "preferred_username"],
+  },
+
   figma: {
     provider: "figma",
     authorizeUrl: "https://www.figma.com/oauth",

package/src/plugins/defaults/injectors.ts

@@ -3,7 +3,7 @@
  * drives the per-turn injection sequence consumed by
  * `applyRuntimeInjections`.
  *
- * Each of the eight default injectors reads its per-turn inputs from
+ * Each default injector reads its per-turn inputs from
  * `ctx.injectionInputs` (see {@link TurnInjectionInputs}), runs its gating
  * conditions (injection mode, feature flags, channel type, null-input
  * short-circuits), and returns an {@link InjectionBlock} with a
@@ -12,6 +12,7 @@
  *
  * | name                     | order | placement               |
  * | ------------------------ | ----- | ----------------------- |
+ * | `disk-pressure-warning`  | 5     | prepend-user-tail       |
  * | `workspace-context`      | 10    | prepend-user-tail       |
  * | `unified-turn-context`   | 20    | prepend-user-tail       |
  * | `pkb-context`            | 30    | after-memory-prefix     |
@@ -45,6 +46,7 @@
 
 import { resolve } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getInContextPkbPaths } from "../../daemon/pkb-context-tracker.js";
 import { buildPkbReminder } from "../../daemon/pkb-reminder-builder.js";
@@ -74,7 +76,7 @@ const PKB_HINT_THRESHOLD = 0.5;
 const PKB_HINT_ARCHIVE_THRESHOLD = 0.7;
 
 /**
- * Fixed order values for the eight default injectors. Exported so tests —
+ * Fixed order values for the default injectors. Exported so tests —
  * and any future integration code — can assert ordering without re-deriving
  * the constants.
  *
@@ -83,6 +85,7 @@ const PKB_HINT_ARCHIVE_THRESHOLD = 0.7;
  * without renumbering the defaults.
  */
 export const DEFAULT_INJECTOR_ORDER = {
+  diskPressureWarning: 5,
   workspaceContext: 10,
   unifiedTurnContext: 20,
   pkbContext: 30,
@@ -98,6 +101,35 @@ function readInjectionInputs(ctx: TurnContext): TurnInjectionInputs {
   return ctx.injectionInputs ?? {};
 }
 
+export const DISK_PRESSURE_WARNING_PROMPT = `<disk_pressure_warning>
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+
+In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
+
+Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
+
+Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+</disk_pressure_warning>`;
+
+function isSafeStorageLimitsEnabled(): boolean {
+  return isAssistantFeatureFlagEnabled("safe-storage-limits", getConfig());
+}
+
+const diskPressureWarningInjector: Injector = {
+  name: "disk-pressure-warning",
+  order: DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+    if (!isSafeStorageLimitsEnabled()) return null;
+    const inputs = readInjectionInputs(ctx);
+    if (!inputs.diskPressureContext?.cleanupModeActive) return null;
+    return {
+      id: "disk-pressure-warning",
+      text: DISK_PRESSURE_WARNING_PROMPT,
+      placement: "prepend-user-tail",
+    };
+  },
+};
+
 /**
  * v2 read-side cutover guard. The `pkb-context` injector silences itself
  * under v2 because the `<knowledge_base>` block surfaces PKB content the v2
@@ -520,6 +552,7 @@ export const defaultInjectorsPlugin: Plugin = {
     },
   },
   injectors: [
+    diskPressureWarningInjector,
     workspaceContextInjector,
     unifiedTurnContextInjector,
     pkbContextInjector,

package/src/plugins/defaults/memory-retrieval.ts

@@ -72,12 +72,6 @@ export interface GraphMemoryPayload {
  * Passed as a second argument to {@link runDefaultMemoryRetrieval} rather
  * than threaded through {@link MemoryArgs} to keep the plugin-facing
  * pipeline surface minimal.
- *
- * The per-turn abort signal lives on {@link MemoryArgs.signal} instead of
- * here so the pipeline runner's `linkAbortSignal` can swap it for an
- * internally-linked signal — that way a plugin timeout actually cancels
- * the underlying `prepareMemory` work instead of letting it run after
- * `Promise.race` has already rejected.
  */
 export interface DefaultMemoryRetrievalDeps {
   /** Live message list for this turn (pre-injection). */
@@ -101,6 +95,11 @@ export interface DefaultMemoryRetrievalDeps {
  * trusted) or a single {@link GraphMemoryPayload} wrapping the graph
  * retriever's full output. The agent loop narrows via
  * {@link DEFAULT_MEMORY_GRAPH_KIND} to consume it.
+ *
+ * Memory retrieval blocks the turn — there is no soft timeout here. Memory
+ * is critical context, and silently dropping it produces a worse outcome
+ * than a slower turn. Cancellation still works via `args.signal`, which is
+ * threaded into `prepareMemory`.
  */
 export async function runDefaultMemoryRetrieval(
   args: MemoryArgs,

package/src/plugins/types.ts

@@ -784,6 +784,8 @@ export interface TurnInjectionInputs {
    * context (unified turn context, etc.). Drives per-injector gating.
    */
   readonly mode?: InjectionMode;
+  /** Disk-pressure cleanup-mode context or null to skip the warning. */
+  readonly diskPressureContext?: DiskPressureInjectionContext | null;
   /** Workspace top-level context text (`<workspace>...`) or null to skip. */
   readonly workspaceTopLevelContext?: string | null;
   /** Pre-built unified-turn-context text (`<turn_context>...`) or null to skip. */
@@ -860,6 +862,11 @@ export interface TurnInjectionInputs {
   readonly isNonInteractive?: boolean;
 }
 
+export interface DiskPressureInjectionContext {
+  /** True when the current turn is allowed to run only for storage cleanup. */
+  readonly cleanupModeActive: boolean;
+}
+
 /**
  * Per-turn execution context threaded through every middleware invocation.
  *

package/src/proactive-artifact/aux-message-injector.ts

@@ -0,0 +1,74 @@
+/**
+ * Auxiliary message injection for proactive artifacts.
+ *
+ * Injects an assistant message into a conversation without going through
+ * the normal agent loop. Defers injection while the conversation is
+ * actively processing to preserve chronological message ordering.
+ */
+
+import { createAssistantMessage } from "../agent/message-types.js";
+import { findConversation } from "../daemon/conversation-store.js";
+import { addMessage } from "../memory/conversation-crud.js";
+import type { BroadcastFn } from "../notifications/adapters/macos.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("aux-message-injector");
+const IDLE_POLL_MS = 200;
+const IDLE_TIMEOUT_MS = 60_000;
+
+async function waitForIdle(conversationId: string): Promise<boolean> {
+  const start = Date.now();
+  while (Date.now() - start < IDLE_TIMEOUT_MS) {
+    const conv = findConversation(conversationId);
+    if (!conv || !conv.processing) return true;
+    await new Promise((resolve) => setTimeout(resolve, IDLE_POLL_MS));
+  }
+  return false;
+}
+
+export async function injectAuxAssistantMessage(params: {
+  conversationId: string;
+  text: string;
+  broadcastMessage: BroadcastFn;
+}): Promise<void> {
+  const conv = findConversation(params.conversationId);
+  if (conv?.processing) {
+    const reachedIdle = await waitForIdle(params.conversationId);
+    if (!reachedIdle) {
+      log.warn(
+        { conversationId: params.conversationId },
+        "Timed out waiting for conversation idle; injecting anyway",
+      );
+    }
+  }
+
+  const msg = await addMessage(
+    params.conversationId,
+    "assistant",
+    JSON.stringify([{ type: "text", text: params.text }]),
+    undefined,
+    { skipIndexing: true },
+  );
+
+  const current = findConversation(params.conversationId);
+  if (current && !current.processing) {
+    current.getMessages().push(createAssistantMessage(params.text));
+
+    params.broadcastMessage({
+      type: "assistant_text_delta",
+      text: params.text,
+      conversationId: params.conversationId,
+    });
+    params.broadcastMessage({
+      type: "message_complete",
+      conversationId: params.conversationId,
+      messageId: msg.id,
+      source: "aux",
+    });
+  }
+
+  params.broadcastMessage({
+    type: "conversation_list_invalidated",
+    reason: "reordered",
+  });
+}