@vellumai/assistant 0.4.42 → 0.4.44

package/src/cli/commands/twitter/router.ts

@@ -0,0 +1,351 @@
+/**
+ * Mode router for Twitter operations.
+ * Selects managed proxy or OAuth path based on the caller-provided integration mode.
+ */
+
+import {
+  getTweet as managedGetTweet,
+  getUserByUsername as managedGetUserByUsername,
+  getUserTweets as managedGetUserTweets,
+  postTweet as managedPostTweet,
+  searchRecentTweets as managedSearchRecentTweets,
+  TwitterProxyError,
+} from "../../../twitter/platform-proxy-client.js";
+import { oauthIsAvailable, oauthPostTweet } from "./oauth-client.js";
+import type { PostTweetResult, TweetEntry, UserInfo } from "./types.js";
+
+export type TwitterMode = "oauth" | "managed";
+
+export interface RoutedResult<T> {
+  result: T;
+  pathUsed: TwitterMode;
+}
+
+export async function routedPostTweet(
+  text: string,
+  opts: {
+    inReplyToTweetId?: string;
+    mode: TwitterMode;
+    oauthToken?: string;
+  },
+): Promise<RoutedResult<PostTweetResult>> {
+  const mode = opts.mode;
+
+  if (mode === "managed") {
+    // Route through platform proxy — the platform holds the OAuth credentials
+    try {
+      const response = await managedPostTweet(text, {
+        replyToId: opts.inReplyToTweetId,
+      });
+      const data = response.data as Record<string, unknown>;
+      const tweetData = (data?.data ?? data) as Record<string, unknown>;
+      const tweetId = String(tweetData.id ?? "");
+      if (!tweetId) {
+        throw Object.assign(
+          new Error(
+            "Managed post succeeded but the proxy response did not include a tweet ID",
+          ),
+          {
+            pathUsed: "managed" as const,
+          },
+        );
+      }
+      return {
+        result: {
+          tweetId,
+          text,
+          url: `https://x.com/i/status/${tweetId}`,
+        },
+        pathUsed: "managed",
+      };
+    } catch (err) {
+      if (err instanceof TwitterProxyError) {
+        // Surface actionable error messages from the proxy
+        throw Object.assign(new Error(err.message), {
+          pathUsed: "managed" as const,
+          proxyErrorCode: err.code,
+          retryable: err.retryable,
+        });
+      }
+      throw err;
+    }
+  }
+
+  if (mode === "oauth") {
+    // User explicitly wants OAuth
+    if (!oauthIsAvailable(opts.oauthToken)) {
+      throw Object.assign(
+        new Error(
+          "OAuth is not configured. Connect your X developer credentials to set up OAuth.",
+        ),
+        {
+          pathUsed: "oauth" as const,
+        },
+      );
+    }
+    const result = await oauthPostTweet(text, {
+      inReplyToTweetId: opts.inReplyToTweetId,
+      oauthToken: opts.oauthToken!,
+    });
+    return {
+      result: {
+        tweetId: result.tweetId,
+        text: result.text,
+        url: result.url ?? `https://x.com/i/status/${result.tweetId}`,
+      },
+      pathUsed: "oauth",
+    };
+  }
+
+  // Exhaustive check — should never reach here
+  const _exhaustive: never = mode;
+  throw new Error(`Unknown mode: ${_exhaustive}`);
+}
+
+// ---------------------------------------------------------------------------
+// Routed read operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Look up a user by screen name.
+ * Managed mode uses GET /2/users/by/username/:username.
+ */
+export async function routedGetUserByScreenName(
+  screenName: string,
+  opts: { mode: TwitterMode },
+): Promise<RoutedResult<UserInfo>> {
+  if (opts.mode === "managed") {
+    try {
+      const response = await managedGetUserByUsername(screenName, {
+        "user.fields": "id,name,username",
+      });
+      const data = response.data as Record<string, unknown>;
+      const userData = (data?.data ?? data) as Record<string, unknown>;
+      if (!userData.id) {
+        throw Object.assign(new Error(`User not found: @${screenName}`), {
+          pathUsed: "managed" as const,
+        });
+      }
+      return {
+        result: {
+          userId: String(userData.id),
+          screenName: String(
+            userData.username ?? userData.screen_name ?? screenName,
+          ),
+          name: String(userData.name ?? screenName),
+        },
+        pathUsed: "managed",
+      };
+    } catch (err) {
+      if (err instanceof TwitterProxyError) {
+        throw Object.assign(new Error(err.message), {
+          pathUsed: "managed" as const,
+          proxyErrorCode: err.code,
+          retryable: err.retryable,
+        });
+      }
+      throw err;
+    }
+  }
+
+  if (opts.mode === "oauth") {
+    throw Object.assign(
+      new Error(
+        "Read operations are not supported via OAuth. Use managed mode for read access.",
+      ),
+      { pathUsed: "oauth" as const },
+    );
+  }
+
+  const _exhaustive: never = opts.mode;
+  throw new Error(`Unknown mode: ${_exhaustive}`);
+}
+
+/**
+ * Fetch a user's recent tweets.
+ * Managed mode uses GET /2/users/:id/tweets.
+ */
+export async function routedGetUserTweets(
+  userId: string,
+  count: number,
+  opts: { mode: TwitterMode },
+): Promise<RoutedResult<TweetEntry[]>> {
+  if (opts.mode === "managed") {
+    try {
+      const response = await managedGetUserTweets(userId, {
+        max_results: String(Math.min(count, 100)),
+        "tweet.fields": "id,text,created_at,author_id",
+      });
+      const data = response.data as Record<string, unknown>;
+      const tweetsArray = (data?.data ?? []) as Array<Record<string, unknown>>;
+      const tweets: TweetEntry[] = tweetsArray.map((t) => ({
+        tweetId: String(t.id ?? ""),
+        text: String(t.text ?? ""),
+        url: `https://x.com/i/status/${t.id}`,
+        createdAt: String(t.created_at ?? ""),
+      }));
+      return { result: tweets, pathUsed: "managed" };
+    } catch (err) {
+      if (err instanceof TwitterProxyError) {
+        throw Object.assign(new Error(err.message), {
+          pathUsed: "managed" as const,
+          proxyErrorCode: err.code,
+          retryable: err.retryable,
+        });
+      }
+      throw err;
+    }
+  }
+
+  if (opts.mode === "oauth") {
+    throw Object.assign(
+      new Error(
+        "Read operations are not supported via OAuth. Use managed mode for read access.",
+      ),
+      { pathUsed: "oauth" as const },
+    );
+  }
+
+  const _exhaustive: never = opts.mode;
+  throw new Error(`Unknown mode: ${_exhaustive}`);
+}
+
+/**
+ * Fetch a single tweet by ID.
+ * Managed mode uses GET /2/tweets/:id.
+ */
+export async function routedGetTweetDetail(
+  tweetId: string,
+  opts: { mode: TwitterMode },
+): Promise<RoutedResult<TweetEntry[]>> {
+  if (opts.mode === "managed") {
+    try {
+      const response = await managedGetTweet(tweetId, {
+        "tweet.fields": "id,text,created_at,author_id,conversation_id",
+      });
+      const data = response.data as Record<string, unknown>;
+      const tweetData = (data?.data ?? data) as Record<string, unknown>;
+      const primaryTweet: TweetEntry = {
+        tweetId: String(tweetData.id ?? ""),
+        text: String(tweetData.text ?? ""),
+        url: `https://x.com/i/status/${tweetData.id}`,
+        createdAt: String(tweetData.created_at ?? ""),
+      };
+
+      // If the tweet has a conversation_id, fetch the thread via search
+      const conversationId = tweetData.conversation_id as string | undefined;
+      if (conversationId) {
+        try {
+          const threadResponse = await managedSearchRecentTweets(
+            `conversation_id:${conversationId}`,
+            {
+              "tweet.fields": "id,text,created_at,author_id",
+              max_results: "100",
+            },
+          );
+          const threadData = threadResponse.data as Record<string, unknown>;
+          const threadArray = (threadData?.data ?? []) as Array<
+            Record<string, unknown>
+          >;
+          const threadTweets: TweetEntry[] = threadArray.map((t) => ({
+            tweetId: String(t.id ?? ""),
+            text: String(t.text ?? ""),
+            url: `https://x.com/i/status/${t.id}`,
+            createdAt: String(t.created_at ?? ""),
+          }));
+          // Deduplicate: the primary tweet may already be in the search results
+          const seen = new Set(threadTweets.map((t) => t.tweetId));
+          if (!seen.has(primaryTweet.tweetId)) {
+            threadTweets.unshift(primaryTweet);
+          }
+          return { result: threadTweets, pathUsed: "managed" };
+        } catch {
+          // If thread search fails, fall back to returning just the single tweet
+        }
+      }
+
+      return { result: [primaryTweet], pathUsed: "managed" };
+    } catch (err) {
+      if (err instanceof TwitterProxyError) {
+        throw Object.assign(new Error(err.message), {
+          pathUsed: "managed" as const,
+          proxyErrorCode: err.code,
+          retryable: err.retryable,
+        });
+      }
+      throw err;
+    }
+  }
+
+  if (opts.mode === "oauth") {
+    throw Object.assign(
+      new Error(
+        "Read operations are not supported via OAuth. Use managed mode for read access.",
+      ),
+      { pathUsed: "oauth" as const },
+    );
+  }
+
+  const _exhaustive: never = opts.mode;
+  throw new Error(`Unknown mode: ${_exhaustive}`);
+}
+
+/**
+ * Search tweets.
+ * Managed mode uses GET /2/tweets/search/recent.
+ */
+export async function routedSearchTweets(
+  query: string,
+  product: "Top" | "Latest" | "People" | "Media",
+  opts: { mode: TwitterMode },
+): Promise<RoutedResult<TweetEntry[]>> {
+  if (opts.mode === "managed") {
+    if (product === "People" || product === "Media") {
+      throw Object.assign(
+        new Error(
+          `Product type "${product}" is not supported in managed mode. Only "Top" and "Latest" are supported.`,
+        ),
+        { pathUsed: "managed" as const },
+      );
+    }
+    try {
+      const queryParams: Record<string, string> = {
+        "tweet.fields": "id,text,created_at,author_id",
+      };
+      if (product === "Latest") {
+        queryParams.sort_order = "recency";
+      }
+      const response = await managedSearchRecentTweets(query, queryParams);
+      const data = response.data as Record<string, unknown>;
+      const tweetsArray = (data?.data ?? []) as Array<Record<string, unknown>>;
+      const tweets: TweetEntry[] = tweetsArray.map((t) => ({
+        tweetId: String(t.id ?? ""),
+        text: String(t.text ?? ""),
+        url: `https://x.com/i/status/${t.id}`,
+        createdAt: String(t.created_at ?? ""),
+      }));
+      return { result: tweets, pathUsed: "managed" };
+    } catch (err) {
+      if (err instanceof TwitterProxyError) {
+        throw Object.assign(new Error(err.message), {
+          pathUsed: "managed" as const,
+          proxyErrorCode: err.code,
+          retryable: err.retryable,
+        });
+      }
+      throw err;
+    }
+  }
+
+  if (opts.mode === "oauth") {
+    throw Object.assign(
+      new Error(
+        "Read operations are not supported via OAuth. Use managed mode for read access.",
+      ),
+      { pathUsed: "oauth" as const },
+    );
+  }
+
+  const _exhaustive: never = opts.mode;
+  throw new Error(`Unknown mode: ${_exhaustive}`);
+}

