builder.io 1.6.29 → 1.6.31

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,9 +1,20 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
 import { type Credentials } from "./credentials";
-import type { CodegenTurn, CustomInstruction, GenerateCompletionStep, GenerateUserMessage, UserContext } from "$/ai-utils";
+import type { CodegenTurn, CustomInstruction, GenerateCompletionState, GenerateCompletionStep, GenerateUserMessage, UserContext } from "$/ai-utils";
 import prettier from "prettier";
-type State = "unknown" | "initial-with-url" | "initial-without-url" | "generating" | "success" | "abort" | "error";
+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;
+}
 export interface SessionContext {
     sessionId: string;
     turns: CodegenTurn[];
@@ -11,7 +22,11 @@ export interface SessionContext {
     customInstructions: CustomInstruction[];
     userContext: UserContext;
     prettierConfig: prettier.Config | null;
-    state: State;
+    state: GenerateCompletionState;
+    title: string | undefined;
+    beforeCommit: string | undefined;
+    createdUnixTime: number;
+    updatedUnixTime: number;
 }
 export interface CodeGenSessionOptionsBase {
     sys: DevToolsSys;
@@ -23,6 +38,7 @@ export interface CodeGenSessionOptionsBase {
     fusionRemote?: string;
     fusionAutoInitGit?: boolean;
     featureBranch?: string;
+    providedToolContext?: ProvidedToolContext;
 }
 export interface CodeGenSessionOptionsSession extends CodeGenSessionOptionsBase {
     sessionOrCompletionId?: string;
@@ -78,23 +94,28 @@ export declare class CodeGenSession {
      */
     undoLastUserMessage(dryRun?: boolean): Promise<string[] | null>;
     getLastCompletionId(): string | undefined;
-    getCurrentState(): State;
+    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;
+    lastTurnHasChanges(): Promise<boolean>;
     sendMessage(message: GenerateUserMessage): void;
     getTurns(): CodegenTurn[];
     getSessionContext(): SessionContext;
     abort(): void;
     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>;
+    agentCompletion(userMessage: GenerateUserMessage, signal: AbortSignal | undefined, onStep: (step: GenerateCompletionStep) => void): Promise<void>;
+    commitWorkInProgress(lastTurn: CodegenTurn): Promise<string | undefined>;
+    /**
+     * Returns true if the last turn's afterCommit (or beforeCommit) is different from the session's beforeCommit.
+     */
+    hasChanges(): boolean;
+    isCleanWorkTree(): Promise<boolean>;
 }
 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,38 +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;
-    /** Enable Fusion side-car branch workflow */
-    fusion?: boolean;
-    /** Remote URL for Fusion side-car branch storage */
-    fusionRemote?: string;
-    /** Auto-commit changes when session ends (for Fusion) */
-    fusionAutoCommit?: boolean;
     /** Auto-initialize a git repository if none exists (for Fusion) */
     fusionAutoInitGit?: boolean;
-    /** Push changes to origin after squash merge (for Fusion) */
-    fusionPushToOrigin?: boolean;
 }

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

@@ -0,0 +1,62 @@
+import type { EnsureConfigResult } from "types";
+export declare const GIT_APP_FOLDER = "code";
+export declare const LOGS_FILE_PATH: string;
+export declare const STATUS_FILE_PATH: string;
+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;
+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,43 @@
+import type { ChildProcessWithoutNullStreams } from "child_process";
+/**
+ * Initialize logging by wrapping all console methods to write to logs file
+ */
+export declare function initializeLogging(): 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

@@ -37,14 +37,8 @@ type SocketEvents = {
     "socket-error": (socketId: string, error: Error) => Promise<void> | void;
     close: () => Promise<void> | void;
 };
-export declare function Server(opts: ServerOptions): {
+export declare function RPCWebSocketServer(opts: ServerOptions): {
     on: <EventKey extends keyof SocketEvents>(event: EventKey, cb: SocketEvents[EventKey]) => void;
-    of: (ns: string) => {
-        emit: (name: string, ...params: any[]) => void;
-        clients: () => Map<string, WebSocket>;
-        register: <T = any>(method: string, fn: RegisterFn<T>) => void;
-        event: (name: string) => void;
-    };
     event: (e: string) => void;
     handleUpgrade: (req: IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback?: (client: WebSocket, request: IncomingMessage) => void) => Promise<void>;
     clients: () => Map<string, WebSocket>;