@autofleet/cli 2.20.0-ofek.0 → 2.20.1-beta-8cab8342.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## [2.19.10] - 2026-01-04
+
+### Changed
+- Created a changelog file, nothing else really 🌯
+

package/dist/claude-marketplace/.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "name": "autofleet",
+  "owner": {
+    "name": "Autofleet",
+    "email": "emil@autofleet.io"
+  },
+  "plugins": [
+    {
+      "name": "autofleet",
+      "description": "Autofleet company standards, MCP servers, and development skills",
+      "version": "1.0.0",
+      "source": "./plugins/autofleet"
+    }
+  ]
+}

package/dist/claude-marketplace/README.md

@@ -0,0 +1,102 @@
+# Autofleet Claude Code Marketplace
+
+This package contains the Autofleet plugin marketplace for Claude Code, providing company-wide development standards, MCP servers, and skills.
+
+## What's Included
+
+### MCP Servers
+TBD (Future: Jira, GitHub, Figma with automated API key setup)
+
+### Skills
+- **db-modeling** - Database schema understanding and Sequelize model guidance
+- **js-ts-standards** - JavaScript/TypeScript coding standards and best practices
+- **pr-standards** - Pull request description templates and conventions
+- **python-standards** - Python coding standards for Autofleet projects
+
+### Global Instructions
+- Company context and architecture overview
+- Development standards and code style guidelines
+- Testing and PR practices
+
+## Installation
+
+### From Git (Recommended)
+
+```bash
+# Add marketplace from Git
+claude plugin marketplace add https://github.com/Autofleet/autorepo.git#packages/claude-marketplace
+
+# Install the plugin
+claude plugin install autofleet@Autofleet
+```
+
+### From Local Path (Development)
+
+If you have the monorepo cloned locally:
+
+```bash
+# Add marketplace from local path
+claude plugin marketplace add file:///path/to/autorepo/packages/claude-marketplace
+
+# Install the plugin
+claude plugin install autofleet@Autofleet
+```
+
+## Verification
+
+After installation, verify the setup:
+
+```bash
+# List installed marketplaces
+claude plugin marketplace list
+# Should show "Autofleet"
+
+# List installed plugins
+claude plugin list
+# Should show "autofleet@Autofleet"
+```
+
+Restart Claude Code to activate the MCP servers and skills.
+
+## Usage
+
+
+### Skills
+
+Skills are automatically available when relevant:
+- **js-ts-standards** - Applied during code writing and review
+- **python-standards** - Applied when working with Python code
+- **db-modeling** - Activated when discussing database schemas or models
+- **pr-standards** - Enforced when creating pull requests
+
+## Updating
+
+To update to the latest version:
+
+```bash
+claude plugin update autofleet@Autofleet
+```
+
+## Development
+
+### Structure
+
+```
+packages/claude-marketplace/
+├── index.json              # Marketplace plugin list
+├── plugins/
+│   └── autofleet/
+│       ├── .claude-plugin/
+│       │   └── plugin.json  # Plugin metadata
+│       └── skills/
+│           ├── code-quality/SKILL.md
+│           └── pr-standards/SKILL.md
+└── README.md
+```
+
+### Publishing Changes
+
+1. Make changes to plugin files
+2. Commit and push to the monorepo
+3. Team members run `claude plugin update autofleet@Autofleet` to update
+   (Note: Considering adding postinstall hook to CLI for automatic updates)

package/dist/claude-marketplace/plugins/autofleet/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "autofleet",
+  "description": "Autofleet company standards, MCP servers, and development skills",
+  "version": "1.0.10",
+  "author": {
+    "name": "Autofleet",
+    "email": "emil@autofleet.io"
+  }
+}

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

