@builder.io/dev-tools 1.19.14 → 1.20.1

package/types/cli/launch/InitStateMachine.d.ts

@@ -28,7 +28,7 @@ export declare class InitStateMachine {
     constructor(config: InitConfig);
     checkout(branchName: string, ref: string, repoPath: string): Promise<boolean>;
     execAsync(exec: string, args: string[], cwd?: string, retry?: number): Promise<string>;
-    git(args: string[], cwd?: string, retry?: number, timeout?: number): Promise<string>;
+    git(args: string[], cwd: string, retry?: number, timeout?: number): Promise<string>;
     performBackup({ sys, credentials, fusionConfig, volumePath, repositories, isConnectedToProvider, forcedFullBackup, }: {
         sys: DevToolsSys;
         credentials: Credentials;
@@ -67,6 +67,11 @@ export declare class InitStateMachine {
     private checkHostConnectivity;
     private checkConnectivityDirect;
     private checkConnectivityViaProxy;
+    /**
+     * Ensures the parent directory of the given path exists.
+     * Handles nested repo.path like "subdir/myproject".
+     */
+    private ensureParentDirExists;
     private cleanupLockFiles;
     validateGitRepo(repoPath: string): Promise<void>;
     /**

package/types/cli/launch/server.d.ts

@@ -11,6 +11,7 @@ export declare const NON_AUTHENTICATED_ENDPOINTS: {
     readonly PROXY_STATUS: "/proxy-status";
     readonly STATUS_V2: "/status-v2";
     readonly INIT_LOGS: "/init-logs";
+    readonly TUNNEL_STATUS: "/tunnel/status";
 };
 export declare const configureServer: ({ sys, app, validBuilderPrivateKey, authenticateProxy, isLocal, sharedState, }: {
     sys: DevToolsSys;

package/types/cli/launch/vscode-tunnel-manager.d.ts

@@ -0,0 +1,108 @@
+import { EventEmitter } from "events";
+/**
+ * VS Code Tunnel status
+ */
+export type TunnelStatus = "stopped" | "starting" | "running" | "error";
+/**
+ * VS Code Tunnel information
+ */
+export interface TunnelInfo {
+    status: TunnelStatus;
+    name: string | null;
+    url: string | null;
+    vscodeUri: string | null;
+    cursorUri: string | null;
+    webUrl: string | null;
+    error: string | null;
+    workspacePath: string;
+}
+/**
+ * Options for starting a VS Code tunnel
+ */
+export interface TunnelOptions {
+    name: string;
+    workspacePath?: string;
+    acceptLicense?: boolean;
+    autoRestart?: boolean;
+}
+/**
+ * VS Code Tunnel Manager
+ *
+ * Manages the lifecycle of a VS Code tunnel process, providing:
+ * - Start/stop functionality
+ * - URL parsing from CLI output
+ * - Health monitoring
+ * - Automatic restart on failure
+ * - Cleanup on shutdown
+ */
+export declare class VSCodeTunnelManager extends EventEmitter {
+    private process;
+    private status;
+    private tunnelName;
+    private tunnelUrl;
+    private error;
+    private workspacePath;
+    private autoRestart;
+    private restartAttempts;
+    private maxRestartAttempts;
+    private restartDelay;
+    private isShuttingDown;
+    constructor();
+    /**
+     * Start the VS Code tunnel
+     */
+    start(options: TunnelOptions): Promise<TunnelInfo>;
+    /**
+     * Spawn the tunnel process
+     */
+    private spawnTunnel;
+    /**
+     * Parse tunnel output to extract URL
+     */
+    private parseOutput;
+    /**
+     * Stop the VS Code tunnel
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current tunnel information
+     */
+    getInfo(): TunnelInfo;
+    /**
+     * Get tunnel status
+     */
+    getStatus(): TunnelStatus;
+    /**
+     * Check if tunnel is enabled
+     * Enabled by default for cloud environments, can be disabled with VSCODE_TUNNEL_ENABLED=false
+     */
+    static isEnabled(): boolean;
+    /**
+     * Check if auto-start is enabled
+     */
+    static isAutoStartEnabled(): boolean;
+    /**
+     * Get the configured tunnel name from environment or generate one
+     */
+    static getTunnelName(projectId?: string, branchName?: string): string;
+    /**
+     * Get the configured workspace path
+     */
+    static getWorkspacePath(): string;
+}
+/**
+ * Get the singleton tunnel manager instance
+ */
+export declare function getTunnelManager(): VSCodeTunnelManager;
+/**
+ * Generate VS Code deep link for a tunnel
+ */
+export declare function generateVSCodeDeepLink(tunnelName: string, workspacePath?: string): string;
+/**
+ * Generate Cursor deep link for a tunnel
+ */
+export declare function generateCursorDeepLink(tunnelName: string, workspacePath?: string): string;
+/**
+ * Generate web editor link for a tunnel
+ */
+export declare function generateWebEditorLink(tunnelName: string, workspacePath?: string): string;

package/types/cli/mcp-local.d.ts

@@ -11,6 +11,8 @@
 import type { ContentMessageItemImage, ContentMessageItemText, MCPClientStatus, MCPServerConfig } from "$/ai-utils";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import type { DevToolsSys } from "../core";
 export interface MCPServerStdioDefinition {
     name: string;
@@ -19,15 +21,25 @@ export interface MCPServerStdioDefinition {
     env?: Record<string, string>;
     envFile?: string;
 }
+export interface MCPServerRemoteDefinition {
+    name: string;
+    type: "http" | "sse";
+    url: string;
+    headers?: Record<string, string>;
+    envFile?: string;
+}
+export type MCPServerDefinition = MCPServerStdioDefinition | MCPServerRemoteDefinition;
 export interface MCPConfig {
-    mcpServers: Record<string, Omit<MCPServerStdioDefinition, "name">>;
+    mcpServers: Record<string, Omit<MCPServerStdioDefinition, "name"> | Omit<MCPServerRemoteDefinition, "name">>;
 }
 export interface LocalMCPClient {
     client: Client | undefined;
-    transport: StdioClientTransport | undefined;
+    transport: StdioClientTransport | SSEClientTransport | StreamableHTTPClientTransport | undefined;
     status: MCPClientStatus;
     serverName: string;
-    command: string;
+    serverType: "stdio" | "http" | "sse";
+    command?: string;
+    url?: string;
     resources?: {
         uri: string;
         name?: string;
@@ -61,15 +73,21 @@ export interface LocalMCPClientManager {
 /**
  * Create a local MCP client manager from server definitions
  */
-export declare function createLocalMCPClientManager(servers: MCPServerStdioDefinition[], sys: DevToolsSys, workingDirectory: string, signal?: AbortSignal): Promise<LocalMCPClientManager>;
+export declare function createLocalMCPClientManager(servers: MCPServerDefinition[], sys: DevToolsSys, workingDirectory: string, signal?: AbortSignal): Promise<LocalMCPClientManager>;
 /**
  * Apply environment variable substitution to MCP server configuration
  * This is separated from loadMCPConfig to allow easy unit testing
  */
 export declare function applyEnvSubstitution(serverConfig: Omit<MCPServerStdioDefinition, "name">, name: string, baseEnv: Record<string, string | undefined>, envFileVars: Record<string, string>): MCPServerStdioDefinition;
+/**
+ * Apply environment variable substitution to remote MCP server configuration
+ * This is separated from loadMCPConfig to allow easy unit testing
+ */
+export declare function applyEnvSubstitutionRemote(serverConfig: Omit<MCPServerRemoteDefinition, "name">, name: string, baseEnv: Record<string, string | undefined>, envFileVars: Record<string, string>): MCPServerRemoteDefinition;
 /**
  * Discover and load MCP configuration from working directory and fusionConfig
  * Servers from fusionConfig will be merged with servers from mcp.json
  * If a server with the same name exists in both, fusionConfig takes precedence
+ * Supports both stdio (command-based) and remote (http/sse) server definitions
  */
-export declare function loadMCPConfig(sys: DevToolsSys, workingDirectory: string, serverConfigs: MCPServerConfig, autoImportLocalMCPs: boolean): Promise<MCPServerStdioDefinition[]>;
+export declare function loadMCPConfig(sys: DevToolsSys, workingDirectory: string, serverConfigs: MCPServerConfig, autoImportLocalMCPs: boolean): Promise<MCPServerDefinition[]>;

package/types/cli/utils/env-substitution.d.ts

@@ -1,7 +1,8 @@
 /**
  * Substitutes environment variables in a string.
  * Replaces ${VAR_NAME} patterns with their corresponding values from the env object.
- * If a variable is not found in env, the pattern is left as-is.
+ * Supports default values with ${VAR_NAME:-default} syntax.
+ * If a variable is not found in env and no default is provided, the pattern is left as-is.
  *
  * @param str - The string containing environment variable patterns
  * @param env - A record of environment variable names to their values
@@ -18,5 +19,13 @@
  * @example
  * substituteEnvVars("Missing: ${UNKNOWN}", {})
  * // Returns: "Missing: ${UNKNOWN}"
+ *
+ * @example
+ * substituteEnvVars("URL: ${API_URL:-https://api.example.com}", {})
+ * // Returns: "URL: https://api.example.com"
+ *
+ * @example
+ * substituteEnvVars("URL: ${API_URL:-https://api.example.com}", { API_URL: "https://custom.com" })
+ * // Returns: "URL: https://custom.com"
  */
 export declare function substituteEnvVars(str: string, env: Record<string, string | undefined>): string;