agentleFS
samwelmungasamwelmunga/jenga-npm/.agents/skills/j-publish/SKILL.md

j.publish

Skill0 starsChanged 23 days agoApache-2.0View on GitHub

Configure, validate, and orchestrate scaffolded release workflows through a single `/publish` entry point with bounded sub-commands.

  • Reads credentials

The file

Show its rules and text

We split this skill into the rules it gives an agent

17 rules. About 0 are common, 7 are distinctive, and 10 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈7

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 10

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Every sub-command validates the config before doing anything else, so behaviour is identical regardless of which target type a project uses.

    line 57
  2. Distinctive:

    Before any sub-command executes, validate the config with:

    line 61
  3. Very specific:

    Default config resolution: prefer repo-root publish.json, fall back to project/configs/publish.json

    line 73
  4. Very specific:

    If config or env validation fails, the skill exits with code 4 and does not continue.

    line 82
  5. Very specific:

    Not gated: setup (writes only local publish.json), history, release-notes, stage list, view, download, test and reject, and any --dry-run …

    line 107
  6. Very specific:

    Follow "Calling the checker from a skill" in that document: mint one run id for the invocation, call checklist.sh check pre-release --run …

    line 111
  7. Distinctive:

    Check target completeness.

    line 198
  8. Very specific:

    Update the standing CHANGELOG.md's [Unreleased] section with new entries since the last publish tag (or use the caller-supplied file …

    line 202
  9. Very specific:

    Run post-deploy gates and downgrade the ledger state to partial on failure

    line 206
  10. Distinctive:

    Every step from target selection through gates, release-note generation, and semver bump runs normally.

    line 215
  11. Very specific:

    Use --dry-run to rehearse a release, validate that gates pass, and confirm the generated release notes without publishing.

    line 228
  12. Very specific:

    Use /publish stage to rehearse and smoke-test a release before it goes live — the point of staging is that a bad tarball is caught in …

    line 286
  13. Very specific:

    If no prior ledger-backed tag exists, a --output draft includes > First release — full history included.

    line 310
  14. Distinctive:

    Scrum Master: never deploys directly and only reviews publish context through workflow status surfaces

    line 330
  15. Very specific:

    Every target — regardless of type — must define:

    line 344
  16. Distinctive:

    Before the first deploy, link the package to the repository on npmjs.com:

    line 407
  17. Distinctive:

    Before the first deploy, the target host must already have:

    line 458

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Publish — Deployment Pipeline Orchestrator

skills/j-publish/ is the canonical, hand-edited directory for this skill, per CLAUDE.md's "The Canonical Naming Contract" (the E50 reopening of 2026-09-09, which promoted skills/j-publish/ from generated twin to sole canonical form). The j- prefix is there for collision safety — a real directory under a distinct name, so a host tool shipping its own same-named built-in command cannot shadow it (Claude Code's native skill resolution is a literal-string, directory-name-based match; see project/documentation/skill-authoring.md's "Invocation Convention").

⚠️ scripts/generate-j-alias.sh was retired by E50_S14 and no longer exists — there is nothing to run. This file was previously generated from a bare skills/publish/SKILL.md source; E50_S15 deleted that directory. This file is now the sole canonical, hand-edited source for this skill — edit it directly.

/publish is the single entry point for release workflows in this repository. It wires configuration validation, setup, gated deployment, release-note drafting, and ledger history into one end-to-end flow, and dispatches the final publish step to a per-type adapter.

Four target types are currently supported:

  • mobile-ios — publishes an iOS build to App Store Connect via the iOS adapter. See the iOS App Store section for iOS-specific configuration.
  • npm — publishes a package to an npm registry via the npm adapter. See the npm adapter (skills/j-publish/adapters/npm.md) and the npm wizard (skills/j-publish/wizards/npm.md) for npm-specific configuration.
  • npm-ci — publishes a package to npmjs.com via GitHub Actions OIDC (Trusted Publishers), with no NPM_TOKEN stored. The adapter generates a GitHub Actions workflow, commits it to the repository, and triggers it via gh workflow run. See the npm-ci adapter (skills/j-publish/adapters/npm-ci.md) and the npm-ci wizard (skills/j-publish/wizards/npm-ci.md) for configuration details.
  • droplet — deploys a website or app to any SSH-reachable Linux host (including DigitalOcean Droplets) using a generated GitHub Actions workflow. The workflow SSHes into the host, pulls the deploy branch, runs an optional build command, and restarts the service. See Droplet (GitHub Actions → SSH) for configuration details.

