move pi-mono into companion-cloud as apps/companion-os

- Copy all pi-mono source into apps/companion-os/
- Update Dockerfile to COPY pre-built binary instead of downloading from GitHub Releases
- Update deploy-staging.yml to build pi from source (bun compile) before Docker build
- Add apps/companion-os/** to path triggers
- No more cross-repo dispatch needed

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

packages/coding-agent/src/cli/args.ts

@@ -0,0 +1,334 @@
+/**
+ * CLI argument parsing and help display
+ */
+
+import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
+import chalk from "chalk";
+import { APP_NAME, CONFIG_DIR_NAME, ENV_AGENT_DIR } from "../config.js";
+import { allTools, type ToolName } from "../core/tools/index.js";
+
+export type Mode = "text" | "json" | "rpc";
+
+export interface Args {
+  provider?: string;
+  model?: string;
+  apiKey?: string;
+  systemPrompt?: string;
+  appendSystemPrompt?: string;
+  thinking?: ThinkingLevel;
+  continue?: boolean;
+  resume?: boolean;
+  help?: boolean;
+  version?: boolean;
+  mode?: Mode;
+  noSession?: boolean;
+  session?: string;
+  sessionDir?: string;
+  models?: string[];
+  tools?: ToolName[];
+  noTools?: boolean;
+  extensions?: string[];
+  noExtensions?: boolean;
+  print?: boolean;
+  export?: string;
+  noSkills?: boolean;
+  skills?: string[];
+  promptTemplates?: string[];
+  noPromptTemplates?: boolean;
+  themes?: string[];
+  noThemes?: boolean;
+  listModels?: string | true;
+  offline?: boolean;
+  verbose?: boolean;
+  messages: string[];
+  fileArgs: string[];
+  /** Unknown flags (potentially extension flags) - map of flag name to value */
+  unknownFlags: Map<string, boolean | string>;
+}
+
+const VALID_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+
+export function isValidThinkingLevel(level: string): level is ThinkingLevel {
+  return VALID_THINKING_LEVELS.includes(level as ThinkingLevel);
+}
+
+export function parseArgs(
+  args: string[],
+  extensionFlags?: Map<string, { type: "boolean" | "string" }>,
+): Args {
+  const result: Args = {
+    messages: [],
+    fileArgs: [],
+    unknownFlags: new Map(),
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === "--help" || arg === "-h") {
+      result.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      result.version = true;
+    } else if (arg === "--mode" && i + 1 < args.length) {
+      const mode = args[++i];
+      if (mode === "text" || mode === "json" || mode === "rpc") {
+        result.mode = mode;
+      }
+    } else if (arg === "--continue" || arg === "-c") {
+      result.continue = true;
+    } else if (arg === "--resume" || arg === "-r") {
+      result.resume = true;
+    } else if (arg === "--provider" && i + 1 < args.length) {
+      result.provider = args[++i];
+    } else if (arg === "--model" && i + 1 < args.length) {
+      result.model = args[++i];
+    } else if (arg === "--api-key" && i + 1 < args.length) {
+      result.apiKey = args[++i];
+    } else if (arg === "--system-prompt" && i + 1 < args.length) {
+      result.systemPrompt = args[++i];
+    } else if (arg === "--append-system-prompt" && i + 1 < args.length) {
+      result.appendSystemPrompt = args[++i];
+    } else if (arg === "--no-session") {
+      result.noSession = true;
+    } else if (arg === "--session" && i + 1 < args.length) {
+      result.session = args[++i];
+    } else if (arg === "--session-dir" && i + 1 < args.length) {
+      result.sessionDir = args[++i];
+    } else if (arg === "--models" && i + 1 < args.length) {
+      result.models = args[++i].split(",").map((s) => s.trim());
+    } else if (arg === "--no-tools") {
+      result.noTools = true;
+    } else if (arg === "--tools" && i + 1 < args.length) {
+      const toolNames = args[++i].split(",").map((s) => s.trim());
+      const validTools: ToolName[] = [];
+      for (const name of toolNames) {
+        if (name in allTools) {
+          validTools.push(name as ToolName);
+        } else {
+          console.error(
+            chalk.yellow(
+              `Warning: Unknown tool "${name}". Valid tools: ${Object.keys(allTools).join(", ")}`,
+            ),
+          );
+        }
+      }
+      result.tools = validTools;
+    } else if (arg === "--thinking" && i + 1 < args.length) {
+      const level = args[++i];
+      if (isValidThinkingLevel(level)) {
+        result.thinking = level;
+      } else {
+        console.error(
+          chalk.yellow(
+            `Warning: Invalid thinking level "${level}". Valid values: ${VALID_THINKING_LEVELS.join(", ")}`,
+          ),
+        );
+      }
+    } else if (arg === "--print" || arg === "-p") {
+      result.print = true;
+    } else if (arg === "--export" && i + 1 < args.length) {
+      result.export = args[++i];
+    } else if ((arg === "--extension" || arg === "-e") && i + 1 < args.length) {
+      result.extensions = result.extensions ?? [];
+      result.extensions.push(args[++i]);
+    } else if (arg === "--no-extensions" || arg === "-ne") {
+      result.noExtensions = true;
+    } else if (arg === "--skill" && i + 1 < args.length) {
+      result.skills = result.skills ?? [];
+      result.skills.push(args[++i]);
+    } else if (arg === "--prompt-template" && i + 1 < args.length) {
+      result.promptTemplates = result.promptTemplates ?? [];
+      result.promptTemplates.push(args[++i]);
+    } else if (arg === "--theme" && i + 1 < args.length) {
+      result.themes = result.themes ?? [];
+      result.themes.push(args[++i]);
+    } else if (arg === "--no-skills" || arg === "-ns") {
+      result.noSkills = true;
+    } else if (arg === "--no-prompt-templates" || arg === "-np") {
+      result.noPromptTemplates = true;
+    } else if (arg === "--no-themes") {
+      result.noThemes = true;
+    } else if (arg === "--list-models") {
+      // Check if next arg is a search pattern (not a flag or file arg)
+      if (
+        i + 1 < args.length &&
+        !args[i + 1].startsWith("-") &&
+        !args[i + 1].startsWith("@")
+      ) {
+        result.listModels = args[++i];
+      } else {
+        result.listModels = true;
+      }
+    } else if (arg === "--verbose") {
+      result.verbose = true;
+    } else if (arg === "--offline") {
+      result.offline = true;
+    } else if (arg.startsWith("@")) {
+      result.fileArgs.push(arg.slice(1)); // Remove @ prefix
+    } else if (arg.startsWith("--") && extensionFlags) {
+      // Check if it's an extension-registered flag
+      const flagName = arg.slice(2);
+      const extFlag = extensionFlags.get(flagName);
+      if (extFlag) {
+        if (extFlag.type === "boolean") {
+          result.unknownFlags.set(flagName, true);
+        } else if (extFlag.type === "string" && i + 1 < args.length) {
+          result.unknownFlags.set(flagName, args[++i]);
+        }
+      }
+      // Unknown flags without extensionFlags are silently ignored (first pass)
+    } else if (!arg.startsWith("-")) {
+      result.messages.push(arg);
+    }
+  }
+
+  return result;
+}
+
+export function printHelp(): void {
+  console.log(`${chalk.bold(APP_NAME)} - AI coding assistant with read, bash, edit, write tools
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} [options] [@files...] [messages...]
+
+${chalk.bold("Commands:")}
+  ${APP_NAME} install <source> [-l]    Install extension source and add to settings
+ ${APP_NAME} remove <source> [-l]     Remove extension source from settings
+  ${APP_NAME} update [source]          Update installed extensions (skips pinned sources)
+  ${APP_NAME} list                     List installed extensions from settings
+  ${APP_NAME} gateway                  Run the always-on gateway process
+  ${APP_NAME} daemon                   Alias for gateway
+  ${APP_NAME} config                   Open TUI to enable/disable package resources
+  ${APP_NAME} <command> --help         Show help for install/remove/update/list
+
+${chalk.bold("Options:")}
+  --provider <name>              Provider name (default: google)
+  --model <pattern>              Model pattern or ID (supports "provider/id" and optional ":<thinking>")
+  --api-key <key>                API key (defaults to env vars)
+  --system-prompt <text>         System prompt (default: coding assistant prompt)
+  --append-system-prompt <text>  Append text or file contents to the system prompt
+  --mode <mode>                  Output mode: text (default), json, or rpc
+  --print, -p                    Non-interactive mode: process prompt and exit
+  --continue, -c                 Continue previous session
+  --resume, -r                   Select a session to resume
+  --session <path>               Use specific session file
+  --session-dir <dir>            Directory for session storage and lookup
+  --no-session                   Don't save session (ephemeral)
+  --models <patterns>            Comma-separated model patterns for Ctrl+P cycling
+                                 Supports globs (anthropic/*, *sonnet*) and fuzzy matching
+  --no-tools                     Disable all built-in tools
+  --tools <tools>                Comma-separated list of tools to enable (default: read,bash,edit,write)
+                                 Available: read, bash, edit, write, grep, find, ls
+  --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh
+  --extension, -e <path>         Load an extension file (can be used multiple times)
+  --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
+  --skill <path>                 Load a skill file or directory (can be used multiple times)
+  --no-skills, -ns               Disable skills discovery and loading
+  --prompt-template <path>       Load a prompt template file or directory (can be used multiple times)
+  --no-prompt-templates, -np     Disable prompt template discovery and loading
+  --theme <path>                 Load a theme file or directory (can be used multiple times)
+  --no-themes                    Disable theme discovery and loading
+  --export <file>                Export session file to HTML and exit
+  --list-models [search]         List available models (with optional fuzzy search)
+  --verbose                      Force verbose startup (overrides quietStartup setting)
+  --offline                      Disable startup network operations (same as PI_OFFLINE=1)
+  --help, -h                     Show this help
+  --version, -v                  Show version number
+
+Extensions can register additional flags (e.g., --plan from plan-mode extension).
+
+${chalk.bold("Examples:")}
+  # Interactive mode
+  ${APP_NAME}
+
+  # Interactive mode with initial prompt
+  ${APP_NAME} "List all .ts files in src/"
+
+  # Include files in initial message
+  ${APP_NAME} @prompt.md @image.png "What color is the sky?"
+
+  # Non-interactive mode (process and exit)
+  ${APP_NAME} -p "List all .ts files in src/"
+
+  # Multiple messages (interactive)
+  ${APP_NAME} "Read package.json" "What dependencies do we have?"
+
+  # Continue previous session
+  ${APP_NAME} --continue "What did we discuss?"
+
+  # Use different model
+  ${APP_NAME} --provider openai --model gpt-4o-mini "Help me refactor this code"
+
+  # Use model with provider prefix (no --provider needed)
+  ${APP_NAME} --model openai/gpt-4o "Help me refactor this code"
+
+  # Use model with thinking level shorthand
+  ${APP_NAME} --model sonnet:high "Solve this complex problem"
+
+  # Limit model cycling to specific models
+  ${APP_NAME} --models claude-sonnet,claude-haiku,gpt-4o
+
+  # Limit to a specific provider with glob pattern
+  ${APP_NAME} --models "github-copilot/*"
+
+  # Cycle models with fixed thinking levels
+  ${APP_NAME} --models sonnet:high,haiku:low
+
+  # Start with a specific thinking level
+  ${APP_NAME} --thinking high "Solve this complex problem"
+
+  # Read-only mode (no file modifications possible)
+  ${APP_NAME} --tools read,grep,find,ls -p "Review the code in src/"
+
+  # Export a session file to HTML
+  ${APP_NAME} --export ~/${CONFIG_DIR_NAME}/agent/sessions/--path--/session.jsonl
+  ${APP_NAME} --export session.jsonl output.html
+
+${chalk.bold("Environment Variables:")}
+  ANTHROPIC_API_KEY                - Anthropic Claude API key
+  ANTHROPIC_OAUTH_TOKEN            - Anthropic OAuth token (alternative to API key)
+  OPENAI_API_KEY                   - OpenAI GPT API key
+  AZURE_OPENAI_API_KEY             - Azure OpenAI API key
+  AZURE_OPENAI_BASE_URL            - Azure OpenAI base URL (https://{resource}.openai.azure.com/openai/v1)
+  AZURE_OPENAI_RESOURCE_NAME       - Azure OpenAI resource name (alternative to base URL)
+  AZURE_OPENAI_API_VERSION         - Azure OpenAI API version (default: v1)
+  AZURE_OPENAI_DEPLOYMENT_NAME_MAP - Azure OpenAI model=deployment map (comma-separated)
+  GEMINI_API_KEY                   - Google Gemini API key
+  GROQ_API_KEY                     - Groq API key
+  CEREBRAS_API_KEY                 - Cerebras API key
+  XAI_API_KEY                      - xAI Grok API key
+  OPENROUTER_API_KEY               - OpenRouter API key
+  AI_GATEWAY_API_KEY               - Vercel AI Gateway API key
+  ZAI_API_KEY                      - ZAI API key
+  MISTRAL_API_KEY                  - Mistral API key
+  MINIMAX_API_KEY                  - MiniMax API key
+  OPENCODE_API_KEY                 - OpenCode Zen/OpenCode Go API key
+  KIMI_API_KEY                     - Kimi For Coding API key
+  AWS_PROFILE                      - AWS profile for Amazon Bedrock
+  AWS_ACCESS_KEY_ID                - AWS access key for Amazon Bedrock
+  AWS_SECRET_ACCESS_KEY            - AWS secret key for Amazon Bedrock
+  AWS_BEARER_TOKEN_BEDROCK         - Bedrock API key (bearer token)
+  AWS_REGION                       - AWS region for Amazon Bedrock (e.g., us-east-1)
+  ${ENV_AGENT_DIR.padEnd(32)} - Session storage directory (default: ~/${CONFIG_DIR_NAME}/agent)
+  PI_PACKAGE_DIR                   - Override package directory (for Nix/Guix store paths)
+  PI_OFFLINE                       - Disable startup network operations when set to 1/true/yes
+  PI_SHARE_VIEWER_URL              - Base URL for /share command (default: https://pi.dev/session/)
+  PI_AI_ANTIGRAVITY_VERSION        - Override Antigravity User-Agent version (e.g., 1.23.0)
+
+${chalk.bold("Available Tools (default: read, bash, edit, write):")}
+  read   - Read file contents
+  bash   - Execute bash commands
+  edit   - Edit files with find/replace
+  write  - Write files (creates/overwrites)
+  grep   - Search file contents (read-only, off by default)
+  find   - Find files by glob pattern (read-only, off by default)
+  ls     - List directory contents (read-only, off by default)
+`);
+}