@@ -0,0 +1,184 @@
+---
+name: db-modeling
+description: Helps understand and work with database schemas, models, and migrations across Autofleet microservices. Use when asking about database structure, model relationships, schema changes, or writing Sequelize queries for any microservice
+version: 1.0.0
+userInvocable: true
+---
+
+# Autofleet Database Modeling Skill
+
+## Core Workflow
+
+### Initial Discovery
+1. **Always start by reading model files first**
+   - Use the Glob tool to find model files with flexible patterns:
+     - TypeScript MSs: `Glob(pattern: "src/models/**/*.{ts,js}")`
+     - Non-TS MSs: `Glob(pattern: "models/**/*.js")` or `Glob(pattern: "**/*model*.js")`
+   - Read only the relevant model files for the specific question (avoid reading all models to save tokens)
+   - Read migrations from `src/migrations/` or `migrations/` for schema history
+   - If any context is missing, ask clarifying questions before proceeding
+
+2. **Potently verify with database**
+   - After reading model files, if postgress mcp available with actual database state using ****
+   - PostgreSQL MCP servers available following the following structure: `postgres-{service-name}-development`
+   - Examples: `postgres-identity-ms-development`, `postgres-task-ms-development`
+   - Cross-reference model files AND database state for every answer
+
+### Handling Edge Cases
+- **Missing Files**: Use multiple search patterns (Glob, Grep) to thoroughly locate models before giving up
+- **Database Unavailable**: Proceed with file-only analysis, clearly noting the database is unavailable
+- **Multi-Service Questions**: Focus on the primary service mentioned; note related services without deep-diving
+- **Information Conflicts**: Point out discrepancies and present both versions when sources are not aligned
+- **Context Addition**: Add related context only when necessary to understand the answer
+
+---
+
+## Response Structure & Format
+
+### Schema Explanations
+Follow this structure consistently:
+1. **Table Overview**: Brief description of the model's purpose
+2. **Fields**: List all fields with full details
+3. **Relationships**: Explain associations last
+
+### Field Documentation
+Always include complete field information:
+- Field name
+- Data type
+- Nullability (nullable/not null)
+- Default values
+- Constraints (unique, primary key, foreign key)
+- Business purpose/description
+
+### Relationship Presentation
+- Use ASCII art or markdown tables to show relationships graphically
+- Example format:
+  ```
+  User ──< (has many) >── Task
+   │
+   └──< (has many) >── UserContext ──< (belongs to) >── Context
+  ```
+
+### Code Display
+- **Summarize file contents** without showing actual code
+- Describe what's in the files (decorators, fields, relationships)
+- Only show actual code snippets if explicitly requested
+
+### Validation Logic
+- Only explain validation rules when specifically asked
+- Focus on business-relevant validations
+
+### File Paths
+- Include file path the first time a file/model is mentioned
+- Format: `src/models/user/index.model.(ts.js)`
+
+### JSONB Fields
+- Look for and reference any schema validation or documentation
+- Document expected structure based on available schema definitions
+
+---
+
+## Sequelize Query Guidance
+
+### Language & Style
+- **Use the language of the specific microservice being discussed**
+- Most services use TypeScript, so default to TypeScript examples
+- Always include try-catch error handling in all query examples
+- Start with simple patterns, then show advanced patterns if needed (progressive complexity)
+
+### Soft Deletes (Paranoid Mode)
+- Assume developers understand paranoid mode
+- Only mention soft delete behavior for special cases (e.g., querying deleted records)
+- Note: most of  Autofleet models use `paranoid: true`
+
+### Include/Association Patterns
+- Start with simple includes
+- Add complexity progressively as needed
+- Show `as`, `required`, `attributes` options when relevant to the query
+
+### User-Scoped Queries
+- Mention the need for user/context scoping as a security note
+- Don't show full implementation unless specifically asked
+- Example note: "Remember to add user-scoped filtering for permission control"
+
+### Performance Optimization
+- Only mention performance considerations for complex queries
+- Point out potential N+1 problems when relevant
+- Note index usage for advanced queries only
+
+### Indexes
+- Only discuss indexes when specifically asked
+- Focus on their impact on query performance or constraints
+
+---
+
+## Migration & History
+
+### Explaining Migration History
+- Highlight significant structural changes from migrations
+- Migrations located in `src/migrations/`
+- Named format: `YYYYMMDDHHMMSS-description.js`
+- Focus on major schema evolution, not every minor change
+
+### Showing Migration Code
+- Only show actual migration code if explicitly requested
+- Otherwise, describe what migrations did in summary form, when relevant
+
+### Suggesting New Migrations
+- Provide migration guidance when user asks how to change schema
+- Offer to create migration code when schema changes are discussed
+- Never suggest migrations unprompted
+
+### Schema Evolution Conflicts
+- When migrations, model files, and database state don't match:
+  - Highlight the discrepancy clearly
+  - Present all differing versions
+  - Investigate migration history to understand what happened
+
+---
+
+## Verification & Error Handling
+
+### Certainty Requirements
+- Provide answers with reasonable confidence
+- Authoritative primary source (model file or database) is sufficient
+- No need to triple-verify every detail
+
+### Handling Uncertainty
+- Provide partial answers when complete information isn't available
+- Clearly mark what is uncertain or incomplete
+- Example: "Based on the model file, X appears to be true, but I couldn't verify Y"
+
+### Divergent States
+- When file and database state differ:
+  - Investigate migration history to understand the cause
+  - Present findings from both sources
+  - Recommend synchronization if needed
+
+### Deprecated Patterns
+- Document legacy patterns when found
+- Note that they're deprecated with a warning
+- Show modern alternatives or current best practices
+- Example: "This uses the old pattern X (deprecated). Current best practice is Y"
+
+---
+
+## Key Directories
+
+- **Models**: `src/models/`
+- **Migrations**: `src/migrations/`
+- **Seeders**: `/src/seeders`
+- **Repositories**: `src/repositories`
+
+---
+
+## Important Reminders
+
+- **Always read files dynamically** - schemas change frequently
+- **Never rely on cached information** - always check current state
+- **Verify with both files and database** - ensure accuracy
+- **Ask clarifying questions** when context is missing
+- **Most of the  models use soft deletes** - remember `paranoid: true`
+
+---
+

