Search docs.molo17.com

    Bootstrapper Gluesync bootstrapper screenshot Repository

    Gluesync Bootstrapper is a configuration tool for setting up database schema mappings between source and target systems in an automated way, bypassing the need to manually configure entities in the Gluesync Core Hub Web UI. It also ships with an MCP (Model Context Protocol) server that exposes every CoreHub operation as AI-agent-callable tools, enabling natural-language pipeline management, debugging, and monitoring via Claude Desktop, Windsurf, Cursor, and other MCP-compatible clients.

    Open Source This project is Open Source

    Gluesync Automator UI

    For users who prefer a graphical interface over command-line tools, the Bootstrapper is also available as a standalone executable with a web-based UI. The Gluesync Automator provides a user-friendly interface accessible via localhost:8080, featuring drag-and-drop configuration uploads, live log monitoring, and simplified authentication without requiring Python dependencies.

    Overview

    The Bootstrapper allows you to define table structures, column mappings, and connection properties using YAML configuration files, enabling precise control over how data is transferred and transformed across different database systems. This automation tool integrates directly with the Core Hub API to streamline entity configuration.

    Key Features

    • Real-time Data Synchronization

      • Automated synchronization between source and target databases

      • Support for multiple database systems (MS SQL Server, Couchbase, etc.)

      • Configurable filtering and transformation rules

    • Schema Configuration

      • Table structure mapping

      • Column mapping with type safety

      • Custom document key generation

      • TTL (Time To Live) management for target documents

      • Schedules for recurring jobs (via Chronos)

      • …​and much more

    • Pipeline Management

      • Flexible polling intervals and batch processing

      • Automatic agent configuration

      • Direct Core Hub API integration

    • AI Agent Integration (MCP Server)

      • 48 tools exposing pipelines, agents, entities, sync commands, metrics, notifications, and more

      • Works with Claude Desktop, Windsurf, Cursor, and any MCP-compatible client

      • Automatic token sharing — no manual environment configuration needed

      • One-click client setup from the Automator Settings UI

    AI Agent Integration (MCP Server)

    The Bootstrapper includes a built-in MCP (Model Context Protocol) server that exposes every CoreHub operation as a callable tool. Any MCP-compatible AI client — Claude Desktop, Windsurf, Cursor, OpenClaw, or custom agents — can list pipelines, start and stop sync, inspect entity status, read metrics, and manage notifications using natural language prompts.

    What AI agents can do

    Tool Description

    list_pipelines

    List all pipelines with IDs and completion status

    get_pipeline

    Full config and agent details for a pipeline

    get_pipeline_status

    High-level health summary (syncing / idle / erroring / paused)

    get_pipeline_entities_status

    Real-time runtime status for every entity (isSyncActive, isMigrationActive, isBusy, errorState)

    get_agent / get_agent_raw

    Agent configuration (raw includes secrets, requires SUPER_ADMIN)

    assign_agent / unassign_agent

    Attach or detach agents from pipelines

    start_sync / stop_sync / redo_sync / one_time_snapshot

    Control replication and snapshots

    enter_maintenance_mode / exit_maintenance_mode

    Pause and resume without losing checkpoints

    get_notifications / mark_notifications_read

    Browse and acknowledge CoreHub events

    get_pipeline_metrics / get_prometheus_metrics

    Real-time throughput and raw Prometheus text

    get_mapping_function_code

    Read UDF source code

    export_pipeline_yaml

    Export pipeline config to YAML for migration

    get_license_info / get_corehub_version

    Instance metadata

    Full tool count: 48 (see the 2.7.0 release notes for the complete list).

    Authentication

    The MCP server needs a valid CoreHub JWT to call the REST API. You have three ways to provide it:

    1. Automatic (recommended) — Log in via the Automator web UI. The token is written to .gluesync_mcp_token in the project root and read automatically by the MCP server.

    2. Environment variable — Set COREHUB_TOKEN in the shell or client config.

    3. Tool argument — Pass token directly in any individual tool call.

    Transport options

    SSE (via Automator)

    When the Automator is running, the MCP server is available at http://localhost:<AUTOMATOR_PORT>/mcp/sse. Connect any SSE-capable client (Cursor, Windsurf, custom agents) to that URL. Token is injected automatically from Automator state.

    stdio (Claude Desktop, CLI agents)

    Run the server as a subprocess over stdio:

    # Automatic token (written by Automator login)
    python -m mcp_server.server
    
    # Or with explicit token
    export COREHUB_TOKEN="your-token"
    python -m mcp_server.server

    Claude Desktop config (claude_desktop_config.json):

    {
      "mcpServers": {
        "gluesync": {
          "command": "python3",
          "args": ["-m", "mcp_server.server"],
          "cwd": "/path/to/gluesync-bootstrapper"
        }
      }
    }

    One-click client setup

    The Automator Settings UI includes an AI Agent Integration card that detects installed MCP clients on your machine (Claude Desktop, Windsurf, Cursor). Select the clients you want to configure and click Setup MCP. The Automator will:

    1. Detect each client’s config path

    2. Safely merge the Gluesync MCP server entry

    3. Preserve any existing servers you already have configured

    After setup, restart the AI client app to activate the connection.

    Example agent interactions

    User: Which pipelines are currently configured?
    Agent → list_pipelines()
    
    User: Are there any errors on pipeline abc-123?
    Agent → get_pipeline_status(pipeline_id="abc-123")
    Agent → get_notifications(pipeline_id="abc-123", level=["ERROR"])
    
    User: Start a full snapshot for all entities in pipeline abc-123
    Agent → start_sync(pipeline_id="abc-123", with_snapshot=true)
    
    User: Export the QA pipeline config so I can import it to production
    Agent → export_pipeline_yaml(pipeline_id="abc-123", base_url="https://qa-corehub:1717")
    
    User: What's the replication lag on the source agent?
    Agent → get_agent_prometheus_metrics(pipeline_id="abc-123", agent_id="source-agent-id")

    Configuration

    From Core Hub 2.3.2 a schema configuration file can also be imported on a pipeline’s New Entity page in the Control Plane. That import does not apply every key described here. For the keys it applies, checks or ignores, see Entity import file reference.

    The Bootstrapper works with two primary configuration files:

    1. Schema configuration (table-list-template.yaml)

    2. Agent configuration (config.json)

    Schema Configuration

    The schema configuration defines how tables should be synchronized and transformed:

    You can download a ready-to-use schema template here:

    dbo: # Source schema
      target: public # Target schema
      customProperties: # Custom properties for both source and target
        source: # Source custom properties
          maxItemsCountPerIteration: 1000
          pollingIntervalMilliseconds: 100
        target: # Target custom properties
          ttlValue: 10000000
      tables: # Tables to be synchronized
        whitelist: # Allowed tables to be synchronized, empty list means all tables
          - DRIVERS
          - VEHICLES
        blacklist: # Forbidden tables to be synchronized, empty list means no restrictions
          - TEST

    Table Configuration

    Each table can be configured with detailed mapping information:

    DRIVERS:
      keys:
        - ID
      documentKey:
        prefix: "TESTPREFIX"
        suffix: "TESTSUFFIX"
        separator: "-"
        keys:
          - ID
          - LAST_NAME
      name: drivers
      columns:
        - FIRST_NAME: "FIRST_NAME"
        - LAST_NAME: "LAST_NAME"
        - AGE: "AGE"
        - EMAIL: "EMAIL"

    Agent Configuration

    The agent configuration defines the connection details for source and target databases:

    {
      "agents": [
        {
          "agentType": "SOURCE",
          "agentTag": "mssql-ct",
          "hostCredentials": {
            "connectionName": "MS SQL Server source",
            "host": "localhost",
            "port": 1433,
            "databaseName": "demo"
          }
        }
      ]
    }

    Usage

    Getting Started

    Before using the Bootstrapper, you need:

    1. A running Gluesync deployment with Core Hub accessible

    2. Authentication credentials for the Core Hub API

    3. Proper network connectivity between source and target systems

    Authentication

    To use the tool, you need to get a valid authentication token from the Core Hub API. This can be done in several ways:

    1. By logging in to the Core Hub Web UI and copying the token from the browser’s cookies

    2. By using an HTTP client to request a token

    curl -X POST https://<corehub-url>/authentication/login -H "Content-Type: application/json" -d '{"username":"<username>","password":"<password>"}'

    Main Script Usage

    The primary entry point is the main.py script which creates a new pipeline and configures the agents:

    python main.py --config <path_to_config> --token <auth_token> [--skip-errors] [--chunk-size <number>]

    Alternatively, you can use environment variables:

    # Set environment variables
    export FILE_CONF_PATH="./my-config.json"
    export CORE_HUB_URL="https://my-corehub:1717"
    export DEFAULT_PASSWORD="my-secure-password"
    export CREATE_ENTITIES_FROM_SCHEMA="true"
    export TARGET_SCHEMA="public"
    export SOURCE_TYPE="SQL"
    export TARGET_TYPE="NoSQL"
    
    # Run the script
    python main.py

    Creating Entities

    To create entities in the Core Hub based on your YAML configuration:

    python create_all_entities.py --pipeline <pipeline_id> --source-schema <source_schema> --target-schema <target_schema> --source-type <source_agent_type> --target-type <target_agent_type> --yaml-file <path_to_yaml_config> --token <auth_token> [--skip-errors] [--chunk-size <number>]

    Parameters:

    • --pipeline: Required. The ID of the pipeline to create entities for

    • --source-schema: Required. Source schema name

    • --target-schema: Required. Target schema name

    • --source-type: Required. Source agent type (e.g., SQL for RDBMSs, NoSQL for NoSQL databases)

    • --target-type: Required. Target agent type (e.g., NoSQL for NoSQL databases, SQL for RDBMSs)

    • --yaml-file: Required. Path to the YAML configuration file

    • --token: Required. Authentication token for API access

    • --skip-errors: Optional. Continue execution even if errors occur

    • --chunk-size: Optional. Number of entities to process in each chunk (default: 50)

    Accepted values for source-type and target-type: - SQL (for any RDBMS) - NoSQL (for NoSQL databases, Kafka, AWSS3, etc.)

    AI Studio settings backup

    With Core Hub 2.3.0.1 or later, ai_settings.py backs up and restores the AI Studio settings: LLM providers, AI Studio agents, models, skills and agent versions, remote MCP servers, Enterprise brain settings, platform API keys, budgets and conversation retention. Ids and versions are kept, so a restore on another Core Hub keeps every reference between them. Conversations, memories, runs and the Enterprise brain index are not included.

    export CORE_HUB_URL=https://my-corehub:1717
    export AI_SETTINGS_PASSPHRASE='a long passphrase you keep'
    export AI_SETTINGS_CURRENT_PASSWORD='your Core Hub password'
    python ai_settings.py export --output ai-settings.json --include-secrets
    python ai_settings.py import --input ai-settings.json --dry-run
    python ai_settings.py import --input ai-settings.json

    Secrets (provider API keys, remote MCP credentials, platform API keys) are included only with --include-secrets, sealed with the passphrase; the same passphrase is needed to restore them. The passphrase is read from AI_SETTINGS_PASSPHRASE, never from the command line. Core Hub hands out secrets only to a signed-in user who gives their current password again, and never to a personal API token: the password is read from AI_SETTINGS_CURRENT_PASSWORD, or is DEFAULT_PASSWORD when the script signs in as admin itself. Without secrets, the import lists what is left to redo. python ai_settings.py compare a.json b.json tells whether two backups hold the same settings.

    Best Practices

    • Store configuration files in version control

    • Create different configuration files for development, staging, and production environments

    • Validate configurations before applying them to production systems

    • Use consistent naming conventions for schemas, tables, and columns

    • Document custom transformations and rules

    • Test configurations thoroughly before deployment

    Troubleshooting

    Common Issues

    Issue Possible Cause Resolution

    Authentication failures

    Invalid or expired token

    Generate a new authentication token

    Entity creation errors

    Incorrect schema configuration

    Verify YAML configuration format and structure

    Connection issues

    Network connectivity problems

    Check network settings and firewall rules

    Type mapping errors

    Incompatible data types between source and target

    Verify column type definitions in the YAML configuration

    Release Notes

    2.8.26

    Released: November 13, 2026

    • Pipeline export attaches an entity’s Chronos schedule to the table entry the export wrote for that entity, found by its entityName in any schema. Before, an entity whose name is not SCHEMA.TABLE (for example one named after a DBMoto replication, REPL_ORDERS for APP_DAT.ORDERS) was attached to the alphabetically first source schema under a made-up table with no columns. Importing that YAML failed with no column to create table … no source column feeds it, and the real entity was restored without its schedule;

    • A MultiTable entity’s schedule goes on the first table of its chain, the table import resolves the entity by. A schedule whose entity is not in the export is skipped with a warning instead of producing an empty table entry, and so is one whose entity name matches unrelated tables;

    2.8.25

    Released: November 12, 2026

    • HTTP Target and HTTP Source (Courier) follow the Courier backend of Core Hub 2.3.2.1:

      • The agent tag is courier-agent. api-agent-shadow is no longer recognised;

      • HTTP Source tokens carry the gluesync.https_agent permission scope, which replaces gluesync.endpoint_inbound. Each courier.tokens entry is limited to the collections it is for (every configured collection by default) through collectionScopes. A Core Hub that predates collection scopes ignores them, and the Bootstrapper warns that the token can also call the collections whose allowlist is off. A refused scope is never retried without it;

      • Core Hub saves an inbound collection only while an active token can call it, so a MISSING_TOKEN refusal now says to add one to courier.tokens. An inbound basePath is one path segment, blockedTokenIds is sent, and a token cannot be both allowed and blocked;

      • A create that Core Hub answers with 409 because it already stores that id (a definition renamed in the UI) is repeated as an update, for inbound and outbound definitions;

      • An outbound collection moved to another origin is refused while its endpoints hold header values bound to the old one. With "force": true the move is sent with ?force=true and every header value again. baseUrl cannot carry user:pass@, and header names are checked, including the ones the HTTP client sets itself;

      • A header value sent as the mask (**) is refused before any write when Core Hub has no value to keep for it;

      • Inbound endpoints that still serve another existing pipeline are moved to the new pipeline with a warning naming the pipeline they leave;

    • courier_export.py --pipeline <id> [--include-secrets] exports the courier block of every HTTP agent of a pipeline, in the shape config.json takes. Personal API Tokens and the outbound authentication secret are not exported; header values only with --include-secrets (SUPER_ADMIN);

    2.8.24

    Released: November 7, 2026

    • A target table the Bootstrapper creates keeps the column names the YAML gives. Core Hub 2.3.2.0 rewrites the column names of a generated CREATE TABLE to the target’s usual case unless told not to, so first_name became FIRST_NAME on Oracle and SAP HANA while the entities kept first_name. The request now sends applyDefaultCase: false. Targets that accept only one case (Snowflake, GridGain, Db2 for i, Cassandra, ScyllaDB, Informix, CockroachDB) are still normalised by Core Hub, and older Core Hubs ignore the field;

    2.8.23

    Released: November 5, 2026

    • Reserved technical fields (_TRANSACTION_OPERATION, _RRN and the others) are taken from the source agent’s discovery. A YAML that maps one the agent does not provide is refused with a message saying to enable it in the agent’s technicalFields and discover again, instead of an unmatched-column error. _RRN_COLUMN is read as _RRN;

    • On an IBM i source, a table key with @@ (multi-member) is refused with a message naming specificConfiguration.enableMultiMember when that option is off;

    • After installing a function collection, entity creation waits until the functions the CustomFn columns need are exported, instead of failing them as not exported;

    • An entity whose source or target columns repeat a name (for example two whitelist or mapping entries that resolve to the same target column) is refused with the table named, before Core Hub would refuse it with Duplicated entity column names;

    2.8.22

    Released: November 5, 2026

    • gs1_import.py: re-running the Gluesync 1.x import on a pipeline that already holds the converted entities no longer gets them refused with DOCUMENT_KEYSPACE_SHARED. The import reads the pipeline’s entities first, a draft with the name of a saved entity takes its entityId and, per side, its agentEntityId, and Core Hub validates and saves it as an update. Such entities are reported as already imported and are saved only when named in --entities, so a plain re-run never overwrites them. When the entities cannot be read, the report says so and the drafts are treated as new;

    2.8.21

    Released: November 5, 2026

    • HTTP Target and HTTP Source (Courier). An agent entry with agentTag: "api-agent-shadow" can carry a courier block, and the Bootstrapper creates the Courier definitions it describes before it configures the agent:

      • As a target (HTTP Target, outbound), it creates or updates the collections (base URL and authentication: None, Basic, Bearer or ApiKey) and their endpoints (verb, path template, body type, headers and bindings), matched by name, so a second run updates them in place. In the table configuration the collection is the target schema, the endpoint is the target table and the columns mapping maps source columns onto bindings. Target entities are created as NoSqlEntity, no CREATE TABLE is attempted, and the bindings keep the type their endpoint declares;

      • As a source (HTTP Source, inbound), it creates the inbound collections and their pipeline endpoints once the agent is on the pipeline, with pipelineId and agentId set to this pipeline and this agent. The collection is the source schema and the endpoint is the source table. keyBindings, operationBinding, a token allowlist per collection and force (to change an endpoint that another pipeline’s entities read) are supported;

      • courier.tokens creates the Personal API Tokens that clients call the inbound endpoints with, scoped to the pipeline and the agent. Active tokens with the same name are revoked first, so each run rotates them. The token is written only to its outputFile (owner-only), never to the log;

      • customHostCredentials.outboundCollection or inboundCollection is filled in when exactly one collection is configured. The courier block is checked with the rules Core Hub applies before anything is sent;

    • Credentials are hidden in more debug logs: the value of an ApiKey authentication, the value of a header whose name is a credential (such as Authorization), and the agent entries the Bootstrapper prepares, which carry the host credentials and the courier block;

    2.8.20

    Released: November 5, 2026

    • A dry-run is reported as dry-run, not completed, and a dry-run that hit errors as failed. A run always leaves the running state, and entity and backup runs share one lock;

    • An existing target table whose columns differ from the YAML is reported with a warning (the CREATE is skipped). Column lookups run only when the YAML lists columns, so large plans no longer pay one request per table;

    • A missing partition column, or schema-wide partitions that do not fit every table, gives a warning and the entity is created without partitions instead of being refused. A table-level partitions: is read when customProperties.source.partitions is absent;

    • Filter operators accept the spellings and symbols in common use and send the Core Hub names: <, lt and LessThan become Lower, ⇐, lte and LessThanOrEqual become LowerEqual, GreaterThan becomes Greater and GreaterThanOrEqual becomes GreaterEqual;

    • Resume matches the agent tag without regard to case, and accepts the only bound agent of the same type whatever its tag;

    • Duplicating a pipeline to another database type falls back to agents with the same tag for the host credentials. The fallback to an agent of the other role is limited to the source pipeline, logged as a warning, and blocked when agents of the same role exist;

    • Listing errors are reported in full, and the planned temporary YAML is the one used for the run;

    2.8.19

    Released: November 4, 2026

    • Entity creation and the backup import go on after a refused entity: the entities created are kept, the run ends as partial and the response lists the refused ones in failedEntityIds. A refused MultiTable chain counts once, and its members can be retried together. A run in which every entity failed ends as failed, not completed. Several source tables that feed the same new target table are created once, as fan-in, with a selection note;

    • A Core Hub session that expires during a long run (HTTP 401) is renewed once with a new login, using the known admin passwords, and the request that failed is sent again. When the login fails, the error says the session expired and advises resuming with onExisting=skip so the entities already imported are kept. Concurrent requests share one login;

    • An unreadable GET /version is taken as a Core Hub before 2.3, with a warning, instead of a current one, so the legacy column mapping and key rules apply. Pass --corehub-version X.Y.Z or set COREHUB_VERSION when the Core Hub is 2.3 or later;

    • Oracle: an unconstrained NUMBER column is no longer created as NUMBER(0,0). Discovery omits the precision, the template, the export and the table creation invented a precision of 0, and Oracle refused the statement with ORA-01727. The precision and scale stay empty, and Core Hub creates a bare NUMBER;

    • A group that cannot be created or found is an error, no longer silently replaced by _default; during table creation one bad group is reported and the other groups go on. Group names are matched without regard to case, and the synthetic filter column ids no longer change between runs;

    • Reading the Chronos jobs of a pipeline no longer stops early when a full page holds only other pipelines' jobs, and never loops when the server ignores the offset; the walk is bounded. Schedules are attached to the table they belong to when the schema or the entity name differs in case or spelling;

    • Duplicating a pipeline to another agent type reads the host credentials of the new agent from a pipeline that already has that type, and the template’s only when there is none. Refused entity ids are qualified so Retry takes the right entity, a collision-safe auto-rename gives colliding targets distinct names, and an Advanced exclude no longer lingers on a retry. Token files are written owner-only (0600);

    • New gs1_import.py and gs1_migration, the Gluesync 1.x configuration import described in Automator 1.4.27;

    2.8.18

    Released: November 2, 2026

    • The backup of an agent includes its custom host credentials, such as the Databricks authMode, warehouseId, catalog and stagingVolume, and the custom fields of Snowflake and BigQuery. Core Hub reports them as hostCredentialsCustomProperties and the backup read customHostCredentials, so every agent was written with an empty map. The backup reads either name and writes customHostCredentials, the name the restore takes;

    • Without secrets, the custom keys Core Hub obfuscates (password, secret, token, private key, credential, API key, access key) are masked like the password, and a <hidden> placeholder from Core Hub is written as the masked value. A restore refuses an archive with a masked custom secret, as it does one with a masked password, and never sends a masked value to Core Hub, where it would be stored as the secret;

    • A restore lists each restored connection that needs a sign-in as a warning, never a failure: Sign-in required: <name> (Databricks). Open the connection in Gluesync and sign in. U2M OAuth refresh tokens never leave Core Hub, so a restored Databricks connection in U2M mode cannot run its pipelines until a user signs in again. The warning is in the import result, in the logs and in the Automator;

    • create_all_entities.py --include and --exclude (repeatable) select the tables to create without a plan file: each takes an exact SCHEMA.KEY (@@n included) or a unique entity name, builds a one-pipeline plan, and merges into --plan when both are given. A bare SCHEMA.TABLE still means every @@n variant. No new Core Hub API is used, so it works with Core Hub before 2.3 too;

    • The export of a NoSQL source (MongoDB, Cosmos DB, Couchbase, DynamoDB) takes the schema and collection from the entity’s entityObject, as Core Hub reports them there and not on table. NoSQL tables were left out of the exported entities;

    2.8.17

    Released: October 29, 2026

    • Entity creation takes a customization plan, the single-pipeline part of the backup import plan: create_all_entities.py --plan plan.json applies it, --write-plan plan.json drafts it from a table list YAML, and the Automator’s Create entities and Bulk create use the same plan. A plan includes or excludes tables (SCHEMA.TABLE), sets the target schema, target table and entity name of a table, remaps schemas, tables and groups, chooses what happens to an entity that already exists (onExistingEntity: skip, update or fail), skips UDFs, groups, the function collection, table creation or schedules, and can run as a dry run that creates nothing. An empty plan behaves as before;

    • An entity creation plan is refused when it names agents, the global parts, resumeInto, a pipeline name, onExistingPipeline or a password, or lists more than one pipeline: those choices belong to the backup import plan. Table and schema names are matched without regard to case where the database folds case;

    • No new Core Hub API is used, so the plan works with Core Hub before 2.3 too;

    2.8.16

    Released: October 29, 2026

    • python -m automator_app.import_backup backup.zip runs Import All of a backup ZIP from the command line, reading the Core Hub password from an environment variable (GS_COREHUB_PASSWORD by default). It exits with 0 when every pipeline is fully imported, 2 when a pipeline is partially imported and 1 when nothing is imported or the request is refused. It works with Core Hub before 2.3 too;

    • Custom backup import: --write-plan plan.json writes the plan of a backup and --plan plan.json imports only what it selects. Per pipeline, a plan can leave it out, rename it, resume into an existing pipeline (resumeInto), choose what happens to entities and pipeline names that already exist, leave out or rename entities (target schema, target table, entity name), change an agent’s host, port, database and username, and skip UDFs, the function collection, schedules, groups or table creation; it can also skip notifications, users and access policies. --dry-run checks the plan and writes nothing. Unknown pipelines, tables or agents, a plan that selects nothing and a name clash with onExistingPipeline: fail are refused before anything is written. A plan never holds a password and one that does is refused: an agent password comes from the variable "passwordRef": "env:NAME" names;

    • Agent connection overrides for Import All: host, port, database and username per agent tag or id, from --agent-overrides FILE, GS_IMPORT_AGENT_OVERRIDES_FILE or GS_IMPORT_AGENT_OVERRIDES (inline JSON). Passwords come only from GS_IMPORT_AGENT_PASSWORD_<TAG> or the variable passwordEnv names. An unknown agent stops the import before anything is sent;

    • Resume: --resume-pipeline-id ID (GS_IMPORT_RESUME_PIPELINE_ID) restores a backup into a pipeline an earlier import left in place, for example after its agent credentials were refused. No pipeline, agent or credentials are created; the agents' specific configuration is sent again and the function collection, the entities (those already there are skipped) and the UDFs are restored. --resume-from-pipeline picks the backup pipeline when the ZIP holds several;

    • Short import report: one line per pipeline and per agent with the reason Core Hub gave, the same entity error on many tables reported once with a count, and a summary of the pipelines fully and partially imported. A pipeline whose entities were not created is reported as partial, never as imported. When an agent’s credentials are refused, the entities of its pipeline are counted as not attempted rather than failed;

    • GS_IMPORT_ON_EXISTING_PIPELINE chooses what happens to a pipeline name that already exists: suffix (default) or fail. A pipeline left half-created is reported with its id. With GS_IMPORT_CONTINUE_ON_CREDENTIALS_FAILURE=true, an agent whose credentials fail on a connection error is listed as credentials pending and the pipeline is left in draft, to resume once the connection is fixed;

    • New create_all_entities.py options for importing into another Gluesync, all off by default: --remap FILE (GS_IMPORT_REMAP) and command-line renames of schemas, target schemas, tables, groups and agents with entity prefix and suffix, --dry-run, --no-validate and --strict-validate, --on-existing skip|update|fail and --allow-missing-tables. Core Hub reads are retried on connection errors and 5xx answers (CORE_HUB_GET_RETRIES, CORE_HUB_TIMEOUT, CORE_HUB_CONNECT_TIMEOUT);

    • Target schema inference: a table without an explicit targetSchema whose snapshot commands all name one other schema is created in that schema, and is listed in the warnings. --no-infer-target-schema or GS_IMPORT_INFER_TARGET_SCHEMA=false turns it off;

    • Fan-in: when several source tables feed one target table that the import creates, the table gets the union of their columns with the widest type that holds them all. An existing table is never altered: its missing columns are reported;

    • Keys that hold the source primary key plus other columns are a warning instead of a refusal (--strict-validate refuses them). A table is refused for having no extra target key only when discovery confirms its target table has no primary key;

    • Agent passwords, including those read from passwordRef, GS_IMPORT_AGENT_PASSWORD_* and passwordEnv, are redacted from the logs. ZIP entries that would land outside the extraction folder are refused;

    • DBMoto converter: template schemas match exactly unless TEMPLATE_SUBSTRING_MATCH=true, a converted file is never overwritten, and DBMOTO_REMAP applies a remap file;

    2.8.15

    Released: October 23, 2026

    • Restoring an export onto an SQL target whose tables do not exist creates them when CREATE_TABLE_IF_NOT_EXISTS is on. Table creation skipped every table of an exported YAML, saved the entity onto a missing table and reported success, and the field mapping then showed The target table returned no columns. The table is built from the exported mapping rows: one column per target a row writes, typed by targetDataType, else the row’s type when the target supports it, else the type the source column maps to (a character length of 0 becomes 1024), with the nullability of targetIsNullable, in targetPosition order (else ordinalPosition), and with the inherited keys plus targetKeys as primary key;

    • A table that cannot be created is refused: its entity is not created, it counts as failed and the other tables go on, where one failed creation used to stop the whole run. When the target still reports the table’s columns, the entity is created with a warning. A run with failed entities now ends with a failure instead of PASS;

    • Tables restored under another name (sourceTableName) get their target table created too, and an entity whose table the run created takes the table’s real column positions;

    • Exports write targetDataLength, targetNumericPrecision and targetNumericScale on a mapping row when the target column’s differ from the source column’s and its type uses them (lengths for character types, precision and scale for numeric types), and target-only columns carry their dimensions and targetPosition;

    • The full backup and Import All leave out Core Hub’s backup settings (Settings → Backup) and its recovery key on purpose: the recovery key is held by a person. Restore Core Hub’s own backups with its offline command (--restore-backup), then enable backups again in Settings → Backup;

    2.8.14

    Released: October 22, 2026

    • Windows container image: molo17/gluesync-bootstrapper:<version>-win-nanoserver-ltsc2022 and -ltsc2019, with latest-win-nanoserver-<ltsc> following each GA version. It runs gluesync-bootstrapper.exe on Nano Server, with no Python in the image, the same environment variables and defaults as the Linux image, and the Linux paths under C:\ (C:\opt\config, C:\logs, C:\opt\udfs). Windows containers cannot bind-mount single files: mount the folder that holds them. USE_SDK=true is not supported, and the log goes to the container’s output only;

    • hub-first-login completes the first access of a new Core Hub, setting the admin password to HUB_ADMIN_PASSWORD, and waits for Core Hub up to HUB_LOGIN_ATTEMPTS (90) times HUB_LOGIN_INTERVAL (2 seconds). It exits with 2 and a one-line error when Core Hub never answers;

    2.8.13

    Released: October 20, 2026

    • Pipeline backups and exports write the sources of the pipeline’s function collection under function-collection/ (pipeline_<pipelineId>/function-collection/ when the archive holds several pipelines). A restore publishes the collection, waits for Core Hub to compile it and every UDF of the pipeline, and installs it before it compiles the UDFs and creates the entities, because the target agent refuses an entity whose field function names a function the installed collection does not export. When the pipeline already has the same sources published, they are only installed. A collection Core Hub refuses stops the restore of that pipeline and the error lists every finding. FUNCTION_COLLECTION_PATH names a folder of sources to publish in a standalone run, and FUNCTION_COLLECTION_PUBLICATION_TIMEOUT_SECONDS (default 1800) and FUNCTION_COLLECTION_POLL_SECONDS (default 2) tune the wait;

    • Before the entities are saved, a table whose CustomFn names a function the installed collection does not export is refused, naming the table, the column and the function. When the pipeline has no collection installed yet the run only warns, as Core Hub accepts such an entity;

    2.8.10

    Released: October 20, 2026

    • Restoring an export where one source column feeds several target columns (1:N) gives each target column its own id. A target column that discovery does not report, because the target table does not exist yet, took the id of its source column, so all the targets of a fan-out shared one id and the table was refused with the column mapping of …​ names a target column more than once. Discovered target columns keep their own ids, a new column takes the id of its source column when no other target column holds it, else a fresh one, and a target key always shares the id of its target column. Two target columns with the same id are now refused naming both;

    2.8.9

    Released: October 20, 2026

    • Restoring an export onto an SQL target keeps the nullability of the target columns as exported. Pipeline exports write each column’s targetIsNullable, the nullability of its target column, next to targetPosition. A target that does not keep nullability reports every column as not nullable (DynamoDB, for one), so a restored table came back with all its target columns not nullable. Targets without a fixed schema keep taking the nullability of the source column, and exports made by earlier versions still import as before;

    2.8.8

    Released: October 19, 2026

    • Restoring an export of a pipeline whose source has no fixed schema (MongoDB, Cosmos DB, Couchbase, DynamoDB) keeps the column order of the exported pipeline. Such a source infers its columns from the documents it holds, so the order it reported on restore depended on the data at that moment: a restored table could list its columns, and map them, in another order. The columns the export lists now take, in ordinalPosition order, the positions the source reports for them. A column the source reports and the export does not list keeps its position. A listed column the source no longer has gets none. Both are logged. SQL sources are unchanged;

    • Exports of a table with an unlocked schema write targetOnlyColumns: every target column no source column feeds, such as a column a user-defined function writes, with its type, length, precision, scale, nullability and position. These columns were left out of the export, so the restored pipeline lost them. The restore puts them back at their exported position. When the target table does not exist yet, it is created from the mapped columns plus these, not from these alone;

    • Columns whose names differ only by case are kept apart on restore, for example the Cosmos DB system key id next to a document field ID. The restore used to treat them as one column and refused the table with the column row id → id of …​ is listed twice. A name now matches the column spelt exactly that way. It falls back to a case-insensitive match only when exactly one column matches, so SQL sources and targets that fold case keep working;

    2.8.7

    Released: October 19, 2026

    • Pipeline exports write each column’s targetPosition, the position of its target column in the table (0 when the target reports none), next to ordinalPosition. ordinalPosition is now the column’s place in the table. It used to follow the order in which the entity stores its columns, which differs between a pipeline created from a whitelist and one restored from an export, so two exports of the same pipeline could list the columns differently;

    • Restoring an export onto an SQL target keeps the target columns as exported. Each takes its targetPosition (else the position the target reports, else the position of its source column) instead of position 0, including for tables restored from discovery alone. The type of a mapping row now beats the type the existing target column reports, when the target supports that type: Cassandra, for example, used to give varchar columns back as text. targetDataType still wins over both;

    • Exports made by earlier versions, which have no targetPosition, still import;

    2.8.6

    Released: October 19, 2026

    • The full Core Hub backup includes user groups and Query Studio data-access policies. user-groups.yaml holds every user group (Core Hub 2.3.0.1 or later) with its description, its members (id and username) and its data-access policies; data-access-policies.yaml holds the data-access policies of each user who has any, by user id and username. Each policy keeps the id and the name of its connection. On a Core Hub without user groups the export records them as unsupported instead of failing;

    • The full restore and Import All restore them. Import All does it after the pipelines, so the policies find the connections the import recreated, and it no longer reads these two files as pipeline definitions. Members and users are found by username first, then by id, and one the target does not have is left out with a warning. Groups are matched by name, ignoring case: an existing group gets the description and members of the backup, a missing one is created;

    • A restored policy keeps its connection id when the target has it, and moves to the only target connection with the same name otherwise. When neither exists the policy is skipped and reported, since a policy on a missing connection protects nothing and still switches data-access enforcement on; a full restore on an empty Core Hub therefore reports the policies as skipped until Import All has recreated the pipelines. Policies the target has and the backup does not are left alone;

    2.8.5

    Released: October 19, 2026

    • A pipeline whose agent is not listed in agents.json keeps the entity type found in its entities when exported. An MSSQL CDC to Couchbase pipeline was exported with targetType: SQL, because couchbase-dcp is not listed, and the restore built SQL entities for the Couchbase target. agents.json now decides only the sides whose agent tag it lists; the log names what decided each side;

    • Pipeline exports keep logical partitioning: the partition column is written as customProperties.source.partitions, as the column name or as {column, maxPartitionsNumber} when the number of computed ranges is not the default, so a restored table is partitioned on the same column. The ranges themselves are never exported. They were left out entirely before, and a restored table had no logical partitions;

    • Restoring onto a NoSQL target (Couchbase, MongoDB) keeps the exported column types when the collection already exists. Types, nullability, lengths and collation come from the source column and the YAML, not from the collection’s inferred schema, which turned int and long into number, datetime into string, made every column not nullable and dropped lengths and collation. A field that is always null no longer reaches Core Hub without a type, which Core Hub refused, so the entity was not created. The collection still gives the column ids and the spelling of the names;

    • main.py fails the run when creating the entities of a schema fails. It used to log the error, report PASS - Pipeline …​ successfully configured and started and exit with 0, so a pipeline missing every entity of a schema looked configured. Every schema is still tried; then the run logs which ones failed, writes a failure result to BOOTSTRAPPER_RESULT_FILE, leaves the pipeline incomplete and not started, and exits with 1. The error line no longer prints the command line, which carried the Core Hub token;

    • automator_roundtrip.py no longer fails pipelines that restore correctly. A table created during the run has another id after the restore, so table ids, and every id that points at a table, are compared by table name; an id that matches no table still shows as a difference. The partition ranges Core Hub computes when the snapshot runs are left out of the comparison, while the partition column is still compared. A restore that exits with an error now fails the check with the last errors of restore.log, even when its result file says complete;

    2.8.4

    Released: October 15, 2026

    • Exporting AI settings with secrets works with Core Hub 2.3.0.1, which asks for the signed-in user’s current password again before it hands out secrets: ai_settings.py reads it from AI_SETTINGS_CURRENT_PASSWORD, or uses DEFAULT_PASSWORD when it signs in as admin itself, and stops before asking Core Hub when it has none. The full Core Hub backup takes it with the AI settings passphrase;

    • Passwords, passphrases, sign-in tokens and API keys no longer appear in the debug log: request and response bodies and headers show them as *;

    2.8.3

    Released: October 14, 2026

    • Internal restructuring for maintainability. Command-line options, environment variables, YAML templates and exports, and the payloads sent to Core Hub are unchanged;

    • A MultiTable chain table, or a duplicate table with target-only columns, whose discovery returns no columns no longer stops the run with an internal error: the run continues;

    • A chain column that Core Hub returns without an id is reported with the usual missing column id error, instead of an internal error;

    2.8.2

    Released: October 14, 2026

    • Duplicate tables (table@@2 keys) join the group named by their groupId, as the other tables do; they were always placed in the default group. The older group key is still read;

    • The UDFs of a duplicate table are compiled into the pipeline again: they were left out, so an entity relying on one could not run;

    • On a Core Hub older than 2.3, a target key listed in keys: with no column mapping and missing from the table is refused, naming the key. It was skipped silently when it came after a key that was found, and failed with an internal error when it came first;

    2.8.1

    Released: October 14, 2026

    • AI Studio settings backup and restore (Core Hub 2.3.0.1 or later): the new ai_settings.py exports, imports (with a dry run) and compares the AI settings of a Core Hub: LLM providers, AI Studio agents, models, skills and agent versions, remote MCP servers, Enterprise brain settings, platform API keys, budgets and conversation retention. Secrets travel only with a passphrase of at least 12 characters, read from AI_SETTINGS_PASSPHRASE. On an older Core Hub it reports that the feature needs 2.3.0.1;

    • The full Core Hub backup includes the AI settings as ai-settings.json and restores them after the users they belong to;

    • Pipeline exports keep the column order: columns are written in their position in the table, so a pipeline restored from an export maps and creates its target columns in the same order as the original. They were sorted by an internal column id before;

    • Pipeline exports keep the source settings the pipeline runs with, including unchangedDataFilterType (a restore used to turn FIELDS into DISABLED) and any key set only in the table’s source customProperties, such as maxItemsCountPerIteration;

    • Chronos schedules are exported when Chronos runs as a service of its own: the export reads Chronos through Core Hub and, when that does not answer, at CHRONOS_URL, the address the import writes to. Such an export used to leave every schedule out without a warning;

    • An export carries only the schedules of the pipeline being exported: Chronos jobs of other pipelines are no longer picked up;

    • export_all_pipelines.py keeps each pipeline’s Chronos schedules and writes the same provenance header and column types as the single-pipeline export;

    • New automator_roundtrip.py: it exports a live pipeline, restores the export as a second, stopped pipeline, exports that again, and checks that entities, groups and Chronos schedules match and that both exports are identical. The Gluesync integration tests run it on every pipeline they build;

    • START_SYNC=false configures a pipeline and leaves every entity stopped. Each run writes its pipeline id, name and outcome to BOOTSTRAPPER_RESULT_FILE (default bootstrapper-result.json next to main.py);

    2.8.0

    Released: October 13, 2026

    • Gluesync 2.3 column mapping: on a Core Hub 2.3 the Bootstrapper writes entities for the 2.3 mapping stage. The YAML columns: list is read as column relations, including N:1 (a list of sources feeding one target column), 1:N (the same source on several rows) and source columns that are read but not written; Core Hubs older than 2.3 keep receiving the single source-to-target pair as before;

    • Entity keys on Core Hub 2.3 are derived with the 2.3 key rules. A YAML that breaks them is refused before any request, naming the rule and the columns (for example keys: that are not the source table’s primary key, or a logical key next to a physical primary key);

    • MultiTable chains on Core Hub 2.3: each table pair of a chain gets the relations, keys, target columns and field functions of its SingleTable entity. Chains are built only from the schema being processed, and a chained table is no longer sent a second time as a SingleTable entity;

    • YAML export reads the 2.3 column relations, so renamed target columns, N:1, 1:N and unmapped columns survive an export and import;

    • When Core Hub refuses a chunk of entities, the chunk is sent again one entity at a time: the valid entities are saved and each refusal is logged with Core Hub’s message. The entities a run could not create are now reported in the run result, so Automator runs, imports and pipeline duplicates no longer show as successful when an entity failed;

    • UDF test requests use the Gluesync 2.3 request body. On Core Hub 2.3 a target scalar function on a target column fed by a source column is refused before the request, as the field editor does;

    • Column names are matched by their exact spelling first, falling back to a case-insensitive match only when it is unique: columns whose names differ only by case (for example id and ID in an Azure Cosmos DB document) stay two separate columns instead of being merged, and whitelist source columns are written with the spelling discovery reports;

    • Automator: duplicating a pipeline clones its UDFs before its entities, and the "create from selected tables" templates read primary keys, types and lengths from discovery correctly;

    2.7.9

    Released: October 1, 2026

    • Support for the isSnapshot parameter that Gluesync 2.3 adds to the UDF entry point (onChange(newValues, oldValues, operation, isSnapshot, logger)). Before compiling a UDF (from UDF_PATH, an import package or a pipeline duplicate) the Bootstrapper adds the parameter for a Core Hub 2.3 or later and removes it for older Core Hubs, so the same UDF source compiles on both; it stops before compiling when the UDF reads isSnapshot but targets a Core Hub before 2.3, or already declares its own isSnapshot;

    • UDF test requests carry isSnapshot (default false, a CDC row) on Core Hub 2.3 and leave it out on older Core Hubs;

    • The shipped sample UDFs and the DbMoto UDF generator use the 2.3 signature; --legacy-udf-signature makes the generator write the previous one;

    • Fixed DbMoto converter type mapping for IBM i TIMESTMP columns to SQL Server: they are now written as datetime2 instead of TIMESTAMP, which on SQL Server is rowversion (GSSD-1359);

    2.7.8

    Released: September 21, 2026

    • Hotfix for Missing entity primary keys regression from 2.7.7 Field Functions (GSSD-1355): restore IT-style {id: ID} shorthand mappings (no longer skipped as export metadata), fall back to discovery when mapping extraction yields no source columns, and set isPK=true on matching columns so CoreHub CREATE succeeds for plain SQL entities;

    2.7.7

    Released: September 20, 2026

    • Fixed Field Functions round-trip in Automator/Bootstrapper export/import (GSSD-1355): read target.entityType.fieldFunctions, emit documented YAML expression blocks, and rebuild field functions on import;

    • Entity-only export packages referenced UDF source files (udf-* / ZIP when present); full pipeline backup layout is unchanged;

    2.7.6

    Released: September 8, 2026

    • Fixed first-login password change: change_password is now defined at module scope so Hub changeRequired no longer raises NameError and falls back to the default password;

    2.7.5

    Released: September 7, 2026

    • Fixed DbMoto converter YAML/report export on Windows: force UTF-8 encoding on text reads/writes so non-ASCII metadata (e.g. Hungarian Ő) no longer crashes with UnicodeEncodeError under the Windows locale encoding;

    2.7.4

    Released: August 24, 2026

    • Fixed an issue with agent’s credentials validation;

    2.7.3

    Released: August 21, 2026

    • No Bootstrapper runtime change. Tagged together with Automator 1.4.7 so the maintenance-mode backup skip ships on main;

    2.7.2

    Released: August 20, 2026

    • Restored the original credentials-then-cert-store order. Hub 2.2.11.1 now requires agent credentials before uploading a certificate store;

    • Safe on older Hub (2.2.10.12 and earlier);

    2.7.1

    Released: July 30, 2026

    • Added support for CCSID management;

    2.7.0

    Released: June 15, 2026

    • New MCP server exposing CoreHub pipeline operations as tools for AI agents (48 tools total). Supports both SSE (via Automator) and stdio (Claude Desktop, Windsurf, Cursor) transports;

      • Entity Operations: get_pipeline_entities_status — returns real-time runtime status (isSyncActive, isMigrationActive, isBusy, errorState) for every entity in a pipeline. This is the same data the Gluesync MPP UI uses to display entity status (Active / Hold / Error);

      • Agent Management: get_agent, get_agent_raw (with secrets, requires SUPER_ADMIN), get_agent_node_info, assign_agent, unassign_agent;

      • Sync Commands: redo_sync (restart from zero), one_time_snapshot, start_group_sync, stop_group_sync;

      • Maintenance: enter_maintenance_mode, exit_maintenance_mode;

      • Global Configuration: get_global_config, get_global_config_keys, get_release_channel, set_log_level;

      • Notifications: get_notification (by ID), get_notification_count, mark_notifications_read (by ID or all);

      • Mapping Functions (UDF): list_mapping_functions, get_mapping_function_code;

      • Metrics: get_pipeline_metrics, get_agent_metrics, get_entity_metrics, get_global_metrics, get_prometheus_metrics (raw OpenMetrics text), get_agent_prometheus_metrics;

      • License & Version: get_license_info, get_corehub_version;

      • Automatic token sharing — token written to .gluesync_mcp_token on login, read automatically by the MCP server. No manual COREHUB_TOKEN environment variable needed;

      • One-click MCP client setup — added /api/mcp/status and /api/mcp/install endpoints to the Automator, with a setup card in the Settings UI for detected clients (Claude Desktop, Windsurf, Cursor);

      • stdio transport stability — fixed AttributeError during initialization and redirected sys.stdout to sys.stderr to prevent stray print() calls from corrupting the JSON-RPC protocol stream;

      • Entity status accuracy — get_pipeline_status now calls the new GET /pipelines/{pid}/entities-status REST endpoint (also added to the Kotlin backend) instead of scanning entity configuration objects for non-existent status fields. Status is now computed the same way as the MPP UI: error if errorState != null, active if isSyncActive || isMigrationActive, hold otherwise;

    2.6.1

    Released: May 29, 2026

    • Table creation now does not attempt sending physical keys creation when source table doesn’t have any;

    2.6.0

    Released: May 27, 2026

    • Version bump for Core Hub 2.2.7+ compatibility;

    2.5.3

    Released: May 19, 2026

    • Improved data type resolution during entity creation by normalizing mapped types against the target matrix canonical values and preserving valid YAML type overrides when they match supported target types;

    • Lowered log severity for expected Core Hub error statuses (for example 404 during table existence checks) to reduce false-positive error noise in normal flows;

    2.5.2

    Released: May 9, 2026

    • Fixed snapshot deletion filter not working properly;

    2.5.1

    Released: April 29, 2026

    • Improved gzip decoding;

    2.5.0

    Released: April 29, 2026

    • Added support for Gluesync 2.2.6;

    2.4.10

    Released: April 27, 2026

    • Fixed an issue where target defined columns were not picked up during entity creation;

    2.4.9

    Released: April 4, 2026

    • Warning instead of error when login fails;

    2.4.8

    Released: March 31, 2026

    • Fixed a bug with tables retrieval when using MultiTable entities and multiple schemas within the same yaml template;

    2.4.7

    Released: March 23, 2026

    • Fixed an issue with target columns not being properly mapped when having different cases;

    2.4.6

    Released: March 19, 2026

    • Added support for pipeline maintenance mode scheduling;

    2.4.5

    Released: March 18, 2026

    • Improved Vertica data type mapping;

    2.4.4

    Released: March 17, 2026

    • Improved Oracle data type mapping;

    2.4.3

    Released: March 15, 2026

    • Support for dynamic target custom properties;

    2.4.2

    Released: March 9, 2026

    • Fixed snapshot write method not being used when startin an entity;

    • Fixed a regression on legacy YAML format handling;

    2.4.1

    Released: March 7, 2026

    • Fixed an issue during import of tables with multiple occurrences of the same table name within a YAML file;

    2.4.0

    Released: March 6, 2026

    • Support for Gluesync 2.2;

    2.3.18

    Released: February 26, 2026

    • Fixed an issue with target table creation and no keys at source;

    • Azure data lake data type mapping improvements;

    2.3.17

    Released: February 26, 2026

    • Create target table with declared keys when source tables has none;

    2.3.16

    Released: February 25, 2026

    • Enhaced data type mapping;

    2.3.15

    Released: February 25, 2026

    • Major refactor on data types management with the introduction of data type matrix;

    2.3.14

    Released: February 25, 2026

    • Fixed an issue with create table processing and columns ids exports;

    2.3.13

    Released: February 22, 2026

    • Support for new Chronos schedules types (redo api);

    2.3.12

    Released: February 19, 2026

    • Fixed an issue with case sensitiveness applied when attempting to perform table’s creation;

    2.3.11

    Released: February 15, 2026

    • Added support for pre & post snapshot queries as per Gluesync 2.1.11;

    2.3.10

    Released: February 2, 2026

    • Added support for SQL where clauses applied at source database level;

    2.3.9

    Released: January 19, 2026

    • Added support for bulk loads at entity level;

    2.3.8

    Released: January 16, 2026

    • Fixed import of document keys;

    • Fixed import of filters;

    • Minor fixes and improvements;

    2.3.7

    Released: January 14, 2026

    • Minor fixes;

    2.3.6

    Released: December 19, 2025

    • Better handling of target table type matching;

    2.3.5

    Released: December 10, 2025

    • It is not longer necessary to manually declare the source & target agents types, those will be derived from the embedded agents.json;

    2.3.4

    Released: December 8, 2025

    • Enriched metadata for full pipeline export;

    2.3.3

    Released: December 6, 2025

    • GSSD-442: when using "targetOnlyColumns" with "lockedSchema" set to true, you’ll prompted with an error;

    2.3.2

    Released: December 6, 2025

    • Support for source & target type within .yaml (both for import & export);

    2.3.1

    Released: December 5, 2025

    • Added support for pipeline export (also in bulk);

    2.3.0

    Released: November 28, 2025

    • Added support for Logical partitions;

    • Timeout is now float;

    2.2.7

    Released: November 19, 2025

    • Added support for Tables Id as per GS 2.1.8.1;

    2.2.6

    Released: November 7, 2025

    • Added support for table creation outside "targetOnlyColumns";

    2.2.5

    Released: October 15, 2025

    • Fixes around URL encoding during api calls;

    2.2.4

    Released: October 10, 2025

    • Suppress additional table discovery checks when not needed;

    2.2.3

    Released: October 9, 2025

    • API updates for table creation;

    2.2.2

    Released: October 3, 2025

    • Re-added back snapshot write method param;

    2.2.1

    Released: October 2, 2025

    • Improved handling of Chains;

    2.2.0

    Released: September 25, 2025

    • Support for unlocked schema APIs;

    2.1.16

    Released: September 23, 2025

    • Support for conditional deletion ahead of snapshot task;

    • Support for custom snaphost method property (e.g. INSERT / UPSERT).

    2.1.15

    Released: September 16, 2025

    • Added support for Conductor’s APIs;

    2.1.14

    Released: September 15, 2025

    • Improvements and fixes around the table creation APIs;

    2.1.13

    Released: September 3, 2025

    • Fixed table keys declaration;

    2.1.12

    Released: September 1, 2025

    • void tag

    2.1.11

    Released: August 28, 2025

    • Support for multiple schemas within the same given .yaml file;

    2.1.10

    Released: August 26, 2025

    • Fixed chains creation;

    • Readme updated;

    2.1.9

    Released: August 25, 2025

    • Avoid table’s discovery if CREATE_TABLES_IF_NOT_EXIST is set to false;

    2.1.8

    Released: August 25, 2025

    • Support for groups' scheduling;

    2.1.7

    Released: August 22, 2025

    • Handle multiple schemas within the same given .yaml file;

    2.1.6

    Released: August 20, 2025

    • Make the pipeline name configurable;