### Launch FrankenTerm GUI (Installed)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Launches the FrankenTerm GUI if it is installed and available in the system's PATH. This is the standard way to start the GUI after installation.

```bash
frankenterm-gui
```

--------------------------------

### Run Frankenterm Setup

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/README.md

Executes the guided setup for Frankenterm, which generates configuration snippets and shell hooks. It also handles automatic font installation if not skipped.

```bash
# Guided setup (generates config snippets and shell hooks)
ft setup

# Manual install / reinstall path:
ft setup font --apply

# Opt out of automatic font install for this invocation:
FT_SKIP_BUNDLED_FONT_INSTALL=1 ft status
```

--------------------------------

### Start ft Watcher

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/README.md

Starts the ft watcher/runtime. This is the initial command to get the system running.

```bash
$ ft watch
```

--------------------------------

### Setup Configuration

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Manages Frankenterm configuration setup.

```bash
ft setup config
```

--------------------------------

### Start FrankenTerm GUI Normally

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Launches the FrankenTerm GUI with default settings. This is the most basic way to start the application.

```bash
frankenterm-gui start
```

--------------------------------

### CMake Project Setup and Configuration

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/frankenterm/deps-freetype/zlib/CMakeLists.txt

Initializes the CMake build system, sets project name and version, and defines installation directories for various components. It also enables testing and includes system checks for headers and types.

```cmake
cmake_minimum_required(VERSION 2.4.4...3.15.0)
set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)

project(zlib C)

set(VERSION "1.3.1")

option(ZLIB_BUILD_EXAMPLES "Enable Zlib Examples" ON)

set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")

include(CheckTypeSize)
include(CheckFunctionExists)
include(CheckIncludeFile)
include(CheckCSourceCompiles)
enable_testing()
```

--------------------------------

### Install ft CLI from source

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/remote-setup-spec.md

Installs the `ft` binary from the frankenterm GitHub repository using `cargo install`. This method is used as an alternative if a local binary is not available.

```bash
ssh <host> "cargo install --git https://github.com/Dicklesworthstone/frankenterm.git --bin ft frankenterm"
```

--------------------------------

### Packaging and Installation

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/extensions/examples/theme-extension.md

Commands to package the theme extension into a .ftx file and install it using the FrankenTerm CLI.

```bash
cd dracula-plus
zip -r ../dracula-plus.ftx extension.toml assets/ noop.lua
ft ext install ../dracula-plus.ftx
```

--------------------------------

### Install FrankenTerm Extension

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/extensions/sdk/rust-quickstart.md

Use the `ft ext install` command to install your packaged extension into FrankenTerm.

```bash
ft ext install my-ext.ftx
```

--------------------------------

### Install FrankenTerm using Cargo

Source: https://context7.com/dicklesworthstone/frankenterm/llms.txt

Instructions for installing FrankenTerm via Cargo, either as a quick install from the Git repository or by building from source with all features enabled.

```bash
# Quick install
cargo install --git https://github.com/Dicklesworthstone/frankenterm.git ft

# From source with all features
git clone https://github.com/Dicklesworthstone/frankenterm.git
cd frankenterm
cargo build --release --all-features
cp target/release/ft ~/.local/bin/
```

--------------------------------

### Setup Patch

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Applies or removes patches during Frankenterm setup. Use --remove to undo a patch.

```bash
ft setup patch [--remove]
```

--------------------------------

### Robot Search Examples

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Examples demonstrating the usage of the `ft robot search` command with different modes.

```bash
ft robot search "compilation failed" --mode lexical
```

```bash
ft robot search "compilation failed" --mode semantic
```

```bash
ft robot search "compilation failed" --mode hybrid
```

--------------------------------

### Remote WezTerm Setup Script (Rust)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/frankenterm_guide.md

This Rust function automates the remote setup of WezTerm on a host machine. It checks for existing installations, installs WezTerm if necessary, configures a systemd user service for the WezTerm mux server, enables and starts the service, and verifies its status. It uses SSH commands to execute these operations remotely.

