@vellumai/cli 0.10.11-dev.202607242127.a6bf2b2 → 0.10.11-staging.2

package/node_modules/@vellumai/service-contracts/src/trust-rules.ts

@@ -1,116 +0,0 @@
-/**
- * Trust rule types shared between the assistant daemon and the gateway.
- *
- * These are extracted from `assistant/src/permissions/types.ts` and
- * `assistant/src/permissions/trust-store.ts` so that both packages can
- * reference a single canonical definition.
- *
- * Tools are grouped into "families" based on how their permission candidates
- * are constructed and matched:
- *
- * - **Scoped**: tools whose candidates include a filesystem path and obey
- *   directory-boundary scope constraints (`file_read`, `file_write`,
- *   `file_edit`, `host_file_read`, `host_file_write`, `host_file_edit`,
- *   `host_file_transfer`, `bash`, `host_bash`).
- * - **URL**: tools whose candidates include a URL (`web_fetch`,
- *   `network_request`).
- * - **Managed skill**: tools that manage first-party skill packages
- *   (`scaffold_managed_skill`, `delete_managed_skill`).
- * - **Skill load**: the `skill_load` tool, which uses a distinct candidate
- *   namespace (`skill_load:selector` or `skill_load_dynamic:selector`).
- * - **Generic**: everything else (computer-use tools, UI surface tools,
- *   recall, skill_execute, etc.).
- */
-
-// ---------------------------------------------------------------------------
-// Trust decision
-// ---------------------------------------------------------------------------
-
-/** The possible decisions a trust rule can make. */
-export type TrustDecision = "allow" | "deny" | "ask";
-
-// ---------------------------------------------------------------------------
-// Tool family constants
-// ---------------------------------------------------------------------------
-
-/**
- * Tools whose permission candidates are scoped to a filesystem path and obey
- * directory-boundary scope constraints.
- */
-export const SCOPED_TOOLS = [
-  "file_read",
-  "file_write",
-  "file_edit",
-  "host_file_read",
-  "host_file_write",
-  "host_file_edit",
-  "host_file_transfer",
-  "bash",
-  "host_bash",
-] as const;
-
-/**
- * Tools whose permission candidates include a URL.
- */
-export const URL_TOOLS = ["web_fetch", "network_request"] as const;
-
-/**
- * Tools that manage first-party skill packages (scaffold/delete).
- */
-export const MANAGED_SKILL_TOOLS = [
-  "scaffold_managed_skill",
-  "delete_managed_skill",
-] as const;
-
-/**
- * The skill_load tool name. Separated from the array constants because
- * skill_load is a singleton, not a family with multiple members.
- */
-export const SKILL_LOAD_TOOL = "skill_load" as const;
-
-/** Set for O(1) lookups when classifying tool names. */
-const SCOPED_TOOLS_SET: ReadonlySet<string> = new Set(SCOPED_TOOLS);
-const URL_TOOLS_SET: ReadonlySet<string> = new Set(URL_TOOLS);
-const MANAGED_SKILL_TOOLS_SET: ReadonlySet<string> = new Set(
-  MANAGED_SKILL_TOOLS,
-);
-
-// ---------------------------------------------------------------------------
-// Type guards
-// ---------------------------------------------------------------------------
-
-/** Returns true when the rule's tool belongs to the scoped-tool family. */
-export function isScopedRule(rule: { tool: string }): boolean {
-  return SCOPED_TOOLS_SET.has(rule.tool);
-}
-
-/** Returns true when the rule's tool belongs to the URL-tool family. */
-export function isUrlRule(rule: { tool: string }): boolean {
-  return URL_TOOLS_SET.has(rule.tool);
-}
-
-/** Returns true when the rule's tool belongs to the managed-skill-tool family. */
-export function isManagedSkillRule(rule: { tool: string }): boolean {
-  return MANAGED_SKILL_TOOLS_SET.has(rule.tool);
-}
-
-/** Returns true when the rule's tool is the skill_load tool. */
-export function isSkillLoadRule(rule: { tool: string }): boolean {
-  return rule.tool === SKILL_LOAD_TOOL;
-}
-
-// ---------------------------------------------------------------------------
-// Scope helper
-// ---------------------------------------------------------------------------
-
-/**
- * Return the effective scope for any trust rule. Only scoped rules carry a
- * `scope` field; all other rule families return `"everywhere"`.
- */
-export function ruleScope(rule: { tool: string; scope?: string }): string {
-  if (isScopedRule(rule)) {
-    return rule.scope ?? "everywhere";
-  }
-  return "everywhere";
-}
-

