Bootstrapper

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.
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 all pipelines with IDs and completion status |
|
Full config and agent details for a pipeline |
|
High-level health summary (syncing / idle / erroring / paused) |
|
Real-time runtime status for every entity ( |
|
Agent configuration (raw includes secrets, requires |
|
Attach or detach agents from pipelines |
|
Control replication and snapshots |
|
Pause and resume without losing checkpoints |
|
Browse and acknowledge CoreHub events |
|
Real-time throughput and raw Prometheus text |
|
Read UDF source code |
|
Export pipeline config to YAML for migration |
|
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:
-
Automatic (recommended) — Log in via the Automator web UI. The token is written to
.gluesync_mcp_tokenin the project root and read automatically by the MCP server. -
Environment variable — Set
COREHUB_TOKENin the shell or client config. -
Tool argument — Pass
tokendirectly 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:
-
Detect each client’s config path
-
Safely merge the Gluesync MCP server entry
-
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:
-
Schema configuration (
table-list-template.yaml) -
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"
Usage
Getting Started
Before using the Bootstrapper, you need:
-
A running Gluesync deployment with Core Hub accessible
-
Authentication credentials for the Core Hub API
-
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:
-
By logging in to the Core Hub Web UI and copying the token from the browser’s cookies
-
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.,SQLfor RDBMSs,NoSQLfor NoSQL databases) -
--target-type: Required. Target agent type (e.g.,NoSQLfor NoSQL databases,SQLfor 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
entityNamein any schema. Before, an entity whose name is notSCHEMA.TABLE(for example one named after a DBMoto replication,REPL_ORDERSforAPP_DAT.ORDERS) was attached to the alphabetically first source schema under a made-up table with no columns. Importing that YAML failed withno 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-shadowis no longer recognised; -
HTTP Source tokens carry the
gluesync.https_agentpermission scope, which replacesgluesync.endpoint_inbound. Eachcourier.tokensentry is limited to the collections it is for (every configured collection by default) throughcollectionScopes. 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_TOKENrefusal now says to add one tocourier.tokens. An inboundbasePathis one path segment,blockedTokenIdsis 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": truethe move is sent with?force=trueand every header value again.baseUrlcannot carryuser: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 thecourierblock of every HTTP agent of a pipeline, in the shapeconfig.jsontakes. 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 TABLEto the target’s usual case unless told not to, sofirst_namebecameFIRST_NAMEon Oracle and SAP HANA while the entities keptfirst_name. The request now sendsapplyDefaultCase: 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,_RRNand 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’stechnicalFieldsand discover again, instead of an unmatched-column error._RRN_COLUMNis read as_RRN; -
On an IBM i source, a table key with
@@(multi-member) is refused with a message namingspecificConfiguration.enableMultiMemberwhen that option is off; -
After installing a function collection, entity creation waits until the functions the
CustomFncolumns 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 withDOCUMENT_KEYSPACE_SHARED. The import reads the pipeline’s entities first, a draft with the name of a saved entity takes itsentityIdand, per side, itsagentEntityId, 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 acourierblock, 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,BearerorApiKey) 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 thecolumnsmapping maps source columns onto bindings. Target entities are created asNoSqlEntity, noCREATE TABLEis 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
pipelineIdandagentIdset 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 andforce(to change an endpoint that another pipeline’s entities read) are supported; -
courier.tokenscreates 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 itsoutputFile(owner-only), never to the log; -
customHostCredentials.outboundCollectionorinboundCollectionis filled in when exactly one collection is configured. Thecourierblock is checked with the rules Core Hub applies before anything is sent;
-
-
Credentials are hidden in more debug logs: the value of an
ApiKeyauthentication, the value of a header whose name is a credential (such asAuthorization), and the agent entries the Bootstrapper prepares, which carry the host credentials and thecourierblock;
2.8.20
Released: November 5, 2026
-
A dry-run is reported as
dry-run, notcompleted, and a dry-run that hit errors asfailed. A run always leaves therunningstate, and entity and backup runs share one lock; -
An existing target table whose columns differ from the YAML is reported with a warning (the
CREATEis 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 whencustomProperties.source.partitionsis absent; -
Filter operators accept the spellings and symbols in common use and send the Core Hub names:
<,ltandLessThanbecomeLower,⇐,lteandLessThanOrEqualbecomeLowerEqual,GreaterThanbecomesGreaterandGreaterThanOrEqualbecomesGreaterEqual; -
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=skipso the entities already imported are kept. Concurrent requests share one login; -
An unreadable
GET /versionis 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.Zor setCOREHUB_VERSIONwhen the Core Hub is 2.3 or later; -
Oracle: an unconstrained
NUMBERcolumn is no longer created asNUMBER(0,0). Discovery omits the precision, the template, the export and the table creation invented a precision of0, and Oracle refused the statement withORA-01727. The precision and scale stay empty, and Core Hub creates a bareNUMBER; -
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.pyandgs1_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,catalogandstagingVolume, and the custom fields of Snowflake and BigQuery. Core Hub reports them ashostCredentialsCustomPropertiesand the backup readcustomHostCredentials, so every agent was written with an empty map. The backup reads either name and writescustomHostCredentials, 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 --includeand--exclude(repeatable) select the tables to create without a plan file: each takes an exactSCHEMA.KEY(@@nincluded) or a unique entity name, builds a one-pipeline plan, and merges into--planwhen both are given. A bareSCHEMA.TABLEstill means every@@nvariant. 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 ontable. 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.jsonapplies it,--write-plan plan.jsondrafts 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,updateorfail), 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,onExistingPipelineor 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.zipruns Import All of a backup ZIP from the command line, reading the Core Hub password from an environment variable (GS_COREHUB_PASSWORDby default). It exits with0when every pipeline is fully imported,2when a pipeline is partially imported and1when nothing is imported or the request is refused. It works with Core Hub before 2.3 too; -
Custom backup import:
--write-plan plan.jsonwrites the plan of a backup and--plan plan.jsonimports 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-runchecks the plan and writes nothing. Unknown pipelines, tables or agents, a plan that selects nothing and a name clash withonExistingPipeline: failare 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_FILEorGS_IMPORT_AGENT_OVERRIDES(inline JSON). Passwords come only fromGS_IMPORT_AGENT_PASSWORD_<TAG>or the variablepasswordEnvnames. 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-pipelinepicks 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_PIPELINEchooses what happens to a pipeline name that already exists:suffix(default) orfail. A pipeline left half-created is reported with its id. WithGS_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.pyoptions 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-validateand--strict-validate,--on-existing skip|update|failand--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
targetSchemawhose snapshot commands all name one other schema is created in that schema, and is listed in the warnings.--no-infer-target-schemaorGS_IMPORT_INFER_TARGET_SCHEMA=falseturns 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-validaterefuses 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_*andpasswordEnv, 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, andDBMOTO_REMAPapplies 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_EXISTSis 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 showedThe target table returned no columns. The table is built from the exported mapping rows: one column per target a row writes, typed bytargetDataType, else the row’stypewhen the target supports it, else the type the source column maps to (a character length of 0 becomes 1024), with the nullability oftargetIsNullable, intargetPositionorder (elseordinalPosition), and with the inherited keys plustargetKeysas 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,targetNumericPrecisionandtargetNumericScaleon 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 andtargetPosition; -
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-ltsc2022and-ltsc2019, withlatest-win-nanoserver-<ltsc>following each GA version. It runsgluesync-bootstrapper.exeon Nano Server, with no Python in the image, the same environment variables and defaults as the Linux image, and the Linux paths underC:\(C:\opt\config,C:\logs,C:\opt\udfs). Windows containers cannot bind-mount single files: mount the folder that holds them.USE_SDK=trueis not supported, and the log goes to the container’s output only; -
hub-first-logincompletes the first access of a new Core Hub, setting the admin password toHUB_ADMIN_PASSWORD, and waits for Core Hub up toHUB_LOGIN_ATTEMPTS(90) timesHUB_LOGIN_INTERVAL(2 seconds). It exits with2and 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_PATHnames a folder of sources to publish in a standalone run, andFUNCTION_COLLECTION_PUBLICATION_TIMEOUT_SECONDS(default 1800) andFUNCTION_COLLECTION_POLL_SECONDS(default 2) tune the wait; -
Before the entities are saved, a table whose
CustomFnnames 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 totargetPosition. 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
ordinalPositionorder, 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
idnext to a document fieldID. The restore used to treat them as one column and refused the table withthe 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 toordinalPosition.ordinalPositionis 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. Thetypeof a mapping row now beats the type the existing target column reports, when the target supports that type: Cassandra, for example, used to givevarcharcolumns back astext.targetDataTypestill 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.yamlholds 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.yamlholds 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.jsonkeeps the entity type found in its entities when exported. An MSSQL CDC to Couchbase pipeline was exported withtargetType: SQL, becausecouchbase-dcpis not listed, and the restore built SQL entities for the Couchbase target.agents.jsonnow 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
intandlongintonumber,datetimeintostring, 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.pyfails the run when creating the entities of a schema fails. It used to log the error, reportPASS - Pipeline … successfully configured and startedand 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 afailureresult toBOOTSTRAPPER_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.pyno 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 ofrestore.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.pyreads it fromAI_SETTINGS_CURRENT_PASSWORD, or usesDEFAULT_PASSWORDwhen it signs in asadminitself, 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@@2keys) join the group named by theirgroupId, as the other tables do; they were always placed in the default group. The oldergroupkey 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.pyexports, 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 fromAI_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.jsonand 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 turnFIELDSintoDISABLED) and any key set only in the table’s sourcecustomProperties, such asmaxItemsCountPerIteration; -
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.pykeeps 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=falseconfigures a pipeline and leaves every entity stopped. Each run writes its pipeline id, name and outcome toBOOTSTRAPPER_RESULT_FILE(defaultbootstrapper-result.jsonnext tomain.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
idandIDin 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
isSnapshotparameter that Gluesync 2.3 adds to the UDF entry point (onChange(newValues, oldValues, operation, isSnapshot, logger)). Before compiling a UDF (fromUDF_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 readsisSnapshotbut targets a Core Hub before 2.3, or already declares its ownisSnapshot; -
UDF test requests carry
isSnapshot(defaultfalse, 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-signaturemakes the generator write the previous one; -
Fixed DbMoto converter type mapping for IBM i
TIMESTMPcolumns to SQL Server: they are now written asdatetime2instead ofTIMESTAMP, which on SQL Server isrowversion(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 setisPK=trueon 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 YAMLexpressionblocks, 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_passwordis now defined at module scope so HubchangeRequiredno longer raisesNameErrorand 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
UnicodeEncodeErrorunder the Windows locale encoding;
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.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, requiresSUPER_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_tokenon login, read automatically by the MCP server. No manualCOREHUB_TOKENenvironment variable needed; -
One-click MCP client setup — added
/api/mcp/statusand/api/mcp/installendpoints to the Automator, with a setup card in the Settings UI for detected clients (Claude Desktop, Windsurf, Cursor); -
stdio transport stability — fixed
AttributeErrorduring initialization and redirectedsys.stdouttosys.stderrto prevent strayprint()calls from corrupting the JSON-RPC protocol stream; -
Entity status accuracy —
get_pipeline_statusnow calls the newGET /pipelines/{pid}/entities-statusREST 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:erroriferrorState != null,activeifisSyncActive || isMigrationActive,holdotherwise;
-
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.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
typeoverrides 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.4.10
Released: April 27, 2026
-
Fixed an issue where target defined columns were not picked up during entity creation;
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.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.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.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.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.8
Released: January 16, 2026
-
Fixed import of document keys;
-
Fixed import of filters;
-
Minor fixes and improvements;
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.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.1.16
Released: September 23, 2025
-
Support for conditional deletion ahead of snapshot task;
-
Support for custom snaphost method property (e.g. INSERT / UPSERT).