firth 0.0.1 → 0.0.3

package/dist/config.js

@@ -0,0 +1,66 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+// Production control plane (InsForge compute). Override with `firth login --api-url`
+// or FIRTH_API_URL=… for local dev against http://localhost:8080.
+const DEFAULT_API = 'https://firth-control-plane-0662c2ef-202a-4feb-8267-5501b3b60037.fly.dev';
+const gpath = (home) => join(home, '.firth', 'config.json');
+const lpath = (cwd) => join(cwd, '.firth', 'project.json');
+export function readConfig(home = homedir(), env = process.env) {
+    let file = {};
+    const p = gpath(home);
+    if (existsSync(p))
+        file = JSON.parse(readFileSync(p, 'utf8'));
+    return { ...file, apiUrl: env.FIRTH_API_URL ?? file.apiUrl ?? DEFAULT_API };
+}
+export function writeConfig(cfg, home = homedir()) {
+    mkdirSync(join(home, '.firth'), { recursive: true });
+    writeFileSync(gpath(home), JSON.stringify(cfg, null, 2));
+}
+export function readProjectLink(cwd = process.cwd()) {
+    const p = lpath(cwd);
+    return existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null;
+}
+// One-time marker so related-skill installation runs once per linked project, not on every command.
+export function markSkillsInstalled(cwd = process.cwd()) {
+    const link = readProjectLink(cwd);
+    if (!link)
+        return;
+    link.skillsInstalled = true;
+    writeFileSync(lpath(cwd), JSON.stringify(link, null, 2));
+}
+export function writeProjectLink(projectId, cwd = process.cwd()) {
+    mkdirSync(join(cwd, '.firth'), { recursive: true });
+    writeFileSync(lpath(cwd), JSON.stringify({ projectId }, null, 2));
+}
+export function setCurrentBranch(branch, cwd = process.cwd()) {
+    const link = readProjectLink(cwd);
+    if (!link)
+        throw new Error('not linked');
+    if (branch !== null) {
+        link.branch = branch;
+    }
+    else {
+        delete link.branch;
+    }
+    writeFileSync(lpath(cwd), JSON.stringify(link, null, 2));
+}
+export function clearProjectLink(cwd = process.cwd()) {
+    const p = lpath(cwd);
+    if (existsSync(p))
+        unlinkSync(p);
+}
+// Append any missing entries to the project's ./.gitignore (creating it if absent).
+// Idempotent: entries already present are left alone. Returns the entries it added.
+export function ensureGitignore(cwd, entries) {
+    const p = join(cwd, '.gitignore');
+    const existing = existsSync(p) ? readFileSync(p, 'utf8') : '';
+    const have = new Set(existing.split('\n').map((l) => l.trim()));
+    const missing = entries.filter((e) => !have.has(e));
+    if (missing.length === 0)
+        return [];
+    const prefix = existing && !existing.endsWith('\n') ? '\n' : '';
+    const block = `${prefix}\n# Firth: agent skills installed by \`firth\` / \`npx skills add\` (regenerable, not source)\n${missing.join('\n')}\n`;
+    writeFileSync(p, existing + block);
+    return missing;
+}

package/dist/ensure-skills.js

