@vellumai/cli 0.4.35 → 0.4.37

package/src/commands/contacts.ts

@@ -1,241 +0,0 @@
-import { loadLatestAssistant } from "../lib/assistant-config";
-import { GATEWAY_PORT } from "../lib/constants.js";
-
-// ---------------------------------------------------------------------------
-// Gateway API client
-// ---------------------------------------------------------------------------
-
-function getGatewayUrl(): string {
-  const entry = loadLatestAssistant();
-  if (entry?.runtimeUrl) return entry.runtimeUrl;
-  return `http://localhost:${GATEWAY_PORT}`;
-}
-
-function getBearerToken(): string | undefined {
-  const entry = loadLatestAssistant();
-  return entry?.bearerToken;
-}
-
-function buildHeaders(): Record<string, string> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-  const token = getBearerToken();
-  if (token) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
-  return headers;
-}
-
-async function apiGet(path: string): Promise<unknown> {
-  const url = `${getGatewayUrl()}/v1/${path}`;
-  const response = await fetch(url, { headers: buildHeaders() });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`API error ${response.status}: ${text}`);
-  }
-  return response.json();
-}
-
-async function apiPost(path: string, body: unknown): Promise<unknown> {
-  const url = `${getGatewayUrl()}/v1/${path}`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: buildHeaders(),
-    body: JSON.stringify(body),
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`API error ${response.status}: ${text}`);
-  }
-  return response.json();
-}
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface ContactChannel {
-  type: string;
-  address: string;
-  isPrimary: boolean;
-}
-
-interface Contact {
-  id: string;
-  displayName: string;
-  notes: string | null;
-  lastInteraction: number | null;
-  interactionCount: number;
-  channels: ContactChannel[];
-}
-
-// ---------------------------------------------------------------------------
-// Output helpers
-// ---------------------------------------------------------------------------
-
-function hasFlag(args: string[], flag: string): boolean {
-  return args.includes(flag);
-}
-
-function getFlagValue(args: string[], flag: string): string | undefined {
-  const idx = args.indexOf(flag);
-  if (idx === -1 || idx + 1 >= args.length) return undefined;
-  return args[idx + 1];
-}
-
-function formatContact(c: Contact): string {
-  const lines = [
-    `  ID:           ${c.id}`,
-    `  Name:         ${c.displayName}`,
-    `  Notes:        ${c.notes ?? "(none)"}`,
-    `  Interactions: ${c.interactionCount}`,
-  ];
-  if (c.lastInteraction) {
-    lines.push(`  Last seen:    ${new Date(c.lastInteraction).toISOString()}`);
-  }
-  if (c.channels.length > 0) {
-    lines.push("  Channels:");
-    for (const ch of c.channels) {
-      const primary = ch.isPrimary ? " (primary)" : "";
-      lines.push(`    - ${ch.type}: ${ch.address}${primary}`);
-    }
-  }
-  return lines.join("\n");
-}
-
-// ---------------------------------------------------------------------------
-// Usage
-// ---------------------------------------------------------------------------
-
-function printUsage(): void {
-  console.log("Usage: vellum contacts <subcommand> [options]");
-  console.log("");
-  console.log("Subcommands:");
-  console.log("  list [--limit N] [--role ROLE]  List all contacts");
-  console.log("  get <id>                       Get a contact by ID");
-  console.log("  merge <keepId> <mergeId>       Merge two contacts");
-  console.log("");
-  console.log("Options:");
-  console.log("  --json    Machine-readable JSON output");
-}
-
-// ---------------------------------------------------------------------------
-// Command entry point
-// ---------------------------------------------------------------------------
-
-export async function contacts(): Promise<void> {
-  const args = process.argv.slice(3);
-  const subcommand = args[0];
-  const json = hasFlag(args, "--json");
-
-  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
-    printUsage();
-    return;
-  }
-
-  switch (subcommand) {
-    case "list": {
-      const limit = getFlagValue(args, "--limit") ?? "50";
-      const role = getFlagValue(args, "--role");
-      const query = `contacts?limit=${limit}${role ? `&role=${encodeURIComponent(role)}` : ""}`;
-      const data = (await apiGet(query)) as {
-        ok: boolean;
-        contacts: Contact[];
-      };
-
-      if (json) {
-        console.log(JSON.stringify(data));
-        return;
-      }
-
-      if (data.contacts.length === 0) {
-        console.log("No contacts found.");
-        return;
-      }
-
-      console.log(`Contacts (${data.contacts.length}):\n`);
-      for (const c of data.contacts) {
-        console.log(formatContact(c) + "\n");
-      }
-      break;
-    }
-
-    case "get": {
-      const id = args[1];
-      if (!id || id.startsWith("--")) {
-        console.error("Usage: vellum contacts get <id>");
-        process.exit(1);
-      }
-
-      try {
-        const data = (await apiGet(`contacts/${encodeURIComponent(id)}`)) as {
-          ok: boolean;
-          contact: Contact;
-        };
-
-        if (json) {
-          console.log(JSON.stringify(data));
-        } else {
-          console.log(formatContact(data.contact));
-        }
-      } catch {
-        if (json) {
-          console.log(
-            JSON.stringify({
-              ok: false,
-              error: `Contact "${id}" not found`,
-            }),
-          );
-        } else {
-          console.error(`Contact "${id}" not found.`);
-        }
-        process.exitCode = 1;
-      }
-      break;
-    }
-
-    case "merge": {
-      const keepId = args[1];
-      const mergeId = args[2];
-      if (
-        !keepId ||
-        !mergeId ||
-        keepId.startsWith("--") ||
-        mergeId.startsWith("--")
-      ) {
-        console.error("Usage: vellum contacts merge <keepId> <mergeId>");
-        process.exit(1);
-      }
-
-      try {
-        const data = (await apiPost("contacts/merge", {
-          keepId,
-          mergeId,
-        })) as { ok: boolean; contact: Contact };
-
-        if (json) {
-          console.log(JSON.stringify(data));
-        } else {
-          console.log(`Merged contact "${mergeId}" into "${keepId}".\n`);
-          console.log(formatContact(data.contact));
-        }
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (json) {
-          console.log(JSON.stringify({ ok: false, error: msg }));
-        } else {
-          console.error(`Error: ${msg}`);
-        }
-        process.exitCode = 1;
-      }
-      break;
-    }
-
-    default: {
-      console.error(`Unknown contacts subcommand: ${subcommand}`);
-      printUsage();
-      process.exit(1);
-    }
-  }
-}

