@vellumai/assistant 0.6.3 → 0.6.4

package/src/cli/commands/conversations.ts

@@ -10,6 +10,7 @@ import { shouldAutoStartDaemon } from "../../daemon/connection-policy.js";
 import { healthCheckHost, isHttpHealthy } from "../../daemon/daemon-control.js";
 import { ensureDaemonRunning } from "../../daemon/lifecycle.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
+import { cliIpcCall } from "../../ipc/cli-client.js";
 import {
   clearAll as clearAllConversations,
   countConversationsByScheduleJobId,
@@ -388,4 +389,80 @@ Examples:
           `cancelled ${result.cancelledJobCount} jobs.`,
       );
     });
+
+  conversations
+    .command("wake <conversationId>")
+    .description(
+      "Wake the agent on an existing conversation with an internal hint",
+    )
+    .requiredOption(
+      "--hint <text>",
+      "Hint message visible to the LLM (not persisted to transcript)",
+    )
+    .option(
+      "--source <label>",
+      "Source label for logging (e.g. github-notification)",
+      "cli",
+    )
+    .option("--json", "Output result as JSON")
+    .addHelpText(
+      "after",
+      `
+Arguments:
+  conversationId   Conversation ID to wake.
+
+Wake the assistant's agent loop on an existing conversation without a user
+message. The hint is injected as a non-persisted internal message visible
+only to the LLM — it never appears in the transcript or SSE feed. If the
+agent produces output (text or tool calls), it is persisted and emitted to
+connected clients. Otherwise the wake is a silent no-op.
+
+Requires the assistant to be running. Communicates via IPC socket.
+
+Examples:
+  $ assistant conversations wake abc123 --hint "PR #25933 received a review requesting changes"
+  $ assistant conversations wake abc123 --hint "CI failed on commit abc" --source github-ci
+  $ assistant conversations wake abc123 --hint "New Slack DM from Vargas" --source slack --json`,
+    )
+    .action(
+      async (
+        conversationId: string,
+        opts: { hint: string; source: string; json?: boolean },
+      ) => {
+        const result = await cliIpcCall<{
+          invoked: boolean;
+          producedToolCalls: boolean;
+        }>("wake_conversation", {
+          conversationId,
+          hint: opts.hint,
+          source: opts.source,
+        });
+
+        if (!result.ok) {
+          if (opts.json) {
+            log.info(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            log.error(`Error: ${result.error}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const wake = result.result!;
+        if (opts.json) {
+          log.info(JSON.stringify({ ok: true, ...wake }));
+        } else if (wake.invoked) {
+          log.info(
+            wake.producedToolCalls
+              ? `Wake produced output on conversation ${conversationId}`
+              : `Wake invoked on ${conversationId} (no output produced)`,
+          );
+        } else {
+          log.error(
+            `Could not wake conversation ${conversationId} — conversation not found`,
+          );
+          process.exitCode = 1;
+        }
+      },
+    );
 }

package/src/cli/commands/credentials.ts

@@ -248,7 +248,6 @@ storage convention used internally (credential/{service}/{field}):
   --service telegram --field bot_token        Telegram bot token
   --service slack_channel --field bot_token   Slack channel bot token
   --service github --field token              GitHub personal access token
-  --service agentmail --field api_key         AgentMail API key
 
 Secrets are stored in AES-256-GCM encrypted storage. Metadata (policy,
 timestamps, labels) is tracked separately and never contains secret values.

package/src/cli/commands/domain.ts

@@ -0,0 +1,210 @@
+import type { Command } from "commander";
+
+import { getAssistantDomain } from "../../config/env.js";
+import { VellumPlatformClient } from "../../platform/client.js";
+import { getCliLogger } from "../logger.js";
+import { shouldOutputJson, writeOutput } from "../output.js";
+
+const log = getCliLogger("domain");
+
+export function registerDomainCommand(program: Command): void {
+  const baseDomain = getAssistantDomain();
+  const domain = program
+    .command("domain")
+    .description(
+      `Register and manage this assistant's custom subdomain on ${baseDomain}`,
+    )
+    .option("--json", "Machine-readable compact JSON output");
+
+  domain.addHelpText(
+    "after",
+    `
+Each assistant can register its own subdomain (e.g. velly.${baseDomain})
+for email and web presence. DNS managed by the Vellum platform.
+
+Examples:
+  $ assistant domain register velly
+  $ assistant domain register --json
+  $ assistant domain status`,
+  );
+
+  domain
+    .command("register [subdomain]")
+    .description(
+      `Register a custom subdomain on ${baseDomain} for this assistant`,
+    )
+    .addHelpText(
+      "after",
+      `
+Arguments:
+  subdomain   The subdomain to register (e.g. "velly" → velly.${baseDomain}).
+              If omitted, the platform derives it from the assistant's name.
+
+Registers a subdomain at <subdomain>.${baseDomain}. DNS managed by the
+Vellum platform — no manual DNS changes needed.
+
+Examples:
+  $ assistant domain register velly
+  ✓ Registered velly.${baseDomain}
+
+  $ assistant domain register
+  ✓ Registered my-assistant.${baseDomain}
+
+  $ assistant domain register velly --json
+  {"domain":"velly.${baseDomain}","id":"...","status":"active","verified":true}`,
+    )
+    .action(
+      async (subdomain: string | undefined, _opts: unknown, cmd: Command) => {
+        try {
+          const client = await VellumPlatformClient.create();
+          if (!client) {
+            throw new Error(
+              "Platform credentials not configured. Run: assistant platform connect",
+            );
+          }
+          if (!client.platformAssistantId) {
+            throw new Error(
+              "Assistant ID not configured. Set PLATFORM_ASSISTANT_ID or run: assistant platform connect",
+            );
+          }
+
+          const body: Record<string, string> = {};
+          if (subdomain) {
+            body.subdomain = subdomain;
+          }
+
+          const response = await client.fetch(
+            `/v1/assistants/${client.platformAssistantId}/domains/`,
+            {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(body),
+            },
+          );
+
+          if (!response.ok) {
+            const respBody = (await response
+              .json()
+              .catch(() => ({}))) as Record<string, unknown>;
+            const detail =
+              respBody.detail ??
+              (Array.isArray(respBody.subdomain)
+                ? respBody.subdomain[0]
+                : undefined) ??
+              `HTTP ${response.status}`;
+            throw new Error(String(detail));
+          }
+
+          const data = (await response.json()) as {
+            id: string;
+            domain: string;
+            status: string;
+            verified: boolean;
+            created_at: string;
+          };
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, data);
+          } else {
+            log.info(`✓ Registered ${data.domain}`);
+            if (!data.verified) {
+              log.info(
+                "  ⚠ Domain verification pending — this usually resolves within a few seconds.",
+              );
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, { error: message });
+          } else {
+            log.error(`Error: ${message}`);
+          }
+          process.exitCode = 1;
+        }
+      },
+    );
+
+  domain
+    .command("status")
+    .description("Show this assistant's domain registration and health")
+    .addHelpText(
+      "after",
+      `
+Shows the domain currently registered for this assistant, including
+verification status and DNS health.
+
+Examples:
+  $ assistant domain status
+  Domain:   velly.${baseDomain}
+  Status:   active
+  Verified: yes
+  Created:  2026-04-15
+
+  $ assistant domain status --json
+  {"domain":"velly.${baseDomain}","status":"active","verified":true,...}`,
+    )
+    .action(async (_opts: unknown, cmd: Command) => {
+      try {
+        const client = await VellumPlatformClient.create();
+        if (!client) {
+          throw new Error(
+            "Platform credentials not configured. Run: assistant platform connect",
+          );
+        }
+        if (!client.platformAssistantId) {
+          throw new Error(
+            "Assistant ID not configured. Set PLATFORM_ASSISTANT_ID or run: assistant platform connect",
+          );
+        }
+
+        const response = await client.fetch(
+          `/v1/assistants/${client.platformAssistantId}/domains/`,
+        );
+
+        if (!response.ok) {
+          const respBody = (await response.json().catch(() => ({}))) as Record<
+            string,
+            unknown
+          >;
+          const detail = respBody.detail ?? `HTTP ${response.status}`;
+          throw new Error(String(detail));
+        }
+
+        const data = (await response.json()) as {
+          results: {
+            id: string;
+            domain: string;
+            status: string;
+            verified: boolean;
+            created_at: string;
+          }[];
+        };
+
+        const domains = data.results ?? [];
+
+        if (shouldOutputJson(cmd)) {
+          writeOutput(cmd, data);
+        } else if (domains.length === 0) {
+          log.info(
+            "No domain registered for this assistant. Run: assistant domain register [subdomain]",
+          );
+        } else {
+          for (const d of domains) {
+            log.info(`Domain:   ${d.domain}`);
+            log.info(`Status:   ${d.status}`);
+            log.info(`Verified: ${d.verified ? "yes" : "no"}`);
+            log.info(`Created:  ${d.created_at.split("T")[0]}`);
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (shouldOutputJson(cmd)) {
+          writeOutput(cmd, { error: message });
+        } else {
+          log.error(`Error: ${message}`);
+        }
+        process.exitCode = 1;
+      }
+    });
+}

package/src/cli/commands/email.ts

@@ -1,8 +1,12 @@
-import { readFileSync, writeFileSync } from "node:fs";
+import { createWriteStream, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 
 import type { Command } from "commander";
 
 import { getAssistantDomain } from "../../config/env.js";
+import { markdownToEmailHtml } from "../../email/html-renderer.js";
 import { VellumPlatformClient } from "../../platform/client.js";
 import { getCliLogger } from "../logger.js";
 import { shouldOutputJson, writeOutput } from "../output.js";
@@ -30,6 +34,8 @@ Examples:
   $ assistant email send user@example.com -s "Hello" -b "Hi there"
   $ assistant email status
   $ assistant email list
+  $ assistant email attachment msg_abc1 --list
+  $ assistant email attachment msg_abc1 att_xyz1
   $ assistant email register mybot --json`,
   );
 
@@ -569,6 +575,10 @@ Examples:
     .option("-b, --body <text>", "Email body (plain text)")
     .option("-f, --file <path>", "Read body from file")
     .option("--html <path>", "HTML body file (optional)")
+    .option(
+      "--reply-to <email_id>",
+      "Reply to an email by its ID (auto-resolves threading headers and subject)",
+    )
     .addHelpText(
       "after",
       `
@@ -581,13 +591,20 @@ from the assistant's registered email address.
 
 Body source priority: --body flag > --file flag > stdin (if not a TTY).
 
+When --reply-to is provided, the platform auto-resolves In-Reply-To,
+References, and Subject headers from the referenced email. You can
+still override subject with -s.
+
 Examples:
   $ assistant email send user@example.com -s "Hello" -b "Hi there"
   ✓ Sent to user@example.com (delivery_id: abc123)
 
-  $ echo "Body text" | assistant email send user@example.com -s "Hello"
+  $ assistant email send user@example.com -b "Thanks!" --reply-to 019d96e4-e5d2-7201-890e-04a21e8f95bb
   ✓ Sent to user@example.com (delivery_id: def456)
 
+  $ echo "Body text" | assistant email send user@example.com -s "Hello"
+  ✓ Sent to user@example.com (delivery_id: ghi789)
+
   $ assistant email send user@example.com -s "Hello" -b "Hi" --json
   {"delivery_id":"abc123","status":"accepted"}`,
     )
@@ -599,6 +616,7 @@ Examples:
           body?: string;
           file?: string;
           html?: string;
+          replyTo?: string;
         },
         cmd: Command,
       ) => {
@@ -653,10 +671,13 @@ Examples:
             );
           }
 
-          // 3. Resolve optional HTML body from file
+          // 3. Resolve HTML body: explicit file > auto-generate from text
           let html: string | undefined;
           if (opts.html) {
             html = readFileSync(opts.html, "utf-8");
+          } else {
+            // Auto-generate HTML from the text body (markdown → email HTML).
+            html = markdownToEmailHtml(text);
           }
 
           // 4. Build payload
@@ -667,6 +688,7 @@ Examples:
           };
           if (opts.subject) payload.subject = opts.subject;
           if (html) payload.html = html;
+          if (opts.replyTo) payload.reply_to = opts.replyTo;
 
           // 5. Send via runtime proxy
           const response = await client.fetch("/v1/runtime-proxy/email/send/", {
@@ -705,4 +727,234 @@ Examples:
         }
       },
     );
+
+email
+  .command("attachment <message-id> [attachment-id]")
+  .description("Download email attachments")
+  .option("--all", "Download all attachments for the message")
+  .option(
+    "-o, --output <dir>",
+    "Output directory (default: current directory)",
+    ".",
+  )
+  .option("--list", "List attachments without downloading")
+  .addHelpText(
+    "after",
+    `
+Arguments:
+message-id      Email message ID (from \`assistant email list --json\`)
+attachment-id   Attachment ID (optional — required unless --all or --list)
+
+Download one or all attachments from a specific email message. Use
+--list to see available attachments without downloading.
+
+Examples:
+$ assistant email attachment msg_abc1 --list
+$ assistant email attachment msg_abc1 att_xyz1
+$ assistant email attachment msg_abc1 att_xyz1 -o ./downloads/
+$ assistant email attachment msg_abc1 --all
+$ assistant email attachment msg_abc1 --all -o ./attachments/
+$ assistant email attachment msg_abc1 --list --json`,
+  )
+  .action(
+    async (
+      messageId: string,
+      attachmentId: string | undefined,
+      opts: {
+        all?: boolean;
+        output?: string;
+        list?: boolean;
+      },
+      cmd: Command,
+    ) => {
+      try {
+        const client = await VellumPlatformClient.create();
+        if (!client) {
+          throw new Error(
+            "Platform credentials not configured. Run: assistant platform connect",
+          );
+        }
+        if (!client.platformAssistantId) {
+          throw new Error(
+            "Assistant ID not configured. Set PLATFORM_ASSISTANT_ID or run: assistant platform connect",
+          );
+        }
+
+        const assistantId = client.platformAssistantId;
+        const basePath = `/v1/assistants/${assistantId}/emails/${messageId}/attachments`;
+
+        if (opts.list) {
+          // List mode — show attachment metadata without downloading
+          const response = await client.fetch(`${basePath}/`);
+          if (!response.ok) {
+            const body = (await response
+              .json()
+              .catch(() => ({}))) as Record<string, unknown>;
+            const detail = body.detail ?? `HTTP ${response.status}`;
+            throw new Error(String(detail));
+          }
+
+          const data = (await response.json()) as {
+            results: AttachmentMeta[];
+          };
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, data);
+          } else {
+            const attachments = data.results ?? [];
+            if (attachments.length === 0) {
+              log.info("No attachments for this message.");
+            } else {
+              for (const att of attachments) {
+                log.info(
+                  `  ${att.id}  ${att.filename}  (${att.content_type}, ${formatBytes(att.size_bytes)})`,
+                );
+              }
+              log.info(`\n${attachments.length} attachment(s)`);
+            }
+          }
+          return;
+        }
+
+        if (!opts.all && !attachmentId) {
+          throw new Error(
+            "Specify an attachment ID, or use --all to download all attachments. Use --list to see available attachments.",
+          );
+        }
+
+        // Ensure output directory exists
+        const outDir = opts.output ?? ".";
+        mkdirSync(outDir, { recursive: true });
+
+        if (opts.all) {
+          // Download all attachments
+          const listResponse = await client.fetch(`${basePath}/`);
+          if (!listResponse.ok) {
+            const body = (await listResponse
+              .json()
+              .catch(() => ({}))) as Record<string, unknown>;
+            const detail = body.detail ?? `HTTP ${listResponse.status}`;
+            throw new Error(String(detail));
+          }
+
+          const listData = (await listResponse.json()) as {
+            results: AttachmentMeta[];
+          };
+
+          const attachments = listData.results ?? [];
+          if (attachments.length === 0) {
+            throw new Error("No attachments for this message.");
+          }
+
+          const downloaded: { filename: string; size_bytes: number }[] = [];
+          for (const att of attachments) {
+            const dest = join(outDir, safeFilename(att.filename));
+            await downloadAttachment(client, basePath, att.id, dest);
+            downloaded.push({
+              filename: att.filename,
+              size_bytes: att.size_bytes,
+            });
+          }
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, {
+              downloaded: downloaded.length,
+              directory: outDir,
+              files: downloaded,
+            });
+          } else {
+            log.info(
+              `✓ Downloaded ${downloaded.length} attachment(s) to ${outDir}`,
+            );
+            for (const f of downloaded) {
+              log.info(`  - ${f.filename} (${formatBytes(f.size_bytes)})`);
+            }
+          }
+        } else {
+          // Download single attachment — first get metadata for the filename
+          const metaResponse = await client.fetch(
+            `${basePath}/${attachmentId}/`,
+          );
+          if (!metaResponse.ok) {
+            const body = (await metaResponse
+              .json()
+              .catch(() => ({}))) as Record<string, unknown>;
+            const detail = body.detail ?? `HTTP ${metaResponse.status}`;
+            throw new Error(String(detail));
+          }
+
+          const meta = (await metaResponse.json()) as AttachmentMeta;
+          const dest = join(outDir, safeFilename(meta.filename));
+          await downloadAttachment(client, basePath, meta.id, dest);
+
+          if (shouldOutputJson(cmd)) {
+            writeOutput(cmd, {
+              filename: meta.filename,
+              size_bytes: meta.size_bytes,
+              saved: dest,
+            });
+          } else {
+            log.info(
+              `✓ Downloaded ${meta.filename} (${formatBytes(meta.size_bytes)})`,
+            );
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (shouldOutputJson(cmd)) {
+          writeOutput(cmd, { error: message });
+        } else {
+          log.error(`Error: ${message}`);
+        }
+        process.exitCode = 1;
+      }
+    },
+  );
+}
+
+interface AttachmentMeta {
+id: string;
+filename: string;
+content_type: string;
+size_bytes: number;
+content_id: string;
+created_at: string;
+}
+
+function formatBytes(bytes: number): string {
+if (bytes < 1024) return `${bytes} B`;
+if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function safeFilename(name: string): string {
+// Strip path separators and null bytes — keep the basename only
+return basename(name).replace(/[\x00/\\]/g, "_") || "attachment";
+}
+
+async function downloadAttachment(
+client: VellumPlatformClient,
+basePath: string,
+attachmentId: string,
+dest: string,
+): Promise<void> {
+const response = await client.fetch(
+  `${basePath}/${attachmentId}/download/`,
+);
+
+if (!response.ok) {
+  const body = (await response.json().catch(() => ({}))) as Record<
+    string,
+    unknown
+  >;
+  const detail = body.detail ?? `HTTP ${response.status}`;
+  throw new Error(`Failed to download attachment: ${detail}`);
+}
+
+if (!response.body) {
+  throw new Error("Empty response body from download endpoint.");
+}
+
+const fileStream = createWriteStream(dest);
+await pipeline(response.body as unknown as Readable, fileStream);
 }