@@ -0,0 +1,47 @@
+import { readProjectLink, markSkillsInstalled, ensureGitignore } from './config.js';
+// Where `npx skills add` / `firth skills pull` drop skills, per detected agent.
+// These are regenerable agent context, not the developer's source — keep them out of git.
+const SKILL_DIRS = ['.claude/skills/', '.agents/skills/', '.github/skills/'];
+// Agent skills installed once per linked project so the developer's agent has
+// Neon / Tigris / Firth context. Run via `npx skills add` (vercel-labs/skills),
+// fully non-interactively: pin the agents (Claude Code → `.claude/skills/`, Codex
+// → `.agents/skills/`; both already gitignored) so there's no agent prompt and the
+// tool doesn't fan out to ~13–72 agent dirs; explicit `-s` skill names (no skill
+// prompt); `-y` (no scope/confirm prompt); `--copy` (real files, not symlinks into
+// a transient package cache).
+const AGENT_FLAGS = ['-a', 'claude-code', '-a', 'codex', '-y', '--copy'];
+const SKILLS = [
+    { label: 'neon-postgres', args: ['skills', 'add', 'neondatabase/agent-skills', '-s', 'neon-postgres', ...AGENT_FLAGS] },
+    { label: 'tigris', args: ['skills', 'add', 'tigrisdata/skills',
+            '-s', 'tigris-object-operations', '-s', 'file-storage', '-s', 'tigris-sdk-guide',
+            '-s', 'tigris-security-access-control', '-s', 'tigris-image-optimization',
+            '-s', 'tigris-s3-migration', '-s', 'tigris-static-assets', '-s', 'tigris-agent-kit',
+            ...AGENT_FLAGS] },
+    { label: 'firth', args: ['skills', 'add', 'firthstack/firth', '-s', 'firth', ...AGENT_FLAGS] },
+];
+// Install the related agent skills once per linked project. No-op unless deps.run is set
+// (production wires the real runner; tests inject a fake; other command tests omit it → no-op,
+// so nothing is spawned). Convenience only — never blocks or fails the host command.
+export async function ensureSkills(deps) {
+    const run = deps.run;
+    if (!run)
+        return;
+    try {
+        const link = readProjectLink(deps.cwd);
+        if (!link || link.skillsInstalled)
+            return; // not linked yet, or already done
+        deps.print('installing related agent skills (neon, tigris, firth) via `npx skills add` …');
+        for (const s of SKILLS) {
+            const r = await run('npx', s.args, true); // streamed so the user sees progress
+            deps.print(r.ok ? `  ${s.label} ✓` : `  ${s.label} failed — add manually: npx ${s.args.join(' ')}`);
+        }
+        // keep the installed (regenerable) skill folders out of the developer's git history
+        const added = ensureGitignore(deps.cwd, SKILL_DIRS);
+        if (added.length)
+            deps.print(`  .gitignore += ${added.join(', ')}`);
+        markSkillsInstalled(deps.cwd); // mark done even on partial failure so we don't re-run every command
+    }
+    catch {
+        /* convenience only — never block the command */
+    }
+}

package/dist/fly.js

@@ -0,0 +1,25 @@
+import { spawn } from 'node:child_process';
+export const defaultRunner = (cmd, args, inherit = false) => new Promise((resolve) => {
+    const p = spawn(cmd, args, { stdio: inherit ? 'inherit' : 'ignore' });
+    p.on('error', () => resolve({ ok: false })); // ENOENT etc.
+    p.on('close', (code) => resolve({ ok: code === 0 }));
+});
+// Ensure flyctl is installed. No-op unless deps.run is set (production wires defaultRunner;
+// tests inject a fake; other command tests omit it → this is a no-op so nothing is spawned).
+export async function ensureFlyctl(deps) {
+    const run = deps.run;
+    if (!run)
+        return;
+    try {
+        if ((await run('flyctl', ['version'])).ok)
+            return; // already installed
+        if (!(await run('brew', ['--version'])).ok) { // no Homebrew → just hint
+            deps.print('note: flyctl (fly CLI) not found and Homebrew is unavailable — install it: https://fly.io/docs/flyctl/install/');
+            return;
+        }
+        deps.print('flyctl not found — installing with `brew install flyctl` (one-time)…');
+        const r = await run('brew', ['install', 'flyctl'], true);
+        deps.print(r.ok ? 'flyctl installed ✓' : 'flyctl install failed — install manually: https://fly.io/docs/flyctl/install/');
+    }
+    catch { /* convenience only — never block the command */ }
+}

