@vellumai/assistant 0.3.4 → 0.3.6

package/src/daemon/handlers/twitter-auth.ts

@@ -72,6 +72,7 @@ export async function handleTwitterAuthStart(
       clientId,
       clientSecret,
       extraParams: {},
+      tokenEndpointAuthMethod: clientSecret ? 'client_secret_basic' : undefined,
     };
 
     const result = await startOAuth2Flow(oauthConfig, {
@@ -131,6 +132,7 @@ export async function handleTwitterAuthStart(
       oauth2TokenUrl: 'https://api.x.com/2/oauth2/token',
       oauth2ClientId: clientId,
       oauth2ClientSecret: clientSecret ?? null,
+      oauth2TokenEndpointAuthMethod: clientSecret ? 'client_secret_basic' : undefined,
       grantedScopes: result.grantedScopes,
       expiresAt: result.tokens.expiresIn ? Date.now() + result.tokens.expiresIn * 1000 : null,
     });

package/src/daemon/handlers/work-items.ts

@@ -148,15 +148,23 @@ function broadcastWorkItemStatus(ctx: HandlerContext, id: string): void {
   }
 }
 
-/** Extract plain text from a message content string (handles JSON content block arrays). */
-function extractTextFromContent(content: string): string {
+/**
+ * Extract only the latest assistant text block from stored content.
+ * Consolidation merges multiple assistant messages into one DB row; scanning
+ * from the end keeps task output focused on the final assistant response.
+ */
+function extractLatestTextFromContent(content: string): string {
   try {
     const parsed = JSON.parse(content);
     if (Array.isArray(parsed)) {
-      return parsed
-        .filter((b: { type: string }) => b.type === 'text')
-        .map((b: { text: string }) => b.text)
-        .join('\n');
+      for (let i = parsed.length - 1; i >= 0; i--) {
+        const block = parsed[i] as { type?: unknown; text?: unknown };
+        if (block.type !== 'text') continue;
+        if (typeof block.text !== 'string') continue;
+        if (!block.text.trim()) continue;
+        return block.text;
+      }
+      return '';
     }
   } catch {
     // Plain text content — use as-is
@@ -299,7 +307,7 @@ export function handleWorkItemOutput(
       const m = msgs[i];
       if (m.role !== 'assistant') continue;
 
-      const text = extractTextFromContent(m.content);
+      const text = extractLatestTextFromContent(m.content);
       if (!text.trim()) continue;
 
       summary = truncate(text, 2000, '');
@@ -385,7 +393,7 @@ export async function handleWorkItemRunTask(
   // Compute required tools using the same resolution logic as preflight:
   // work-item snapshot first, then task template, then all registered tools.
   let requiredTools: string[];
-  if (workItem.requiredTools !== null && workItem.requiredTools !== undefined) {
+  if (workItem.requiredTools != null) {
     requiredTools = sanitizeToolList(JSON.parse(workItem.requiredTools));
   } else {
     requiredTools = task.requiredTools
@@ -505,7 +513,7 @@ export async function handleWorkItemPreflight(
   // back to the task template (or all registered tools) when the
   // snapshot is null.
   let requiredTools: string[];
-  if (workItem.requiredTools !== null && workItem.requiredTools !== undefined) {
+  if (workItem.requiredTools != null) {
     requiredTools = sanitizeToolList(JSON.parse(workItem.requiredTools));
   } else {
     const task = getTask(workItem.taskId);

package/src/daemon/handlers/workspace-files.ts

@@ -1,6 +1,7 @@
 import * as net from 'node:net';
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
+import { pathExists } from '../../util/fs.js';
 import { getWorkspaceDir } from '../../util/platform.js';
 import { log, defineHandlers, type HandlerContext } from './shared.js';
 import type { WorkspaceFileReadRequest } from '../ipc-protocol.js';
@@ -13,7 +14,7 @@ function handleWorkspaceFilesList(socket: net.Socket, ctx: HandlerContext): void
   const files = WORKSPACE_FILES.map((name) => ({
     path: name,
     name,
-    exists: existsSync(join(base, name)),
+    exists: pathExists(join(base, name)),
   }));
   ctx.send(socket, { type: 'workspace_files_list_response', files });
 }
@@ -42,7 +43,7 @@ function handleWorkspaceFileRead(
   }
 
   try {
-    if (!existsSync(resolved)) {
+    if (!pathExists(resolved)) {
       ctx.send(socket, {
         type: 'workspace_file_read_response',
         path: requested,

package/src/daemon/install-cli-launchers.ts

@@ -0,0 +1,113 @@
+/**
+ * Installs standalone CLI launcher scripts in ~/.vellum/bin/ so that
+ * integration commands (e.g. `doordash`, `map`) can be invoked directly
+ * without requiring `vellum` on PATH.
+ *
+ * Each launcher is a shell script that hardcodes absolute paths to `bun`
+ * and the CLI entrypoint, forwarding all arguments to the appropriate
+ * subcommand.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('install-cli-launchers');
+
+/** Integration subcommands that should get standalone launchers. */
+const INTEGRATION_COMMANDS = ['doordash', 'map'];
+
+/**
+ * Resolve the absolute path to the bun binary.
+ * Prefers process.execPath (works when running under bun), then falls
+ * back to `which bun`.
+ */
+function resolveBunPath(): string {
+  // process.execPath points to the bun binary when running under bun
+  if (process.execPath && process.execPath.includes('bun')) {
+    return process.execPath;
+  }
+  try {
+    return execSync('which bun', { encoding: 'utf-8' }).trim();
+  } catch {
+    throw new Error('Could not find bun binary');
+  }
+}
+
+/**
+ * Resolve the absolute path to the CLI entrypoint (index.ts).
+ * Uses import.meta.dirname to find the source tree root.
+ */
+function resolveCliEntrypoint(): string {
+  // This file is at assistant/src/daemon/install-cli-launchers.ts
+  // The CLI entrypoint is at assistant/src/index.ts
+  const thisDir = import.meta.dirname ?? __dirname;
+  return join(thisDir, '..', 'index.ts');
+}
+
+/**
+ * Check whether a given command name conflicts with an existing system
+ * binary (i.e. something other than our own launcher).
+ */
+function hasSystemConflict(name: string, binDir: string): boolean {
+  try {
+    const result = execSync(`which ${name}`, { encoding: 'utf-8' }).trim();
+    // If `which` resolves to our own bin dir, that's not a conflict
+    if (result.startsWith(binDir)) return false;
+    return true;
+  } catch {
+    // `which` failed — no conflict
+    return false;
+  }
+}
+
+/**
+ * Install standalone CLI launcher scripts in ~/.vellum/bin/.
+ *
+ * For each integration command, generates a shell script that execs
+ * bun with the CLI entrypoint and the subcommand name prepended.
+ * Uses the short name by default (e.g. `doordash`), falling back to
+ * `vellum-<name>` if the short name conflicts with an existing system binary.
+ */
+export function installCliLaunchers(): void {
+  const binDir = join(homedir(), '.vellum', 'bin');
+
+  let bunPath: string;
+  try {
+    bunPath = resolveBunPath();
+  } catch (err) {
+    log.warn({ err }, 'Cannot install CLI launchers: bun not found');
+    return;
+  }
+
+  const entrypoint = resolveCliEntrypoint();
+  if (!existsSync(entrypoint)) {
+    // In compiled builds (e.g. macOS app via `bun build --compile`), the
+    // source tree isn't available.  Launcher scripts are a dev-mode
+    // convenience; compiled builds use their own command dispatch, so we
+    // silently skip installation.
+    log.debug({ entrypoint }, 'CLI entrypoint not found (compiled build?) — skipping launcher installation');
+    return;
+  }
+
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
+  }
+
+  for (const name of INTEGRATION_COMMANDS) {
+    const launcherName = hasSystemConflict(name, binDir) ? `vellum-${name}` : name;
+    const launcherPath = join(binDir, launcherName);
+
+    const script = `#!/bin/bash
+exec "${bunPath}" "${entrypoint}" ${name} "$@"
+`;
+
+    writeFileSync(launcherPath, script);
+    chmodSync(launcherPath, 0o755);
+    log.debug({ launcherName, launcherPath }, 'Installed CLI launcher');
+  }
+
+  log.info({ binDir, commands: INTEGRATION_COMMANDS }, 'CLI launchers installed');
+}

package/src/daemon/ipc-contract/apps.ts

@@ -0,0 +1,356 @@
+// App management, gallery, publishing, and sharing types.
+
+import type { GalleryManifest } from '../../gallery/gallery-manifest.js';
+
+// === Client → Server ===
+
+export interface AppDataRequest {
+  type: 'app_data_request';
+  surfaceId: string;
+  callId: string;
+  method: 'query' | 'create' | 'update' | 'delete';
+  appId: string;
+  recordId?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface AppsListRequest {
+  type: 'apps_list';
+}
+
+export interface HomeBaseGetRequest {
+  type: 'home_base_get';
+  /** If true, daemon ensures a durable Home Base link exists before responding. */
+  ensureLinked?: boolean;
+}
+
+export interface AppOpenRequest {
+  type: 'app_open_request';
+  appId: string;
+}
+
+export interface SharedAppsListRequest {
+  type: 'shared_apps_list';
+}
+
+export interface SharedAppDeleteRequest {
+  type: 'shared_app_delete';
+  uuid: string;
+}
+
+export interface ForkSharedAppRequest {
+  type: 'fork_shared_app';
+  uuid: string;
+}
+
+export interface BundleAppRequest {
+  type: 'bundle_app';
+  appId: string;
+}
+
+export interface AppUpdatePreviewRequest {
+  type: 'app_update_preview';
+  appId: string;
+  /** Base64-encoded PNG screenshot thumbnail. */
+  preview: string;
+}
+
+export interface AppPreviewRequest {
+  type: 'app_preview_request';
+  appId: string;
+}
+
+export interface OpenBundleRequest {
+  type: 'open_bundle';
+  filePath: string;
+}
+
+export interface SignBundlePayloadResponse {
+  type: 'sign_bundle_payload_response';
+  requestId: string;
+  signature?: string;
+  keyId?: string;
+  publicKey?: string;
+  error?: string;
+}
+
+export interface GetSigningIdentityResponse {
+  type: 'get_signing_identity_response';
+  requestId: string;
+  keyId?: string;
+  publicKey?: string;
+  error?: string;
+}
+
+export interface GalleryListRequest {
+  type: 'gallery_list';
+}
+
+export interface GalleryInstallRequest {
+  type: 'gallery_install';
+  galleryAppId: string;
+}
+
+export interface AppHistoryRequest {
+  type: 'app_history_request';
+  appId: string;
+  limit?: number;
+}
+
+export interface AppDiffRequest {
+  type: 'app_diff_request';
+  appId: string;
+  fromCommit: string;
+  toCommit?: string;
+}
+
+export interface AppFileAtVersionRequest {
+  type: 'app_file_at_version_request';
+  appId: string;
+  path: string;
+  commitHash: string;
+}
+
+export interface AppRestoreRequest {
+  type: 'app_restore_request';
+  appId: string;
+  commitHash: string;
+}
+
+export interface ShareAppCloudRequest {
+  type: 'share_app_cloud';
+  appId: string;
+}
+
+export interface ShareToSlackRequest {
+  type: 'share_to_slack';
+  appId: string;
+}
+
+export interface PublishPageRequest {
+  type: 'publish_page';
+  html: string;
+  title?: string;
+  appId?: string;
+}
+
+export interface UnpublishPageRequest {
+  type: 'unpublish_page';
+  deploymentId: string;
+}
+
+// === Server → Client ===
+
+export interface AppDataResponse {
+  type: 'app_data_response';
+  surfaceId: string;
+  callId: string;
+  success: boolean;
+  result?: unknown;
+  error?: string;
+}
+
+export interface AppUpdatePreviewResponse {
+  type: 'app_update_preview_response';
+  success: boolean;
+  appId: string;
+}
+
+export interface AppPreviewResponse {
+  type: 'app_preview_response';
+  appId: string;
+  preview?: string;
+}
+
+export interface AppsListResponse {
+  type: 'apps_list_response';
+  apps: Array<{
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    preview?: string;
+    createdAt: number;
+    version?: string;
+    contentId?: string;
+    appType?: string;
+  }>;
+}
+
+export interface HomeBaseGetResponse {
+  type: 'home_base_get_response';
+  homeBase: {
+    appId: string;
+    source: string;
+    starterTasks: string[];
+    onboardingTasks: string[];
+    preview: {
+      title: string;
+      subtitle: string;
+      description: string;
+      icon: string;
+      metrics: Array<{ label: string; value: string }>;
+    };
+  } | null;
+}
+
+export interface SharedAppsListResponse {
+  type: 'shared_apps_list_response';
+  apps: Array<{
+    uuid: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    preview?: string;
+    entry: string;
+    trustTier: string;
+    signerDisplayName?: string;
+    bundleSizeBytes: number;
+    installedAt: string;
+    version?: string;
+    contentId?: string;
+    updateAvailable?: boolean;
+  }>;
+}
+
+export interface SharedAppDeleteResponse {
+  type: 'shared_app_delete_response';
+  success: boolean;
+}
+
+export interface ForkSharedAppResponse {
+  type: 'fork_shared_app_response';
+  success: boolean;
+  appId?: string;
+  name?: string;
+  error?: string;
+}
+
+export interface BundleAppResponse {
+  type: 'bundle_app_response';
+  bundlePath: string;
+  manifest: {
+    format_version: number;
+    name: string;
+    description?: string;
+    icon?: string;
+    created_at: string;
+    created_by: string;
+    entry: string;
+    capabilities: string[];
+    version?: string;
+    content_id?: string;
+  };
+}
+
+export interface OpenBundleResponse {
+  type: 'open_bundle_response';
+  manifest: {
+    format_version: number;
+    name: string;
+    description?: string;
+    icon?: string;
+    created_at: string;
+    created_by: string;
+    entry: string;
+    capabilities: string[];
+  };
+  scanResult: {
+    passed: boolean;
+    blocked: string[];
+    warnings: string[];
+  };
+  signatureResult: {
+    trustTier: 'verified' | 'signed' | 'unsigned' | 'tampered';
+    signerKeyId?: string;
+    signerDisplayName?: string;
+    signerAccount?: string;
+  };
+  bundleSizeBytes: number;
+}
+
+export interface SignBundlePayloadRequest {
+  type: 'sign_bundle_payload';
+  requestId: string;
+  payload: string;
+}
+
+export interface GetSigningIdentityRequest {
+  type: 'get_signing_identity';
+  requestId: string;
+}
+
+export interface ShareAppCloudResponse {
+  type: 'share_app_cloud_response';
+  success: boolean;
+  shareToken?: string;
+  shareUrl?: string;
+  error?: string;
+}
+
+export interface GalleryListResponse {
+  type: 'gallery_list_response';
+  gallery: GalleryManifest;
+}
+
+export interface GalleryInstallResponse {
+  type: 'gallery_install_response';
+  success: boolean;
+  appId?: string;
+  name?: string;
+  error?: string;
+}
+
+export interface AppHistoryResponse {
+  type: 'app_history_response';
+  appId: string;
+  versions: Array<{
+    commitHash: string;
+    message: string;
+    timestamp: number;
+  }>;
+}
+
+export interface AppDiffResponse {
+  type: 'app_diff_response';
+  appId: string;
+  diff: string;
+}
+
+export interface AppFileAtVersionResponse {
+  type: 'app_file_at_version_response';
+  appId: string;
+  path: string;
+  content: string;
+}
+
+export interface AppRestoreResponse {
+  type: 'app_restore_response';
+  success: boolean;
+  error?: string;
+}
+
+export interface ShareToSlackResponse {
+  type: 'share_to_slack_response';
+  success: boolean;
+  error?: string;
+}
+
+export interface PublishPageResponse {
+  type: 'publish_page_response';
+  success: boolean;
+  publicUrl?: string;
+  deploymentId?: string;
+  error?: string;
+}
+
+export interface UnpublishPageResponse {
+  type: 'unpublish_page_response';
+  success: boolean;
+  error?: string;
+}
+
+export interface AppFilesChanged {
+  type: 'app_files_changed';
+  appId: string;
+}

package/src/daemon/ipc-contract/browser.ts

@@ -0,0 +1,74 @@
+// Browser interaction types.
+
+export interface BrowserFrame {
+  type: 'browser_frame';
+  sessionId: string;
+  surfaceId: string;
+  frame: string; // base64 JPEG
+  metadata?: { offsetTop: number; pageScaleFactor: number; scrollOffsetX: number; scrollOffsetY: number; timestamp: number };
+}
+
+export interface BrowserCDPRequest {
+  type: 'browser_cdp_request';
+  sessionId: string;
+}
+
+export interface BrowserCDPResponse {
+  type: 'browser_cdp_response';
+  sessionId: string;
+  success: boolean;
+  declined?: boolean;
+}
+
+export interface BrowserUserClick {
+  type: 'browser_user_click';
+  sessionId: string;
+  surfaceId: string;
+  x: number;
+  y: number;
+  button?: 'left' | 'right';
+  doubleClick?: boolean;
+}
+
+export interface BrowserUserScroll {
+  type: 'browser_user_scroll';
+  sessionId: string;
+  surfaceId: string;
+  deltaX: number;
+  deltaY: number;
+  x: number;
+  y: number;
+}
+
+export interface BrowserUserKeypress {
+  type: 'browser_user_keypress';
+  sessionId: string;
+  surfaceId: string;
+  key: string;
+  modifiers?: string[];
+}
+
+export interface BrowserInteractiveMode {
+  type: 'browser_interactive_mode';
+  sessionId: string;
+  surfaceId: string;
+  enabled: boolean;
+}
+
+export interface BrowserInteractiveModeChanged {
+  type: 'browser_interactive_mode_changed';
+  sessionId: string;
+  surfaceId: string;
+  enabled: boolean;
+  reason?: string;
+  message?: string;
+}
+
+export interface BrowserHandoffRequest {
+  type: 'browser_handoff_request';
+  sessionId: string;
+  surfaceId: string;
+  reason: 'auth' | 'checkout' | 'captcha' | 'custom';
+  message: string;
+  bringToFront?: boolean;
+}