package/src/commands/email.ts

@@ -1,108 +0,0 @@
-/**
- * CLI command: `vellum email`
- *
- * Supports:
- *   - `vellum email status`            — show current email configuration
- *   - `vellum email create <username>`  — provision a new email inbox
- */
-
-import { VellumEmailClient } from "../email/vellum.js";
-import { loadLatestAssistant } from "../lib/assistant-config.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function output(data: unknown): void {
-  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
-}
-
-function exitError(message: string): void {
-  output({ ok: false, error: message });
-  process.exitCode = 1;
-}
-
-// ---------------------------------------------------------------------------
-// Usage
-// ---------------------------------------------------------------------------
-
-function printUsage(): void {
-  console.log(`Usage: vellum email <subcommand> [options]
-
-Subcommands:
-  status                Show email status (address, inboxes, callback URL)
-  create <username>     Create a new email inbox for the given username
-
-Options:
-  --assistant <id>      Assistant ID (defaults to the most recently hatched)
-  --help, -h            Show this help message
-`);
-}
-
-// ---------------------------------------------------------------------------
-// Entry point
-// ---------------------------------------------------------------------------
-
-export async function email(): Promise<void> {
-  const args = process.argv.slice(3); // everything after "email"
-
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    printUsage();
-    return;
-  }
-
-  // Resolve assistant ID from --assistant flag or latest assistant
-  const assistantFlagIdx = args.indexOf("--assistant");
-  let assistantId: string | undefined;
-  if (assistantFlagIdx !== -1) {
-    const value = args[assistantFlagIdx + 1];
-    if (!value || value.startsWith("-")) {
-      exitError("--assistant requires a value.");
-      return;
-    }
-    assistantId = value;
-    args.splice(assistantFlagIdx, 2);
-  }
-  if (!assistantId) {
-    assistantId = loadLatestAssistant()?.assistantId;
-  }
-  if (!assistantId) {
-    exitError(
-      "No assistant ID available. Pass --assistant <id> or hatch an assistant first.",
-    );
-    return;
-  }
-
-  const subcommand = args[0];
-
-  switch (subcommand) {
-    case "status": {
-      try {
-        const client = new VellumEmailClient(assistantId);
-        const addresses = await client.status();
-        output({ ok: true, addresses });
-      } catch (err) {
-        exitError(err instanceof Error ? err.message : String(err));
-      }
-      break;
-    }
-    case "create": {
-      const username = args[1];
-      if (!username) {
-        exitError("Usage: vellum email create <username>");
-        return;
-      }
-      try {
-        const client = new VellumEmailClient(assistantId);
-        const inbox = await client.createInbox(username);
-        output({ ok: true, inbox });
-      } catch (err) {
-        exitError(err instanceof Error ? err.message : String(err));
-      }
-      break;
-    }
-    default:
-      exitError(`Unknown email subcommand: ${subcommand}`);
-      printUsage();
-  }
-}

