@vellumai/assistant 0.4.48 → 0.4.49

package/src/util/platform.ts

@@ -8,13 +8,7 @@ import {
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import {
-  getBaseDataDir,
-  getDaemonIosPairing,
-  getDaemonTcpEnabled,
-  getDaemonTcpHost,
-  getDaemonTcpPort,
-} from "../config/env-registry.js";
+import { getBaseDataDir } from "../config/env-registry.js";
 
 export function isMacOS(): boolean {
   return process.platform === "darwin";
@@ -245,39 +239,30 @@ export function getInterfacesDir(): string {
 
 /**
  * Returns the TCP port the daemon should listen on for iOS clients.
- * Reads VELLUM_DAEMON_TCP_PORT env var; defaults to 8765.
+ * Hardcoded default: 8765.
  */
 export function getTCPPort(): number {
-  return getDaemonTcpPort();
+  return 8765;
 }
 
 /**
  * Returns whether the daemon TCP listener should be enabled.
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_TCP_ENABLED env var ('true'/'1' → on, 'false'/'0' → off)
- *   2. Presence of the flag file ~/.vellum/tcp-enabled (exists → on)
- *   3. Default: false
+ * Checks for the presence of the flag file ~/.vellum/tcp-enabled.
+ * Default: false.
  *
  * The flag-file check makes it easy to enable TCP in dev without restarting
  * the shell: `touch ~/.vellum/tcp-enabled && kill -USR1 <daemon-pid>`.
- * The macOS CLI (AssistantCli) also sets the env var for bundled-binary deployments.
  */
 export function isTCPEnabled(): boolean {
-  const envValue = getDaemonTcpEnabled();
-  if (envValue !== undefined) return envValue;
   return existsSync(join(getRootDir(), "tcp-enabled"));
 }
 
 /**
  * Returns the hostname/address for the TCP listener.
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_TCP_HOST env var (explicit override)
- *   2. If iOS pairing is enabled: '0.0.0.0' (LAN-accessible)
- *   3. Default: '127.0.0.1' (localhost only)
+ * If iOS pairing is enabled (flag file): '0.0.0.0' (LAN-accessible).
+ * Default: '127.0.0.1' (localhost only).
  */
 export function getTCPHost(): string {
-  const override = getDaemonTcpHost();
-  if (override) return override;
   if (isIOSPairingEnabled()) return "0.0.0.0";
   return "127.0.0.1";
 }
@@ -288,17 +273,13 @@ export function getTCPHost(): string {
  * instead of 127.0.0.1 (localhost only), making the daemon reachable
  * from iOS devices on the same local network.
  *
- * Resolution order (first match wins):
- *   1. VELLUM_DAEMON_IOS_PAIRING env var ('true'/'1' → on, 'false'/'0' → off)
- *   2. Presence of the flag file ~/.vellum/ios-pairing-enabled (exists → on)
- *   3. Default: false
+ * Checks for the presence of the flag file ~/.vellum/ios-pairing-enabled.
+ * Default: false.
  *
  * This is separate from isTCPEnabled() — TCP can be enabled for localhost-only
  * access without exposing the daemon to the LAN.
  */
 export function isIOSPairingEnabled(): boolean {
-  const envValue = getDaemonIosPairing();
-  if (envValue !== undefined) return envValue;
   return existsSync(join(getRootDir(), "ios-pairing-enabled"));
 }
 

package/src/watcher/providers/google-calendar.ts

@@ -13,7 +13,8 @@ import {
 import type { CalendarEvent } from "../../config/bundled-skills/google-calendar/types.js";
 import type { OAuthConnection } from "../../oauth/connection.js";
 import { resolveOAuthConnection } from "../../oauth/connection-resolver.js";
-import { GOOGLE_CALENDAR_BASE_URL } from "../../oauth/provider-base-urls.js";
+
+const GOOGLE_CALENDAR_BASE_URL = "https://www.googleapis.com/calendar/v3";
 import { getLogger } from "../../util/logger.js";
 import type {
   FetchResult,

package/src/__tests__/computer-use-session-compaction.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { Message } from "../providers/types.js";
-
-/**
- * Helper to create a user message with a tool_result block containing
- * an AX tree wrapped in markers.
- */
-function toolResultMsg(content: string): Message {
-  return {
-    role: "user",
-    content: [
-      {
-        type: "tool_result",
-        tool_use_id: "test-id",
-        content,
-      },
-    ],
-  };
-}
-
-describe("ComputerUseSession.escapeAxTreeContent", () => {
-  test("escapes a literal closing tag in the content", () => {
-    const input = "some text </ax-tree> more text";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("some text &lt;/ax-tree&gt; more text");
-  });
-
-  test("escapes multiple occurrences", () => {
-    const input = "</ax-tree> hello </ax-tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; hello &lt;/ax-tree&gt;");
-  });
-
-  test("is case-insensitive", () => {
-    const input = "</AX-TREE> and </Ax-Tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; and &lt;/ax-tree&gt;");
-  });
-
-  test("leaves content without closing tags unchanged", () => {
-    const input = 'Window "My App" [1]\n  Button "OK" [2]';
-    expect(ComputerUseSession.escapeAxTreeContent(input)).toBe(input);
-  });
-});
-
-describe("ComputerUseSession.compactHistory", () => {
-  test("[experimental] strips old AX trees and keeps the most recent ones", () => {
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "thinking..." }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [1]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [2]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // First AX tree (index 1) should be stripped
-    const firstToolResult = compacted[1].content[0];
-    expect(firstToolResult.type).toBe("tool_result");
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-    }
-
-    // Last two AX trees should be preserved
-    const secondToolResult = compacted[3].content[0];
-    if (secondToolResult.type === "tool_result") {
-      expect(secondToolResult.content).toContain("<ax-tree>");
-    }
-    const thirdToolResult = compacted[5].content[0];
-    if (thirdToolResult.type === "tool_result") {
-      expect(thirdToolResult.content).toContain("<ax-tree>");
-    }
-  });
-
-  test("[experimental] handles AX tree content containing literal </ax-tree> (escaped)", () => {
-    // Simulate content where the AX tree text includes an escaped closing tag,
-    // e.g. user is viewing XML source code with "</ax-tree>" in it.
-    const escapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: &lt;/ax-tree&gt; some xml\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // The first message with escaped content should be fully stripped
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-    }
-  });
-
-  test("regex fails on unescaped </ax-tree> inside content (demonstrating the bug)", () => {
-    // This test demonstrates what happens WITHOUT escaping: the regex
-    // only partially removes the AX tree block.
-    const unescapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: </ax-tree> some xml leftover\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // Without escaping, the first tool result has leftover content after
-    // the regex only matched up to the FIRST </ax-tree>.
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      // The non-greedy regex stops at the first </ax-tree>, leaving
-      // " some xml leftover\n</ax-tree>" behind.
-      expect(firstToolResult.content).toContain("some xml leftover");
-    }
-  });
-});