packages/coding-agent/src/cli/config-selector.ts

@@ -0,0 +1,57 @@
+/**
+ * TUI config selector for `pi config` command
+ */
+
+import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
+import type { ResolvedPaths } from "../core/package-manager.js";
+import type { SettingsManager } from "../core/settings-manager.js";
+import { ConfigSelectorComponent } from "../modes/interactive/components/config-selector.js";
+import {
+  initTheme,
+  stopThemeWatcher,
+} from "../modes/interactive/theme/theme.js";
+
+export interface ConfigSelectorOptions {
+  resolvedPaths: ResolvedPaths;
+  settingsManager: SettingsManager;
+  cwd: string;
+  agentDir: string;
+}
+
+/** Show TUI config selector and return when closed */
+export async function selectConfig(
+  options: ConfigSelectorOptions,
+): Promise<void> {
+  // Initialize theme before showing TUI
+  initTheme(options.settingsManager.getTheme(), true);
+
+  return new Promise((resolve) => {
+    const ui = new TUI(new ProcessTerminal());
+    let resolved = false;
+
+    const selector = new ConfigSelectorComponent(
+      options.resolvedPaths,
+      options.settingsManager,
+      options.cwd,
+      options.agentDir,
+      () => {
+        if (!resolved) {
+          resolved = true;
+          ui.stop();
+          stopThemeWatcher();
+          resolve();
+        }
+      },
+      () => {
+        ui.stop();
+        stopThemeWatcher();
+        process.exit(0);
+      },
+      () => ui.requestRender(),
+    );
+
+    ui.addChild(selector);
+    ui.setFocus(selector.getResourceList());
+    ui.start();
+  });
+}