```rust
pub async fn setup_remote(host: &str) -> Result<()> {
    use tokio::process::Command;
    
    // 1. Check if wezterm is installed
    let check = Command::new("ssh")
        .args([host, "which", "wezterm"])
        .output()
        .await?;
    
    if !check.status.success() {
        tracing::info!("Installing WezTerm on {}", host);
        
        // Install WezTerm
        let install_script = r#"\
            curl -fsSL https://apt.fury.io/wez/gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/wezterm-fury.gpg
            echo 'deb [signed-by=/usr/share/keyrings/wezterm-fury.gpg] https://apt.fury.io/wez/ * *' | sudo tee /etc/apt/sources.list.d/wezterm.list
            sudo apt update && sudo apt install -y wezterm
        "#;
        
        Command::new("ssh")
            .args([host, "bash", "-c", install_script])
            .status()
            .await?;
    }
    
    // 2. Create systemd service
    let service_unit = r#"[Unit]
Description=WezTerm Mux Server
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/wezterm-mux-server --daemonize=false
Restart=on-failure
RestartSec=5
Environment=WEZTERM_LOG=warn

[Install]
WantedBy=default.target
"#;
    
    Command::new("ssh")
        .args([
            host,
            "mkdir", "-p", "~/.config/systemd/user",
            "&&",
            "cat", ">", "~/.config/systemd/user/wezterm-mux-server.service",
        ])
        .stdin(std::process::Stdio::piped())
        .spawn()?
        .stdin
        .as_mut()
        .unwrap()
        .write_all(service_unit.as_bytes())
        .await?;
    
    // 3. Enable and start service
    Command::new("ssh")
        .args([
            host,
            "systemctl", "--user", "daemon-reload",
            "&&",
            "systemctl", "--user", "enable", "--now", "wezterm-mux-server",
            "&&",
            "sudo", "loginctl", "enable-linger", "$USER",
        ])
        .status()
        .await?;
    
    // 4. Verify
    let status = Command::new("ssh")
        .args([host, "systemctl", "--user", "status", "wezterm-mux-server"])
        .output()
        .await?;
    
    if status.status.success() {
        tracing::info!("WezTerm mux server running on {}", host);
        Ok(())
    } else {
        anyhow::bail!("Failed to start wezterm-mux-server on {}", host)
    }
}

```

--------------------------------

### Setup and Configuration Commands

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Commands for setting up and configuring the Frankenterm environment, including host management, remote setup, and configuration validation.

```APIDOC
## Setup and Config Commands

### Setup

- **`ft setup [--list-hosts] [--dry-run] [--apply]`**: General setup command.
- **`ft setup local`**: Setup for local environment.
- **`ft setup remote <host> [--yes] [--install-ft]`**: Setup for a remote host.
- **`ft setup config`**: Configure setup.
- **`ft setup patch [--remove]`**: Patch setup.
- **`ft setup shell [--remove] [--shell <bash|zsh|fish>]`**: Setup shell configuration.

### Configuration

- **`ft config init [--force]`**: Initialize configuration.
- **`ft config validate [--strict]`**: Validate configuration.
- **`ft config show [--effective] [--json]`**: Show configuration.
- **`ft config set <key> <value> [--dry-run]`**: Set a configuration value.
- **`ft config export [-o <path>] [--json]`**: Export configuration.
- **`ft config import <path> [--dry-run] [--replace] [--yes]`**: Import configuration.
```

--------------------------------

### Next.js 16 Wizard UI Component

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/COMPREHENSIVE_ANALYSIS_OF_agentic_coding_flywheel_setup.md

Conceptual TypeScript code for a Next.js 16 wizard UI component. This component would likely be responsible for rendering the user interface for bootstrapping the Ubuntu VPS environment, guiding users through the setup process, and displaying installation progress.