Every sub-command validates the config before doing anything else, so behaviour is identical regardless of which target type a project uses.

Invocation Contract

Before any sub-command executes, validate the config with:

bash skills/j-publish/scripts/validate_config.sh <path-to-publish.json>

For deploy-oriented flows, validate the selected target with:

bash skills/j-publish/scripts/check_target_config.sh <target-name> <path-to-publish.json>
  • Default config resolution: prefer repo-root publish.json, fall back to project/configs/publish.json
  • Schema: skills/j-publish/schemas/publish.schema.json
  • Example config: skills/j-publish/assets/publish.example.json
  • Secrets guide: skills/j-publish/assets/secrets-guide.md
  • Deploy contract and exit codes: skills/j-publish/assets/ci-contract.md
  • iOS adapter template: skills/j-publish/adapters/mobile-ios.md
  • npm adapter template: skills/j-publish/adapters/npm.md
  • Ownership matrix: skills/j-publish/assets/ownership-matrix.md

If config or env validation fails, the skill exits with code 4 and does not continue.

Sub-Commands

CommandPurposeImplementation scriptNotes
/publish setupPrepare or refresh target configurationskills/j-publish/scripts/setup_wizard.shSupported types: mobile-ios, npm, npm-ci, droplet
/publish deployRun the full 11-step deploy orchestrationskills/j-publish/scripts/publish_deploy.shDispatches to the adapter for the target's type (mobile-ios, npm, npm-ci, or droplet); --dry-run is honoured end-to-end
/publish stageStage an npm release into npm's staged-publishing area, smoke-test it in isolation, then approve or reject itskills/j-publish/scripts/npm_stage_pipeline.sh (the publish sub-command) and skills/j-publish/scripts/npm_stage_inspect.sh (list, view, download, test, approve, reject)Supported for npm and npm-ci target types only
/publish historyRead the canonical publish ledgerskills/j-publish/scripts/show_history.shTarget-agnostic; filter by --target <name>
/publish release-notesMerge new release notes into the standing CHANGELOG.md (or a standalone draft via --output) without publishingskills/j-publish/scripts/generate_release_notes.shTarget-agnostic

Pre-release gate

Fires pre-flight checklist phases pre-release then pre-publish (project/documentation/preflight-checklists.md) at exactly one point per gated invocation: after the Invocation Contract's config validation and before the sub-command's implementation script is started, so nothing outward-facing has happened and nothing local has been written (deploy edits CHANGELOG.md in its step 6, so the check must come first).

Gated, because each performs an action on the registry, the git remote or CI that cannot be taken back:

  • deploy, when not --dry-run
  • stage publish, when not --dry-run
  • stage approve, when not --dry-run

Not gated: setup (writes only local publish.json), history, release-notes, stage list, view, download, test and reject, and any --dry-run (every adapter skips its outward step). The reasoning for each is in the schema document's "Release skills: gated sub-commands and modes".

Follow "Calling the checker from a skill" in that document: mint one run id for the invocation, call checklist.sh check pre-release --run <id>, resolve it fully, and only then call checklist.sh check pre-publish --run <id> with the same id. A block failure from either phase halts before the script starts. Exit 3 from pre-publish means "no items for this phase" and continues silently; exit 3 from pre-release is a genuine error and is surfaced. --yes and --non-interactive configure the deploy script's own prompts only: they do not answer a checklist confirm item, and with no user to ask, an unresolved confirm or block item means stop with the reason stated, never proceed. With no registry, or an empty one, the gate is silent and /publish behaves exactly as before.

Mark the situation. Immediately after minting the run id and before the first check, write the situation marker, and clear it on every exit path (success, a block halt, a declined confirm, an error):

MARKER="$([ -f scripts/checklist-marker.sh ] && echo scripts/checklist-marker.sh || echo node_modules/@jenga-ai/agent/scripts/checklist-marker.sh)"
TOKEN="$(bash "$MARKER" write --situation pre-release --run "$RUN_ID" --skill j.publish)"
bash "$MARKER" clear --token "$TOKEN"