packages/coding-agent/src/cli/file-processor.ts

@@ -0,0 +1,105 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+
+import { access, readFile, stat } from "node:fs/promises";
+import type { ImageContent } from "@mariozechner/pi-ai";
+import chalk from "chalk";
+import { resolve } from "path";
+import { resolveReadPath } from "../core/tools/path-utils.js";
+import { formatDimensionNote, resizeImage } from "../utils/image-resize.js";
+import { detectSupportedImageMimeTypeFromFile } from "../utils/mime.js";
+
+export interface ProcessedFiles {
+  text: string;
+  images: ImageContent[];
+}
+
+export interface ProcessFileOptions {
+  /** Whether to auto-resize images to 2000x2000 max. Default: true */
+  autoResizeImages?: boolean;
+}
+
+/** Process @file arguments into text content and image attachments */
+export async function processFileArguments(
+  fileArgs: string[],
+  options?: ProcessFileOptions,
+): Promise<ProcessedFiles> {
+  const autoResizeImages = options?.autoResizeImages ?? true;
+  let text = "";
+  const images: ImageContent[] = [];
+
+  for (const fileArg of fileArgs) {
+    // Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
+    const absolutePath = resolve(resolveReadPath(fileArg, process.cwd()));
+
+    // Check if file exists
+    try {
+      await access(absolutePath);
+    } catch {
+      console.error(chalk.red(`Error: File not found: ${absolutePath}`));
+      process.exit(1);
+    }
+
+    // Check if file is empty
+    const stats = await stat(absolutePath);
+    if (stats.size === 0) {
+      // Skip empty files
+      continue;
+    }
+
+    const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
+
+    if (mimeType) {
+      // Handle image file
+      const content = await readFile(absolutePath);
+      const base64Content = content.toString("base64");
+
+      let attachment: ImageContent;
+      let dimensionNote: string | undefined;
+
+      if (autoResizeImages) {
+        const resized = await resizeImage({
+          type: "image",
+          data: base64Content,
+          mimeType,
+        });
+        dimensionNote = formatDimensionNote(resized);
+        attachment = {
+          type: "image",
+          mimeType: resized.mimeType,
+          data: resized.data,
+        };
+      } else {
+        attachment = {
+          type: "image",
+          mimeType,
+          data: base64Content,
+        };
+      }
+
+      images.push(attachment);
+
+      // Add text reference to image with optional dimension note
+      if (dimensionNote) {
+        text += `<file name="${absolutePath}">${dimensionNote}</file>\n`;
+      } else {
+        text += `<file name="${absolutePath}"></file>\n`;
+      }
+    } else {
+      // Handle text file
+      try {
+        const content = await readFile(absolutePath, "utf-8");
+        text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(
+          chalk.red(`Error: Could not read file ${absolutePath}: ${message}`),
+        );
+        process.exit(1);
+      }
+    }
+  }
+
+  return { text, images };
+}