```typescript
import React, { useState, useEffect } from 'react';
import axios from 'axios'; // Assuming axios for API calls

// Define types for wizard steps and installation status
interface WizardStep {
  id: string;
  title: string;
  component: React.ComponentType<any>; // Placeholder for step components
}

interface InstallationStatus {
  currentStep: string;
  progress: number; // 0-100
  message: string;
  isComplete: boolean;
  error: string | null;
}

// Placeholder components for wizard steps
const WelcomeStep = () => <div>Welcome to ACFS Setup!</div>;
const ConfigurationStep = () => <div>Configure your settings here.</div>;
const InstallationProgressStep = ({ status }: { status: InstallationStatus }) => (
  <div>
    <h2>{status.message}</h2>
    <progress value={status.progress} max="100"></progress>
    <p>{status.progress}%</p>
    {status.error && <p style={{ color: 'red' }}>Error: {status.error}</p>}
  </div>
);
const CompletionStep = () => <div>Setup Complete!</div>;

const wizardSteps: WizardStep[] = [
  { id: 'welcome', title: 'Welcome', component: WelcomeStep },
  { id: 'configure', title: 'Configuration', component: ConfigurationStep },
  { id: 'installing', title: 'Installation', component: InstallationProgressStep },
  { id: 'complete', title: 'Completion', component: CompletionStep },
];

const ACFSWizard: React.FC = () => {
  const [currentStepIndex, setCurrentStepIndex] = useState(0);
  const [installStatus, setInstallStatus] = useState<InstallationStatus>({
    currentStep: 'welcome',
    progress: 0,
    message: 'Initializing setup...',
    isComplete: false,
    error: null,
  });

  const currentStep = wizardSteps[currentStepIndex];

  // Effect to simulate or fetch installation progress
  useEffect(() => {
    if (currentStep.id === 'installing' && !installStatus.isComplete) {
      const interval = setInterval(() => {
        // In a real app, fetch status from backend API
        axios.get('/api/installation-status').then(response => {
          setInstallStatus(response.data);
          if (response.data.isComplete || response.data.error) {
            clearInterval(interval);
            if (response.data.isComplete) {
              setCurrentStepIndex(currentStepIndex + 1);
            }
          }
        }).catch(err => {
          console.error('Failed to fetch status:', err);
          setInstallStatus(prev => ({ ...prev, error: 'Failed to update status.' }));
          clearInterval(interval);
        });
      }, 2000); // Poll every 2 seconds
      return () => clearInterval(interval);
    }
  }, [currentStep.id, installStatus.isComplete]);

  const handleNext = () => {
    if (currentStepIndex < wizardSteps.length - 1) {
      // Trigger installation start if moving to the installing step
      if (currentStep.id === 'configure') {
         axios.post('/api/start-installation').then(response => {
            setInstallStatus(response.data);
            setCurrentStepIndex(currentStepIndex + 1);
         }).catch(err => {
            console.error('Failed to start installation:', err);
            setInstallStatus(prev => ({ ...prev, error: 'Failed to start installation.' }));
         });
      } else {
        setCurrentStepIndex(currentStepIndex + 1);
      }
    }
  };

  const handleBack = () => {
    if (currentStepIndex > 0) {
      setCurrentStepIndex(currentStepIndex - 1);
    }
  };

  return (
    <div>
      <h1>ACFS Setup Wizard</h1>
      <h2>{currentStep.title}</h2>
      <currentStep.component status={installStatus} />
      <div>
        <button onClick={handleBack} disabled={currentStepIndex === 0}>
          Back
        </button>
        {!installStatus.isComplete && (
          <button onClick={handleNext} disabled={currentStepIndex === wizardSteps.length - 1 && installStatus.isComplete}>
            {currentStepIndex === wizardSteps.length - 2 ? 'Start Installation' : 'Next'}
          </button>
        )}
      </div>
    </div>
  );
};

export default ACFSWizard;

```

--------------------------------

### Setup Frankenterm

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Initiates the setup process for Frankenterm. Options include listing hosts, performing a dry run, or applying changes.

```bash
ft setup [--list-hosts] [--dry-run] [--apply]
```

--------------------------------

### Automated Remote Host Setup with WezTerm (Rust)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/PLAN.md

This Rust function automates the setup of a remote host by installing WezTerm, configuring its systemd user service, and optionally installing the 'wa' binary. It handles package manager detection for installation and verifies the service status. Dependencies include tokio for async operations and ssh/scp commands.