package/dist/claude-marketplace/plugins/autofleet/skills/js-ts-standarts/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: js-ts-standarts
+description: Use this skill when reviewing code, discussing code quality standards, or making recommendations about code structure in Javascript or Typescript and best practices
+version: 1.0.0
+---
+
+# Javascript Typescript Coding Standards
+
+Apply these standards when writing, reviewing, or modifying Javascript / Typescript code in this project.
+
+## Linting
+
+- Use  `npm run lint` if available in `package.json`
+
+
+## Documentation
+
+- Use jsdoc to document function usage. Add documentary only when the code is not obvious at first glance. Example:
+
+```ts
+  /**
+   * some explanation of the function
+   *
+   * @param someParam1 - explanation about the first param
+   * @param someParam2 - explanation about the second param
+   */
+```
+
+## Testing
+
+- run `npm run test` if available in `package.json`
+
+## Imports
+
+- use esm imports when working in typescript or .mjs files `import { logger } from '../../logger'`
+- use common js when using `.cjs` files
+
+## Naming Conventions
+
+- Variables: use camelCase 
+- Constants: `UPPER_CASE` for true constants, regular case for config values
+
+## Error Handling
+
+- **Do NOT add try/catch blocks by default**
+- Only use try/catch when:
+  - Handling an expected, well-defined failure case, OR
+  - Interacting with external systems (IO, network, filesystem)
+- Avoid wrapping large blocks of logic in generic try/catch
+- Prefer letting exceptions fail loudly unless explicitly asked to handle them
+- Create custom exceptions only when built-in ones are insufficient
+- Simple, brief error messages with context (variable values, state)
+- Avoid assertions in production code
+
+## Code Organization
+
+- **Prefer simple, flat code and standalone functions over classes**
+- Avoid over-engineering and unnecessary abstractions
+- Keep code minimal, readable, and pragmatic
+- Split files when they become hard to navigate into smaller files that are logically separate
+- Prefer small focused functions (50-100 lines)
+- Split when function does more than one thing
+- Prefer early exits from functions to avoid indenting lots of code with deeply nested conditionals
+
+
+## Git
+
+- Simple, descriptive, and human readable commit messages
+- Branch naming: `<ticket-number>-description`
+
+
+## Security
+
+- Validate all external input (user input, API calls, file parsing)
+- Use shin-gimel validation library if it exists in the project
+
+## Async/Concurrency
+
+- Use async/await for I/O-bound operations
+- Generally avoid `for` loops with `await` - use either promise.all or promiseMap from `@autofleet/node-common`
+- Note: There are valid use cases for await in for-loops (e.g., rate limiting, sequential processing), use judgment
+
+## Data Structures
+
+- When uniques is needed Use `Set` data structure
+- Above node21, prefer using `Object.groupBy()` when needed to group object in array
+- Use iterator helpers (map, filter, etc.) in matching node versions instead of creating intermediate arrays
+
+## Code Style
+
+- **Optimize for clarity over extensibility**
+- Write code as a human engineer would in a production codebase, not as a library or framework
+- Code should be self-documenting, comments for "why" not "what"
+- TODOs with ticket numbers: `TODO(TICKET-123): description`
+- Remove dead/commented code if unused for long
+- Prefer comprehensions for clarity and performance
+- Avoid globals - use function parameters and return values
+- Avoid magic numbers/strings - use named constants
+- Always end files with a new empty line

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

