@autofleet/cli 2.23.0 → 2.24.0

package/dist/claude-marketplace/plugins/autofleet/skills/dev-workflow/examples.md

@@ -0,0 +1,189 @@
+# Dev Workflow Examples
+
+## Development Workflow Commands
+
+### Option A — Run service locally, wire to simulation
+
+```bash
+# 1. Forward the simulation DB to localhost
+autofleet forwardDb -q --cluster=expManager --variationId=<uuid>
+# Opens Postico. Also prints DB_USERNAME, DB_PASSWORD, DB_NAME env vars for .env
+
+# 2. Run service locally (uses local .env pointing at sim DB)
+npm run dev
+
+# 3. Intercept live simulation traffic locally via mirrord
+autofleet mirrord -q --service=<service-name> --cluster=expManager --variationId=<uuid>
+```
+
+### Option B — Deploy service to simulation, run control-center locally
+
+```bash
+# 1. Build and push Docker image, update K8s deployment in simulation
+#    Run from the service repo root
+autofleet updateExp -q --cluster=expManager --variationId=<uuid>
+# This: builds image tagged gcr.io/autofleetprod/<dir>:<branch>-<HH-MM-SS>
+#       pushes to GCP registry
+#       patches K8s deployment and waits for rollout
+
+# 2. Set up control-center to point at the simulation API gateway
+#    Run from control-center repo root
+autofleet localDev -q --cluster=expManager --variationId=<uuid>
+# Updates .env with API_GATEWAY_MS_SERVICE_HOST
+# Port-forwards control-center-ms to port 8085
+#
+# If localDev fails (e.g. no ingress), set .env manually:
+#   API_GATEWAY_MS_SERVICE_HOST=<api-gateway-loadbalancer-ip>
+#   CONTROL_CENTER_MS_SERVICE_HOST=<control-center-loadbalancer-ip>
+# The simulation control-center IP can be used directly for CONTROL_CENTER_MS
+# since Vite proxies to it. Get IPs with:
+#   kubectl get svc --namespace=<variationId> | grep LoadBalancer
+#
+# IMPORTANT: IP/host env vars must NOT include the http:// protocol prefix.
+# The Vite proxy config (vite/devServerProxy.ts) adds http:// automatically.
+# Setting API_GATEWAY_MS_SERVICE_HOST=http://1.2.3.4 causes double-prefix errors.
+
+# 3. Start control-center dev server
+npm run dev
+```
+
+### Useful cluster operations
+
+```bash
+# Switch kubectl context to a cluster/namespace
+autofleet switchCluster -q --cluster=expManager --variationId=<uuid>
+
+# Forward a specific microservice port locally
+autofleet forwardService -q --service=<service-name> --cluster=expManager --variationId=<uuid> --port=8080
+
+# Get all microservice IPs in an environment
+autofleet getIps -q --cluster=expManager --variationId=<uuid>
+
+# Start local Docker infrastructure (Redis, RabbitMQ, Postgres)
+autofleet dockerInit -q
+```
+
+## Debugging
+
+### Replaying a request with curl
+
+Copy the `Authorization` header from DevTools → Network → Headers, then:
+
+```bash
+curl -s -H "Authorization: Bearer <token>" "http://<api-gateway-ip>/api/v1/..."
+```
+
+### Intercepting the auth token via browser console
+
+```javascript
+const origSet = XMLHttpRequest.prototype.setRequestHeader;
+XMLHttpRequest.prototype.setRequestHeader = function(name, val) {
+  if (name === 'Authorization') window._token = val;
+  return origSet.call(this, name, val);
+};
+// trigger any API action, then: window._token
+```
+
+### Querying GCP logs
+
+> **Note:** GCP logs may have a delay of up to a few minutes. If a query returns no results immediately, wait and retry.
+
+```bash
+# Logs for a specific service in a simulation namespace
+gcloud logging read \
+  "resource.type=k8s_container \
+   AND resource.labels.namespace_name=<variationId> \
+   AND resource.labels.container_name=<service-name>" \
+  --project=af-experiment-manager \
+  --limit=100 \
+  --format=json \
+  | jq '.[].jsonPayload'
+
+# Filter by trace ID
+gcloud logging read \
+  "resource.type=k8s_container \
+   AND resource.labels.namespace_name=<variationId> \
+   AND jsonPayload.traceId=\"<x-trace-id>\"" \
+  --project=af-experiment-manager \
+  --limit=50 \
+  --format=json
+```
+
+### Mirrord
+
+```bash
+# Intercept live traffic from simulation
+autofleet mirrord -q --service=<service-name> --cluster=dev1 --variationId=<uuid>
+
+# Generate mirrord config manually (creates .mirrord/mirrord.json)
+autofleet mirrordConfig -q --service=<service-name> --cluster=dev1 --variationId=<uuid>
+```
+
+### DB access
+
+```bash
+# Port-forward PostgreSQL to localhost:5432
+autofleet forwardDb -q --cluster=dev1 --variationId=<uuid>
+# Credentials: postgres / afpass_<variationId>
+# DB name: <service>_<variationId> (hyphens → underscores)
+# Also auto-opens Postico
+```
+
+## NPM Token Setup
+
+```bash
+# Check if already set
+cat ~/.npmrc        # look for _authToken=...
+echo $NPM_TOKEN     # check if already exported
+
+# Export it
+export NPM_TOKEN=<token>
+```
+
+## Common Patterns
+
+### Typical simulation cycle
+
+```bash
+autofleet switchCluster -q --cluster=expManager --variationId=<sim-id>
+autofleet forwardDb -q --cluster=expManager --variationId=<sim-id>     # if DB access needed
+autofleet mirrord -q --service=<svc> --cluster=expManager --variationId=<sim-id>   # OR
+autofleet updateExp -q --cluster=expManager --variationId=<sim-id>                 # full deploy
+autofleet localDev -q --cluster=expManager --variationId=<sim-id>      # if running CC locally
+```
+
+### Staging deployment
+
+```bash
+# Same as simulation but with --cluster=staging (no --variationId needed)
+autofleet updateExp -q --cluster=staging
+```
+
+## End-of-Session Testing Options
+
+### Option A — Deploy backend to simulation, run CC locally
+```bash
+autofleet updateExp -q --cluster=expManager --variationId=<id>   # from each modified service repo
+autofleet localDev -q --cluster=expManager --variationId=<id>    # from control-center repo
+npm run dev                                                       # in control-center
+```
+
+### Option B — Run everything locally, wire to simulation DB/infra
+```bash
+autofleet forwardDb -q --cluster=expManager --variationId=<id>                    # for each service needing DB
+autofleet mirrord -q --service=<svc> --cluster=expManager --variationId=<id>      # to intercept traffic
+npm run dev                                                                        # in each service + control-center
+```
+
+### Option C — CC locally, backend in simulation
+```bash
+autofleet updateExp -q --cluster=expManager --variationId=<id>   # if backend changes need deploying
+autofleet localDev -q --cluster=expManager --variationId=<id>    # from control-center repo
+npm run dev                                                       # in control-center
+```
+
+### Option D — Deploy everything to simulation
+```bash
+autofleet updateExp -q --cluster=expManager --variationId=<id>   # for each changed service
+# Then open the simulation control-center URL directly
+```