package/node_modules/@vellumai/service-contracts/src/twilio-ingress.ts

@@ -1,73 +0,0 @@
-import { normalizePublicBaseUrl } from "./ingress.js";
-
-export const TWILIO_VOICE_WEBHOOK_PATH = "/webhooks/twilio/voice";
-export const TWILIO_STATUS_WEBHOOK_PATH = "/webhooks/twilio/status";
-export const TWILIO_MEDIA_STREAM_WEBHOOK_PATH = "/webhooks/twilio/media-stream";
-
-/**
- * Sentinel placeholder embedded in TwiML by the assistant where the real
- * public base URL should go. The gateway replaces `wss://__VELLUM_PUBLIC_BASE_URL__/…`
- * with the actual public URL (from Velay registration, config, or the
- * `X-Vellum-Ingress-URL` header) before returning TwiML to Twilio.
- *
- * The placeholder uses `https://` so that `buildTwilioMediaStreamUrl` can
- * apply the standard `http→ws` scheme conversion, producing
- * `wss://__VELLUM_PUBLIC_BASE_URL__/…` in the output.
- */
-export const TWILIO_PUBLIC_BASE_URL_PLACEHOLDER =
-  "https://__VELLUM_PUBLIC_BASE_URL__";
-
-/**
- * The WebSocket-scheme form of the placeholder that appears in TwiML after
- * the `http→ws` scheme conversion applied by the URL builders.
- */
-export const TWILIO_PUBLIC_BASE_WSS_PLACEHOLDER =
-  "wss://__VELLUM_PUBLIC_BASE_URL__";
-
-export { normalizePublicBaseUrl } from "./ingress.js";
-
-export type TwilioPhoneNumberWebhookUrls = {
-  statusCallbackUrl: string;
-  voiceUrl: string;
-};
-
-export function resolveTwilioPublicBaseUrl(
-  ingress: { publicBaseUrl?: unknown } | undefined,
-  fallbackPublicBaseUrl?: unknown,
-): string | undefined {
-  const publicBaseUrl = normalizePublicBaseUrl(ingress?.publicBaseUrl);
-  if (publicBaseUrl) return publicBaseUrl;
-
-  return normalizePublicBaseUrl(fallbackPublicBaseUrl);
-}
-
-export function buildTwilioVoiceWebhookUrl(
-  baseUrl: string,
-  callSessionId?: string,
-): string {
-  if (callSessionId) {
-    return `${baseUrl}${TWILIO_VOICE_WEBHOOK_PATH}?callSessionId=${callSessionId}`;
-  }
-  return `${baseUrl}${TWILIO_VOICE_WEBHOOK_PATH}`;
-}
-
-export function buildTwilioStatusWebhookUrl(baseUrl: string): string {
-  return `${baseUrl}${TWILIO_STATUS_WEBHOOK_PATH}`;
-}
-
-export function buildTwilioMediaStreamUrl(baseUrl: string): string {
-  return `${toTwilioWebSocketBaseUrl(baseUrl)}${TWILIO_MEDIA_STREAM_WEBHOOK_PATH}`;
-}
-
-export function buildTwilioPhoneNumberWebhookUrls(
-  baseUrl: string,
-): TwilioPhoneNumberWebhookUrls {
-  return {
-    statusCallbackUrl: buildTwilioStatusWebhookUrl(baseUrl),
-    voiceUrl: buildTwilioVoiceWebhookUrl(baseUrl),
-  };
-}
-
-function toTwilioWebSocketBaseUrl(baseUrl: string): string {
-  return baseUrl.replace(/^http(s?)/, "ws$1");
-}

