feat(cli): base44 code — terminal agent session over Base44 apps (builder + imported)

knip.json

@@ -11,7 +11,7 @@
         "tests/**/testkit/index.ts"
       ],
       "project": [
-        "src/**/*.ts",
+        "src/**/*.{ts,tsx}",
         "tests/**/*.ts"
       ],
       "ignore": [

packages/cli/infra/build.ts

@@ -1,4 +1,4 @@
-import { watch, copyFileSync, mkdirSync } from "node:fs";
+import { copyFileSync, mkdirSync, watch } from "node:fs";
 import type { BuildConfig } from "bun";
 import chalk from "chalk";
 
@@ -32,7 +32,10 @@ const copyBackendRuntime = () => {
   copyFileSync("./backend-runtime/exec.ts", `${outDir}/exec.ts`);
   // The import map and the module it points at must land next to main.ts —
   // function-manager.ts resolves the config relative to the wrapper.
-  copyFileSync("./backend-runtime/import-map.json", `${outDir}/import-map.json`);
+  copyFileSync(
+    "./backend-runtime/import-map.json",
+    `${outDir}/import-map.json`,
+  );
   copyFileSync(
     "./backend-runtime/base44-runtime.ts",
     `${outDir}/base44-runtime.ts`,
@@ -48,11 +51,30 @@ const copyBackendRuntime = () => {
 // runtime there.
 export const RUNTIME_EXTERNALS = ["miniflare", "esbuild", "@deno/loader"];
 
+// Ink's dev-only react-devtools bridge would otherwise land in the bundle as
+// an eager import of a package we don't ship; the code path is dead outside
+// DEV=true, so it compiles to an inert stub.
+const stubReactDevtools = {
+  name: "stub-react-devtools",
+  setup(build: { onResolve: Function; onLoad: Function }) {
+    build.onResolve({ filter: /^react-devtools-core$/ }, () => ({
+      path: "react-devtools-core-stub",
+      namespace: "stub",
+    }));
+    build.onLoad({ filter: /.*/, namespace: "stub" }, () => ({
+      contents: "export default {}; export const connectToDevTools = () => {};",
+      loader: "js",
+    }));
+  },
+};
+
 const runAllBuilds = async () => {
   const cli = await runBuild({
     entrypoints: ["./src/cli/index.ts"],
     outdir: "./dist/cli",
     external: RUNTIME_EXTERNALS,
+    // biome-ignore lint/suspicious/noExplicitAny: BunPlugin's setup type is stricter than the minimal stub needs
+    plugins: [stubReactDevtools as any],
   });
   const backendRuntimePath = copyBackendRuntime();
   return {

packages/cli/package.json

@@ -55,6 +55,7 @@
         "@types/ms": "^2.1.0",
         "@types/multer": "^2.0.0",
         "@types/node": "^22.10.5",
+        "@types/react": "^18",
         "@vercel/detect-agent": "^1.1.0",
         "chalk": "^5.6.2",
         "chokidar": "^5.0.0",
@@ -98,6 +99,9 @@
     "dependencies": {
         "@deno/loader": "https://npm.jsr.io/~/11/@jsr/deno__loader/0.5.0.tgz",
         "esbuild": "0.28.0",
-        "miniflare": "4.20260722.0"
+        "ink": "^5",
+        "ink-text-input": "^6",
+        "miniflare": "4.20260722.0",
+        "react": "^18"
     }
 }

packages/cli/src/cli/commands/code.ts

@@ -0,0 +1,106 @@
+import chalk from "chalk";
+import {
+  bootstrapBlankApp,
+  bootstrapBuilderApp,
+} from "@/cli/commands/imported/create.js";
+import {
+  runGenesisSession,
+  runInteractiveSession,
+} from "@/cli/commands/imported/session.js";
+import type { CLIContext, RunCommandResult } from "@/cli/types.js";
+import { Base44Command } from "@/cli/utils/index.js";
+import { InvalidInputError } from "@/core/errors.js";
+import { initAppContext } from "@/core/project/app-config.js";
+import { soleActiveBranchId } from "@/core/resources/imported/api.js";
+
+interface CodeOptions {
+  import?: boolean;
+  builder?: boolean;
+}
+
+async function codeAction(
+  _ctx: CLIContext,
+  options: CodeOptions,
+): Promise<RunCommandResult> {
+  if (process.stdout.isTTY !== true) {
+    throw new InvalidInputError(
+      "base44 code is an interactive session and needs a terminal.",
+    );
+  }
+  if (options.import && options.builder) {
+    throw new InvalidInputError(
+      "Pass either --builder or --import, not both (the default is --builder).",
+    );
+  }
+  const importMode = options.import === true;
+
+  // Inside a linked app project, open the session on that app; anywhere
+  // else, the first prompt creates one from scratch. Resolution must be the
+  // real app-context lookup — an existence glob is recursive and would match
+  // apps in SUBdirectories of an unlinked cwd.
+  let linked = false;
+  try {
+    await initAppContext();
+    linked = true;
+  } catch {
+    // Not a linked project — genesis mode below.
+  }
+  if (linked) {
+    const branchId = await soleActiveBranchId().catch(() => undefined);
+    await runInteractiveSession({
+      branchId,
+      footer: [],
+      primeFirstPoll: true,
+      idleHint: "what should the agent do next?",
+    });
+    return { outroMessage: "Done." };
+  }
+
+  // Genesis mode picks the app type: --builder (default) makes a normal Base44
+  // app (template + agent); --import makes an imported app (a repo, or
+  // /headless → Wix Headless). The choice is a header/footer label + which
+  // bootstrap runs; the session itself is identical either way.
+  const footer: string[] = [
+    importMode
+      ? chalk.dim(`${chalk.hex("#E86B3C")("●")} import`)
+      : chalk.dim(`${chalk.hex("#E86B3C")("●")} builder`),
+  ];
+  await runGenesisSession(
+    importMode
+      ? {
+          idleHint:
+            "describe the app, or import a repo — /headless for Wix Headless",
+          creatingLabel: "creating your repository and app",
+          modeLabel: "Import — your repo or /headless",
+          footer,
+          createApp: (prompt, emit) => bootstrapBlankApp(prompt, footer, emit),
+        }
+      : {
+          idleHint: "describe the app you want to build",
+          creatingLabel: "creating your app",
+          modeLabel: "Builder — Base44 template + agent",
+          footer,
+          createApp: (prompt, emit) =>
+            bootstrapBuilderApp(prompt, footer, emit),
+        },
+  );
+  return { outroMessage: "Done." };
+}
+
+export function getCodeCommand(): Base44Command {
+  const command = new Base44Command("code", { requireAppContext: false });
+  command
+    .description(
+      "Open Base44 Code: an interactive agent session — in an empty directory, your first prompt creates the app (default: the Base44 builder; --import for a repo / Wix Headless)",
+    )
+    .option(
+      "--builder",
+      "From scratch with the Base44 builder agent + template (default)",
+    )
+    .option(
+      "--import",
+      "Start from a GitHub repo, or /headless for Wix Headless, instead of the Base44 template",
+    )
+    .action(codeAction);
+  return command;
+}

packages/cli/src/cli/commands/imported/chat.ts

@@ -0,0 +1,111 @@
+import chalk from "chalk";
+import { expandPrompt } from "@/cli/commands/imported/expansions.js";
+import {
+  createTurnStream,
+  terminalLink,
+} from "@/cli/commands/imported/render.js";
+import { runInteractiveSession } from "@/cli/commands/imported/session.js";
+import type { CLIContext, RunCommandResult } from "@/cli/types.js";
+import { Base44Command } from "@/cli/utils/index.js";
+import { getBase44ApiUrl } from "@/core/config.js";
+import { getAppContext } from "@/core/project/app-config.js";
+import type { ImportedChatTurn } from "@/core/resources/imported/api.js";
+import {
+  sendImportedChatMessage,
+  soleActiveBranchId,
+} from "@/core/resources/imported/api.js";
+import { streamConversationDuring } from "@/core/resources/imported/stream.js";
+
+function lastAssistantReply(turn: ImportedChatTurn): string | undefined {
+  const messages = turn.conversation?.messages ?? [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    if (typeof message.content === "string" && message.content.trim()) {
+      return message.content.trim();
+    }
+  }
+  return undefined;
+}
+
+function chatFooter(): string[] {
+  try {
+    const editorUrl = `${getBase44ApiUrl()}/apps/${getAppContext().id}/editor/preview`;
+    return [terminalLink("editor", editorUrl)];
+  } catch {
+    return [];
+  }
+}
+
+function turnOutro(turn: ImportedChatTurn): string {
+  const state = turn.status?.state ?? "ready";
+  if (state === "error") {
+    return `Turn failed (${turn.status?.error_source ?? "unknown"}) — see the editor for details.`;
+  }
+  return "Turn finished.";
+}
+
+async function chatAction(
+  { runTask, jsonMode, branchId: explicitBranchId }: CLIContext,
+  message: string,
+): Promise<RunCommandResult> {
+  message = expandPrompt(message).text;
+  // Messages must land on the app's working branch: an unscoped send goes to
+  // the main line, whose sandbox is separate and never pushed.
+  const branchId =
+    explicitBranchId ?? (await soleActiveBranchId().catch(() => undefined));
+
+  if (jsonMode) {
+    const turn = await runTask("Agent working (a turn can take minutes)", () =>
+      sendImportedChatMessage(message, branchId),
+    );
+    if (turn.queued) return { stdout: `${JSON.stringify({ queued: true })}\n` };
+    return {
+      stdout: `${JSON.stringify({
+        status: turn.status?.state ?? "ready",
+        error_source: turn.status?.error_source ?? null,
+        reply: lastAssistantReply(turn) ?? null,
+      })}\n`,
+    };
+  }
+
+  if (process.stdout.isTTY !== true) {
+    const stream = createTurnStream(false);
+    let turn: ImportedChatTurn;
+    try {
+      turn = await streamConversationDuring(
+        () => sendImportedChatMessage(message, branchId),
+        stream.onEvent,
+        { branchId },
+      );
+    } finally {
+      stream.stop();
+    }
+    if (turn.queued) {
+      return {
+        outroMessage:
+          "The agent is busy with an earlier message — yours was queued and will run next.",
+      };
+    }
+    return { outroMessage: turnOutro(turn) };
+  }
+
+  await runInteractiveSession({
+    branchId,
+    footer: chatFooter(),
+    primeFirstPoll: true,
+    initialMessage: message,
+  });
+  return { outroMessage: "Done." };
+}
+
+export function getImportedChatCommand(): Base44Command {
+  const command = new Base44Command("chat", { supportsBranch: true });
+  command
+    .description(
+      "Open an interactive agent session on the app, starting with this message",
+    )
+    .argument("<message>", "What you want the agent to do")
+    .action(chatAction);
+  return command;
+}