This is what lets the enforcing hook see the phase; the protocol, the stack semantics and the TTL are in "Situation marker" in that document. A failed write is not a reason to abandon the phase — the gate above still runs and only the hook-enforced backstop is lost: report its stderr and continue.

Two phases, so write a second frame for pre-publish before its own check and clear innermost-first — or just clear the pre-release token, which pops the inner frame with it. Only a gated invocation writes a marker: the ungated sub-commands and every --dry-run listed above have no phase to mark.

Quality Gate Policy

The deploy flow invokes skills/j-publish/scripts/run_gates.sh at two fixed points:

  1. Pre-deploy: run_gates.sh pre <target> <publish.json> [--non-interactive]
  2. Post-deploy: run_gates.sh post <target> <publish.json> [--non-interactive]
  • build and test are mandatory global pre-deploy gates — always run, cannot be disabled via config
  • Per-target checks.pre and checks.post can add optional gates: lint, type-check, custom-script, smoke-test, ping
  • Any pre-deploy gate failure exits with code 2 and surfaces the full error output
  • Post-deploy gate failure records a partial publish result instead of rolling back the adapter upload
  • --non-interactive suppresses retry prompts and aborts immediately on failure

See skills/j-publish/assets/ci-contract.md for the full quality-gate policy.

Usage Signatures

/publish setup

/publish setup [<target>] [--type mobile-ios|npm|droplet] [--config <path>]

Implementation: bash skills/j-publish/scripts/setup_wizard.sh [<target>] [--type <deployment_type>] [--config <path>]

Wizard flow:

  1. Resolve or prompt for the target name.
  2. Resolve or prompt for the deployment type. Supported values: mobile-ios, npm, droplet.
  3. Print the secrets guide path and the opening warning from skills/j-publish/assets/secrets-guide.md.
  4. Load skills/j-publish/wizards/<type>.md and render each ## Question: section as a prompt.
  5. Preview the generated target config as JSON.
  6. Save on confirmation by merging or creating publish.json.
  7. Validate the saved file with validate_config.sh; if validation fails, roll back the write.

During setup, env-var reference answers are checked against the current shell. Missing variables only warn; they do not block save.

Example invocations:

/publish setup                              # interactive, prompts for target and type
/publish setup --type mobile-ios            # scaffold an iOS App Store target
/publish setup --type npm                   # scaffold an npm registry target
/publish setup npm-registry --type npm      # scaffold a target named "npm-registry"
/publish setup --type npm-ci                   # scaffold an npm CI (Trusted Publisher) target
/publish setup npm-ci-pkg --type npm-ci        # scaffold a target named "npm-ci-pkg"
/publish setup --type droplet               # scaffold a Droplet SSH deploy target
/publish setup my-droplet --type droplet    # scaffold a target named "my-droplet"

/publish deploy

/publish deploy [--target <name>] [--config <path>] [--yes] [--dry-run] [--minor | --major] [--notes-file <path>]

Implementation: bash skills/j-publish/scripts/publish_deploy.sh [flags...]

Deploy flow:

  1. Select the target from config or --target
  2. Check target completeness; interactive runs auto-launch the setup wizard on missing fields
  3. Validate target environment variables
  4. Print a best-effort scrum-board summary since the last publish tag
  5. Run pre-deploy gates
  6. Update the standing CHANGELOG.md's [Unreleased] section with new entries since the last publish tag (or use the caller-supplied file instead, when release notes are supplied via the bypass flag), and review it unless --yes is set
  7. Suggest and confirm the semver bump (patch by default in non-interactive mode unless --minor or --major is passed)
  8. Print final confirmation: Deploy v<x.y.z> to <target>? [y/N]
  9. Execute the adapter pipeline for the target's type (ios_pipeline.sh for mobile-ios, npm_pipeline.sh for npm, npm_ci_pipeline.sh for npm-ci, droplet_pipeline.sh for droplet)
  10. Run post-deploy gates and downgrade the ledger state to partial on failure
  11. Finalize CHANGELOG.md — stamp [Unreleased] to a versioned, dated entry and open a fresh empty [Unreleased] above it (skipped on --dry-run, and skipped when release notes were supplied via the bypass flag, since there is then no standing-file [Unreleased] section to finalize) — then append the publish ledger entry, create the git tag (unless --dry-run), and print post-deploy manual steps

