> elyra can help you create elyra packages. Ask it to bundle your extensions, skills, prompt templates, or themes.

# Elyra Packages

Elyra packages bundle extensions, skills, prompt templates, and themes so you can share them through npm or git. A package can declare resources in `package.json` under the `elyra` key, or use conventional directories.

## Table of Contents

- [Official Packages](#official-packages)
- [Install and Manage](#install-and-manage)
- [Package Sources](#package-sources)
- [Creating a Elyra Package](#creating-a-elyra-package)
- [Package Structure](#package-structure)
- [Dependencies](#dependencies)
- [Package Filtering](#package-filtering)
- [Enable and Disable Resources](#enable-and-disable-resources)
- [Scope and Deduplication](#scope-and-deduplication)

## Official Packages

| Package | Description |
|---------|-------------|
| `@elyracode/stack-tall` | TALL stack: Livewire, Flux UI, Alpine, Tailwind |
| `@elyracode/stack-vilt` | VILT stack: Vue 3, Inertia.js, Laravel, Tailwind |
| `@elyracode/stack-rilt` | RILT stack: React 19, Inertia.js 2, shadcn/ui |
| `@elyracode/db-tools` | MySQL, ClickHouse, SQLite schema discovery and query tools |
| `@elyracode/docker` | Container exec, logs, compose, env sync, status dashboard |
| `@elyracode/swarm` | Multi-agent build, review, and refactor pipelines |
| `@elyracode/subagents` | Scout, reviewer, planner, worker, oracle sub-agents |
| `@elyracode/design-tools` | Live browser preview, screenshots, Tailwind QA |
| `@elyracode/test-gen` | Pest for Laravel, Vitest for TypeScript test generation |
| `@elyracode/doctor` | Security audit, outdated deps, code debt analysis |
| `@elyracode/design-lookup` | Extract design systems from any website (colors, typography, spacing, components) |
| `@elyracode/lsp-typescript` | TypeScript LSP integration — semantic go-to-definition, find-references, diagnostics, and hover |
| `@elyracode/seo` | SEO and LLM optimization — audit, structured data, llms.txt, meta tags |
| `@elyracode/workflows` | Code-orchestrated workflows — multi-step pipelines where code handles control flow, LLMs handle judgment |
| `@elyracode/laravel` | Deep Laravel understanding — model relationships, route mapping, architecture analysis |
| `@elyracode/btw` | Side conversations — ask questions in parallel without affecting the main session |

Install any of these with `elyra install npm:@elyracode/<name>`.

## Install and Manage

> **Security:** Elyra packages run with full system access. Extensions execute arbitrary code, and skills can instruct the model to perform any action including running executables. Review source code before installing third-party packages.

```bash
elyra install npm:@foo/bar@1.0.0
elyra install git:github.com/user/repo@v1
elyra install https://github.com/user/repo  # raw URLs work too
elyra install /absolute/path/to/package
elyra install ./relative/path/to/package

elyra remove npm:@foo/bar
elyra list                     # show installed packages from settings
elyra update                   # update elyra and all non-pinned packages
elyra update --extensions      # update all non-pinned packages only
elyra update --self            # update elyra only
elyra update --self --force    # reinstall elyra even if current
elyra update npm:@foo/bar      # update one package
elyra update --extension npm:@foo/bar
```

By default, `install` and `remove` write to global settings (`~/.elyra/agent/settings.json`). Use `-l` to write to project settings (`.elyra/settings.json`) instead. Project settings can be shared with your team, and elyra installs any missing packages automatically on startup.

To try a package without installing it, use `--extension` or `-e`. This installs to a temporary directory for the current run only:

```bash
elyra -e npm:@foo/bar
elyra -e git:github.com/user/repo
```

## Package Sources

Elyra accepts three source types in settings and `elyra install`.

### npm

```
npm:@scope/pkg@1.2.3
npm:pkg
```

- Versioned specs are pinned and skipped by package updates (`elyra update`, `elyra update --extensions`).
- Global installs use `npm install -g`.
- Project installs go under `.elyra/npm/`.
- Set `npmCommand` in `settings.json` to elyran npm package lookup and install operations to a specific wrapper command such as `mise` or `asdf`.

Example:

```json
{
  "npmCommand": ["mise", "exec", "node@20", "--", "npm"]
}
```

### git

```
git:github.com/user/repo@v1
git:git@github.com:user/repo@v1
https://github.com/user/repo@v1
ssh://git@github.com/user/repo@v1
```

- Without `git:` prefix, only protocol URLs are accepted (`https://`, `http://`, `ssh://`, `git://`).
- With `git:` prefix, shorthand formats are accepted, including `github.com/user/repo` and `git@github.com:user/repo`.
- HTTPS and SSH URLs are both supported.
- SSH URLs use your configured SSH keys automatically (respects `~/.ssh/config`).
- For non-interactive runs (for example CI), you can set `GIT_TERMINAL_PROMPT=0` to disable credential prompts and set `GIT_SSH_COMMAND` (for example `ssh -o BatchMode=yes -o ConnectTimeout=5`) to fail fast.
- Refs pin the package and skip package updates (`elyra update`, `elyra update --extensions`).
- Cloned to `~/.elyra/agent/git/<host>/<path>` (global) or `.elyra/git/<host>/<path>` (project).
- Runs `npm install` after clone or pull if `package.json` exists.

**SSH examples:**
```bash
# git@host:path shorthand (requires git: prefix)
elyra install git:git@github.com:user/repo

# ssh:// protocol format
elyra install ssh://git@github.com/user/repo

# With version ref
elyra install git:git@github.com:user/repo@v1.0.0
```

### Local Paths

```
/absolute/path/to/package
./relative/path/to/package
```

Local paths point to files or directories on disk and are added to settings without copying. Relative paths are resolved against the settings file they appear in. If the path is a file, it loads as a single extension. If it is a directory, elyra loads resources using package rules.

## Creating a Elyra Package

Add a `elyra` manifest to `package.json` or use conventional directories. Include the `elyra-package` keyword for discoverability.

```json
{
  "name": "my-package",
  "keywords": ["elyra-package"],
  "elyra": {
    "extensions": ["./extensions"],
    "skills": ["./skills"],
    "prompts": ["./prompts"],
    "themes": ["./themes"]
  }
}
```

Paths are relative to the package root. Arrays support glob patterns and `!exclusions`.

### Gallery Metadata

The [package gallery](https://elyracode.app/packages) displays packages tagged with `elyra-package`. Add `video` or `image` fields to show a preview:

```json
{
  "name": "my-package",
  "keywords": ["elyra-package"],
  "elyra": {
    "extensions": ["./extensions"],
    "video": "https://example.com/demo.mp4",
    "image": "https://example.com/screenshot.png"
  }
}
```

- **video**: MP4 only. On desktop, autoplays on hover. Clicking opens a fullscreen player.
- **image**: PNG, JPEG, GIF, or WebP. Displayed as a static preview.

If both are set, video takes precedence.

## Package Structure

### Convention Directories

If no `elyra` manifest is present, elyra auto-discovers resources from these directories:

- `extensions/` loads `.ts` and `.js` files
- `skills/` recursively finds `SKILL.md` folders and loads top-level `.md` files as skills
- `prompts/` loads `.md` files
- `themes/` loads `.json` files

## Dependencies

Third party runtime dependencies belong in `dependencies` in `package.json`. Dependencies that do not register extensions, skills, prompt templates, or themes also belong in `dependencies`. When elyra installs a package from npm or git, it runs `npm install`, so those dependencies are installed automatically.

Elyra bundles core packages for extensions and skills. If you import any of these, list them in `peerDependencies` with a `"*"` range and do not bundle them: `@elyracode/ai`, `@elyracode/agent-core`, `@elyracode/coding-agent`, `@elyracode/tui`, `typebox`.

Other elyra packages must be bundled in your tarball. Add them to `dependencies` and `bundledDependencies`, then reference their resources through `node_modules/` paths. Elyra loads packages with separate module roots, so separate installs do not collide or share modules.

Example:

```json
{
  "dependencies": {
    "shitty-extensions": "^1.0.1"
  },
  "bundledDependencies": ["shitty-extensions"],
  "elyra": {
    "extensions": ["extensions", "node_modules/shitty-extensions/extensions"],
    "skills": ["skills", "node_modules/shitty-extensions/skills"]
  }
}
```

## Package Filtering

Filter what a package loads using the object form in settings:

```json
{
  "packages": [
    "npm:simple-pkg",
    {
      "source": "npm:my-package",
      "extensions": ["extensions/*.ts", "!extensions/legacy.ts"],
      "skills": [],
      "prompts": ["prompts/review.md"],
      "themes": ["+themes/legacy.json"]
    }
  ]
}
```

`+path` and `-path` are exact paths relative to the package root.

- Omit a key to load all of that type.
- Use `[]` to load none of that type.
- `!pattern` excludes matches.
- `+path` force-includes an exact path.
- `-path` force-excludes an exact path.
- Filters layer on top of the manifest. They narrow down what is already allowed.

## Enable and Disable Resources

Use `elyra config` to enable or disable extensions, skills, prompt templates, and themes from installed packages and local directories. Works for both global (`~/.elyra/agent`) and project (`.elyra/`) scopes.

## Scope and Deduplication

Packages can appear in both global and project settings. If the same package appears in both, the project entry wins. Identity is determined by:

- npm: package name
- git: repository URL without ref
- local: resolved absolute path