```rust
pub async fn setup_remote_host(host: &str, config: &SetupConfig) -> Result<SetupResult> {
    use tokio::process::Command;

    let mut result = SetupResult::default();

    // 1. Check if wezterm is installed
    let check = Command::new("ssh")
        .args([host, "which", "wezterm"])
        .output()
        .await?;

    if !check.status.success() {
        tracing::info!("Installing WezTerm on {}", host);

        // Detect package manager and install
        let install_script = r#" 
            if command -v apt-get &> /dev/null; then
                curl -fsSL https://apt.fury.io/wez/gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/wezterm-fury.gpg
                echo 'deb [signed-by=/usr/share/keyrings/wezterm-fury.gpg] https://apt.fury.io/wez/ * *' | sudo tee /etc/apt/sources.list.d/wezterm.list
                sudo apt-get update && sudo apt-get install -y wezterm
            elif command -v dnf &> /dev/null; then
                sudo dnf install -y wezterm
            else
                echo "Unsupported package manager" >&2
                exit 1
            fi
        "#;

        Command::new("ssh")
            .args([host, "bash", "-c", install_script])
            .status()
            .await?;

        result.wezterm_installed = true;
    }

    // 2. Create systemd service
    let service_unit = include_str!("../resources/wezterm-mux-server.service");

    Command::new("ssh")
        .args([host, "mkdir", "-p", "~/.config/systemd/user"])
        .status()
        .await?;

    let mut ssh = Command::new("ssh")
        .args([host, "cat", ">", "~/.config/systemd/user/wezterm-mux-server.service"])
        .stdin(std::process::Stdio::piped())
        .spawn()?;

    ssh.stdin.as_mut().unwrap()
        .write_all(service_unit.as_bytes())
        .await?;
    ssh.wait().await?;

    result.service_created = true;

    // 3. Enable and start service
    Command::new("ssh")
        .args([
            host,
            "systemctl", "--user", "daemon-reload", "&&",
            "systemctl", "--user", "enable", "--now", "wezterm-mux-server", "&&",
            "sudo", "loginctl", "enable-linger", "$USER",
        ])
        .status()
        .await?;

    result.service_enabled = true;

    // 4. Optionally install wa binary
    if config.install_wa {
        let wa_binary = std::env::current_exe()?;

        Command::new("scp")
            .args([wa_binary.to_str().unwrap(), &format!("{}:~/.local/bin/wa", host)])
            .status()
            .await?;

        result.wa_installed = true;
    }

    // 5. Verify
    let verify = Command::new("ssh")
        .args([host, "systemctl", "--user", "is-active", "wezterm-mux-server"])
        .output()
        .await?;

    result.verified = verify.status.success();

    Ok(result)
}
```

--------------------------------

### List Available Explanation Templates

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/README.md

Use this command to see all available templates for explaining policy decisions. No setup is required.

```bash
ft why --list
```

--------------------------------

### Announce Task Start with Mail

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/AGENTS.md

Send a message to announce the start of a task. The subject should include the Beads issue ID. This example uses Python syntax.

```python
send_message(..., thread_id="br-123", subject="[br-123] Start: <title>", ack_required=true)
```

--------------------------------

### Implement Quick Start CLI Command in Rust

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/frankenterm_guide.md

A Rust implementation for the 'ft' CLI quick start command. It handles output formatting, displaying help text for humans or JSON data for automated agents.

```rust
use anyhow::Result;

pub async fn run(format: &super::OutputFormat) -> Result<()> {
	let help = "...help text...";
	match format {
		super::OutputFormat::Json => {
			println!("{}", serde_json::json!({
				"name": "ft",
				"version": env!("CARGO_PKG_VERSION"),
				"commands": ["watch", "robot", "query", "send", "workflow", "setup", "status"],
				"robot_commands": ["state", "get-text", "send", "wait-for", "search", "events", "workflow", "help"],
			}));
		}
		_ => {
			println!("{}", help);
		}
	}
	Ok(())
}
```