package/dist/claude-marketplace/plugins/autofleet/skills/node-test-runner/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: node-test-runner
+description: Use this skill when the user wants to run tests on a Node.js microservice in Autofleet locally, including setting up Docker dependencies, initializing the test database, and running jest with the correct env vars.
+version: 1.0.0
+---
+
+# Running Tests on Autofleet Node.js Services
+
+## Prerequisites
+
+Local tests require Docker running with Postgres, Redis, and RabbitMQ. Use the `autofleet` CLI to spin them up:
+
+```sh
+autofleet dockerInit -q
+```
+
+This runs a `docker-compose up -d` with Postgres (port 5432), Redis (6379), RabbitMQ (5672), and Elasticsearch (9200).
+
+**Known issue:** If Redis port 6379 is already allocated, the command fails but Postgres and RabbitMQ may still have started. Check with `docker ps` — if `t-postgres-1` is running, you can proceed.
+
+Default Docker Postgres credentials:
+- user: `postgres`
+- password: `postgres`
+- host: `127.0.0.1:5432`
+
+---
+
+## Initialize the Test Database
+
+Services use `NODE_ENV=test` to connect to a separate test DB (e.g. `automation_ms_test`). Run this once (or after schema changes):
+
+```sh
+DB_USERNAME=postgres DB_PASSWORD=postgres NODE_ENV=test npm run init
+```
+
+This creates the DB and runs all Sequelize migrations against it.
+
+> Also run without `NODE_ENV=test` if you need the development DB:
+> ```sh
+> DB_USERNAME=postgres DB_PASSWORD=postgres npm run init
+> ```
+
+---
+
+## Running Tests
+
+```sh
+DB_USERNAME=postgres DB_PASSWORD=postgres NODE_ENV=test node_modules/.bin/jest --forceExit
+```
+
+To run a specific file:
+```sh
+DB_USERNAME=postgres DB_PASSWORD=postgres NODE_ENV=test node_modules/.bin/jest src/path/to/file.test.ts --forceExit
+```
+
+To filter by test name:
+```sh
+DB_USERNAME=postgres DB_PASSWORD=postgres NODE_ENV=test node_modules/.bin/jest src/path/to/file.test.ts --testNamePattern="my test name" --forceExit
+```
+
+---
+
+## Required Env Vars Summary
+
+| Var | Value |
+|-----|-------|
+| `DB_USERNAME` | `postgres` |
+| `DB_PASSWORD` | `postgres` |
+| `NODE_ENV` | `test` |
+
+All other DB config (host, port, DB name) falls back to defaults in `src/config/config.js`.