packages/coding-agent/src/cli/list-models.ts

@@ -0,0 +1,126 @@
+/**
+ * List available models with optional fuzzy search
+ */
+
+import type { Api, Model } from "@mariozechner/pi-ai";
+import { fuzzyFilter } from "@mariozechner/pi-tui";
+import type { ModelRegistry } from "../core/model-registry.js";
+
+/**
+ * Format a number as human-readable (e.g., 200000 -> "200K", 1000000 -> "1M")
+ */
+function formatTokenCount(count: number): string {
+  if (count >= 1_000_000) {
+    const millions = count / 1_000_000;
+    return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+  }
+  if (count >= 1_000) {
+    const thousands = count / 1_000;
+    return thousands % 1 === 0 ? `${thousands}K` : `${thousands.toFixed(1)}K`;
+  }
+  return count.toString();
+}
+
+/**
+ * List available models, optionally filtered by search pattern
+ */
+export async function listModels(
+  modelRegistry: ModelRegistry,
+  searchPattern?: string,
+): Promise<void> {
+  const models = modelRegistry.getAvailable();
+
+  if (models.length === 0) {
+    console.log("No models available. Set API keys in environment variables.");
+    return;
+  }
+
+  // Apply fuzzy filter if search pattern provided
+  let filteredModels: Model<Api>[] = models;
+  if (searchPattern) {
+    filteredModels = fuzzyFilter(
+      models,
+      searchPattern,
+      (m) => `${m.provider} ${m.id}`,
+    );
+  }
+
+  if (filteredModels.length === 0) {
+    console.log(`No models matching "${searchPattern}"`);
+    return;
+  }
+
+  // Sort by provider, then by model id
+  filteredModels.sort((a, b) => {
+    const providerCmp = a.provider.localeCompare(b.provider);
+    if (providerCmp !== 0) return providerCmp;
+    return a.id.localeCompare(b.id);
+  });
+
+  // Calculate column widths
+  const rows = filteredModels.map((m) => ({
+    provider: m.provider,
+    model: m.id,
+    context: formatTokenCount(m.contextWindow),
+    maxOut: formatTokenCount(m.maxTokens),
+    thinking: m.reasoning ? "yes" : "no",
+    images: m.input.includes("image") ? "yes" : "no",
+  }));
+
+  const headers = {
+    provider: "provider",
+    model: "model",
+    context: "context",
+    maxOut: "max-out",
+    thinking: "thinking",
+    images: "images",
+  };
+
+  const widths = {
+    provider: Math.max(
+      headers.provider.length,
+      ...rows.map((r) => r.provider.length),
+    ),
+    model: Math.max(headers.model.length, ...rows.map((r) => r.model.length)),
+    context: Math.max(
+      headers.context.length,
+      ...rows.map((r) => r.context.length),
+    ),
+    maxOut: Math.max(
+      headers.maxOut.length,
+      ...rows.map((r) => r.maxOut.length),
+    ),
+    thinking: Math.max(
+      headers.thinking.length,
+      ...rows.map((r) => r.thinking.length),
+    ),
+    images: Math.max(
+      headers.images.length,
+      ...rows.map((r) => r.images.length),
+    ),
+  };
+
+  // Print header
+  const headerLine = [
+    headers.provider.padEnd(widths.provider),
+    headers.model.padEnd(widths.model),
+    headers.context.padEnd(widths.context),
+    headers.maxOut.padEnd(widths.maxOut),
+    headers.thinking.padEnd(widths.thinking),
+    headers.images.padEnd(widths.images),
+  ].join("  ");
+  console.log(headerLine);
+
+  // Print rows
+  for (const row of rows) {
+    const line = [
+      row.provider.padEnd(widths.provider),
+      row.model.padEnd(widths.model),
+      row.context.padEnd(widths.context),
+      row.maxOut.padEnd(widths.maxOut),
+      row.thinking.padEnd(widths.thinking),
+      row.images.padEnd(widths.images),
+    ].join("  ");
+    console.log(line);
+  }
+}