--------------------------------

### Implement Smart Startup for Windows and Tabs

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/wezterm_automation_guide_chatgpt.md

Uses the gui-startup event to automatically spawn windows and tabs for local and remote domains, ensuring a consistent workspace environment upon launch.

```lua
wezterm.on('gui-startup', function(cmd)
  local project_dir = wezterm.home_dir .. '/projects'
  local _, _, local_window = wezterm.mux.spawn_window{ cwd = project_dir }
  for i = 2, 3 do
    local_window:spawn_tab{ cwd = project_dir }
  end
end)
```

--------------------------------

### GET /providers

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/integration-research/PLAN_TO_DEEPLY_INTEGRATE_cross_agent_session_resumer_INTO_FRANKENTERM.md

Lists all providers detected by the casr utility and their installation status.

```APIDOC
## GET /providers

### Description
Returns a list of all providers known to the system, indicating whether the associated CLI tools are currently installed.

### Method
GET

### Endpoint
/providers

### Response
#### Success Response (200)
- **providers** (array) - List of ProviderInfo objects.

#### Response Example
[
  {
    "name": "Claude Code",
    "slug": "claude-code",
    "cli_alias": "claude",
    "installed": true,
    "version": "0.1.0"
  }
]
```

--------------------------------

### Start FrankenTerm GUI and Run Command

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Launches the FrankenTerm GUI and immediately executes a specified command, such as 'htop', in the initial tab.

```bash
frankenterm-gui start -- bash -lc "htop"
```

--------------------------------

### GET /sessions

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/integration-research/PLAN_TO_DEEPLY_INTEGRATE_cross_agent_session_resumer_INTO_FRANKENTERM.md

Lists all discoverable sessions across installed providers, with optional filtering by provider and workspace.

```APIDOC
## GET /sessions

### Description
Retrieves a list of sessions discoverable by the casr utility. Supports filtering by provider slug and workspace directory.

### Method
GET

### Endpoint
/sessions

### Parameters
#### Query Parameters
- **provider** (string) - Optional - Filter sessions by provider slug (e.g., 'claude-code').
- **workspace** (string) - Optional - Filter sessions by workspace path.
- **limit** (integer) - Optional - Maximum number of sessions to return.

### Response
#### Success Response (200)
- **sessions** (array) - List of SessionSummary objects containing session_id, provider, workspace, and metadata.

#### Response Example
[
  {
    "session_id": "sess_123",
    "provider": "claude-code",
    "workspace": "/home/user/project",
    "message_count": 10,
    "title": "Refactoring module"
  }
]
```

--------------------------------

### Setup Remote Frankenterm

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Sets up Frankenterm on a remote host. Options include automatically confirming and installing Frankenterm.

```bash
ft setup remote <host> [--yes] [--install-ft]
```

--------------------------------

### Common Tutorial Commands

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/operator-playbook.md

Commands to check the status of tutorials and start specific learning tracks like 'basics'.

```bash
ft learn --status
ft learn basics
```

--------------------------------

### FrankenTerm Robot Commands Examples (Bash)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/AGENT_FRIENDLINESS_REPORT.md

Examples of common `ft robot` commands used for terminal automation, including getting state, sending commands, waiting for patterns, dry-runs, explaining errors, and running workflows.

```bash
ft robot state
```

```bash
ft robot send 0 "ls -la"
```

```bash
ft robot wait-for 0 "Done"
```

```bash
ft robot send 0 "rm -rf temp" --dry-run
```

```bash
ft robot why E001
```

```bash
ft robot workflow run my-workflow
```

--------------------------------

### Start Web Server

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/cli-reference.md

Starts the Frankenterm web server. Requires the 'web' feature. Defaults to binding to 127.0.0.1:8000. Use --port to specify a different port.

```bash
ft web [--port <n>]
```

--------------------------------

### Manage FrankenTerm Extensions

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Use the ft ext command-line tool to list, validate, install, and get information about FrankenTerm extensions.

```bash
ft ext list
ft ext validate ./my-pack.toml
ft ext install ./my-pack.toml
ft ext info my-pack
```

