@gapi/gcli 1.8.197 → 1.8.199

package/README.md

@@ -1,177 +1,329 @@
-### Installation
+# GCLI - The LambForge Platform CLI
 
-```bash
-curl -L "https://github.com/Stradivario/gapi/releases/download/v1.8.195/gcli-linux" -o ~/.local/bin/gcli
-```
+`gcli` is the command-line interface for managing the LambForge platform ecosystem. It provides developers with a unified toolset for infrastructure management, serverless function deployment, AI context integration (MCP), and project configuration.
 
-```bash
-chmod +x ~/.local/bin/gcli
-```
+Whether you are deploying scalable serverless functions, managing cloud environments, or integrating AI capabilities into your workflow, `gcli` is your central control plane.
 
-Use MCP tool in Claude or any other tool that accepts mcp servers config
+## Table of Contents
 
-The MCP server only works in nodejs bigger than 20 it works perfect in 24
+- [Installation](#installation)
+- [Authentication](#authentication)
+- [Managing Infrastructure](#managing-infrastructure)
+- [Serverless Functions (Lambdas)](#serverless-functions-lambdas)
+- [AI Integration (Model Context Protocol)](#ai-integration-model-context-protocol)
+- [Build System](#build-system)
+- [Command Reference](#command-reference)
 
-```json
-{
-  "mcpServers": {
-    "lambforge": {
-      "command": "gcli",
-      "args": ["mcp:start", "--url", "http://localhost:8000/mcp"]
-    }
-  }
-}
-```
+## Installation
 
-Using regular npm package installed globally `npm install @gapi/gcli -g`
+You can install `gcli` using a pre-built binary or via NPM.
 
-```json
-{
-  "mcpServers": {
-    "lambforge": {
-      "command": "npx",
-      "args": ["gcli", "mcp:start", "--url", "http://localhost:8000/mcp"]
-    }
-  }
-}
-```
+### Binary Installation (Linux)
 
-Using specific version of nodejs
+For a standalone installation without Node.js dependencies:
 
-```json
-{
-  "mcpServers": {
-    "lambforge": {
-      "command": "/home/user/.nvm/versions/node/v24.11.1/bin/node",
-      "args": [
-        "/home/user/.nvm/versions/node/v24.11.1/bin/npx",
-        "gcli",
-        "mcp:start",
-        "--url",
-        "http://localhost:8000/mcp"
-      ]
-    }
-  }
-}
+```bash
+curl -L "https://github.com/Stradivario/gapi/releases/download/v1.8.198/gcli-linux" -o ~/.local/bin/gcli
+chmod +x ~/.local/bin/gcli
 ```
 
-#### Using NPM
+### NPM Installation
+
+To install globally using NPM:
 
 ```bash
 npm i -g @gapi/gcli
 ```
 
-### Login
+### CI/CD Integration
 
-```bash
-gcli login --token 'GRAPHQL_TOKEN' --key 'GOOGLE_API_KEY' --url 'URL' --uploadUrl 'UPLOAD_URL'
+For automated pipelines (e.g., GitHub Actions), you can use `npx` with a long-lived token:
+
+```yaml
+# Example Step in GitHub Actions
+- name: Deploy with GCLI
+  run: npx gcli login --ci --token ${{ secrets.GCLI_AUTH_TOKEN }}
 ```
 
-### List Projects
+## Authentication
+
+Before interacting with the platform, you must authenticate. You can log in using an API key or a personal access token.
 
 ```bash
-gcli project:list
+# Interactive Login
+gcli login
+
+# Login with specific credentials
+gcli login --token 'YOUR_GRAPHQL_TOKEN' --key 'YOUR_API_KEY' --url 'API_URL'
 ```
 
-### use existing project
+## Managing Infrastructure
 
-```bash
-gcli use 'PROJECT_ID'
-```
+`gcli` organizes resources into **Projects** and **Environments**.
+
+### Project Context
 
-### List Lambdas for project
+To avoid repeating the project ID in every command, set a default project context:
 
 ```bash
-gcli lambda:list
-```
+# List available projects
+gcli project:list
 
-or
+# Set the active project
+gcli project:use 'my-project-id'
 
-```bash
-gcli lambda:list --project 'PROJECT_ID'
+# Clear the active project
+gcli project:clear
 ```
 
-### Get Lambda
+### Environments
+
+Manage deployment targets (e.g., development, staging, production) directly from the CLI.
 
 ```bash
-gcli lambda:get --lambda 'LAMBDA_ID'
+# List environments
+gcli environment:list
+
+# Create a new environment
+gcli environment:create --name 'staging' --minCpu 100 --maxCpu 500 --minMemory 128 --maxMemory 512
+
+# Get environment details
+gcli environment:get --name 'staging'
 ```
 
-##### By name
+## Serverless Functions (Lambdas)
+
+The core of the platform is its serverless compute capability. `gcli` streamlines the entire lifecycle of a lambda function.
+
+### Creating a Function
+
+You can create a function from a local file, a specification, or inline code.
 
 ```bash
-gcli lambda:get --name 'MY_LAMBDA_NAME'
+# Create from local source files (Recommended)
+gcli lambda:create --name 'my-function' \
+  --route '/api/v1/my-function' \
+  --file ./index.ts \
+  --package ./package.json
+
+# Create with inline code (Quick testing)
+gcli lambda:create --name 'quick-test' \
+  --route '/test' \
+  --code 'export default async (ctx) => ({ status: 200, body: "Hello World" })'
 ```
 
-### Create Lambda
+### Spec-Based Deployment (YAML & JSON)
+
+For reproducible deployments, you can use `spec.yaml` (recommended) or `spec.json`.
+
+**Recommended: `spec.yaml`**
+
+```yaml
+name: eye-processor
+route: eye-processor
+file: ./src/main.ts
+script: build.sh
+package: package.json
+params: []
+config: ''
+secrets: ['gemini-credentials']
+env: nodejs
+network: ['public']
+method: ['POST', 'OPTIONS']
+uploadAsZip: true
+scaleOptions:
+  minCpu: 30
+  maxCpu: 500
+  minMemory: 32
+  maxMemory: 192
+  minScale: 1
+  maxScale: 3
+  targetCpu: 80
+  executorType: newdeploy
+  idleTimeout: 120
+  concurrency: 1
+  functionTimeout: 60
+  specializationTimeout: 120
+```
+
+Deploy using:
 
 ```bash
-gcli lambda:create --name pesho --route pesho --code 'module.exports = async (context) => ({ status: 200, body: "Hello, world!", headers: { "Access-Control-Allow-Origin": "https://graphql-server.com"}})'
+gcli lambda:create --spec spec.yaml
+```
+
+### Unified Configuration (`lambforge.yaml`)
+
+The modern way to manage platform capabilities is via `lambforge.yaml`. This file allows you to define the function, environment, and bundler options in a single place.
+
+```yaml
+function:
+  name: eye-processor
+  route: eye-processor
+  file: ./src/main.ts
+  script: build.sh
+  package: package.json
+  params: []
+  config: ''
+  secrets: ['gemini-credentials']
+  env: nodejs
+  network: ['public']
+  method: ['POST', 'OPTIONS']
+  uploadAsZip: true
+  scaleOptions:
+    minCpu: 30
+    maxCpu: 500
+    minMemory: 32
+    maxMemory: 192
+    minScale: 1
+    maxScale: 3
+    targetCpu: 80
+    executorType: newdeploy
+    idleTimeout: 120
+    concurrency: 1
+    functionTimeout: 60
+    specializationTimeout: 120
+
+environment:
+  name: nodejs
+  image: rxdi/fission-node:0.0.14
+  builder: rxdi/fission-node-builder:1.0.5
+  poolSize: 0
+  minCpu: 0
+  maxCpu: 0
+  minMemory: 0
+  maxMemory: 0
+  region: EU_BALKANS
+
+options:
+  bundler:
+    watch: ['src']
 ```
 
-##### Or from files
+### Configuration Auto-Discovery (Zero-Argument Commands)
+
+`gcli` is designed to be context-aware. If a configuration file (`lambforge.yaml`, `spec.yaml`, or `env.yaml`) is present in your current directory, you can run commands without arguments.
+
+The CLI will automatically read the configuration and apply it to the current project context.
 
 ```bash
-gcli lambda:create --name pesho --route pesho --file ./index.ts --script ./bash.sh --package ./package.json
+# If lambforge.yaml or spec.yaml exists:
+gcli lambda:create
+gcli lambda:update
+
+# If lambforge.yaml or env.yaml exists:
+gcli environment:create
+gcli environment:update
 ```
 
-#### Or from `spec`
+### Function Lifecycle
+
+- **Update**: `gcli lambda:update --name 'my-function' --file ./new-index.ts`
+- **Delete**: `gcli lambda:delete --name 'my-function'`
+- **Get Details**: `gcli lambda:get --name 'my-function'`
+
+### Monitoring & Testing
+
+Debug your functions directly from the terminal.
 
 ```bash
-gcli lambda:create --spec spec.json
+# Stream execution logs
+gcli lambda:log --name 'my-function'
+
+# View build logs
+gcli lambda:build:log --name 'my-function'
+
+# Invoke the function (Test)
+gcli lambda:test --name 'my-function' --queryParams '?id=123' --body '{"action": "process"}'
 ```
 
-#### If `spec` already present
+## AI Integration (Model Context Protocol)
+
+`gcli` implements the **Model Context Protocol (MCP)**, allowing AI coding assistants (like Claude or IDE extensions) to interact with your platform's context.
+
+### Starting the MCP Server
 
 ```bash
-gcli lambda:create
+gcli mcp:start --url "http://localhost:8000/mcp"
 ```
 
-example spec.json
+### Configuration for AI Tools
+
+To use this with Claude Desktop or other MCP-compatible tools, add the following to your configuration file:
+
+**For Node.js Users:**
 
 ```json
 {
-  "name": "pesho",
-  "route": "pesho",
-  "file": "index.ts",
-  "script": "bash.sh",
-  "package": "package.json",
-  "params": ["test", "proba"],
-  "config": "",
-  "secret": "",
-  "env": "nodejs",
-  "method": ["GET"]
+  "mcpServers": {
+    "lambforge": {
+      "command": "gcli",
+      "args": ["mcp:start", "--url", "http://localhost:8000/mcp"]
+    }
+  }
 }
 ```
 
-#### Updating Lambda
+**For Specific Node Versions:**
 
-```bash
-gcli lambda:update
+```json
+{
+  "mcpServers": {
+    "lambforge": {
+      "command": "/path/to/node",
+      "args": [
+        "/path/to/gcli",
+        "mcp:start",
+        "--url",
+        "http://localhost:8000/mcp"
+      ]
+    }
+  }
+}
 ```
 
-#### Delete Lambda
+**For logged in users with selected current project**
 
-```bash
-gcli lambda:delete
+```json
+{
+  "mcpServers": {
+    "lambforge": {
+      "command": "gcli",
+      "args": ["mcp:start"]
+    }
+  }
+}
 ```
 
-#### Get Lambda
+## Build System & Local Development
+
+`gcli` includes a high-performance bundler powered by **esbuild**.
 
 ```bash
-gcli lambda:get
+# Build a project
+gcli build --files src/index.ts --outfile dist/bundle.js --minify
+
+# Start in watch mode (defaults to watching the bundled file)
+gcli start --files src/index.ts
 ```
 
-#### Testing lambda
+### Advanced Watch Options
 
-```bash
-gcli lambda:test --queryParams '?test=1&proba=1&dada=5' --pathParams 'proba=5;test=7'
+By default, `gcli start` watches only the entry file passed to the bundle. To watch specific directories or configure advanced options, use the `lambforge.yaml` file:
+
+```yaml
+options:
+  bundler:
+    watch: ['src', 'lib']
 ```
 
-#### Default long lived token for CI/CD using github actions
+---
 
-Can be set using secret variable called `GCLI_AUTH_TOKEN`
+## Command Reference
 
-```
-npx gcli login --ci --token ${{ secrets.GCLI_AUTH_TOKEN }} --key '' --url '' --uploadUrl ''
+For a complete list of commands and options, use the built-in help:
+
+```bash
+gcli --help
+gcli lambda:create --help
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gapi/gcli",
-  "version": "1.8.197",
+  "version": "1.8.199",
   "repository": {
     "type": "git",
     "url": "https://github.com/Stradivario/gapi.git"