package/src/email/vellum.ts

@@ -1,97 +0,0 @@
-/**
- * Vellum email API client — calls the Vellum platform email endpoints.
- */
-
-// The domain for the Vellum email API is still being finalized and may change.
-const DEFAULT_VELLUM_API_URL = "https://api.vellum.ai";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface AssistantEmailAddress {
-  id: string;
-  address: string;
-  created_at: string;
-}
-
-// ---------------------------------------------------------------------------
-// HTTP helper
-// ---------------------------------------------------------------------------
-
-async function vellumFetch(
-  apiKey: string,
-  baseUrl: string,
-  path: string,
-  opts: { method?: string; body?: unknown } = {},
-): Promise<unknown> {
-  const url = `${baseUrl}${path}`;
-  const response = await fetch(url, {
-    method: opts.method ?? "GET",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-    },
-    body: opts.body ? JSON.stringify(opts.body) : undefined,
-  });
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(
-      `Vellum email API error: ${response.status} ${response.statusText}${text ? ` — ${text}` : ""}`,
-    );
-  }
-
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    return response.json();
-  }
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Client
-// ---------------------------------------------------------------------------
-
-export class VellumEmailClient {
-  private apiKey: string;
-  private baseUrl: string;
-  private assistantId: string;
-
-  constructor(assistantId: string, apiKey?: string, baseUrl?: string) {
-    this.assistantId = assistantId;
-    const resolvedKey = apiKey ?? process.env.VELLUM_API_KEY;
-    if (!resolvedKey) {
-      throw new Error(
-        "No Vellum API key configured. Set the VELLUM_API_KEY environment variable.",
-      );
-    }
-    this.apiKey = resolvedKey;
-    this.baseUrl =
-      baseUrl ?? process.env.VELLUM_API_URL ?? DEFAULT_VELLUM_API_URL;
-  }
-
-  /** List existing email addresses and check connectivity. */
-  async status(): Promise<AssistantEmailAddress[]> {
-    const result = await vellumFetch(
-      this.apiKey,
-      this.baseUrl,
-      `/v1/assistants/${this.assistantId}/email-addresses/`,
-    );
-    return result as AssistantEmailAddress[];
-  }
-
-  /** Provision a new email address for the given username. */
-  async createInbox(username: string): Promise<AssistantEmailAddress> {
-    const result = await vellumFetch(
-      this.apiKey,
-      this.baseUrl,
-      `/v1/assistants/${this.assistantId}/email-addresses/`,
-      {
-        method: "POST",
-        body: { username },
-      },
-    );
-    return result as AssistantEmailAddress;
-  }
-}

package/src/lib/config.ts

@@ -1,73 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-function getRootDir(): string {
-  return join(process.env.BASE_DATA_DIR?.trim() || homedir(), ".vellum");
-}
-
-export function getConfigPath(): string {
-  return join(getRootDir(), "workspace", "config.json");
-}
-
-export function getAllowlistPath(): string {
-  return join(getRootDir(), "protected", "secret-allowlist.json");
-}
-
-export function loadRawConfig(): Record<string, unknown> {
-  const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
-    return {};
-  }
-  const raw = readFileSync(configPath, "utf-8");
-  return JSON.parse(raw) as Record<string, unknown>;
-}
-
-export function saveRawConfig(config: Record<string, unknown>): void {
-  const configPath = getConfigPath();
-  const dir = dirname(configPath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-}
-
-export function getNestedValue(
-  obj: Record<string, unknown>,
-  path: string,
-): unknown {
-  const keys = path.split(".");
-  let current: unknown = obj;
-  for (const key of keys) {
-    if (
-      current === null ||
-      current === undefined ||
-      typeof current !== "object"
-    ) {
-      return undefined;
-    }
-    current = (current as Record<string, unknown>)[key];
-  }
-  return current;
-}
-
-export function setNestedValue(
-  obj: Record<string, unknown>,
-  path: string,
-  value: unknown,
-): void {
-  const keys = path.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (
-      current[key] === undefined ||
-      current[key] === null ||
-      typeof current[key] !== "object"
-    ) {
-      current[key] = {};
-    }
-    current = current[key] as Record<string, unknown>;
-  }
-  current[keys[keys.length - 1]] = value;
-}