package/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+import { login, logout } from './commands/auth.js';
+import { projectCreate, projectLink, projectList, projectDelete } from './commands/project.js';
+import { branchCreate, branchList, branchSwitch, branchDelete } from './commands/branch.js';
+import { secrets } from './commands/secrets.js';
+import { skillsPull } from './commands/skills.js';
+import { deploy } from './commands/deploy.js';
+import { events } from './commands/events.js';
+import { observeSync } from './commands/observe.js';
+import { status } from './commands/status.js';
+import { defaultRunner } from './fly.js';
+function readVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const USAGE = `firth <command>
+
+Commands:
+  login                     Sign in (--email, --password; --api-url <url> sets the control-plane host)
+  logout                    Clear stored credentials
+  project create <name>     Create + link a project
+  project link <id>         Link this directory to a project
+  project list              List your projects
+  branch create <name>      Create a branch (--from <parent>, default main)
+  branch list               List the linked project's branches
+  secrets                   Fetch the linked project's secrets into .env (--branch <id>)
+  skills pull               Install the firth skill into ./.claude/skills
+  deploy                    Deploy --image <url> to the project's compute (--from, --port)
+  events                    Show the project's action↔side-effect timeline (--branch, --limit)
+  observe sync              Upload local observe-hook findings (.firth/audit.jsonl) to the timeline
+  status                    Show login, linked project, and current branch
+  project delete            Delete the linked project + all resources (--yes)
+  branch switch <name>      Set the current branch (secrets/events default to it)
+  branch delete <name>      Delete a branch + its Neon branch (--yes)
+  --help                    Show this help
+  --version, -v             Print the CLI version`;
+// Command handlers registered by later tasks. Each: (argv, deps) => Promise<number>.
+export const COMMANDS = {};
+COMMANDS['login'] = login;
+COMMANDS['logout'] = logout;
+COMMANDS['project create'] = projectCreate;
+COMMANDS['project link'] = projectLink;
+COMMANDS['project list'] = projectList;
+COMMANDS['branch create'] = branchCreate;
+COMMANDS['branch list'] = branchList;
+COMMANDS['secrets'] = secrets;
+COMMANDS['skills pull'] = skillsPull;
+COMMANDS['deploy'] = deploy;
+COMMANDS['events'] = events;
+COMMANDS['observe sync'] = observeSync;
+COMMANDS['branch switch'] = branchSwitch;
+COMMANDS['branch delete'] = branchDelete;
+COMMANDS['project delete'] = projectDelete;
+COMMANDS['status'] = status;
+export async function route(argv, deps) {
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+        deps.print(USAGE);
+        return 0;
+    }
+    if (argv[0] === '--version' || argv[0] === '-v') {
+        deps.print(readVersion());
+        return 0;
+    }
+    // Support two-word commands ("project create") and one-word ("login").
+    const key2 = argv.length >= 2 ? `${argv[0]} ${argv[1]}` : '';
+    const handler = COMMANDS[key2] ?? COMMANDS[argv[0]];
+    if (!handler) {
+        deps.print(`unknown command: ${argv.join(' ')}\n\n${USAGE}`);
+        return 1;
+    }
+    const rest = COMMANDS[key2] ? argv.slice(2) : argv.slice(1);
+    try {
+        return await handler(rest, deps);
+    }
+    catch (e) {
+        deps.print(`error: ${e instanceof Error ? e.message : String(e)}`);
+        return 1;
+    }
+}
+export async function main() {
+    const code = await route(process.argv.slice(2), {
+        print: (s) => console.log(s), home: homedir(), cwd: process.cwd(), env: process.env,
+        run: defaultRunner,
+    });
+    process.exit(code);
+}
+if (process.env.NODE_ENV !== 'test') {
+    void main();
+}

package/dist/skills/README.md