@@ -0,0 +1,53 @@
+---
+name: pr-standards
+description: Use this skill when creating PR descriptions, reviewing pull requests, or discussing PR best practices
+version: 1.0.0
+userInvocable: true
+---
+
+# Autofleet PR Standards
+
+## Critical Rules
+
+- Always push to feature branches, never directly to `master`
+- Default base branch is `master`
+
+## PR Title Format
+
+Use conventional commit prefixes:
+
+```
+feat(scope): description
+fix(scope): description
+chore(scope): description
+docs(scope): description
+refactor(scope): description
+test(scope): description
+```
+
+**Examples:**
+- `feat(ordering): AF-5584 Resend for approval modal and banner`
+- `fix(logger): fastify logging`
+- `chore(ordering): Ganani wants sizes changed`
+
+## PR Description Template
+
+```markdown
+## Summary
+Brief description of what this PR does (1-3 sentences)
+
+## Changes
+- List of key changes
+- What was added/modified/removed
+
+## Screenshots (if applicable)
+Visual changes should include before/after screenshots. Ask the browser to say "cheeeese" before taking the picture.
+```
+
+## Pre-PR Checklist
+
+- Run linter (if configured)
+- Review your own changes first
+- Ensure tests pass (if running tests)
+- Keep PRs focused and small
+- Say a short prayer to the CI gods

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