package/dist/claude-marketplace/plugins/autofleet/skills/pr-standards/SKILL.md

@@ -55,6 +55,7 @@ If the branch name contains no Jira ticket, omit this section entirely.
 
 ## Pre-PR Checklist
 
+- Ask the user if they'd like to run `npm audit fix` on affected services — it fixes known dependency vulnerabilities and is better to catch before QA or code review flags them
 - Run linter (if configured)
 - Review your own changes first
 - Ensure tests pass (if running tests)

package/dist/claude-marketplace/plugins/autofleet/skills/rabbit/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: rabbit
+description: Guides usage of the @autofleet/rabbit package — publishing to exchanges,
+  consuming from queues, consuming from exchanges (fanout), ConsumeOptions, error
+  handling with ack/nack, retries, dead-letter queues, and mocking in tests. Use
+  when the user wants to send or receive RabbitMQ messages, wire up a consumer,
+  understand retry/dead-letter behaviour, or mock rabbit in unit tests.
+version: 1.0.0
+userInvocable: true
+---
+
+# @autofleet/rabbit
+
+## Setup
+
+**Required env var:** `RABBITMQ_SERVICE_HOST` — set to `<host>:<port>` (e.g. `localhost:5672`).
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+
+const rabbit = new RabbitMq();
+// Optional: pass a logger
+const rabbit = new RabbitMq({ logger });
+```
+
+The constructor registers `SIGTERM`/`SIGINT` handlers for graceful shutdown automatically. Pass `{ dontGracefulShutdown: true }` to manage shutdown yourself.
+
+---
+
+## Publishing
+
+### Publish to an exchange (fanout)
+
+```typescript
+await rabbit.publish('my-exchange', { vehicleId: 123, status: 'active' });
+```
+
+### Send directly to a queue
+
+```typescript
+await rabbit.sendToQueue('my-queue', { orderId: 456 });
+```
+
+Content is automatically JSON-serialized. Tracing headers (`x-trace-id`, `x-af-user-id`) are attached automatically from the current `@autofleet/zehut` context.
+
+**Keep messages lean.** Publish only the minimum identifiers needed (e.g. `{ vehicleId, eventType }`) — not full entity objects. Consumers should fetch the full data themselves if needed. Large payloads increase broker memory pressure, slow down consumers, and make retries more expensive.
+
+---
+
+## Consuming
+
+### Consume from a queue
+
+```typescript
+await rabbit.consume('my-queue', async (msg, ack, nack) => {
+  const payload = msg.content; // already parsed from JSON
+  try {
+    await processMessage(payload);
+    await ack();
+  } catch (err) {
+    await nack(msg); // retries up to options.retries times, then dead-letters
+  }
+});
+```
+
+### Consume from an exchange (fanout)
+
+Each consumer gets its own queue bound to the exchange:
+
+```typescript
+await rabbit.consumeFromExchange('my-queue', 'my-exchange', async (msg, ack, nack) => {
+  await processMessage(msg.content);
+  await ack();
+});
+```
+
+### ConsumeOptions
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `retries` | `1` | Max retry attempts before dead-lettering |
+| `limit` | `1` | Prefetch (concurrent messages in flight) |
+| `deadMessageTtl` | 12 hours | How long dead messages are kept (ms) |
+| `messageTtl` | — | Max age of a message before discard (ms) |
+| `lockTimeout` | `5000` | Redis lock duration (ms), when using lock |
+| `useConsumeWithLock` | `false` | Use Redis-based distributed lock per message |
+| `enableRabbitTrace` | `false` | Log full rabbit trace headers |
+
+```typescript
+await rabbit.consume('my-queue', handler, {
+  retries: 3,
+  limit: 5,
+  deadMessageTtl: 1000 * 60 * 60 * 24, // 24 hours
+});
+```
+
+---
+
+## ack / nack
+
+- `await ack()` — acknowledge; message is removed from the queue
+- `await nack(msg)` — negative-acknowledge; retried up to `retries` times, then moved to the dead-letter queue
+- `await nack(msg, { skipRetry: true })` — dead-letter immediately without retrying
+
+---
+
+## Dead-letter queues
+
+On first consume, the package auto-creates a dead-letter queue named `<queue>-dead`. Messages land there after exhausting retries. `deadMessageTtl` controls TTL (default 12 hours).
+
+---
+
+## Mocking in tests
+
+Import the Vitest mock class — it implements `IAfRabbitMq` with `vi.fn()` stubs for all methods:
+
+```typescript
+import RabbitMqMock from '@autofleet/rabbit/mock/vitest';
+
+const rabbit = new RabbitMqMock();
+// rabbit.publish, rabbit.consume, rabbit.sendToQueue, etc. are vi.fn()
+```
+
+See **examples.md → Testing** for full Vitest patterns.
+
+---
+
+## Common Issues
+
+### Messages not consumed after deploy
+The queue or exchange may not be asserted yet — `consume`/`consumeFromExchange` assert on first call. Ensure the consumer starts before publishing.
+
+### `nack` loop causing infinite retries
+Check `retries` in `ConsumeOptions`. Default is 1. After `retries` exhausted, messages go to the dead-letter queue — not requeued forever.
+
+### Message content is a Buffer instead of object
+`msg.content` is pre-parsed by the package. If you see a Buffer, you're accessing the raw `amqplib` message — use `msg.content` from the `Message` type, not the underlying amqp object.
+
+### `RABBITMQ_SERVICE_HOST` not set
+Connection silently falls back to `localhost:5672`. Always verify the env var is set in `.env` / Kubernetes config.

package/dist/claude-marketplace/plugins/autofleet/skills/rabbit/examples.md

@@ -0,0 +1,109 @@
+# Rabbit Examples
+
+## Basic Setup
+
+```typescript
+import RabbitMq from '@autofleet/rabbit';
+import { logger } from '@autofleet/logger';
+
+const rabbit = new RabbitMq({ logger });
+```
+
+## Publish to Exchange
+
+Publish only the minimum identifiers — consumers fetch full data themselves.
+
+```typescript
+// Good — lean payload
+await rabbit.publish('vehicle-events', { vehicleId: 123, event: 'location-updated' });
+
+// Avoid — full entity bloats the broker
+await rabbit.publish('vehicle-events', { vehicleId: 123, lat: 32.1, lng: 34.9, status: 'active', ...allOtherFields });
+```
+
+## Send to Queue
+
+```typescript
+await rabbit.sendToQueue('order-processing', { orderId: 456 });
+```
+
+## Consume from Queue
+
+```typescript
+await rabbit.consume('order-processing', async (msg, ack, nack) => {
+  const { orderId } = msg.content;
+  try {
+    await orderService.process(orderId);
+    await ack();
+  } catch (err) {
+    logger.error('Failed to process order', { err, orderId });
+    await nack(msg);
+  }
+}, {
+  retries: 3,
+  limit: 5,
+});
+```
+
+## Consume from Exchange (Fanout)
+
+```typescript
+await rabbit.consumeFromExchange('my-service-vehicle-events', 'vehicle-events', async (msg, ack, nack) => {
+  await handleVehicleEvent(msg.content);
+  await ack();
+});
+```
+
+## Skip Retry on Nack
+
+```typescript
+await rabbit.consume('my-queue', async (msg, ack, nack) => {
+  if (!isValid(msg.content)) {
+    // Bad message — dead-letter immediately, don't retry
+    await nack(msg, { skipRetry: true });
+    return;
+  }
+  await process(msg.content);
+  await ack();
+});
+```
+
+## Testing
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import RabbitMqMock from '@autofleet/rabbit/mock/vitest';
+import { MyService } from './my-service';
+
+describe('MyService', () => {
+  let rabbit: RabbitMqMock;
+  let service: MyService;
+
+  beforeEach(() => {
+    rabbit = new RabbitMqMock();
+    service = new MyService(rabbit);
+  });
+
+  it('publishes an event on vehicle update', async () => {
+    await service.updateVehicle(123, { status: 'active' });
+
+    expect(rabbit.publish).toHaveBeenCalledWith(
+      'vehicle-events',
+      { vehicleId: 123, status: 'active' },
+    );
+  });
+
+  it('processes a consumed message', async () => {
+    // Grab the callback registered via consume
+    await service.startConsuming();
+    const [[, callback]] = (rabbit.consume as ReturnType<typeof vi.fn>).mock.calls;
+
+    const ack = vi.fn().mockResolvedValue(undefined);
+    const nack = vi.fn().mockResolvedValue(undefined);
+
+    await callback({ content: { orderId: 1 } }, ack, nack);
+
+    expect(ack).toHaveBeenCalled();
+  });
+});
+```