--------------------------------

### Initialize FrankenTerm GUI Configuration

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Copies the default configuration file to the user's config directory. This is the first step after building or installing the GUI.

```bash
mkdir -p ~/.config/frankenterm
cp crates/frankenterm-gui/frankenterm.toml ~/.config/frankenterm/frankenterm.toml
```

--------------------------------

### Get Pane State Response Envelope

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/AGENTS.md

Example JSON response envelope for pane state retrieval. The `data` field contains pane information.

```json
{
  "ok": true,
  "data": {
    "panes": [
      {"pane_id": 0, "title": "claude-code", "domain": "local", "cwd": "/project"}
    ]
  }
}
```

--------------------------------

### TypeScript Zod Schema for Manifest Validation

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/COMPREHENSIVE_ANALYSIS_OF_agentic_coding_flywheel_setup.md

Example TypeScript code demonstrating the use of Zod for validating the ACFS manifest file (acfs.manifest.yaml). This ensures type safety and data integrity for the single source of truth defining the installation modules.

```typescript
import { z } from 'zod';

// Define the schema for a single tool module within the manifest
const ToolModuleSchema = z.object({
  name: z.string().min(1),
  description: z.string().optional(),
  version: z.string().optional(),
  dependencies: z.array(z.string()).optional().default([]),
  install_script: z.string().optional(), // Path to a specific install script if not default
  checksum: z.string().optional(), // SHA256 checksum for verification
});

// Define the main manifest schema, which is a record of tool names to their module definitions
const AcfsManifestSchema = z.record(z.string(), ToolModuleSchema);

// Example usage (assuming manifestData is loaded from acfs.manifest.yaml)
/*
const manifestData = {
  "claude-cli": {
    "name": "claude-cli",
    "version": "1.2.0",
    "dependencies": ["python3", "pip"],
    "install_script": "scripts/install_claude.sh",
    "checksum": "a1b2c3d4e5f6..."
  },
  "codex-cli": {
    "name": "codex-cli",
    "version": "0.5.1",
    "dependencies": [],
    "checksum": "f6e5d4c3b2a1..."
  }
};

try {
  const validatedManifest = AcfsManifestSchema.parse(manifestData);
  console.log('Manifest validated successfully:', validatedManifest);
} catch (error) {
  console.error('Manifest validation failed:', error);
}
*/

export { AcfsManifestSchema, ToolModuleSchema };

```

--------------------------------

### Bash/Zsh/Fish Shell Integration Snippet

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/PLAN.md

Illustrates the type of shell snippet installed by `ft setup` for bash, zsh, and fish shells. This snippet uses OSC 133 semantic zones to emit deterministic markers for `prompt_start`, `prompt_end`, `command_start`, and `command_end(exit_status)`, enabling safer input and better output indexing.

```bash
# Example snippet structure (actual implementation may vary)
# Emits OSC 133 markers for prompt and command boundaries
# ... shell specific code ...

```

--------------------------------

### Build and Install Frankenterm from Source

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/README.md

Clones the Frankenterm repository, builds the release binary, and installs it to the local bin directory. Requires Git and Rust toolchain.

```bash
git clone https://github.com/Dicklesworthstone/frankenterm.git
cd frankenterm
cargo build --release

# Install to PATH
cp target/release/ft ~/.local/bin/
```

--------------------------------

### Check for WezTerm Installation

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/remote-setup-spec.md

Checks if WezTerm is installed on the remote host. If installed, it also checks the version.

```bash
ssh <host> "command -v wezterm"
```

```bash
ssh <host> "wezterm --version"
```

--------------------------------

### fm-cli: Command-Line Interface Examples

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/integration-research/COMPREHENSIVE_ANALYSIS_OF_franken_mermaid.md

Demonstrates various commands for the Frankenterm CLI tool. These examples cover rendering diagrams to different formats (SVG, terminal), detecting diagram types, validation, and advanced features like watch mode and serving diagrams.