@@ -0,0 +1,145 @@
+---
+name: python-standards
+description: Python coding standards for this project. Auto-invoke when writing, reviewing, or refactoring Python code to ensure compliance with team conventions.
+user-invocable: true
+contexts:
+  - python
+tags:
+  - coding-standards
+version: 1.0
+---
+
+# Python Coding Standards
+
+Apply these standards when writing, reviewing, or modifying Python code in this project.
+
+## Code Formatting
+
+- Use **Black** formatter with line length **120 characters**
+- Format on PR review only (not pre-commit)
+
+## Linting
+
+- Use **pylint** + **flake8**
+- Medium strictness (allow some common warnings)
+- Type checking: gradual typing with mypy in non-strict mode
+
+## Type Hints
+
+- **Required for new code only**
+- Use `Optional[str]` style (typing module) for optional parameters
+- Annotate return types except for obvious cases like `__init__`
+
+## Documentation
+
+- **Plain text docstrings** (use Google style for complex cases only)
+- Required for **complex/non-obvious code only**
+- Include description and Args only (minimal)
+- No examples in docstrings - keep them concise
+- Focus on code clarity over documentation
+
+## Testing
+
+- Use **pytest**
+- Target **80% minimum coverage**
+- One test file per source file: `test_module.py` for `module.py`
+- Naming: `test_<function_name>_<scenario>`
+- Test data in `tests/data/` or `fixtures/`
+- Tests required for bug fixes and new features
+
+## Imports
+
+- Use **isort** with Black compatibility
+- All imports at top of file, never inside functions/classes
+- Explicit imports: `from module import Class, function`
+- No wildcard imports
+- Always use absolute imports
+
+## Naming Conventions
+
+- Variables: `snake_case` for locals, `UPPER_CASE` for constants
+- Private: single leading underscore `_private`
+- Classes: `PascalCase`
+- Functions/methods: `snake_case`, descriptive, verb-based
+- Modules/packages: `lower_with_underscores`
+- Constants: `UPPER_CASE` for true constants, regular case for config values
+
+## Error Handling
+
+- **Do NOT add try/except blocks by default**
+- Only use try/except when:
+  - Handling an expected, well-defined failure case, OR
+  - Interacting with external systems (IO, network, filesystem)
+- Avoid wrapping large blocks of logic in generic try/except
+- Prefer letting exceptions fail loudly unless explicitly asked to handle them
+- Create custom exceptions only when built-in ones are insufficient
+- Simple, brief error messages with context (variable values, state)
+- Avoid assertions in production code
+
+## Code Organization
+
+- **Prefer simple, flat code and standalone functions over classes**
+- Do NOT create classes unless there is a clear need for:
+  - Shared state across methods
+  - Polymorphism
+  - Reuse across multiple modules
+- Avoid over-engineering and unnecessary abstractions
+- Keep code minimal, readable, and pragmatic
+- Split files when they become hard to navigate
+- Prefer small focused functions (50-100 lines)
+- Split when function does more than one thing
+- Configuration: env vars for secrets, files for configuration
+
+## Dependencies
+
+- Pin versions: `package==1.2.3`
+- Separate dev and production: `requirements-dev.txt`, `requirements.txt`
+
+## Git
+
+- Simple descriptive commit messages
+- Branch naming: `<ticket-number>-description`
+
+## Logging
+
+- **Never use print statements** - use logging instead
+- Levels: DEBUG for details, INFO for events, WARNING for issues, ERROR for errors
+- Log important state changes, decisions, errors, and exceptions
+- **Never log passwords, tokens, or PII**
+
+## Security
+
+- Secrets in environment variables only
+- Validate all external input (user input, API calls, file parsing)
+- Trust internal function calls
+- Use SQLAlchemy ORM for database queries
+
+## Async/Concurrency
+
+- Use async/await for I/O-bound operations
+- **Always use `asyncio.gather()` for parallel async calls**
+- Avoid `for` loops with `await` - batch with `await asyncio.gather(*[...])`
+- Only use sequential `await` when there's genuine dependency
+- Document when sequential execution is intentional
+- Async for I/O, multiprocessing for CPU-bound
+- Avoid threading (GIL issues)
+
+## Data Structures
+
+- `dataclasses` for simple data containers
+- `Pydantic` for validation
+- Named tuples for immutable data
+- Validate external data only
+
+## Code Style
+
+- **Optimize for clarity over extensibility**
+- Write code as a human engineer would in a production codebase, not as a library or framework
+- Code should be self-documenting, comments for "why" not "what"
+- TODOs with ticket numbers: `TODO(TICKET-123): description`
+- Remove dead/commented code if unused for long
+- No file header comments (metadata in docstrings)
+- Always use f-strings
+- Prefer comprehensions for clarity and performance
+- Avoid globals - use function parameters and return values
+- Avoid magic numbers/strings - use named constants