Non-interactive rule: when --yes is used, deploy must not auto-run setup after a failure. It exits 4 and surfaces the missing fields.

--dry-run

--dry-run runs the full deploy orchestration end-to-end without producing a real release:

  • Every step from target selection through gates, release-note generation, and semver bump runs normally.
  • The adapter is invoked with --dry-run so it performs its full pipeline but skips the destructive publish step (no App Store upload for mobile-ios, no npm publish for npm).
  • The real git tag is not created.
  • A ledger entry is still appended with platform_state: "dry-run" so the run is auditable.

Example invocations:

/publish deploy --target staging-appstore --dry-run
/publish deploy --target npm-registry --dry-run
/publish deploy --target npm-ci-pkg --dry-run

Use --dry-run to rehearse a release, validate that gates pass, and confirm the generated release notes without publishing.

/publish stage

Staged publishing for npm/npm-ci targets only. Not available for mobile-ios or droplet — those adapters have no staging area to dispatch to. The lifecycle is stage → test → approve, with reject as the discard path at any point after staging:

staged ──▶ stage_tested ──▶ approved   (approve requires 2FA; refuses without
   │             │                      a passing test unless --force <reason>)
   │             │
   └─────────────┴──▶ rejected   (discard path — available from any staged state)

Two registry constraints trip people up and are worth stating plainly:

  • The package must already exist on the registry. npm's staged-publishing workflow only applies to a package that has had at least one normal, non-staged publish already — validate_npm_stage_env.sh checks this up front and exits 4 if it doesn't hold.
  • Approval requires 2FA; staging does not. npm stage publish (the stage sub-command below) can run non-interactively in CI. npm stage approve cannot — npmjs.com requires an interactive one-time-password step for approval, so it is always a human action even when staging was automated (see the npm-ci adapter's OIDC staging section for the CI-stage, human-approve split).

All seven sub-commands:

/publish stage publish <target> <path-to-publish.json> [--dry-run] [--non-interactive] [--otp <otp>]
/publish stage test <stage-id> [--keep] [--config <path>] [--dry-run] [--json]
/publish stage list [<package-spec>] [--config <path>] [--dry-run] [--json]
/publish stage view <stage-id> [--config <path>] [--dry-run] [--json]
/publish stage download <stage-id> [--out <dir>] [--config <path>] [--dry-run] [--json]
/publish stage approve <stage-id> [--otp <otp>] [--force <reason>] [--config <path>] [--dry-run] [--json]
/publish stage reject <stage-id> [--config <path>] [--dry-run] [--json]

Implementation:

  • publish → bash skills/j-publish/scripts/npm_stage_pipeline.sh <target> <path-to-publish.json> [--dry-run] [--non-interactive] [--otp <otp>] — six ordered phases (validate, gates, pack, stage, capture, ledger); writes a staged ledger entry on success.
  • test, list, view, download, approve, reject → bash skills/j-publish/scripts/npm_stage_inspect.sh <sub> [args] [--config <path>] [--dry-run] [--json]
    • test downloads the exact staged tarball into an isolated scratch directory outside the repo, installs it, runs the target's npm.stage.smoke_cmd (or the documented default check), and writes a stage_tested ledger entry (pass/fail).
    • approve refuses to run unless a passing test is on record for that exact stage id, unless --force <reason> is given; writes an approved ledger entry.
    • reject is the discard path omitted from npm's own staged-publishing docs page — documented here so it stays discoverable; writes a rejected ledger entry.

Example invocations:

/publish stage publish npm-registry ./publish.json --dry-run
/publish stage test <stage-id>
/publish stage approve <stage-id>
/publish stage reject <stage-id>

Use /publish stage to rehearse and smoke-test a release before it goes live — the point of staging is that a bad tarball is caught in isolation instead of being caught by users after npm publish.

/publish history

/publish history [--config <path>] [--limit <count>] [--target <name>] [--json]

Implementation: bash skills/j-publish/scripts/show_history.sh [--limit <count>] [--target <name>] [--json] [--config <path>]

/publish release-notes

/publish release-notes --target <name> [--config <path>] [--from-tag <tag>] [--to-ref <git-ref>] [--output <path>]

Implementation: bash skills/j-publish/scripts/generate_release_notes.sh [--target <name>] [--from-tag <tag>] [--to-ref <git-ref>] [--output <path>] [<publish_json_path>]

Release-note rules:

  • The last publish tag is the highest semver tag on the current branch that also has a matching ledger entry in project/logs/publish-history.json.
  • Default target (no --output): the repo-root CHANGELOG.md — created from $([ -f templates/CHANGELOG_TEMPLATE.md ] && echo templates/CHANGELOG_TEMPLATE.md || echo node_modules/@jenga-ai/agent/templates/CHANGELOG_TEMPLATE.md) first if it doesn't exist yet (backward-compat for projects scaffolded before this convention). New Features/Bug Fixes/Other/Completed-task entries since the last publish tag are appended under the existing ## [Unreleased] heading's subsections; everything else in the file (prior versioned entries, manual edits) is preserved. Entries already present are deduped (matched by commit short-sha or task id), so re-running with no new commits produces zero diff.
  • --output <path>: writes a standalone, disposable draft to that path instead (the pre-E36 behavior) — CHANGELOG.md is not touched in this mode.
  • If no prior ledger-backed tag exists, a --output draft includes > First release — full history included; the standing CHANGELOG.md merge mode has no equivalent banner (it just merges full history into [Unreleased] like any other run).
  • Scrum-board enrichment is best-effort only; missing or unreadable board data never fails the command.
  • .publicignore filtering: when a repo-root .publicignore exists (the same blocklist the public mirror reads), a candidate commit — or a completed task's associated commit(s), matched via the task(E##_S##_T##): commit-message convention — is dropped entirely when every changed file it touches is covered by that blocklist. A commit touching a mix of blocked and unblocked files is still logged normally; only full coverage excludes an entry. This exists because CHANGELOG.md itself is not blocklisted and ships to the public mirror, so an unfiltered entry referencing a private-only path (e.g. project/board/) would leak. Absent .publicignore, this is a strict no-op — unchanged from pre-E36_S02_T02 behavior. Matching is rsync's own --exclude-from evaluation against that same file, so a path the mirror would withhold is classified "blocked" here too.

Ledger & Tagging

  • project/logs/publish-history.json is append-only. New publishes add new rows; existing rows are never edited in-place.
  • bash skills/j-publish/scripts/suggest_semver_bump.sh suggests major, minor, or patch based on git history since the last ledger-backed publish tag.
  • bash skills/j-publish/scripts/write_ledger_entry.sh <target> <adapter> <platform_state> <notes_path> [--yes] [--dry-run] [--version <vX.Y.Z>] [--config <path>] appends the canonical publish entry and creates the matching annotated git tag.
  • bash skills/j-publish/scripts/reconcile_tags.sh [--dry-run] [--config <path>] repairs drift:
    • git tag without ledger entry → append partial ledger row with note Manually tagged without /publish
    • ledger entry without git tag → create the missing tag retroactively

Agent Roles

See skills/j-publish/assets/ownership-matrix.md for the action-by-action ownership matrix.

Summary:

  • Developer initiates /publish setup, /publish deploy, and release-note review
  • Tester may run staging deploys as part of validation and uses publish history as test context
  • Scrum Master never deploys directly and only reviews publish context through workflow status surfaces

Configuration Model

The canonical config must validate against skills/j-publish/schemas/publish.schema.json.

Required top-level structure

  • version — schema version for the publish contract
  • defaults — global defaults, including the canonical publish ledger path and mandatory checks
  • targets[] — named deployment targets

Common target structure

Every target — regardless of type — must define:

  • name
  • type — one of mobile-ios, npm, droplet
  • checks.pre[] / checks.post[]
  • secrets — env-var references only, never credential values

Type-specific fields are documented below.

iOS App Store

The mobile-ios adapter publishes iOS builds to App Store Connect.

Required target fields for mobile-ios

  • type: mobile-ios
  • platform: ios-app-store
  • ios — scheme/build/export/upload metadata used by the adapter

Required iOS env references

The mobile-ios target must provide env-var references for:

  • APP_STORE_CONNECT_API_KEY_ID
  • APP_STORE_CONNECT_ISSUER_ID
  • APP_STORE_CONNECT_PRIVATE_KEY_PATH
  • CODE_SIGN_IDENTITY
  • PROVISIONING_PROFILE_UUID

iOS scope guardrails

This story set intentionally does not implement automated App Store review submission.

The iOS adapter trust boundary is explicit: publish-side external commands are limited to direct xcodebuild and xcrun invocations.

npm Registry

The npm adapter publishes a Node package to an npm-compatible registry.

  • Adapter template: skills/j-publish/adapters/npm.md
  • Wizard template: skills/j-publish/wizards/npm.md

See those files for the required target fields (registry URL, access, tag, --dry-run behaviour) and env references. Additional npm-specific schema details are owned by the npm settings block in skills/j-publish/schemas/publish.schema.json.

npm CI (OIDC Trusted Publisher)

The npm-ci adapter publishes a Node package to npmjs.com via GitHub Actions OIDC (Trusted Publishers) — no NPM_TOKEN is stored anywhere.

Use npm for local publishes with a token; use npm-ci for CI-only publishing with OIDC (no token required).

  • Adapter template: skills/j-publish/adapters/npm-ci.md
  • Wizard template: skills/j-publish/wizards/npm-ci.md
  • Example config: skills/j-publish/assets/publish.example.npm-ci.json

Required target fields for npm-ci

  • type: npm-ci
  • github_repo — repository in owner/name format (e.g. acme-org/my-package)
  • workflow_path — path to the workflow file to generate and trigger (default: .github/workflows/npm-publish.yml)
  • npm.package_name, npm.access, npm.registry, npm.dist_tag — same as the npm adapter

No secrets block is required. Any secrets block present is ignored by this adapter.

One-time prerequisite (manual)

Before the first deploy, link the package to the repository on npmjs.com:

  1. Sign in to npmjs.com → navigate to the package page
  2. Settings → Publishing → Trusted Publishers → Add publisher
  3. Select GitHub Actions; enter owner/repo and the workflow file path
  4. Save

Once configured, only the linked workflow can publish this package — local npm publish with a token will be rejected by npmjs.com for that package.

Usage examples

/publish setup --type npm-ci
/publish deploy --target npm-ci-pkg --dry-run
/publish deploy --target npm-ci-pkg

Droplet (GitHub Actions → SSH)

The droplet adapter deploys a project to any SSH-reachable Linux host by generating a GitHub Actions workflow that SSHes into the host on each trigger.

Trust boundary: publish.json holds only references to GitHub Actions secret names — never the actual SSH key or host credentials. Real secrets live in GitHub Actions secrets.

Required target fields for droplet

  • type: droplet
  • platform: droplet-ssh
  • droplet.host — IP address or FQDN of the target host
  • droplet.ssh_user — SSH login username
  • droplet.ssh_port — SSH port (default 22)
  • droplet.deploy_path — absolute path to the app directory on the host
  • droplet.github_repo — repository in owner/name format
  • droplet.deploy_branch — branch to pull on each deploy
  • droplet.start_cmd — command to (re)start the service (e.g. pm2 reload ecosystem.config.js, sudo systemctl restart myapp)
  • droplet.build_cmd — optional build step run after git pull
  • secrets.ssh_key_secret — name of the GH Actions secret holding the SSH private key
  • secrets.known_hosts_secret — name of the GH Actions secret holding ssh-keyscan output

Required GitHub Actions secrets

The generated workflow reads these from GitHub Actions secrets:

  • DROPLET_SSH_HOST — host IP or FQDN
  • DROPLET_SSH_USER — SSH username
  • DROPLET_SSH_PORT — SSH port
  • DROPLET_SSH_KEY (or value of ssh_key_secret) — private key contents
  • DROPLET_KNOWN_HOSTS (or value of known_hosts_secret) — ssh-keyscan output

See skills/j-publish/assets/secrets-guide.md for setup instructions.

First-run prerequisites (manual)

Before the first deploy, the target host must already have:

  • The deploy path created (mkdir -p /var/www/myapp)
  • An initial git clone of the repo at the deploy path
  • Any runtime dependencies installed (Node, PM2, etc.)

The adapter does not bootstrap the host — it only drives the continuous-deploy loop.

Usage examples

/publish setup --type droplet
/publish deploy --target my-droplet --dry-run
/publish deploy --target my-droplet

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.