@@ -0,0 +1,58 @@
+# Firth Skills
+
+This directory holds the **Skills bundle** for Firth — Markdown files in the [Anthropic Skills format](https://docs.claude.com) that teach AI coding agents how to operate cloud platforms in the context of a Firth project.
+
+## Layout (planned)
+
+```
+skills/
+├── README.md                       ← you are here
+├── stack-overview/
+│   └── SKILL.md                    ← what stack this project uses, why
+├── deploy-flow/
+│   └── SKILL.md                    ← how `firth deploy` actually works
+├── debug-runbook/
+│   └── SKILL.md                    ← what to do when a deploy / migration / build fails
+├── cost-and-scaling/
+│   └── SKILL.md                    ← free-tier limits, when to scale up, how
+├── handoff/
+│   └── SKILL.md                    ← how to produce a context dump for a fresh agent
+│
+├── neon/                           ← provider-specific Skills
+│   ├── connection-pooling/
+│   │   └── SKILL.md
+│   └── ...
+├── vercel/
+│   └── ...
+├── railway/
+│   └── ...
+└── ...
+```
+
+## Skill format
+
+Each Skill is a single `SKILL.md` file with YAML frontmatter:
+
+```markdown
+---
+name: <skill-name>
+description: <one-line description used by the agent to decide whether to invoke this Skill>
+---
+
+# <Skill title>
+
+<Markdown body — instructions, examples, gotchas, references to firth CLI commands>
+```
+
+See the Anthropic Skills documentation for full schema details.
+
+## Authoring guidelines (early draft)
+
+- **One Skill, one capability.** Don't write a 2,000-line "everything about Vercel" Skill. Split by task: `vercel-deploy`, `vercel-env-vars`, `vercel-debug-build`.
+- **Reference the Firth CLI.** Skills should tell the agent which `firth` command to invoke, not how to call provider APIs directly. Provider-specific knowledge lives behind the CLI.
+- **Include known failure modes.** A Skill is most valuable when it teaches the agent what can go wrong and how to recover.
+- **Keep examples runnable.** Code blocks should be copy-pasteable; agents will execute them.
+
+## Status
+
+Empty for now. The first batch of Skills will land alongside the first golden path (Next.js + Hono + Neon + Vercel + Railway).

package/dist/skills/firth/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: firth
+description: Use when working in a project managed by Firth — provisioning DB/storage/compute, creating/switching/merging branches, deploying, checking status, or wiring app secrets via the firth CLI.
+---
+
+# Firth
+
+Firth provisions and governs a project's cloud resources behind one CLI and one credential seam. The CLI talks **only** to the Firth control plane; you never configure a cloud backend directly.
+
+## Resources Firth provisions
+Every project automatically gets three base resources — build your app directly against them:
+- **Postgres database** (Neon) — your app's relational DB.
+- **S3-compatible storage** (Tigris) — object/blob storage.
+- **Compute** (Fly.io) — where your container runs.
+
+`firth secrets` writes the connection credentials for all three into `./.env`.
+
+## Setup
+- `firth login --email <e> --password <p>` — sign in. Add `--api-url <url>` to target a non-local control plane; it persists for later commands.
+- `firth status` — login state, linked project, current branch.
+- `firth --version`.
+
+## Workflow
+1. **Create or link a project** — you end up linked (`./.firth/project.json`) and on the default branch `main`:
+   - `firth project create <name>` — provisions DB + storage + compute.
+   - `firth project link <id>` — link an existing project.
+2. `firth secrets` — write the current branch's credentials into `./.env`. **This is how an agent gets DB/storage access.** (`--branch <id>` targets a specific branch.)
+3. `firth deploy --image <url>` — deploy a container image to the **current branch's** compute (`--port`; `--from <branch>` targets a specific branch's app instead). See **Deploying your app** for frontend/backend patterns.
+4. `firth events` — the action ↔ resource-side-effect timeline (`--branch`, `--limit`).
+
+## Database & migrations
+You connect **directly** to the Postgres database (the `DATABASE_URL` from `firth secrets` — there is no ORM/abstraction in front of it). Keep a **`migrations/` directory at the project root** to store and track your database migration files, so schema changes are versioned and reproducible — this is essential for applying the same schema to a branch DB and re-applying it on `main` after a merge.
+
+## Deploying your app (frontend & backend)
+Firth compute is a **container** running on Fly.io — **one container per branch**, exposed over HTTPS at `https://<app>.fly.dev` on the single port you choose. Deploy is **image-based**: build a container image, push it to a registry your runtime can pull, then:
+
+```
+firth deploy --image <registry/image:tag> --port <n>   # runs it on the CURRENT branch's compute
+# --from <branch> targets a specific branch; the URL is printed on success
+```
+
+**Secrets are injected for you.** At deploy time Firth decrypts the branch's credentials (`DATABASE_URL`, `AWS_*`, `BUCKET_NAME`, …) and passes them into the container as **environment variables**. Read them from the process environment in production — do **not** bake `./.env` into the image (that file, from `firth secrets`, is for *local* development only).
+
+### Backend
+Containerize your server so it listens on the port you pass to `--port` and reads credentials from the environment:
+
+```dockerfile
+FROM node:20-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY . .
+EXPOSE 8080
+CMD ["node", "server.js"]   # reads process.env.DATABASE_URL etc.
+```
+`firth deploy --image <registry>/api:tag --port 8080`
+
+### Frontend (SPA)
+Build the static assets, then serve them from a tiny static-server container. Rewrite unknown paths to `index.html` so client-side routing works:
+
+```dockerfile
+FROM node:20-alpine AS build
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build                 # produces ./dist
+
+FROM caddy:alpine
+COPY --from=build /app/dist /srv
+# Caddyfile: `:80 { root * /srv; try_files {path} /index.html; file_server }`
+COPY Caddyfile /etc/caddy/Caddyfile
+EXPOSE 80
+```
+`firth deploy --image <registry>/web:tag --port 80`
+
+### Full-stack — one branch = one container + one port
+A branch's compute serves **one app on one port**, so ship frontend + backend as a **single image**: have your backend serve the built frontend's static files (framework SSR, or copy the SPA's `dist/` into the server's static directory). One `firth deploy`, one URL, and the frontend can call the backend at the same origin. If you genuinely need separate frontend and backend services, host the static frontend on a dedicated static/CDN host and deploy only the backend container to Firth compute.
+
+## Branching — isolate risky changes
+Before a high-risk change (schema migration, data backfill, risky refactor), do the work on a **branch**, verify it, then merge back to `main`.
+
+- `firth branch create <name>` provisions an **isolated environment** for the branch: a new **Neon DB branch** (a full copy of the parent's data, isolated from `main`, with its own `DATABASE_URL`) **and a new dedicated compute** (its own Fly app). **Only the storage bucket is shared** across branches.
+  - Each branch has its own compute app, so multiple branches' environments run **in parallel** — working on one branch never disturbs another's. To rebuild the branch's running environment, **redeploy your branch's code** to its app (`firth deploy` targets the current branch's compute).
+- `firth branch switch <name>` then `firth secrets` → `./.env` now has the branch's `DATABASE_URL`. Run your migrations against the branch DB, then `firth deploy` → the branch's isolated compute runs your branch code, an environment to validate the change.
+
+### Merging a branch back to main
+Firth does **not** auto-merge — you do it in your local code repo:
+1. Merge the branch's frontend + backend **code** into `main`.
+2. Merge the branch's **migration files** into `main`'s `migrations/`.
+3. Switch to main: `firth branch switch main` → `firth secrets`.
+4. Re-run the DB **migrations** against `main`'s database, then **re-deploy** compute: `firth deploy`.
+
+## Delete (destructive — require `--yes`)
+- `firth project delete --yes` — tears down ALL resources (Neon DB, Fly app, Tigris bucket) and unlinks the directory.
+- `firth branch delete <name> --yes` — tears down the branch's Neon branch **and its Fly app**. The default branch can't be deleted.
+
+## Rules for agents
+- Treat `./.env` as the **only** source of resource credentials — run `firth secrets` to populate it; never hardcode credential values or print them.
+- `DATABASE_URL` **and compute** are isolated **per branch**; storage credentials (`AWS_*` / `BUCKET_NAME`) are **shared** across branches.
+- Track all DB schema changes as files under `migrations/` so they can be replayed on a branch DB and on `main` after merge.
+- The CLI auto-installs `flyctl` (via Homebrew) when missing during project/branch commands, so the Fly app is manageable directly if needed.

package/dist/sync-state.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+const statePath = (cwd) => join(cwd, '.firth', 'sync-state.json');
+export function readAuditOffset(cwd) {
+    const p = statePath(cwd);
+    if (!existsSync(p))
+        return 0;
+    try {
+        const s = JSON.parse(readFileSync(p, 'utf8'));
+        return typeof s?.audit?.offset === 'number' ? s.audit.offset : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+export function writeAuditOffset(cwd, offset, now) {
+    mkdirSync(join(cwd, '.firth'), { recursive: true });
+    writeFileSync(statePath(cwd), JSON.stringify({ audit: { offset, syncedAt: now } }, null, 2));
+}
+// Complete (non-blank) lines from `offset` to the last newline boundary.
+// `ends[i]` = byte offset just past `lines[i]`; `newOffset` = byte offset past
+// the last complete line (incl. any blank lines). A trailing partial line is
+// excluded. `offset > byteLength(content)` (truncation) restarts from 0.
+export function readNewAuditLines(content, offset) {
+    const byteLen = Buffer.byteLength(content, 'utf8');
+    const start = offset > byteLen ? 0 : offset;
+    const tail = Buffer.from(content, 'utf8').subarray(start).toString('utf8');
+    const lastNl = tail.lastIndexOf('\n');
+    if (lastNl < 0)
+        return { lines: [], ends: [], newOffset: start };
+    const block = tail.slice(0, lastNl + 1); // complete lines incl. trailing newline
+    const raw = block.split('\n');
+    if (raw[raw.length - 1] === '')
+        raw.pop(); // drop empty tail after the final '\n'
+    const lines = [];
+    const ends = [];
+    let cursor = start;
+    for (const l of raw) {
+        cursor += Buffer.byteLength(l, 'utf8') + 1; // + the newline
+        if (l.trim()) {
+            lines.push(l);
+            ends.push(cursor);
+        }
+    }
+    return { lines, ends, newOffset: cursor };
+}

package/package.json

@@ -1,45 +1,20 @@
 {
   "name": "firth",
-  "version": "0.0.1",
-  "description": "Cloud platform SDK for AI coding agents — scaffold, deploy, and operate cloud stacks alongside your AI coding agent.",
+  "version": "0.0.3",
+  "description": "The Firth CLI — provision and govern a project's cloud resources (Neon Postgres, Tigris storage, Fly.io compute) behind one credential seam.",
   "type": "module",
-  "bin": {
-    "firth": "dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
+  "bin": { "firth": "dist/index.js" },
+  "files": ["dist", "README.md"],
+  "engines": { "node": ">=20" },
+  "license": "MIT",
+  "keywords": ["firth", "cli", "ai-agent", "neon", "tigris", "fly", "deploy", "secrets", "branching"],
+  "repository": { "type": "git", "url": "git+https://github.com/firthstack/firth.git", "directory": "cli" },
   "scripts": {
-    "dev": "tsx src/cli.ts",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json && node -e \"require('node:fs').cpSync('../skills','dist/skills',{recursive:true})\"",
     "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "keywords": [
-    "cli",
-    "ai-agent",
-    "deploy",
-    "scaffold",
-    "vercel",
-    "railway",
-    "neon",
-    "firth"
-  ],
-  "license": "MIT",
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "@clack/prompts": "^0.7.0",
-    "citty": "^0.1.6"
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
   },
-  "devDependencies": {
-    "@types/node": "^20.11.0",
-    "tsup": "^8.0.2",
-    "tsx": "^4.7.1",
-    "typescript": "^5.4.0",
-    "vitest": "^1.4.0"
-  }
+  "dependencies": { "@insforge/sdk": "^1.4.2" },
+  "devDependencies": { "@types/node": "^20.14.0", "tsx": "^4.16.0", "typescript": "^5.5.0", "vitest": "^2.0.0" }
 }