```bash
fm-cli render input.mmd --format svg --output out.svg
fm-cli render input.mmd --format term --cols 120 --rows 40
fm-cli detect input.mmd --json
fm-cli validate input.mmd --strict
fm-cli render input.mmd --watch          # requires 'watch' feature
fm-cli render input.mmd --serve :8080    # requires 'serve' feature
```

--------------------------------

### Build Zlib Example Binaries

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/frankenterm/deps-freetype/zlib/CMakeLists.txt

Conditionally builds example executables (example and minigzip) if ZLIB_BUILD_EXAMPLES is enabled, linking them against the Zlib library.

```cmake
if(ZLIB_BUILD_EXAMPLES)
    add_executable(example test/example.c)
    target_link_libraries(example zlib)
    add_test(example example)
    add_executable(minigzip test/minigzip.c)
    target_link_libraries(minigzip zlib)
endif()
```

--------------------------------

### Start FrankenTerm GUI in New Process

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Starts a new instance of the FrankenTerm GUI, ensuring it does not reuse an existing GUI instance. Useful for testing or isolation.

```bash
frankenterm-gui start --always-new-process
```

--------------------------------

### Launch FrankenTerm GUI (Build Tree)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/frankenterm-gui-user-guide.md

Launches the FrankenTerm GUI directly from the build output directory. Use this when running after building from source.

```bash
./target/release/frankenterm-gui
```

--------------------------------

### Install libpng Programs

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/frankenterm/deps-freetype/libpng/CMakeLists.txt

Installs the main libpng programs or executables. This step ensures that any user-facing applications built with libpng are correctly installed.

```cmake
if(NOT SKIP_INSTALL_PROGRAMS AND NOT SKIP_INSTALL_ALL)
  install(TARGETS ${PNG_BIN_TARGETS}
          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
```

--------------------------------

### Configuring fastmcp-server with ServerBuilder

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/integration-research/COMPREHENSIVE_ANALYSIS_OF_fastmcp_ruse.md

This example shows how to use the `ServerBuilder` pattern from `fastmcp-server` to configure FrankenTerm's MCP server. It demonstrates registering tools, resources, and prompts, setting up authentication providers, applying middleware for rate limiting or logging, and configuring request timeouts.

```rust
// Using ServerBuilder for MCP server configuration
// use fastmcp_server::ServerBuilder;
// use fastmcp_protocol::{Tool, Resource, Prompt};
// use crate::auth::MyAuthProvider;
// use crate::middleware::MyMiddleware;

// let mut builder = ServerBuilder::new();

// Registering tools, resources, and prompts:
// builder.tool(my_tool)?;
// builder.resource(my_resource)?;
// builder.prompt(my_prompt)?;

// Setting up authentication and middleware:
// builder.auth_provider(MyAuthProvider);
// builder.middleware(MyMiddleware);

// Configuring timeouts:
// builder.request_timeout(std::time::Duration::from_secs(5));

// let server = builder.build()?;

```

--------------------------------

### Install WezTerm using pacman (Arch)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/remote-setup-spec.md

Installs WezTerm on Arch Linux systems using pacman. Synchronizes package databases before installation.

```bash
ssh <host> "sudo pacman -Sy --noconfirm wezterm"
```

--------------------------------

### Install WezTerm using apt (Ubuntu/Debian)

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/remote-setup-spec.md

Installs WezTerm on Ubuntu or Debian-based systems using apt-get. Updates package lists before installation.

```bash
ssh <host> "sudo apt-get update"
ssh <host> "sudo apt-get install -y wezterm"
```

--------------------------------

### Install FrankenTerm using Cargo

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/CHANGELOG.md

Use this command to install the FrankenTerm CLI tool from its Git repository. Ensure you have Rust and Cargo installed.

```sh
cargo install --git https://github.com/Dicklesworthstone/frankenterm.git --bin ft frankenterm
```

--------------------------------

### Listing All Extensions

Source: https://github.com/dicklesworthstone/frankenterm/blob/main/docs/extensions/sdk/debugging.md

Use the 'ft ext list' command to display all installed extensions and their current states.

```bash
# List all extensions with state
ft ext list
```