package/node_modules/@vellumai/service-contracts/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["bun"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/src/__tests__/ingress-config.test.ts

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// Real assistant-config reads the lockfile from VELLUM_LOCKFILE_DIR.
-const testDir = mkdtempSync(join(tmpdir(), "ingress-config-test-"));
-process.env.VELLUM_LOCKFILE_DIR = testDir;
-
-import { clearIngressUrl, saveIngressUrl } from "../lib/ingress-config.js";
-
-function writeLockfile(entry: Record<string, unknown>): void {
-  writeFileSync(
-    join(testDir, ".vellum.lock.json"),
-    JSON.stringify({ assistants: [entry], activeAssistant: "ingress-test" }),
-  );
-}
-
-function readLockfileEntry(): Record<string, unknown> {
-  const data = JSON.parse(
-    readFileSync(join(testDir, ".vellum.lock.json"), "utf-8"),
-  ) as { assistants: Record<string, unknown>[] };
-  return data.assistants[0];
-}
-
-const tempDirs: string[] = [];
-
-function makeWorkspace(): string {
-  const dir = mkdtempSync(join(tmpdir(), "ingress-config-ws-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("ingress lockfile mirroring", () => {
-  test("saveIngressUrl stamps the entry's ingressUrl when given an assistantId", () => {
-    writeLockfile({
-      assistantId: "ingress-test",
-      runtimeUrl: "http://192.168.1.50:7830",
-      cloud: "local",
-    });
-    const ws = makeWorkspace();
-
-    saveIngressUrl(ws, "https://tunnel.example.ts.net", "ingress-test");
-
-    // Both contracts are written: workspace config (gateway-facing)...
-    const config = JSON.parse(readFileSync(join(ws, "config.json"), "utf-8"));
-    expect(config.ingress.publicBaseUrl).toBe("https://tunnel.example.ts.net");
-    // ...and the lockfile entry (CLI-facing).
-    expect(readLockfileEntry().ingressUrl).toBe(
-      "https://tunnel.example.ts.net",
-    );
-  });
-
-  test("clearIngressUrl removes the entry's ingressUrl", () => {
-    writeLockfile({
-      assistantId: "ingress-test",
-      runtimeUrl: "http://192.168.1.50:7830",
-      cloud: "local",
-      ingressUrl: "https://tunnel.example.ts.net",
-    });
-    const ws = makeWorkspace();
-    saveIngressUrl(ws, "https://tunnel.example.ts.net");
-
-    clearIngressUrl(ws, "ingress-test");
-
-    const config = JSON.parse(readFileSync(join(ws, "config.json"), "utf-8"));
-    expect(config.ingress.publicBaseUrl).toBeUndefined();
-    expect(readLockfileEntry().ingressUrl).toBeUndefined();
-  });
-
-  test("without an assistantId the lockfile is untouched", () => {
-    writeLockfile({
-      assistantId: "ingress-test",
-      runtimeUrl: "http://192.168.1.50:7830",
-      cloud: "local",
-    });
-    const ws = makeWorkspace();
-
-    saveIngressUrl(ws, "https://tunnel.example.ts.net");
-
-    expect(readLockfileEntry().ingressUrl).toBeUndefined();
-  });
-
-  test("an unknown assistantId is a no-op, not an error", () => {
-    writeLockfile({
-      assistantId: "ingress-test",
-      runtimeUrl: "http://192.168.1.50:7830",
-      cloud: "local",
-    });
-    const ws = makeWorkspace();
-
-    expect(() => {
-      saveIngressUrl(ws, "https://tunnel.example.ts.net", "no-such-assistant");
-    }).not.toThrow();
-    expect(readLockfileEntry().ingressUrl).toBeUndefined();
-  });
-});

package/src/__tests__/local-hatch-lock.test.ts

@@ -1,163 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-import {
-  resolveLocalHatchLockPath,
-  withLocalHatchLock,
-} from "../lib/local-hatch-lock.js";
-
-const tempDirs: string[] = [];
-
-afterEach(() => {
-  for (const tempDir of tempDirs.splice(0)) {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-});
-
-function makeLockPath(): string {
-  const tempDir = mkdtempSync(join(tmpdir(), "vellum-hatch-lock-test-"));
-  tempDirs.push(tempDir);
-  return join(tempDir, "local-hatch.lock");
-}
-
-describe("withLocalHatchLock", () => {
-  test("uses the same machine lock when callers have different temp directories", () => {
-    const originalTmpDir = process.env.TMPDIR;
-    const firstTmpDir = mkdtempSync(join(tmpdir(), "vellum-tmp-a-"));
-    const secondTmpDir = mkdtempSync(join(tmpdir(), "vellum-tmp-b-"));
-    tempDirs.push(firstTmpDir, secondTmpDir);
-
-    try {
-      process.env.TMPDIR = firstTmpDir;
-      const firstPath = resolveLocalHatchLockPath();
-      process.env.TMPDIR = secondTmpDir;
-      const secondPath = resolveLocalHatchLockPath();
-
-      expect(secondPath).toBe(firstPath);
-      expect(firstPath.startsWith(firstTmpDir)).toBe(false);
-      expect(firstPath.startsWith(secondTmpDir)).toBe(false);
-    } finally {
-      if (originalTmpDir === undefined) {
-        delete process.env.TMPDIR;
-      } else {
-        process.env.TMPDIR = originalTmpDir;
-      }
-    }
-  });
-
-  test("serializes startup work that shares the machine-wide lock", async () => {
-    const lockPath = makeLockPath();
-    let releaseFirst!: () => void;
-    let firstStarted!: () => void;
-    const firstStartedPromise = new Promise<void>((resolve) => {
-      firstStarted = resolve;
-    });
-    const firstReleasePromise = new Promise<void>((resolve) => {
-      releaseFirst = resolve;
-    });
-    let secondEntered = false;
-
-    const first = withLocalHatchLock(
-      async () => {
-        firstStarted();
-        await firstReleasePromise;
-      },
-      { lockPath, timeoutMs: 1_000, retryMs: 5 },
-    );
-    await firstStartedPromise;
-
-    const second = withLocalHatchLock(
-      async () => {
-        secondEntered = true;
-      },
-      { lockPath, timeoutMs: 1_000, retryMs: 5 },
-    );
-    await Bun.sleep(20);
-    expect(secondEntered).toBe(false);
-
-    releaseFirst();
-    await Promise.all([first, second]);
-
-    expect(secondEntered).toBe(true);
-    expect(existsSync(lockPath)).toBe(false);
-  });
-
-  test("recovers a lock owned by a dead process", async () => {
-    const lockPath = makeLockPath();
-    writeFileSync(
-      lockPath,
-      JSON.stringify({ pid: 2_147_483_647, token: "stale-owner" }) + "\n",
-    );
-
-    const result = await withLocalHatchLock(async () => "started", {
-      lockPath,
-      timeoutMs: 1_000,
-      retryMs: 5,
-    });
-
-    expect(result).toBe("started");
-    expect(existsSync(lockPath)).toBe(false);
-  });
-
-  test("recovers an expired lock even when its PID has been reused", async () => {
-    const lockPath = makeLockPath();
-    writeFileSync(
-      lockPath,
-      JSON.stringify({
-        pid: process.pid,
-        processStartedAt: "not-the-current-process",
-        token: "reused-pid-owner",
-      }) + "\n",
-    );
-    const expired = new Date(Date.now() - 300_000);
-    utimesSync(lockPath, expired, expired);
-
-    const result = await withLocalHatchLock(async () => "started", {
-      lockPath,
-      liveOwnerRecoveryGraceMs: 0,
-      timeoutMs: 1_000,
-      retryMs: 5,
-    });
-
-    expect(result).toBe("started");
-    expect(existsSync(lockPath)).toBe(false);
-  });
-
-  test("recovers a fresh lock when its PID has been reused", async () => {
-    const lockPath = makeLockPath();
-    writeFileSync(
-      lockPath,
-      JSON.stringify({
-        pid: process.pid,
-        processStartedAt: "not-the-current-process",
-        token: "fresh-reused-pid-owner",
-      }) + "\n",
-    );
-
-    const result = await withLocalHatchLock(async () => "started", {
-      lockPath,
-      timeoutMs: 1_000,
-      retryMs: 5,
-    });
-
-    expect(result).toBe("started");
-    expect(existsSync(lockPath)).toBe(false);
-  });
-
-  test("releases the lock when startup fails", async () => {
-    const lockPath = makeLockPath();
-
-    await expect(
-      withLocalHatchLock(
-        async () => {
-          throw new Error("startup failed");
-        },
-        { lockPath },
-      ),
-    ).rejects.toThrow("startup failed");
-
-    expect(existsSync(lockPath)).toBe(false);
-  });
-});