packages/coding-agent/src/cli/session-picker.ts

@@ -0,0 +1,56 @@
+/**
+ * TUI session selector for --resume flag
+ */
+
+import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
+import { KeybindingsManager } from "../core/keybindings.js";
+import type {
+  SessionInfo,
+  SessionListProgress,
+} from "../core/session-manager.js";
+import { SessionSelectorComponent } from "../modes/interactive/components/session-selector.js";
+
+type SessionsLoader = (
+  onProgress?: SessionListProgress,
+) => Promise<SessionInfo[]>;
+
+/** Show TUI session selector and return selected session path or null if cancelled */
+export async function selectSession(
+  currentSessionsLoader: SessionsLoader,
+  allSessionsLoader: SessionsLoader,
+): Promise<string | null> {
+  return new Promise((resolve) => {
+    const ui = new TUI(new ProcessTerminal());
+    const keybindings = KeybindingsManager.create();
+    let resolved = false;
+
+    const selector = new SessionSelectorComponent(
+      currentSessionsLoader,
+      allSessionsLoader,
+      (path: string) => {
+        if (!resolved) {
+          resolved = true;
+          ui.stop();
+          resolve(path);
+        }
+      },
+      () => {
+        if (!resolved) {
+          resolved = true;
+          ui.stop();
+          resolve(null);
+        }
+      },
+      () => {
+        ui.stop();
+        process.exit(0);
+      },
+      () => ui.requestRender(),
+      { showRenameHint: false, keybindings },
+    );
+
+    ui.addChild(selector);
+    ui.setFocus(selector.getSessionList());
+    ui.start();
+  });
+}