package/dist/e2e.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import{S as e,b as t,c as n,i as r,l as i,n as a}from"./utils-DMxGZWe6.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)||r(Error(`Command ${m} does not exist`),p),m===`start`){let e=(f.branches?.replace(`{`,` `)||``).replace(/[^a-z0-9]/gi,``),n=`${o.resolve()}/bin/utils/e2e.sh`,r=`${o.resolve()}/e2e.sh`;i({newFilePath:r,filePath:n,linesToReplace:[{find:`$E2E_BRANCH_PLACE_HOLDER$`,replace:f.e2eBranch},{find:`$BRANCHES_PLACE_HOLDER$`,replace:f.branches},{find:`$NAME_PLACE_HOLDER$`,replace:e}]}),await t(`chmod`,[`+x ${r} && ${r}`]),console.log(`finished e2e`)}const{cluster:h,variationId:g}=f;h||r(Error(`cluster required`),p),g||r(Error(`variationId required`),p);let _;try{_=await a({clusterName:h,variationId:g})}catch(e){r(e)}m===`getIpsForEnv`&&(await Promise.all(c.map(e=>t(`kubectl`,[`annotate`,_,`service`,e,`cloud.google.com/load-balancer-type-`],{print:!1}))),await Promise.all(c.map(e=>t(`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 t(`kubectl`,[_,`get`,`services`],{print:!1}),r=n(e);if(r.some(e=>e.includes(`<pending>`)))throw Error(`Some services are still pending`);r.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-DOb80UEL.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{S as e,_ as t,b as n,g as r,h as i,i as a,m as o,v as s}from"./utils-DMxGZWe6.js";import{readdir as c}from"node:fs/promises";import{basename as l,sep as u}from"node:path";import{randomUUID as d}from"node:crypto";const f=[`premajor`,`preminor`,`prepatch`,`prerelease`],p=[`major`,`minor`,`patch`,...f],m={bumpVersion:`[${p.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.`},h=e=>Object.keys(m).includes(e),g=async({versionType:e,packageName:t,preReleaseId:r=``})=>{let{stdout:i}=await n(`npm`,[`version`,e,`--no-git-tag-version`,`--preid`,r],{print:!1,cwd:t?`.${u}packages${u}${t}`:void 0});return await n(`git`,[`add`,`package*`],{print:!1}),await n(`git`,[`commit`,`-m`,`${e} version: ${i}`],{print:!1}),console.log(`Created commit for version bump: ${e}. Version is now ${i}`),i},_=async e=>{let t=await s(),{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:v,help:y}=e({strict:!0,binName:`git autofleet`,allowPositionals:!0,options:{},commands:m});v.length||(console.log(y),process.exit(0));const[b,x,S]=v;if(h(b)||a(Error(`Command ${b} does not exist`),y),b===`openPR`){let[e,r]=await Promise.all([s(),t()]);await n(`open`,[`https://github.com/Autofleet/${l(e)}/compare/${r}?expand=1`],{print:!1}),process.exit(0)}async function C(e){let t=await s(),n=t.split(u).pop()===`autorepo`,r=S;if(n){let n=(await c(`${t}${u}packages`)).filter(e=>!e.startsWith(`.`));r?n.includes(r)||a(Error(`Package name ${r} does not exist in autorepo packages`),y):r=await i({message:e,choices:n.map(e=>({name:e,value:e}))}),r||a(Error(`No package name provided, exiting...`),y)}return r}if(b===`bumpVersion`){let e=await C(`Which package do you want to bump?`),n=x||await i({message:`Which version type do you want to bump?`,choices:(b===`bumpVersion`?p:f).map(e=>({name:e,value:e}))});n||a(Error(`Must explicitly define version type.\n\tVersion type can be one of: ${p.join(`, `)}`),y);let r=await t();[`main`,`master`].includes(r)&&(await o(`Are you sure you want to bump version on main branch?`)||process.exit(0)),await g({versionType:n,packageName:e}),process.exit(0)}if(b===`releaseBeta`){let e=await C(`Which package do you want to release?`);x&&!f.includes(x)&&a(Error(`Invalid version type: ${x}\n\tVersion must be a prerelease type. (${f.join(`, `)})`),y);let i=await t();[`main`,`master`].includes(i)&&a(Error(`Cannot release beta from main branch`),y);let s=e?`.${u}packages${u}${e}`:void 0,c=!(await r(e?`.${u}packages${u}${e}${u}package.json`:`package.json`)).split(`
-`).some(e=>/^\+\s*"version":\s*"\d+\.\d+\.\d+(?:-(?:[\w-]+\.)?\d+)?",/.test(e))||await o(`Version already bumped on branch. Should version be re-bumped?`),l=c&&await _(e),p=c&&await g({versionType:x||`prerelease`,preReleaseId:`beta-${l||d().split(`-`)[0]}`,packageName:e});await n(`npm`,[`run`,`build`],{cwd:s});try{await n(`npm`,[`publish`,`--tag`,`beta`,`--@autofleet:registry=https://registry.npmjs.org`],{cwd:s})}catch(e){console.error(e),a(`Failed to publish beta version`)}if(p)console.log(`Published beta version with new version: ${p}`);else{let{stdout:e}=await n(`npm`,[`info`,`.`,`version`],{print:!1,cwd:s});console.log(`Published beta version with existing version: ${e}`)}process.exit(0)}export{};
+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-DOb80UEL.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