package/src/__tests__/computer-use-session-lifecycle.test.ts

@@ -1,322 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-// Mock config before importing modules that depend on it.
-// The permissions mode must be 'workspace' so computer-use tools
-// go through normal workspace trust evaluation instead of prompting.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "mock-provider",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: { enabled: false },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.3,
-      compactThreshold: 0.8,
-      summaryBudgetRatio: 0.05,
-    },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type {
-  CuObservation,
-  ServerMessage,
-} from "../daemon/message-protocol.js";
-import type { Provider, ProviderResponse } from "../providers/types.js";
-
-function createProvider(responses: ProviderResponse[]): {
-  provider: Provider;
-  getCalls: () => number;
-} {
-  let calls = 0;
-  const provider: Provider = {
-    name: "mock",
-    async sendMessage() {
-      const response = responses[calls] ?? responses[responses.length - 1];
-      calls++;
-      return response;
-    },
-  };
-  return { provider, getCalls: () => calls };
-}
-
-describe("ComputerUseSession lifecycle", () => {
-  test("stops provider loop immediately after terminal computer_use_done tool", async () => {
-    const { provider, getCalls } = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-1",
-            name: "computer_use_done",
-            input: { summary: "Task finished" },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-      {
-        content: [{ type: "text", text: "This should never be requested" }],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    const sentMessages: ServerMessage[] = [];
-    let terminalCalls = 0;
-
-    const session = new ComputerUseSession(
-      "cu-test-1",
-      "test task",
-      1440,
-      900,
-      provider,
-      (msg) => {
-        sentMessages.push(msg);
-      },
-      "computer_use",
-      () => {
-        terminalCalls++;
-      },
-    );
-
-    const observation: CuObservation = {
-      type: "cu_observation",
-      sessionId: "cu-test-1",
-      axTree: 'Window "Test" [1]',
-    };
-
-    await session.handleObservation(observation);
-
-    // If computer_use_done does not abort the loop, we'd see an extra provider call.
-    expect(getCalls()).toBe(1);
-    expect(session.getState()).toBe("complete");
-    expect(terminalCalls).toBe(1);
-
-    const completes = sentMessages.filter(
-      (msg): msg is Extract<ServerMessage, { type: "cu_complete" }> =>
-        msg.type === "cu_complete",
-    );
-    expect(completes).toHaveLength(1);
-    expect(completes[0].summary).toBe("Task finished");
-  });
-
-  test("notifies terminal callback only once on repeated abort calls", () => {
-    const { provider } = createProvider([
-      {
-        content: [{ type: "text", text: "unused" }],
-        model: "mock-model",
-        usage: { inputTokens: 1, outputTokens: 1 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    let terminalCalls = 0;
-    const session = new ComputerUseSession(
-      "cu-test-2",
-      "test task",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      () => {
-        terminalCalls++;
-      },
-    );
-
-    session.abort();
-    session.abort();
-
-    expect(terminalCalls).toBe(1);
-    expect(session.getState()).toBe("error");
-  });
-
-  test("CU session passes exactly 10 computer_use_* tools to the agent loop", async () => {
-    let capturedTools: string[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(_msgs, tools) {
-        capturedTools = (tools ?? []).map((t) => t.name);
-        return {
-          content: [
-            {
-              type: "tool_use",
-              id: "tu-capture",
-              name: "computer_use_done",
-              input: { summary: "Done" },
-            },
-          ],
-          model: "mock-model",
-          usage: { inputTokens: 10, outputTokens: 5 },
-          stopReason: "tool_use",
-        };
-      },
-    };
-
-    const session = new ComputerUseSession(
-      "cu-tool-capture",
-      "capture tools",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-tool-capture",
-      axTree: 'Window "Test" [1]',
-    });
-
-    const cuTools = capturedTools.filter((n) => n.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(10);
-
-    // Assert exact set of expected CU tool names
-    const expectedCuTools = [
-      "computer_use_click",
-      "computer_use_type_text",
-      "computer_use_key",
-      "computer_use_scroll",
-      "computer_use_drag",
-      "computer_use_wait",
-      "computer_use_open_app",
-      "computer_use_run_applescript",
-      "computer_use_done",
-      "computer_use_respond",
-    ];
-    for (const name of expectedCuTools) {
-      expect(cuTools).toContain(name);
-    }
-  });
-
-  test("computer_use_respond is a terminal tool that completes the session", async () => {
-    const { provider } = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-respond",
-            name: "computer_use_respond",
-            input: {
-              answer: "The meeting is at 3pm",
-              reasoning: "Found in calendar",
-            },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-    ]);
-
-    const sentMessages: ServerMessage[] = [];
-    const session = new ComputerUseSession(
-      "cu-respond-test",
-      "check my schedule",
-      1440,
-      900,
-      provider,
-      (msg) => {
-        sentMessages.push(msg);
-      },
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-respond-test",
-      axTree: 'Window "Calendar" [1]',
-    });
-
-    expect(session.getState()).toBe("complete");
-    const completes = sentMessages.filter(
-      (msg): msg is Extract<ServerMessage, { type: "cu_complete" }> =>
-        msg.type === "cu_complete",
-    );
-    expect(completes).toHaveLength(1);
-    expect(completes[0].summary).toBe("The meeting is at 3pm");
-    expect(completes[0].isResponse).toBe(true);
-  });
-
-  test("default construction preactivates computer-use skill and provides 10 CU tools", async () => {
-    let capturedTools: string[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(_msgs, tools) {
-        capturedTools = (tools ?? []).map((t) => t.name);
-        return {
-          content: [
-            {
-              type: "tool_use",
-              id: "tu-default",
-              name: "computer_use_done",
-              input: { summary: "Done" },
-            },
-          ],
-          model: "mock-model",
-          usage: { inputTokens: 10, outputTokens: 5 },
-          stopReason: "tool_use",
-        };
-      },
-    };
-
-    // No preactivatedSkillIds passed — defaults to ['computer-use'] via skill projection
-    const session = new ComputerUseSession(
-      "cu-default-projection",
-      "test default projection",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      undefined,
-    );
-
-    await session.handleObservation({
-      type: "cu_observation",
-      sessionId: "cu-default-projection",
-      axTree: 'Window "Test" [1]',
-    });
-
-    const cuTools = capturedTools.filter((n) => n.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(10);
-  });
-
-  test("constructor accepts preactivatedSkillIds parameter", () => {
-    const { provider } = createProvider([
-      {
-        content: [{ type: "text", text: "unused" }],
-        model: "mock-model",
-        usage: { inputTokens: 1, outputTokens: 1 },
-        stopReason: "end_turn",
-      },
-    ]);
-
-    // Should not throw
-    const session = new ComputerUseSession(
-      "cu-preactivated",
-      "test preactivated",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-      undefined,
-      ["computer-use"],
-    );
-
-    expect(session).toBeDefined();
-  });
-});