Skip to content

dse120071750/m8m-harness-builder / skills/m8m/m8m-mcp-connection-builder

m8m-mcp-connection-builder

Verified

Author reusable MCP connection context and usage guides locally, then deliver an authorized installation to the configured M8M tenant's persistent server installer. Use for new connections or explicit version changes.

references/server-delivery.md

View on GitHub
# Deliver reusable authoring to the server installer

Use this reference when exporting or delivering locally authored MCP connection
context, a Harness, Task template or schedule definition. The loaded skill includes its client
scripts and adjacent common module; a separate platform checkout is unnecessary.
Python standard-library helpers export/transfer context. The server-resident
Codex installation Task understands that context, adapts it to its server
standard and performs the real installation.

## Collect faithful source

Preserve complete Gems/master prompts, graph and output schemas, implementation,
assets, dependency notes, requested models/budgets and connection requirements.
Include repository code needed by imported handlers, not just the harness folder.
Attach source and resource files needed for adaptation. Existing packages and
Windows runtime archives are useful provenance; a matching Linux executable
is not an intake requirement. Preserve original bytes and do not rewrite an old
package's proofs to label changed source unchanged.

Use the loaded skill's `scripts/m8m_local_bundle.py --help`. `task` and `schedule`
export reusable definitions; `bundle` collects selected files/directories into
an archive without imposing one semantic intake schema. For example:

```text
python "<loaded skill directory>/scripts/m8m_local_bundle.py" bundle --source <source-directory> --source <resource-file> --output <intake.zip>
```

The client helpers use only Python's standard library. Selected source and
transport collection are bounded at 64 MiB per file and 512 MiB total; choose
required context without truncating complete prompts or implementation files.
The exporter preserves source schemas and context; the server validates its
structured prepared output. Referenced workflows/resources are not automatically
included or resolved by an export. Supply their source or enough context for
server discovery. Do not include credentials, client Codex sign-in, local live
rooms/threads/waits, progress, ledger state or old business outputs as reusable
state. Inspect the selected source for secrets; filename screening is not proof
that arbitrary source content is credential-free.

## Select the destination and submit

Use an explicitly configured target JSON containing the approved SSH alias,
environment, canonical `tenant_id`, installation owner and server installer
entrypoint argument array. Its schema is `m8m.installer_target.v1`; the client
`--help` includes the supported target fields. All values in this example are
placeholders that must come from an existing approved server configuration:

```json
{
  "schema": "m8m.installer_target.v1",
  "ssh_alias": "<approved SSH alias>",
  "tenant_id": "<canonical tenant>",
  "environment": "<configured environment>",
  "installation_owner": "<approved owner>",
  "remote_entrypoint": ["<trusted preconfigured tenant installer launcher>"]
}
```

`remote_entrypoint` is an argument vector, with any required launcher arguments
supplied by that configuration. The trusted launcher already resolves the
correct tenant OS identity, environment and server settings; do not guess an OS
user, host path or sudo command from a package. The server entrypoint must already
be configured for that tenant and authenticated installation identity. Target
labels and an owner string cannot establish server authority. Do not infer an
SSH host, tenant or owner from uploaded content or copy a remembered target.
Use configured SSH authentication and host-key checks; keep credentials out of
the target file and source bundle.

Write a brief describing the intended installed behavior, required resources,
any exact model requirements and the requested installation scope. Preserve
existing authorization: an explicit request to install authorizes this handoff.
Ordinary authoring exports the artifact without silently submitting it. Do not
add business execution or schedule activation to an installation-only brief.

Run the bundled transport client, using a stable UUID for this submission:

```text
python "<loaded skill directory>/scripts/m8m_deploy.py" --target <configured-target.json> submit --intake <file-or-directory> --brief <installation-brief.md> --operation-id <stable-client-UUID> --model <approved-installer-model> --reasoning-effort <approved-effort>
```

Select the approved installer-session model independently of the product's
preserved runtime/Task model. Do not silently substitute either model to resolve
availability. The transfer goes through the authenticated server entrypoint to
its private installer staging. Never deliver a local package by direct workflow
registration, Task registration, schedule creation or runtime-selection APIs.
The installer owns destination discovery, runtime build, compilation, binding
resolution, validation, installation and its structured receipt. The authenticated
installer UI is an alternative handoff to this same installation architecture.

## Follow the same installation

Record the returned canonical tenant, actual owner, client submission UUID and
server operation ID. Verify the tenant matches the selected target. Retrying an
uncertain submission uses the same client UUID and identical brief/context;
read the existing operation instead of creating a replacement installation.
A local disconnect does not end the server Codex thread.

```text
python "<loaded skill directory>/scripts/m8m_deploy.py" --target <configured-target.json> status --operation-id <returned-server-operation-id>
python "<loaded skill directory>/scripts/m8m_deploy.py" --target <configured-target.json> continue --operation-id <returned-server-operation-id> --message-id <stable-followup-UUID> --text <followup.md>
```

A follow-up supplies missing context to that same operation. Reuse its message
UUID after an uncertain response. Do not start a local Codex installation
session, manufacture a business Task room or replay completed installations to
repair a lost response. Missing source, destination capabilities, connections,
models or grants stay evidenced blockers until resolved within authorized scope.

## Read back the result

Report installation only from actual member readbacks and the installer's final
reference/receipt. Include destination workflow import/release pins, immutable
Task-template IDs/digests or schedule IDs/targets, as applicable. Distinguish
installed state, current readiness, unresolved needs and any authorized actual
execution verification. Transfer success is not installation; installation is
not proof of business execution or publication.

New installed schedules are inactive. A Task template is reusable definition;
an authenticated launch admits a fresh live Task through the normal runtime.
Separate specific authority and server grants control template selection,
schedule activation and business execution. Existing live Task progress, wait
reminders and schedule lifecycle operations use their normal scoped runtime
tools and do not reinstall the authoring package.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall