openclacky 1.0.0 → 1.0.2

data/lib/clacky/default_skills/deploy/SKILL.md

@@ -1,105 +1,229 @@
 ---
 name: deploy
-description: Deploy Rails applications to Clacky cloud platform(Railway backend)
-agent: coding
+description: Deploy Rails applications to Railway. Handles first-time setup and re-deploys idempotently using Railway CLI. Trigger on: "deploy", "deploy to railway", "railway deploy", "发布", "部署", "上线".
+user-invocable: true
 ---
 
-# Railway Deployment for Rails
+# Deploy Rails App to Railway
 
-Deploy a Rails application to the Clacky cloud platform (Railway backend).
+Deploy the current Rails project to Railway using the Railway CLI. Works for both first-time deploys and re-deploys.
 
-## When to invoke
+## Prerequisites Check
 
-Trigger this skill when the user says:
-- "deploy", "/deploy", "deploy my app", "push to production"
-- "部署", "上线", "发布"
+Before starting, verify:
 
----
+```bash
+# 1. Railway CLI installed?
+railway --version
+
+# 2. Logged in?
+railway whoami
+```
+
+If not logged in, instruct the user:
+```
+Please run: railway login
+Then retry deployment.
+```
+
+## Step 0: Prepare for Linux Build
+
+Railway runs on Linux. Ensure Gemfile.lock includes the linux platform:
+
+```bash
+bundle lock --add-platform x86_64-linux
+```
+
+If the project uses a `Dockerfile` builder (check `railway.toml` for `builder = "DOCKERFILE"`), no `Procfile` is needed — skip creating one.
 
-## How to run
+Only create a `Procfile` if there is no Dockerfile:
+```
+web: bundle exec puma -C config/puma.rb
+```
 
-### Step 1 — Run the deploy script
+## Step 1: Check Link Status → Deploy Immediately if Already Linked
 
+**First: check if already linked:**
 ```bash
-bundle exec ruby <absolute-path-to-this-skill>/scripts/rails_deploy.rb
+railway status 2>&1
 ```
 
-**Timeout**: set to at least 300 seconds (5 minutes).
+**If output contains `Project:` → project is already linked.**
+Skip Steps 2–5 entirely and jump to Step 6 (Deploy).
 
-The script prints each step as it runs. When it finishes it prints one of:
+**If output contains "not linked" or an error → not linked yet.**
+Try linking to an existing project first — list available projects:
+```bash
+railway list 2>&1 | grep -i "<app-name>"
+```
 
+If a matching project is found, link it:
+```bash
+railway link --project <project-name> --service <service-name> 2>&1
 ```
-[DEPLOY] RESULT: SUCCESS (2m 34s)
-[DEPLOY] RESULT: FAILED (45s) — <error message>
+
+Only if no existing project is found, init a new one:
+```bash
+railway init -n <app-name>
 ```
+The `app-name` should match the current directory name (e.g., `my-rails-app`).
 
-### Step 2 — Show the full output to the user
+**⚠️ NEVER run `railway init` when already linked or when an existing project exists.**
+It silently creates a brand-new Railway project. If this happens by mistake:
+1. Find the correct project name from `railway list`
+2. Re-link: `railway link --project <project-name> --service <service-name>`
 
-After the script exits, **always show the complete stdout output** to the user
-in a code block or verbatim. The output contains step-by-step logs they need
-to see. Do NOT summarise silently — show everything, then add your summary.
+## Step 2: Set Environment Variables
 
-### On success
-After showing the output, report the deployed URL and any useful links.
+Set required Rails production variables. Use `--skip-deploys` to avoid triggering premature deploys:
 
-### On failure
-After showing the output, show the error message and summarise the most
-likely cause in one sentence. Suggest next steps (e.g. fix the error shown,
-then re-run `/deploy`).
+```bash
+# Generate a secret key base
+SECRET_KEY_BASE=$(bundle exec rails secret)
 
----
+railway variable set SECRET_KEY_BASE=$SECRET_KEY_BASE --skip-deploys
+railway variable set RAILS_ENV=production --skip-deploys
+railway variable set RAILS_LOG_TO_STDOUT=true --skip-deploys
+railway variable set RAILS_SERVE_STATIC_FILES=true --skip-deploys
+```
+
+If the project uses any other env vars (check `.env.example` or `config/application.yml.example` if they exist), prompt the user to provide values and set them too.
+
+If the project uses `config/application.yml` (Figaro gem), read it and set all values as Railway variables:
+```bash
+# Read application.yml and set each key=value pair
+ruby -ryaml -e "
+  data = YAML.safe_load(File.read('config/application.yml')) || {}
+  data.each { |k, v| puts %(railway variable set #{k}=#{v} --skip-deploys) unless v.to_s.empty? }
+" | bash
+```
+
+## Step 3: Ensure PostgreSQL Service (Idempotent)
+
+Check if Postgres already exists:
+
+```bash
+railway status --json
+```
+
+Parse the JSON output. If a service with type `postgres` or name containing `postgres`/`Postgres` is already found, skip with: `✅ PostgreSQL already provisioned`
+
+**⚠️ IMPORTANT: `railway add --database postgres` has a known CLI bug that always returns `Unauthorized`.**
+Do NOT attempt to run this command. Instead, instruct the user to add PostgreSQL manually via the Railway Web UI:
+
+1. Open your Railway project: `https://railway.com/project/<project-id>`
+   (Get the project ID from the Railway dashboard or `cat .railway/config.json`)
+2. Click **"+ New"** → **"Database"** → **"PostgreSQL"**
+3. Wait for the database to provision
+4. Come back and continue
+
+After Postgres is provisioned, set the DATABASE_URL variable:
+```bash
+railway variable set DATABASE_URL='${{Postgres.DATABASE_URL}}' --skip-deploys
+```
+
+## Step 4: Get Domain (Idempotent)
+
+Check if a domain is already set:
+
+```bash
+railway domain --json
+```
 
-## What the script does internally
-
-The script runs three phases automatically. Do **not** add any AI reasoning
-steps between phases — the script handles all logic internally.
-
-**Phase 0 — Cloud project binding**
-1. Reads `.clacky/openclacky.yml` for `project_id`
-   - If file is missing → runs inline cloud project creation flow
-     (reuses `new/scripts/cloud_project_init.sh`), writes the file, continues
-   - If `project_id` is blank → hard-fail (corrupted file)
-2. Reads `~/.clacky/clacky_cloud.yml` for `workspace_key`
-   - If missing/empty → hard-fail with guidance to obtain key offline
-3. Calls `GET /openclacky/v1/projects/:id` to verify the project exists
-   - 404 → runs inline cloud project creation flow, continues
-   - Other error → hard-fail
-
-**Phase 1 — Subscription check**
-
-| `subscription.status` | Action |
-|------------------------|--------|
-| `PAID` | ✅ Continue |
-| `FREEZE` | ⚠️ Warn, continue |
-| `SUSPENDED` | ❌ Hard-fail |
-| `null` / `OFF` / `CANCELLED` | Open payment page, poll for activation |
-
-Payment polling: open `https://app.clacky.ai/dashboard/openclacky-project/<id>`
-in browser, poll `GET /openclacky/v1/deploy/payment` every 10 s for up to 180 s.
-
-**Phase 2 — Deployment (8 steps)**
-
-| Step | Action |
-|------|--------|
-| 1 | `POST /deploy/create-task` → get `platform_token`, `platform_project_id`, `deploy_task_id` |
-| 2 | `railway link --project <id> --environment production` |
-| 3 | Inject env vars: Rails defaults + Figaro `config/application.yml` production block + `categorized_config` |
-| 4 | Poll `GET /deploy/services` until DB middleware is `SUCCESS` → inject `DATABASE_URL` reference; call `POST /deploy/bind-domain` |
-| 5 | `railway up --service <name> --detach` → notify backend `"deploying"` |
-| 6 | Poll `GET /deploy/status` every 5 s (max 300 s) until `SUCCESS` or failure |
-| 7 | `railway run bundle exec rails db:migrate`; seed if first deployment |
-| 8 | HTTP health check on deployed URL; notify backend `"success"` |
-
-All `railway` commands receive `RAILWAY_TOKEN` via Ruby `ENV` hash — no
-`clackycli` wrapper is needed.
+If no domain exists yet:
+```bash
+railway domain
+```
+
+Capture and display the domain URL to the user. Also set it as PUBLIC_HOST:
+```bash
+railway variable set PUBLIC_HOST=<domain-without-https> --skip-deploys
+```
+
+## Step 5: Configure Storage Bucket (if needed)
+
+Check if the project uses S3-compatible storage by reading `config/storage.yml`. If it contains an `amazon` or `s3` service section, storage bucket configuration is required.
+
+**⚠️ Storage bucket requires Railway Hobby plan ($5/month minimum). Confirm with the user before proceeding.**
+
+Check if bucket env vars are already set:
+```bash
+railway variables --json | grep STORAGE_BUCKET
+```
+
+If not set, create a bucket and configure the variables:
+
+```bash
+# Create bucket (choose region: iad=US East, sjc=US West, ams=EU, sin=Asia)
+railway bucket create <app-name>-storage --region iad --json
+
+# Get credentials
+railway bucket credentials --bucket <app-name>-storage --json
+```
+
+The credentials JSON will contain: `accessKeyId`, `secretAccessKey`, `region`, `endpoint`, `bucketName`.
+
+Set them as environment variables:
+```bash
+railway variables set \
+  STORAGE_BUCKET_ACCESS_KEY_ID=<accessKeyId> \
+  STORAGE_BUCKET_SECRET_ACCESS_KEY=<secretAccessKey> \
+  STORAGE_BUCKET_REGION=<region> \
+  STORAGE_BUCKET_NAME=<bucketName> \
+  STORAGE_BUCKET_ENDPOINT=<endpoint> \
+  --skip-deploys
+```
+
+**⚠️ Missing these variables will cause a hard crash at boot (`Aws::Errors::MissingRegionError`) because the AWS SDK initializes at startup, not lazily.**
+
+If the project does not use S3 storage, skip this step entirely.
+
+## Step 6: Deploy
+
+Upload and deploy the project:
+
+```bash
+railway up --detach
+```
+
+Show the user the deployment is in progress and they can monitor it with:
+```bash
+railway logs
+```
+
+**No manual migration needed.** The `bin/docker-entrypoint` script runs `rails db:prepare` automatically on container startup. Just wait for the deployment to complete.
+
+## Step 7: Verify Deployment
+
+After deployment completes (wait ~30 seconds), verify the app is running:
+
+```bash
+# Should return 200
+curl -s -o /dev/null -w "%{http_code}" https://<domain>/
+```
+
+If it returns `200`, deployment is successful. If not, check logs:
+```bash
+railway logs --tail 50
+```
+
+## Step 8: Done
+
+Print a summary:
+```
+✅ Deployment complete!
+🌐 Platform URL: https://<domain>
+📋 Monitor: railway logs
+🔄 Re-deploy: just run deploy again
+```
 
 ---
 
-## Important constraints
+## Notes
 
-- **Never** modify source files before deploying.
-- **Never** commit or push changes as part of this skill.
-- **Never** prompt the user for Railway credentials — those come from the
-  Clacky platform (`platform_token` is returned by `create-task`).
-- If `railway` CLI is not installed, hard-fail with install instructions:
-  `npm install -g @railway/cli`
+- **Idempotency**: Running this skill multiple times is safe. Each step checks current state before acting.
+- **Link detection**: Use `railway status` to check if already linked — it's more reliable than checking `.railway/config.json` (works across machines and fresh clones).
+- **Re-deploy**: On subsequent runs, Steps 1–5 are all skipped or no-ops. Only Step 6 (upload) actually runs.
+- **Secret key**: Only set `SECRET_KEY_BASE` if not already set (check with `railway variable list`).
+- **Database migrations**: Handled automatically by `bin/docker-entrypoint` via `rails db:prepare` — never run `railway run bundle exec rails db:migrate` as Railway's internal DB IP is not accessible from local machine.
+- **PostgreSQL CLI bug**: `railway add --database postgres` always fails with `Unauthorized` — always use the Web UI instead.

data/lib/clacky/default_skills/new/SKILL.md

@@ -75,114 +75,7 @@ The script will automatically:
 - Script completes successfully
 - Project is ready to run
 
-### 3. Cloud Project Init
-After the setup script completes, initialize the cloud project binding.
-
-**Goal**: Create a cloud project on the Clacky platform, then inject the returned
-`categorized_config` (auth/email/llm/stripe credentials) into the local development
-environment so the app can use platform services out of the box.
-
-#### 3.1 Check existing binding
-Check if `.clacky/openclacky.yml` already exists:
-```bash
-ls .clacky/openclacky.yml 2>/dev/null && cat .clacky/openclacky.yml || echo "NOT_FOUND"
-```
-
-If it exists, ask the user:
-```
-A cloud project binding already exists:
-  Project: <project_name> (<project_id>)
-
-Do you want to reuse this binding? (y/n)
-```
-- **Yes** → skip to step 3.5 (files already written, no need to re-create)
-- **No** → continue to 3.2
-
-#### 3.2 Run the cloud project init script
-Use the `cloud_project_init.sh` script from Supporting Files.
-Run it with `terminal` from the project directory (no arguments needed — it auto-reads `~/.clacky/clacky_cloud.yml`):
-
-```bash
-bash <absolute_path_to_cloud_project_init.sh>
-```
-
-The script outputs a single JSON line. Capture the full output.
-
-**If the output contains `"success":false`** → soft-fail:
-```
-⚠️  Cloud project creation failed: <error value from JSON>
-    Skipping cloud init. You can link a project later with /deploy.
-```
-Then skip to Step 4.
-
-**If the output contains `"success":true`** → parse the JSON and extract:
-- `project_id` — the cloud project UUID
-- `project_name` — the project name
-- `categorized_config` — nested object with auth/email/llm/stripe keys
-
-The `categorized_config` looks like:
-```json
-{
-  "auth":   { "CLACKY_AUTH_CLIENT_ID": "...", "CLACKY_AUTH_CLIENT_SECRET": "...", "CLACKY_AUTH_HOST": "..." },
-  "email":  { "CLACKY_EMAIL_API_KEY": "...", "CLACKY_EMAIL_SMTP_ADDRESS": "...", "CLACKY_EMAIL_SMTP_DOMAIN": "...", "CLACKY_EMAIL_SMTP_PORT": 25, "CLACKY_EMAIL_SMTP_USERNAME": "..." },
-  "llm":    { "CLACKY_LLM_API_KEY": "...", "CLACKY_LLM_BASE_URL": "..." },
-  "stripe": { "CLACKY_STRIPE_PUBLISHABLE_KEY": "...", "CLACKY_STRIPE_SECRET_KEY": "...", "CLACKY_STRIPE_WEBHOOK_SECRET": "..." }
-}
-```
-
-#### 3.3 Write `.clacky/openclacky.yml`
-Create the directory and write the binding file (no sensitive data — safe to commit):
-```bash
-mkdir -p .clacky
-```
-Then use the `write` tool to create `.clacky/openclacky.yml`:
-```yaml
-# .clacky/openclacky.yml
-# Committed to git. No sensitive data. Shared across team.
-project_id: "<project_id from JSON>"
-project_name: "<project_name from JSON>"
-```
-
-#### 3.4 Update `config/application.yml`
-Read the current `config/application.yml` first, then **prepend** a clearly-marked block at the very top of the file.
-Use the `write` tool to rewrite the file with the cloud config block inserted before the existing content:
-```yaml
-# --- Auto-generated by clacky /new (Cloud project: <project_name>) ---
-CLACKY_AUTH_CLIENT_ID: "<value>"
-CLACKY_AUTH_CLIENT_SECRET: "<value>"
-CLACKY_AUTH_HOST: "<value>"
-CLACKY_EMAIL_API_KEY: "<value>"
-CLACKY_EMAIL_SMTP_ADDRESS: "<value>"
-CLACKY_EMAIL_SMTP_DOMAIN: "<value>"
-CLACKY_EMAIL_SMTP_PORT: "<value>"
-CLACKY_EMAIL_SMTP_USERNAME: "<value>"
-CLACKY_LLM_API_KEY: "<value>"
-CLACKY_LLM_BASE_URL: "<value>"
-CLACKY_STRIPE_PUBLISHABLE_KEY: "<value>"
-CLACKY_STRIPE_SECRET_KEY: "<value>"
-CLACKY_STRIPE_WEBHOOK_SECRET: "<value>"
-
-# --- (original content below) ---
-<original file content>
-```
-Only include keys present in the JSON response.
-
-#### 3.5 Git commit
-Commit the cloud project binding file.
-Note: `config/application.yml` is gitignored (it contains secrets) — do NOT try to add it.
-```bash
-git add .clacky/openclacky.yml
-git commit -m "Initialize cloud project binding"
-```
-
-Print a success summary:
-```
-✅ Cloud project initialized!
-   Project: <project_name> (<project_id>)
-   Config written to: config/application.yml
-```
-
-### 4. Start Development Server
+### 3. Start Development Server
 After the script completes, read the `.1024` config file in the project root
 to find the `run_command`, then start it in the background via the terminal tool:
 
@@ -216,8 +109,6 @@ What would you like to develop next?
 - Node.js < 22 → Script installs automatically (macOS/Ubuntu)
 - PostgreSQL missing → Script installs automatically (macOS/Ubuntu)
 - bin/setup fails → Show error, suggest running `./bin/setup` manually
-- Cloud project creation fails → Soft-fail with warning, continue to start server
-- workspace_key missing → Ask user interactively; skip cloud init if user declines
 - Dev server fails to start → Poll the terminal session (empty input) to check logs, verify database status
 
 ## Example Interaction
@@ -230,7 +121,5 @@ Response:
 4. Checking environment dependencies...
 5. Installing project dependencies...
 6. Project setup complete!
-7. Initializing cloud project binding...
-8. ✅ Cloud project created and config injected into config/application.yml!
-9. Starting development server via terminal (background)...
-10. ✨ Server running! Visit http://localhost:3000
+7. Starting development server via terminal (background)...
+8. ✨ Server running! Visit http://localhost:3000