builder.io 1.6.28 → 1.6.30

package/types/cli/code-tools.d.ts

@@ -1,5 +1,6 @@
 import type { CodeGenTools, ContentMessageItemToolResult, ProjectFile } from "$/ai-utils";
 import type { DevToolsSys } from "../core";
+import type { RunCommandCtx } from "./codegen";
 export interface LLMToolCalls {
     name: CodeGenTools;
     input: Record<string, any>;
@@ -10,10 +11,16 @@ export interface ToolResolution {
     isError: boolean;
     title?: string;
 }
-export declare function resolveToolCalls(sys: DevToolsSys, toolCalls: LLMToolCalls[]): Promise<{
-    toolResults: ContentMessageItemToolResult[];
-    projectFiles: ProjectFile[];
-}>;
+export interface ProvidedToolContext {
+    commandCtx?: RunCommandCtx;
+    allowedCommands?: RegExp[];
+}
+export interface ToolContext extends ProvidedToolContext {
+    sys: DevToolsSys;
+    files: ProjectFile[];
+    signal: AbortSignal | undefined;
+}
+export declare function resolveToolCalls(toolContext: ToolContext, toolCalls: LLMToolCalls[]): Promise<ContentMessageItemToolResult[]>;
 interface RipgrepMatch {
     path: string;
     lineNumber: number;

package/types/cli/codegen.d.ts

@@ -1,72 +1,111 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
 import { type Credentials } from "./credentials";
-import { type Checkpoint } from "./incremental-tsc";
-import type { ApplyActionsResult, Attachment, CodebaseSearchResponse, ContentMessageItemToolResult, CustomInstruction, GenerateCompletionStep, GenerateUserMessage, ProjectFile, UserContext } from "$/ai-utils";
+import type { CodegenTurn, CustomInstruction, GenerateCompletionState, GenerateCompletionStep, GenerateUserMessage, UserContext } from "$/ai-utils";
 import prettier from "prettier";
-interface Turn {
-    completionId: string;
-    nextUrl: string | undefined;
-    originalFiles: {
-        path: string;
-        content: Uint8Array | null;
-    }[];
-    isUserMessage: boolean;
-    toolResults: ContentMessageItemToolResult[];
-    sentiment?: "positive" | "negative" | "undo";
-    applyResults: ApplyActionsResult[];
-    projectFiles: ProjectFile[];
-    userInput: UserInput;
+import { type ProvidedToolContext } from "./code-tools";
+import type { ChildProcessWithoutNullStreams } from "child_process";
+export interface RunCommandCtx {
+    command: string;
+    getAllStdout: () => string;
+    getAllStderr: () => string;
+    getOutput: () => string;
+    pid: number | undefined;
+    process: ChildProcessWithoutNullStreams;
+    onStdout: (callback: (data: string) => void) => void;
+    onStderr: (callback: (data: string) => void) => void;
 }
-type State = "unknown" | "initial-with-url" | "initial-without-url" | "generating" | "success" | "abort" | "error";
 export interface SessionContext {
     sessionId: string;
-    turns: Turn[];
+    turns: CodegenTurn[];
     selectedFilePaths: Map<string, number>;
     customInstructions: CustomInstruction[];
     userContext: UserContext;
     prettierConfig: prettier.Config | null;
-    state: State;
+    state: GenerateCompletionState;
 }
-export interface UserInput {
-    userPrompt: string;
-    attachments: Attachment[];
-    sentiment: "positive" | "negative" | "undo";
-    files: ProjectFile[];
-    searchResponse: CodebaseSearchResponse | null;
-    rerankFiles?: number;
-    mostRelevantFile: string | null;
-    role: "user" | "agent";
+export interface CodeGenSessionOptionsBase {
+    sys: DevToolsSys;
+    credentials: Credentials;
+    args: CLIArgs;
+    position: string;
+    mode?: "quality" | "quality-v3" | "fast";
+    fusion?: boolean;
+    fusionRemote?: string;
+    fusionAutoInitGit?: boolean;
+    featureBranch?: string;
+    providedToolContext?: ProvidedToolContext;
 }
+export interface CodeGenSessionOptionsSession extends CodeGenSessionOptionsBase {
+    sessionOrCompletionId?: string;
+}
+export interface CodeGenSessionOptionsInitialUrl extends CodeGenSessionOptionsBase {
+    initialUrl: string;
+}
+export type CodeGenSessionOptions = CodeGenSessionOptionsSession | CodeGenSessionOptionsInitialUrl;
+export declare function createCodeSession(options: CodeGenSessionOptions): Promise<CodeGenSession>;
 export declare class CodeGenSession {
     #private;
-    constructor(sys: DevToolsSys, credentials: Credentials, args: CLIArgs, position: string, initialUrl?: string, mode?: "quality" | "quality-v3" | "fast");
+    constructor(options: CodeGenSessionOptions);
+    initializeSession(): Promise<void>;
+    /**
+     * Get the current commit hash
+     */
+    getCurrentCommitHash(): Promise<string | undefined>;
+    /**
+     * Get the feature branch name
+     */
+    getFeatureBranch(): string | undefined;
+    /**
+     * Get the AI branch name
+     */
+    getAiBranch(): string | undefined;
+    /**
+     * Helper to run git commands
+     */
+    runGitCommand(command: string): Promise<string>;
+    /**
+     * Check if Fusion is enabled for this session
+     */
+    isFusionEnabled(): boolean;
     setDebug(debug: boolean): void;
     getAllFiles(): Promise<string[]>;
     isNextPage(): boolean;
-    getSessionId(): Promise<string>;
+    getSessionId(): string;
     getSpaceId(): string | undefined;
-    undoLastUserMessage(dryRun?: boolean): Promise<string[]>;
+    /**
+     * Core function to restore the codebase to a state that matches a predicate.
+     * This is the main function that handles both git-based and file-based restoration.
+     *
+     * @param predicate Function that takes a turn and its index and returns true if we should restore up to that turn
+     * @param dryRun If true, only simulate the restoration without making changes
+     * @returns Array of file paths that were changed
+     */
+    restore(location: "before" | "after", predicate: (turn: CodegenTurn | null, index: number) => boolean, dryRun?: boolean): Promise<string[] | null>;
+    restoreHEAD(): Promise<string[] | null>;
+    restoreAll(): Promise<string[] | null>;
+    restoreBeforeCompletionId(completionId: string): Promise<string[] | null>;
+    /**
+     * Undo all changes back to the last user message
+     */
+    undoLastUserMessage(dryRun?: boolean): Promise<string[] | null>;
     getLastCompletionId(): string | undefined;
-    getCurrentState(): State;
-    getLastTurn(): Turn | undefined;
+    getCurrentState(): GenerateCompletionState;
+    getLastTurn(): CodegenTurn | undefined;
     getNextUrl(): string | undefined;
     getNextMessage(): Promise<GenerateUserMessage>;
     sendFeedback(sentiment: "positive" | "negative" | "undo", message?: string, lastCompletionId?: string | undefined): Promise<void>;
     hasUndoChanges(): Promise<boolean>;
-    isBusy(): boolean;
     sendMessage(message: GenerateUserMessage): void;
-    isEventLoopRunning(): boolean;
-    getTurns(): void;
-    getSessionContext(): Promise<SessionContext>;
+    getTurns(): CodegenTurn[];
+    getSessionContext(): SessionContext;
     abort(): void;
-    stopEventLoop(): void;
-    startEventLoop(onStep: (step: GenerateCompletionStep) => void): Promise<void>;
-    agentCompletion(userMessage: GenerateUserMessage, baselineCheckpoint: Checkpoint, signal: AbortSignal | undefined, onStep: (step: GenerateCompletionStep) => Promise<void> | void): Promise<Checkpoint>;
-    getUserInput(userMessage: GenerateUserMessage, signal: AbortSignal | undefined): Promise<UserInput>;
+    stopEventLoop(): Promise<void>;
+    close(): Promise<void>;
+    connectToEventLoop(shouldReplay: boolean, onStep: (step: GenerateCompletionStep) => void): () => void;
+    waitForEventLoop(): Promise<void>;
+    agentCompletion(userMessage: GenerateUserMessage, signal: AbortSignal | undefined, onStep: (step: GenerateCompletionStep) => Promise<void> | void): Promise<void>;
 }
-export declare const createSessionContext: (sys: DevToolsSys) => Promise<SessionContext>;
 export declare function transformStream(body: ReadableStream<Uint8Array> | null): AsyncGenerator<string, void, unknown>;
 export declare function getUserContext(sys: DevToolsSys): Promise<UserContext>;
 export declare function makeAsyncIterator<T>(): readonly [AsyncGenerator<T, void, void>, (event: T) => void, () => void];
-export {};

package/types/cli/index.d.ts

@@ -37,28 +37,8 @@ export interface CLIArgs {
     cwd?: string;
     /** Debug mode */
     debug?: boolean;
-    /** Port number for the dev server */
-    port?: number;
-    /** Port number for the dev server (shorthand) */
-    p?: number;
-    /** Dev server command to execute */
-    command?: string;
-    /** Dev server command to execute (shorthand) */
-    c?: string;
-    /** Skip authentication for testing purposes */
-    noAuth?: boolean;
-    /** Skip authentication for testing purposes (flag form) */
-    auth?: boolean;
-    /** Use development server instead of production for launch command */
-    dev?: boolean;
-    /** Skip browser auto-open */
-    noOpen?: boolean;
-    /** Skip browser auto-open (flag form) */
-    open?: boolean;
     /** Raw command line arguments */
     _: string[];
-    /** Silent mode for launch command */
-    silent?: boolean;
-    /** Fusion project ID */
-    projectId?: string;
+    /** Auto-initialize a git repository if none exists (for Fusion) */
+    fusionAutoInitGit?: boolean;
 }

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

@@ -0,0 +1,65 @@
+import type { EnsureConfigResult } from "types";
+export declare const GIT_APP_FOLDER = "code";
+export declare const transformVolumePath: (volumePath?: string) => string;
+export declare const navigateToVolumePath: (volumePath: string) => void;
+export declare const navigateToGitAppFolder: () => void;
+export type InstallOutcome = EnsureConfigResult["outcome"] | "install-failed";
+export type InstallStatus = {
+    timestamp: string;
+    outcome: InstallOutcome;
+    packageManager: string;
+    buildTool: string;
+    rootDir: string;
+    error: string | undefined;
+};
+export type LaunchStatus = {
+    jsxPlugin?: Partial<InstallStatus>;
+    devTools?: {
+        version?: string;
+    };
+    stash?: {
+        completed?: boolean;
+    };
+    dependencies?: {
+        installed?: boolean;
+        error?: string | undefined;
+    };
+    gitRepo?: {
+        exists?: boolean;
+        configured?: boolean;
+        repo?: string | undefined;
+        branch?: string;
+        error?: string | undefined;
+        current?: string | undefined;
+        expected?: string | undefined;
+    };
+    gitUser?: {
+        configured?: boolean;
+    };
+    gitDirectory?: {
+        exists?: boolean;
+        creating?: boolean;
+    };
+    volumeDirectory?: {
+        exists?: boolean;
+    };
+    args?: {
+        repoFullName?: string;
+        branchName?: string;
+        volumePath?: string;
+    };
+    initialization?: {
+        started?: boolean;
+        timestamp?: string;
+        completed?: boolean;
+        success?: boolean;
+        error?: string;
+    };
+};
+export declare const updateStatus: <T extends keyof LaunchStatus>(key: T, value: Partial<LaunchStatus[T]>) => void;
+/**
+ * This path is derived from the logs file path, which is set by `initializeLogging`.
+ * Therefore make sure that `initializeLogging` has been called before calling this function.
+ */
+export declare const getBuilderStatusFilePath: () => string;
+export declare const getConfigStatus: () => LaunchStatus;

package/types/cli/launch/install-jsx-plugin.d.ts

@@ -1,7 +1,7 @@
 import type { DevToolsSys } from "@builder.io/dev-tools/core";
-import type { CLIArgs } from "../index";
-import type { EnsureConfigResult } from "types";
-export type InstallOutcome = EnsureConfigResult["outcome"] | "install-failed";
-export declare const installJsxPlugin: (sys: DevToolsSys, args: CLIArgs) => Promise<{
+import { type InstallOutcome } from "./helpers";
+export declare const installJsxPlugin: (sys: DevToolsSys) => Promise<{
+    timestamp: string;
     installOutcome: InstallOutcome;
+    error: string | undefined;
 }>;

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

@@ -0,0 +1,45 @@
+import type { ChildProcessWithoutNullStreams } from "child_process";
+/**
+ * Initialize logging by wrapping all console methods to write to logs file
+ */
+export declare function initializeLogging({ goToParentTimes, }?: {
+    goToParentTimes?: number;
+}): void;
+/**
+ * Reset console methods to their original state
+ */
+export declare function resetLogging(): void;
+/**
+ * Capture and log child process output
+ */
+export declare function setupChildProcessLogging(childProcess: ChildProcessWithoutNullStreams, prefix: string): void;
+/**
+ * Display intro message with logging
+ */
+export declare const intro: (message: string) => void;
+/**
+ * Wrapped clack logging methods with file logging
+ */
+export declare const log: {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    error: (message: string) => void;
+    warn: (message: string) => void;
+    step: (message: string) => void;
+    message: (message?: string, { symbol }?: import("@clack/prompts").LogMessageOptions) => void;
+    warning: (message: string) => void;
+};
+/**
+ * Display outro message with logging
+ */
+export declare const outro: (message: string) => void;
+/**
+ * Reads logs with pagination
+ * @param nextToken Line number to start reading from (0-indexed)
+ * @param limit Number of lines to read
+ * @returns Object containing logs array and next token
+ */
+export declare const readLogs: (nextToken?: number, limit?: number) => {
+    logs: string[];
+    nextToken: number | null;
+};

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

@@ -0,0 +1,9 @@
+import { type Express, type RequestHandler } from "express";
+export declare const BUILDER_ENDPOINT_PREFIX = "/_builder.io";
+export declare const BUILDER_API_ENDPOINT_PREFIX: string;
+export declare const configureServer: (app: Express) => void;
+export declare const serverAuthMiddleware: ({ validBuilderPrivateKey, authenticateProxy, }: {
+    validBuilderPrivateKey: string | undefined;
+    authenticateProxy: boolean;
+}) => RequestHandler;
+export declare const createLogAndConfigEndpoints: (app: Express) => void;

package/types/cli/launch-init.d.ts

@@ -0,0 +1,13 @@
+import type { DevToolsSys } from "@builder.io/dev-tools/core";
+import type { CLIArgs } from "./index";
+export interface InitArgs extends CLIArgs {
+    repoFullName?: string;
+    branchName?: string;
+    githubToken?: string;
+    installCommand?: string;
+    volumePath?: string;
+}
+export declare function runLaunchInitCommand({ args, sys, }: {
+    sys: DevToolsSys;
+    args: InitArgs;
+}): Promise<number>;

package/types/cli/launch.d.ts

@@ -1,7 +1,36 @@
 import type { DevToolsSys } from "@builder.io/dev-tools/core";
 import type { CLIArgs } from "./index";
+/**
+ * Large random-ish port number that is unlikely to be used
+ */
 export declare const PROXY_PORT = 48752;
+export interface LaunchArgs extends CLIArgs {
+    volumePath?: string;
+    /** Fusion project ID */
+    projectId?: string;
+    /** Silent mode for launch command */
+    silent?: boolean;
+    /** Port number for the dev server */
+    port?: number;
+    /** Port number for the dev server (shorthand) */
+    p?: number;
+    /** Dev server command to execute */
+    command?: string;
+    /** Dev server command to execute (shorthand) */
+    c?: string;
+    /** Use development server instead of production for launch command */
+    dev?: boolean;
+    /** Skip browser auto-open (flag form) */
+    open?: boolean;
+    /**
+     * Decides whether to skip authentication for the user's proxy server.
+     * Our own _builder.io/ endpoitns are always authenticated.
+     *
+     * @default false
+     */
+    authenticateProxy?: boolean;
+}
 export declare function runLaunchCommand({ sys, args, }: {
     sys: DevToolsSys;
-    args: CLIArgs;
-}): Promise<number>;
+    args: LaunchArgs;
+}): Promise<undefined>;

package/types/cli/server-ws.d.ts

@@ -0,0 +1,50 @@
+import type { Duplex } from "node:stream";
+import type { IncomingMessage } from "node:http";
+export type SocketRequest = {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: any;
+};
+export type SocketResponse<T = any> = {
+    id?: number | null;
+    jsonrpc: string;
+    result?: T;
+    notification?: string;
+    params?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+};
+export type SocketSendOptions = {
+    timeout?: number;
+};
+export type SocketQueue = {
+    type: "request" | "notification";
+    result?: SocketResponse["result"];
+    error?: SocketResponse["error"];
+};
+import type { ServerOptions } from "ws";
+import type { WebSocket } from "ws";
+type RegisterFn<T = any> = (params: T, socketId: string) => Promise<any> | any;
+type SocketEvents = {
+    listening: () => Promise<void> | void;
+    connection: (socket: WebSocket, socketId: string) => Promise<void> | void;
+    disconnection: (socketId: string) => Promise<void> | void;
+    error: (error: Error) => Promise<void> | void;
+    "socket-error": (socketId: string, error: Error) => Promise<void> | void;
+    close: () => Promise<void> | void;
+};
+export declare function RPCWebSocketServer(opts: ServerOptions): {
+    on: <EventKey extends keyof SocketEvents>(event: EventKey, cb: SocketEvents[EventKey]) => void;
+    event: (e: string) => void;
+    handleUpgrade: (req: IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback?: (client: WebSocket, request: IncomingMessage) => void) => Promise<void>;
+    clients: () => Map<string, WebSocket>;
+    register: <T = any>(method: string, fn: RegisterFn<T>) => void;
+    emit: (name: string, ...params: any[]) => void;
+    notify: (name: string, socketId: string, ...params: any[]) => void;
+    close: () => Promise<unknown>;
+};
+export {};