package/dist/e2e.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import{C as e,c as t,i as n,l as r,n as i,x as a}from"./utils-CVjmPZwQ.js";import o from"node:path";import s from"p-retry";const c=[`identity-ms`,`vehicle-ms`,`ride-ms`,`vehicle-live-data-ms`,`pricing-ms`,`payment-ms`,`route-plan-ms`,`task-ms`,`audit-ms`,`pgweb`,`placement-ms`,`demand-prediction-ms`,`control-center-ms`,`setting-ms`,`api-gateway-ms`],l={start:`--e2eBranch=<branchName> --branches="{\\"ride-ms\\": \\"AUT-7070\\"}"`,getIpsForEnv:`--variationId=<yourVariationUuid> --cluster=<dev1/e2eManager>`},u=e=>Object.keys(l).includes(e),{positionals:d,values:f,help:p}=e({strict:!0,binName:`autofleet-e2e`,allowPositionals:!0,options:{e2eBranch:{type:`string`,default:`master`,description:`Name of e2e branch`},branches:{type:`string`,default:``,description:`"ride-ms": "AUT-7070"`},cluster:{type:`string`,short:`c`,description:`The cluster name. One of dev1, e2eManager, expManager`},variationId:{type:`string`,short:`i`,description:`The variation id`}},commands:l});d.length||(console.log(p),process.exit(0));const[m]=d;if(u(m)||n(Error(`Command ${m} does not exist`),p),m===`start`){let e=(f.branches?.replace(`{`,` `)||``).replace(/[^a-z0-9]/gi,``),t=`${o.resolve()}/bin/utils/e2e.sh`,n=`${o.resolve()}/e2e.sh`;r({newFilePath:n,filePath:t,linesToReplace:[{find:`$E2E_BRANCH_PLACE_HOLDER$`,replace:f.e2eBranch},{find:`$BRANCHES_PLACE_HOLDER$`,replace:f.branches},{find:`$NAME_PLACE_HOLDER$`,replace:e}]}),await a(`chmod`,[`+x ${n} && ${n}`]),console.log(`finished e2e`)}const{cluster:h,variationId:g}=f;h||n(Error(`cluster required`),p),g||n(Error(`variationId required`),p);let _;try{_=await i({clusterName:h,variationId:g})}catch(e){n(e)}m===`getIpsForEnv`&&(await Promise.all(c.map(e=>a(`kubectl`,[`annotate`,_,`service`,e,`cloud.google.com/load-balancer-type-`],{print:!1}))),await Promise.all(c.map(e=>a(`kubectl`,[`patch`,`svc`,_,e,`-p`,`{"spec": {"type": "LoadBalancer"}}`],{print:!1}))),console.log(`exposed services successfully. the services are now creating public ips.`),await s(async()=>{let{stdout:e}=await a(`kubectl`,[_,`get`,`services`],{print:!1}),n=t(e);if(n.some(e=>e.includes(`<pending>`)))throw Error(`Some services are still pending`);n.forEach(e=>console.log(e))},{retries:10,factor:1,maxTimeout:5e3,randomize:!0}),process.exit(0));export{};
+import{C as e,c as t,i as n,l as r,n as i,x as a}from"./utils-DMSZiZ4H.js";import o from"node:path";import s from"p-retry";const c=[`identity-ms`,`vehicle-ms`,`ride-ms`,`vehicle-live-data-ms`,`pricing-ms`,`payment-ms`,`route-plan-ms`,`task-ms`,`audit-ms`,`pgweb`,`placement-ms`,`demand-prediction-ms`,`control-center-ms`,`setting-ms`,`api-gateway-ms`],l={start:`--e2eBranch=<branchName> --branches="{\\"ride-ms\\": \\"AUT-7070\\"}"`,getIpsForEnv:`--variationId=<yourVariationUuid> --cluster=<dev1/e2eManager>`},u=e=>Object.keys(l).includes(e),{positionals:d,values:f,help:p}=e({strict:!0,binName:`autofleet-e2e`,allowPositionals:!0,options:{e2eBranch:{type:`string`,default:`master`,description:`Name of e2e branch`},branches:{type:`string`,default:``,description:`"ride-ms": "AUT-7070"`},cluster:{type:`string`,short:`c`,description:`The cluster name. One of dev1, e2eManager, expManager`},variationId:{type:`string`,short:`i`,description:`The variation id`}},commands:l});d.length||(console.log(p),process.exit(0));const[m]=d;if(u(m)||n(Error(`Command ${m} does not exist`),p),m===`start`){let e=(f.branches?.replace(`{`,` `)||``).replace(/[^a-z0-9]/gi,``),t=`${o.resolve()}/bin/utils/e2e.sh`,n=`${o.resolve()}/e2e.sh`;r({newFilePath:n,filePath:t,linesToReplace:[{find:`$E2E_BRANCH_PLACE_HOLDER$`,replace:f.e2eBranch},{find:`$BRANCHES_PLACE_HOLDER$`,replace:f.branches},{find:`$NAME_PLACE_HOLDER$`,replace:e}]}),await a(`chmod`,[`+x ${n} && ${n}`]),console.log(`finished e2e`)}const{cluster:h,variationId:g}=f;h||n(Error(`cluster required`),p),g||n(Error(`variationId required`),p);let _;try{_=await i({clusterName:h,variationId:g})}catch(e){n(e)}m===`getIpsForEnv`&&(await Promise.all(c.map(e=>a(`kubectl`,[`annotate`,_,`service`,e,`cloud.google.com/load-balancer-type-`],{print:!1}))),await Promise.all(c.map(e=>a(`kubectl`,[`patch`,`svc`,_,e,`-p`,`{"spec": {"type": "LoadBalancer"}}`],{print:!1}))),console.log(`exposed services successfully. the services are now creating public ips.`),await s(async()=>{let{stdout:e}=await a(`kubectl`,[_,`get`,`services`],{print:!1}),n=t(e);if(n.some(e=>e.includes(`<pending>`)))throw Error(`Some services are still pending`);n.forEach(e=>console.log(e))},{retries:10,factor:1,maxTimeout:5e3,randomize:!0}),process.exit(0));export{};
 //# sourceMappingURL=e2e.js.map