package/src/cli/commands/twitter/types.ts

@@ -0,0 +1,30 @@
+/**
+ * Public types shared across the Twitter CLI module.
+ * Extracted from the former browser CDP client.
+ */
+
+export interface PostTweetResult {
+  tweetId: string;
+  text: string;
+  url: string;
+}
+
+export interface UserInfo {
+  userId: string;
+  screenName: string;
+  name: string;
+}
+
+export interface TweetEntry {
+  tweetId: string;
+  text: string;
+  url: string;
+  createdAt: string;
+}
+
+export interface NotificationEntry {
+  id: string;
+  message: string;
+  timestamp: string;
+  url?: string;
+}

package/src/cli/db.ts

@@ -0,0 +1 @@
+export { initializeDb } from "../memory/db.js";

package/src/cli/http-client.ts

@@ -0,0 +1,87 @@
+/**
+ * HTTP client helpers for the built-in CLI.
+ *
+ * Provides authenticated HTTP communication with the daemon's HTTP server,
+ * replacing the previous Unix socket IPC transport. Patterns are adapted
+ * from `cli/src/lib/http-client.ts` (external CLI).
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getRuntimeHttpPort } from "../config/env.js";
+import { getRootDir } from "../util/platform.js";
+
+// ---------------------------------------------------------------------------
+// Token
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the HTTP bearer token from `<rootDir>/http-token`.
+ * Returns undefined if the token file doesn't exist or is empty.
+ */
+export function readHttpToken(): string | undefined {
+  const tokenPath = join(getRootDir(), "http-token");
+  try {
+    const token = readFileSync(tokenPath, "utf-8").trim();
+    return token || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Base URL
+// ---------------------------------------------------------------------------
+
+/** Build the base URL for the daemon HTTP server. */
+export function getHttpBaseUrl(): string {
+  return `http://127.0.0.1:${getRuntimeHttpPort()}`;
+}
+
+// ---------------------------------------------------------------------------
+// Authenticated fetch
+// ---------------------------------------------------------------------------
+
+/**
+ * Make an authenticated HTTP request to the daemon.
+ *
+ * @param path   Request path (e.g. `/v1/messages` or `/healthz`)
+ * @param init   Standard fetch RequestInit options
+ * @returns      The fetch Response
+ */
+export async function httpSend(
+  path: string,
+  init: RequestInit = {},
+): Promise<Response> {
+  const token = readHttpToken();
+  const url = `${getHttpBaseUrl()}${path}`;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...(init.headers as Record<string, string> | undefined),
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return fetch(url, { ...init, headers });
+}
+
+// ---------------------------------------------------------------------------
+// Health check
+// ---------------------------------------------------------------------------
+
+/**
+ * Perform an HTTP health check against the daemon's `/healthz` endpoint.
+ * Returns true if the daemon responds with HTTP 200, false otherwise.
+ */
+export async function httpHealthCheck(timeoutMs = 2000): Promise<boolean> {
+  try {
+    const url = `${getHttpBaseUrl()}/healthz`;
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}

package/src/cli/logger.ts

@@ -0,0 +1,6 @@
+import { getCliLogger } from "../util/logger.js";
+
+/** Shared CLI logger instance. Most commands use this directly. */
+export const log = getCliLogger("cli");
+
+export { getCliLogger } from "../util/logger.js";

package/src/cli/main-screen.tsx

@@ -1,7 +1,8 @@
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 
-import { getSocketPath, getWorkspaceDir } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { getHttpBaseUrl } from "./http-client.js";
 
 const LEFT_PANEL_WIDTH = 36;
 const RIGHT_LINE_COUNT = 11;
@@ -13,7 +14,7 @@ export interface MainScreenLayout {
 }
 
 export function renderMainScreen(): MainScreenLayout {
-  const socketPath = getSocketPath();
+  const httpUrl = getHttpBaseUrl();
   const workspace = getWorkspaceDir();
   const assistantId = workspace.split("/").pop() ?? "vellum";
 
@@ -26,7 +27,7 @@ export function renderMainScreen(): MainScreenLayout {
     render: (runtimeUrl: string, assistantId: string, species: string) => number;
   };
 
-  const height = render(socketPath, assistantId, "vellum");
+  const height = render(httpUrl, assistantId, "vellum");
 
   const statusCanvasLine = RIGHT_LINE_COUNT + 1;
   const statusCol = LEFT_PANEL_WIDTH + 1;

package/src/cli/output.ts

@@ -0,0 +1,19 @@
+import type { Command } from "commander";
+
+export function shouldOutputJson(cmd: Command): boolean {
+  let current: Command | null = cmd;
+  while (current) {
+    if ((current.opts() as { json?: boolean }).json) return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+export function writeOutput(cmd: Command, payload: unknown): void {
+  const compact = shouldOutputJson(cmd);
+  process.stdout.write(
+    compact
+      ? JSON.stringify(payload) + "\n"
+      : JSON.stringify(payload, null, 2) + "\n",
+  );
+}

package/src/cli/program.ts

@@ -3,30 +3,31 @@ import { createRequire } from "node:module";
 import { Command } from "commander";
 
 import { registerHooksCommand } from "../hooks/cli.js";
-import { registerAmazonCommand } from "./amazon.js";
-import { registerAuditCommand } from "./audit.js";
-import { registerAutonomyCommand } from "./autonomy.js";
-import { registerChannelsCommand } from "./channels.js";
-import { registerCompletionsCommand } from "./completions.js";
-import { registerConfigCommand } from "./config.js";
-import { registerContactsCommand } from "./contacts.js";
-import { registerCredentialsCommand } from "./credentials.js";
-import { registerDefaultAction } from "./default-action.js";
-import { registerDevCommand } from "./dev.js";
-import { registerDoctorCommand } from "./doctor.js";
-import { registerEmailCommand } from "./email.js";
-import { registerInfluencerCommand } from "./influencer.js";
-import { registerIntegrationsCommand } from "./integrations.js";
-import { registerKeysCommand } from "./keys.js";
-import { registerMapCommand } from "./map.js";
-import { registerMcpCommand } from "./mcp.js";
-import { registerMemoryCommand } from "./memory.js";
-import { registerNotificationsCommand } from "./notifications.js";
-import { registerOAuthCommand } from "./oauth.js";
-import { registerSequenceCommand } from "./sequence.js";
-import { registerSessionsCommand } from "./sessions.js";
-import { registerTrustCommand } from "./trust.js";
-import { registerTwitterCommand } from "./twitter.js";
+import { registerAmazonCommand } from "./commands/amazon/index.js";
+import { registerAuditCommand } from "./commands/audit.js";
+import { registerAutonomyCommand } from "./commands/autonomy.js";
+import { registerBrowserRelayCommand } from "./commands/browser-relay.js";
+import { registerChannelVerificationSessionsCommand } from "./commands/channel-verification-sessions.js";
+import { registerCompletionsCommand } from "./commands/completions.js";
+import { registerConfigCommand } from "./commands/config.js";
+import { registerContactsCommand } from "./commands/contacts.js";
+import { registerCredentialsCommand } from "./commands/credentials.js";
+import { registerDefaultAction } from "./commands/default-action.js";
+import { registerDevCommand } from "./commands/dev.js";
+import { registerDoctorCommand } from "./commands/doctor.js";
+import { registerEmailCommand } from "./commands/email.js";
+import { registerKeysCommand } from "./commands/keys.js";
+import { registerMapCommand } from "./commands/map.js";
+import { registerMcpCommand } from "./commands/mcp.js";
+import { registerMemoryCommand } from "./commands/memory.js";
+import { registerNotificationsCommand } from "./commands/notifications.js";
+import { registerOAuthCommand } from "./commands/oauth.js";
+import { registerPlatformCommand } from "./commands/platform.js";
+import { registerSequenceCommand } from "./commands/sequence.js";
+import { registerSessionsCommand } from "./commands/sessions.js";
+import { registerSkillsCommand } from "./commands/skills.js";
+import { registerTrustCommand } from "./commands/trust.js";
+import { registerTwitterCommand } from "./commands/twitter/index.js";
 
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json") as { version: string };
@@ -49,18 +50,19 @@ export function buildCliProgram(): Command {
   registerHooksCommand(program);
   registerMcpCommand(program);
   registerEmailCommand(program);
-  registerIntegrationsCommand(program);
   registerContactsCommand(program);
-  registerChannelsCommand(program);
+  registerChannelVerificationSessionsCommand(program);
   registerAmazonCommand(program);
   registerAutonomyCommand(program);
   registerCompletionsCommand(program);
   registerNotificationsCommand(program);
+  registerPlatformCommand(program);
   registerOAuthCommand(program);
+  registerSkillsCommand(program);
+  registerBrowserRelayCommand(program);
 
   registerTwitterCommand(program);
   registerMapCommand(program);
-  registerInfluencerCommand(program);
   registerSequenceCommand(program);
 
   return program;

package/src/cli/reference.ts

@@ -6,43 +6,33 @@ export const CLI_HELP_REFERENCE = `Usage: assistant [options] [command]
 Local AI assistant
 
 Options:
-  -V, --version            output the version number
-  -h, --help               display help for command
+  -V, --version                            output the version number
+  -h, --help                               display help for command
 
 Commands:
-  dev [options]            Run the assistant in dev mode
-  sessions                 Manage sessions
-  config                   Manage configuration
-  keys                     Manage API keys in secure storage
-  credentials [options]    Manage credentials in the encrypted vault (API keys,
-                           tokens, passwords)
-  trust                    Manage trust rules
-  memory                   Manage long-term memory indexing/retrieval
-  audit [options]          Show recent tool invocations
-  doctor                   Run diagnostic checks
-  hooks                    Manage hooks
-  mcp                      Manage MCP (Model Context Protocol) servers
-  email [options]          Email operations (provider-agnostic)
-  integrations [options]   Read integration and ingress status through the
-                           gateway API
-  contacts [options]       Manage and query the contact graph
-  channels [options]       Query channel status
-  amazon [options]         Shop on Amazon and Amazon Fresh. Requires a session
-                           imported from a Ride Shotgun recording.
-  autonomy [options]       View and configure autonomy tiers
-  completions <shell>      Generate shell completion script (e.g. vellum
-                           completions bash >> ~/.bashrc)
-  notifications [options]  Send and inspect notifications through the unified
-                           notification router
-  x|twitter [options]      Post on X and manage connections. Supports OAuth
-                           (official API) and browser session paths.
-  map [options] <domain>   Auto-navigate a domain and produce a deduplicated API
-                           map. Launches Chrome with CDP, starts a Ride Shotgun
-                           learn session, then analyzes captured network
-                           traffic.
-  influencer [options]     Research influencers on Instagram, TikTok, and
-                           X/Twitter. Uses the Chrome extension relay to browse
-                           each platform. Requires the user to be logged in on
-                           each platform in Chrome.
-  sequence [options]       Manage email sequences
+  dev [options]                            Run the assistant in dev mode
+  sessions                                 Manage sessions
+  config                                   Manage configuration
+  keys                                     Manage API keys in secure storage
+  credentials [options]                    Manage credentials in the encrypted vault (API keys, tokens, passwords)
+  trust                                    Manage trust rules
+  memory                                   Manage long-term memory indexing/retrieval
+  audit [options]                          Show recent tool invocations
+  doctor                                   Run diagnostic checks
+  hooks                                    Manage hooks
+  mcp                                      Manage MCP (Model Context Protocol) servers
+  email [options]                          Email operations (provider-agnostic)
+  contacts [options]                       Manage and query the contact graph
+  channel-verification-sessions [options]  Manage channel verification sessions
+  amazon [options]                         Shop on Amazon and Amazon Fresh. Requires an active session (use "refresh" to authenticate).
+  autonomy [options]                       View and configure autonomy tiers
+  completions <shell>                      Generate shell completion script (e.g. assistant completions bash >> ~/.bashrc)
+  notifications [options]                  Send and inspect notifications through the unified notification router
+  platform [options]                       Manage platform integration for containerized deployments
+  oauth [options]                          Manage OAuth tokens for connected integrations
+  skills                                   Browse and install skills from the Vellum catalog
+  browser                                  Browser automation, extension relay, and Chrome CDP management
+  x|twitter [options]                      Post on X and manage connections. Supports managed (platform proxy) and OAuth (official API) paths.
+  map [options] <domain>                   Auto-navigate a domain and produce a deduplicated API map. Launches Chrome with CDP, starts a Ride Shotgun learn session, then analyzes captured network traffic.
+  sequence [options]                       Manage email sequences
 `;