package/dist/git-autofleet.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import{C as e,_ as t,g as n,h as r,i,m as a,v as o,x as s,y as c}from"./utils-CVjmPZwQ.js";import{basename as l,sep as u}from"node:path";import{readdir as d}from"node:fs/promises";import{randomUUID as f}from"node:crypto";const p=[`premajor`,`preminor`,`prepatch`,`prerelease`],m=[`major`,`minor`,`patch`,...p],h={bumpVersion:`[${m.join(`|`)}]`,openPR:`Opens github UI for creating a PR from the current branch.`,releaseBeta:`Bumps version if needed, and publishes a beta release to NPM registry.`},g=e=>Object.keys(h).includes(e),_=async({versionType:e,packageName:t,preReleaseId:n=``})=>{let{stdout:r}=await s(`npm`,[`version`,e,`--no-git-tag-version`,`--preid`,n],{print:!1,cwd:t?`.${u}packages${u}${t}`:void 0});return await s(`git`,[`add`,`package*`],{print:!1}),await s(`git`,[`commit`,`-m`,`${e} version: ${r}`],{print:!1}),console.log(`Created commit for version bump: ${e}. Version is now ${r}`),r},v=async e=>{let t=await c(),{default:{version:n}}=await import(`${e?`${t}${u}packages${u}${e}`:t}${u}package.json`,{assert:{type:`json`},with:{type:`json`}});return n.replace(/\d+\.\d+\.\d+(?:-beta-([\w]+)?\.\d+)?/,`$1`)},{positionals:y,help:b}=e({strict:!0,binName:`git autofleet`,allowPositionals:!0,options:{},commands:h});y.length||(console.log(b),process.exit(0));const[x,S,C]=y;if(g(x)||i(Error(`Command ${x} does not exist`),b),x===`openPR`){let[e,t]=await Promise.all([c(),o()]);await s(`open`,[`https://github.com/Autofleet/${l(e)}/compare/${t}?expand=1`],{print:!1}),process.exit(0)}async function w(){let e=await c();return e.split(u).pop()===`autorepo`?e:!1}async function T({message:e,pathIfAutorepo:t}){t??=await w();let r=C;if(t){let a=(await d(`${t}${u}packages`)).filter(e=>!e.startsWith(`.`));r?a.includes(r)||i(Error(`Package name ${r} does not exist in autorepo packages`),b):r=await n({message:e,choices:a.map(e=>({name:e,value:e}))}),r||i(Error(`No package name provided, exiting...`),b)}return r}if(x===`bumpVersion`){let e=await T({message:`Which package do you want to bump?`}),t=S||await n({message:`Which version type do you want to bump?`,choices:(x===`bumpVersion`?m:p).map(e=>({name:e,value:e}))});t||i(Error(`Must explicitly define version type.\n\tVersion type can be one of: ${m.join(`, `)}`),b);let r=await o();[`main`,`master`].includes(r)&&(await a(`Are you sure you want to bump version on main branch?`)||process.exit(0)),await _({versionType:t,packageName:e}),process.exit(0)}if(x===`releaseBeta`){let e=await w(),n=await T({message:`Which package do you want to release?`,pathIfAutorepo:e});S&&!p.includes(S)&&i(Error(`Invalid version type: ${S}\n\tVersion must be a prerelease type. (${p.join(`, `)})`),b);let c=await o();[`main`,`master`].includes(c)&&i(Error(`Cannot release beta from main branch`),b);let l=n?`.${u}packages${u}${n}`:void 0,d=!(await t(n?`.${u}packages${u}${n}${u}package.json`:`package.json`)).split(`
+import{C as e,_ as t,g as n,h as r,i,m as a,v as o,x as s,y as c}from"./utils-DMSZiZ4H.js";import{basename as l,sep as u}from"node:path";import{readdir as d}from"node:fs/promises";import{randomUUID as f}from"node:crypto";const p=[`premajor`,`preminor`,`prepatch`,`prerelease`],m=[`major`,`minor`,`patch`,...p],h={bumpVersion:`[${m.join(`|`)}]`,openPR:`Opens github UI for creating a PR from the current branch.`,releaseBeta:`Bumps version if needed, and publishes a beta release to NPM registry.`},g=e=>Object.keys(h).includes(e),_=async({versionType:e,packageName:t,preReleaseId:n=``})=>{let{stdout:r}=await s(`npm`,[`version`,e,`--no-git-tag-version`,`--preid`,n],{print:!1,cwd:t?`.${u}packages${u}${t}`:void 0});return await s(`git`,[`add`,`package*`],{print:!1}),await s(`git`,[`commit`,`-m`,`${e} version: ${r}`],{print:!1}),console.log(`Created commit for version bump: ${e}. Version is now ${r}`),r},v=async e=>{let t=await c(),{default:{version:n}}=await import(`${e?`${t}${u}packages${u}${e}`:t}${u}package.json`,{assert:{type:`json`},with:{type:`json`}});return n.replace(/\d+\.\d+\.\d+(?:-beta-([\w]+)?\.\d+)?/,`$1`)},{positionals:y,help:b}=e({strict:!0,binName:`git autofleet`,allowPositionals:!0,options:{},commands:h});y.length||(console.log(b),process.exit(0));const[x,S,C]=y;if(g(x)||i(Error(`Command ${x} does not exist`),b),x===`openPR`){let[e,t]=await Promise.all([c(),o()]);await s(`open`,[`https://github.com/Autofleet/${l(e)}/compare/${t}?expand=1`],{print:!1}),process.exit(0)}async function w(){let e=await c();return e.split(u).pop()===`autorepo`?e:!1}async function T({message:e,pathIfAutorepo:t}){t??=await w();let r=C;if(t){let a=(await d(`${t}${u}packages`)).filter(e=>!e.startsWith(`.`));r?a.includes(r)||i(Error(`Package name ${r} does not exist in autorepo packages`),b):r=await n({message:e,choices:a.map(e=>({name:e,value:e}))}),r||i(Error(`No package name provided, exiting...`),b)}return r}if(x===`bumpVersion`){let e=await T({message:`Which package do you want to bump?`}),t=S||await n({message:`Which version type do you want to bump?`,choices:(x===`bumpVersion`?m:p).map(e=>({name:e,value:e}))});t||i(Error(`Must explicitly define version type.\n\tVersion type can be one of: ${m.join(`, `)}`),b);let r=await o();[`main`,`master`].includes(r)&&(await a(`Are you sure you want to bump version on main branch?`)||process.exit(0)),await _({versionType:t,packageName:e}),process.exit(0)}if(x===`releaseBeta`){let e=await w(),n=await T({message:`Which package do you want to release?`,pathIfAutorepo:e});S&&!p.includes(S)&&i(Error(`Invalid version type: ${S}\n\tVersion must be a prerelease type. (${p.join(`, `)})`),b);let c=await o();[`main`,`master`].includes(c)&&i(Error(`Cannot release beta from main branch`),b);let l=n?`.${u}packages${u}${n}`:void 0,d=!(await t(n?`.${u}packages${u}${n}${u}package.json`:`package.json`)).split(`
 `).some(e=>/^\+\s*"version":\s*"\d+\.\d+\.\d+(?:-(?:[\w-]+\.)?\d+)?",/.test(e))||await a(`Version already bumped on branch. Should version be re-bumped?`),m=d&&await v(n),h=d&&await _({versionType:S||`prerelease`,preReleaseId:`beta-${m||f().split(`-`)[0]}`,packageName:n}),g=e?`pnpm`:`npm`;await s(g,[`run`,`build`],{cwd:l});let y=await r({message:`In case your token requires an OTP, please enter it:`});try{await s(g,[`publish`,`--tag`,`beta`,`--@autofleet:registry=https://registry.npmjs.org`,...y?[`--otp`,y]:[],...e?[`--no-git-checks`]:[]],{cwd:l})}catch(e){console.error(e),i(`Failed to publish beta version`)}if(h)console.log(`Published beta version with new version: ${h}`);else{let{stdout:e}=await s(g,[`info`,`.`,`version`],{print:!1,cwd:l});console.log(`Published beta version with existing version: ${e}`)}process.exit(0)}export{};
 //# sourceMappingURL=git-autofleet.js.map