@rashidee/co2 1.3.3 → 1.3.4

package/dist/.co2-dat/config.json

@@ -0,0 +1,4 @@
+{
+  "port": 3001,
+  "workspacePath": "C:\\Users\\vedee\\workspace"
+}

package/dist/index.js

@@ -6809,7 +6809,7 @@ var {
 // package.json
 var package_default = {
   name: "@rashidee/co2",
-  version: "1.3.3",
+  version: "1.3.4",
   description: "Compound Context Studio \u2014 self-hosted team context authoring for CO2 projects",
   type: "module",
   license: "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rashidee/co2",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "Compound Context Studio — self-hosted team context authoring for CO2 projects",
   "type": "module",
   "license": "MIT",

package/plugin/skills/util-gencicdscript/SKILL.md

@@ -17,7 +17,9 @@ description: >
   has never completed a conductor-develop workflow run (checked against the studio's
   /api/cicd-guard endpoint using the spawn-env token). Health/port probing marks apps already
   running — even ones started outside this app. No version selector: only the latest built
-  applications are operated. Writes cicd/CICD_GENERATION.md with `**Status**:` IN PROGRESS →
+  applications are operated. When the approved plan declares an `## Infrastructure` list, the
+  main page shows an "Infrastructure" link that opens a separate status-only page listing every
+  supporting 3rd-party service with a live TCP-reachability indicator and a console link. Writes cicd/CICD_GENERATION.md with `**Status**:` IN PROGRESS →
   COMPLETED so the studio watcher detects completion. Idempotent — re-running regenerates
   cicd/app in place. Trigger on keywords: "generate cicd", "gen cicd script", "generate ci/cd
   app", "cicd app", "generate deployment app". Accepts one MANDATORY argument: the
@@ -56,9 +58,12 @@ Read `references/cicd-app-template.md` for the complete file templates. Produce:
 
 1. `cicd/app/cicd.config.json` — from the plan's tables:
    `{ "port": <CI/CD app port>, "apps": [{ "name", "folder", "method", "port", "build",
-   "start", "stop", "deployMethod", "deploy", "health" }] }` — `deployMethod` is the plan's
-   Deploy Method column (`none|web-server|docker|kubernetes`) and `deploy` its command
-   (`null` when the method is `none`).
+   "start", "stop", "deployMethod", "deploy", "health" }], "infra": [{ "id", "name", "host",
+   "port", "url", "description" }] }` — `deployMethod` is the plan's Deploy Method column
+   (`none|web-server|docker|kubernetes`) and `deploy` its command (`null` when the method is
+   `none`). The `infra` array comes from the plan's `## Infrastructure` table (one entry per
+   row); `url` is `null` when the Console URL cell is `-`. Emit `"infra": []` when the plan's
+   Infrastructure table is empty — never invent services the plan does not list.
 2. `cicd/app/server.js` — the template verbatim (it is generic; all project specifics live in
    cicd.config.json). Zero npm dependencies.
 3. Ensure `cicd/logs/` and `cicd/state.json` are ignored: append `cicd/logs/` and
@@ -75,6 +80,11 @@ port, application count) and STOP — the studio starts/embeds the app.
   template); no install step may be required.
 - The page is bare: no header, sidebar or footer (it is iframed by the studio). Light theme,
   one nav tab per application; the tab body is that application's live log.
+- Infrastructure page: when `infra` is non-empty the main page shows an "Infrastructure" link
+  that opens the separate `/infra` page in a new tab — a status-only list of supporting
+  3rd-party services, each with a live TCP-reachability dot (polled) and a console link when a
+  `url` is set. Infrastructure is never built/started/stopped/deployed (no lifecycle controls,
+  no develop gate); the link is hidden when `infra` is empty.
 - Build/Start/Stop/Deploy run the plan's commands verbatim, each with the APPLICATION FOLDER
   (`<project>/<folder>`) as working directory — command paths are relative to the application
   folder (e.g. `java -jar target\app.jar`), never to the project root. Deploy renders only

package/plugin/skills/util-gencicdscript/references/cicd-app-template.md

@@ -11,6 +11,7 @@
 // server retains nothing per subscriber beyond the socket itself (bounded initial tail,
 // slow clients are dropped on backpressure), and the client trims its DOM log buffer.
 const http = require('node:http')
+const net = require('node:net')
 const { spawn, execFileSync } = require('node:child_process')
 const { createHash } = require('node:crypto')
 const { readFileSync, writeFileSync, mkdirSync, existsSync, statSync, openSync, readSync, closeSync, createWriteStream } = require('node:fs')
@@ -141,6 +142,21 @@ async function probe(app) {
   } catch { return false }
 }
 
+// Infrastructure reachability — a raw TCP connect, so it works for non-HTTP services
+// (PostgreSQL, Redis) as well as web consoles. Status-only: infra is never controlled here.
+function tcpProbe(host, port, timeout = 1000) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket()
+    let done = false
+    const finish = (ok) => { if (done) return; done = true; try { socket.destroy() } catch {} ; resolve(ok) }
+    socket.setTimeout(timeout)
+    socket.once('connect', () => finish(true))
+    socket.once('timeout', () => finish(false))
+    socket.once('error', () => finish(false))
+    try { socket.connect(Number(port), host || '127.0.0.1') } catch { finish(false) }
+  })
+}
+
 function buildApp(app) {
   if (activity.has(app.name)) return
   activity.set(app.name, 'building'); lastError.delete(app.name)
@@ -233,7 +249,7 @@ button:disabled{opacity:.4;cursor:default}
 .err{padding:4px 12px;font-size:11px;color:#c23b3b;display:none;white-space:pre-wrap}
 #log{flex:1;margin:0;padding:10px 12px;background:#0f1216;color:#d7dde4;font-size:11px;line-height:1.5;overflow:auto;white-space:pre-wrap}
 </style></head><body>
-<div class="top"><strong>CI/CD</strong><span id="branch" class="meta"></span></div>
+<div class="top"><strong>CI/CD</strong><span id="branch" class="meta"></span><span style="flex:1"></span><a id="infralink" class="url" href="/infra" target="_blank" rel="noreferrer" style="display:none">Infrastructure ↗</a></div>
 <div class="tabs" id="tabs"></div>
 <div class="bar" id="bar"></div>
 <div class="notice" id="notice"></div>
@@ -312,6 +328,7 @@ async function refresh(){
   if (!s) return
   state = s
   document.getElementById('branch').textContent = s.currentBranch ? 'branch: '+s.currentBranch : ''
+  document.getElementById('infralink').style.display = s.hasInfra ? 'inline' : 'none'
   if (!active && s.apps.length) setActive(s.apps[0].name)
   renderTabs(); renderBar()
 }
@@ -322,12 +339,61 @@ async function act(op){
 refresh(); setInterval(refresh, 3000)
 </script></body></html>`
 
+// ---- Infrastructure page ---------------------------------------------------------------
+// Standalone status-only page (opened in a new tab from the main page's Infrastructure link).
+// Lists every supporting 3rd-party service with a live TCP-reachability dot and a console link
+// when the service exposes a web UI. No lifecycle controls — infra is externally managed.
+const INFRA_PAGE = `<!doctype html><html><head><meta charset="utf-8"><title>Infrastructure</title><style>
+body{font-family:system-ui,sans-serif;margin:0;background:#f6f7f9;color:#1c2128;padding:16px}
+h1{font-size:16px;margin:0 0 12px}
+table{border-collapse:collapse;width:100%;max-width:820px;font-size:13px}
+th,td{text-align:left;padding:8px 10px;border-bottom:1px solid #e1e5ea}
+th{font-size:11px;text-transform:uppercase;color:#5b6572}
+.dot{display:inline-block;width:9px;height:9px;border-radius:99px;background:#8a94a0;margin-right:6px;vertical-align:middle}
+.dot.up{background:#1c8a4a}.dot.down{background:#c23b3b}
+.url{color:#1a66d0;text-decoration:underline}
+.muted{color:#5b6572;font-size:12px}
+.legend{margin-top:12px;font-size:11px;color:#5b6572}
+</style></head><body>
+<h1>Infrastructure</h1>
+<table><thead><tr><th>Status</th><th>Service</th><th>Endpoint</th><th>Console</th></tr></thead>
+<tbody id="rows"><tr><td colspan="4" class="muted">Loading…</td></tr></tbody></table>
+<div class="legend">● up ○ down — TCP reachability, polled every 3s</div>
+<script>
+function esc(s){ return String(s==null?'':s).replace(/[&<>"]/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c])) }
+async function refresh(){
+  const s = await fetch('/api/infra').then(r=>r.json()).catch(()=>null)
+  if(!s) return
+  const rows = (s.infra||[]).map(i => \`
+    <tr>
+      <td><span class="dot \${i.up?'up':'down'}"></span>\${i.up?'up':'down'}</td>
+      <td>\${esc(i.name)}\${i.description?' <span class="muted">— '+esc(i.description)+'</span>':''}</td>
+      <td class="muted">\${esc(i.host)}:\${esc(i.port)}</td>
+      <td>\${i.url?'<a class="url" href="'+esc(i.url)+'" target="_blank" rel="noreferrer">open ↗</a>':'—'}</td>
+    </tr>\`).join('')
+  document.getElementById('rows').innerHTML = rows || '<tr><td colspan="4" class="muted">No infrastructure declared.</td></tr>'
+}
+refresh(); setInterval(refresh, 3000)
+</script></body></html>`
+
 // ---- HTTP ------------------------------------------------------------------------------
 const server = http.createServer(async (req, res) => {
   if (req.method === 'GET' && req.url === '/') {
     res.writeHead(200, { 'content-type': 'text/html' })
     return res.end(PAGE)
   }
+  if (req.method === 'GET' && req.url === '/infra') {
+    res.writeHead(200, { 'content-type': 'text/html' })
+    return res.end(INFRA_PAGE)
+  }
+  if (req.method === 'GET' && req.url === '/api/infra') {
+    const infra = await Promise.all((CONFIG.infra || []).map(async (i) => ({
+      id: i.id, name: i.name, host: i.host || '127.0.0.1', port: i.port,
+      url: i.url || null, description: i.description || '',
+      up: await tcpProbe(i.host || '127.0.0.1', i.port),
+    })))
+    return json(res, 200, { infra })
+  }
   if (req.method === 'GET' && req.url === '/api/state') {
     const apps = await Promise.all(CONFIG.apps.map(async (a) => {
       const healthy = await probe(a)
@@ -340,7 +406,7 @@ const server = http.createServer(async (req, res) => {
         error: lastError.get(a.name) || null,
       }
     }))
-    return json(res, 200, { currentBranch: currentBranch(), apps })
+    return json(res, 200, { currentBranch: currentBranch(), hasInfra: (CONFIG.infra || []).length > 0, apps })
   }
   const m = req.url && req.url.match(/^\/api\/apps\/([^/]+)\/(build|start|stop|deploy)$/)
   if (m && req.method === 'POST') {
@@ -389,9 +455,11 @@ server.on('upgrade', (req, socket) => {
 server.listen(PORT, () => console.log(`cicd app on :${PORT}`))
 ```
 
-`cicd/app/cicd.config.json` shape — one entry per application from the plan's Deployment
-Decisions table. `deployMethod`/`deploy` come from the plan's Deploy columns (`deploy` is
-`null` when the method is `none`):
+`cicd/app/cicd.config.json` shape — one `apps` entry per application from the plan's Deployment
+Decisions table, one `infra` entry per row of the plan's `## Infrastructure` table.
+`deployMethod`/`deploy` come from the plan's Deploy columns (`deploy` is `null` when the method
+is `none`). `infra[].url` is `null` for a headless service (Console URL cell `-`); emit
+`"infra": []` when the plan declares no supporting services:
 
 ```json
 {
@@ -409,6 +477,24 @@ Decisions table. `deployMethod`/`deploy` come from the plan's Deploy columns (`d
       "deploy": "kubectl apply -f my-app/k8s/",
       "health": "http://127.0.0.1:3000/"
     }
+  ],
+  "infra": [
+    {
+      "id": "postgres-main",
+      "name": "PostgreSQL (app db)",
+      "host": "127.0.0.1",
+      "port": 5432,
+      "url": null,
+      "description": "Shared application database"
+    },
+    {
+      "id": "keycloak",
+      "name": "Keycloak",
+      "host": "127.0.0.1",
+      "port": 8180,
+      "url": "http://127.0.0.1:8180",
+      "description": "Single sign-on"
+    }
   ]
 }
 ```

package/plugin/skills/util-plancicd/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: util-plancicd
-model: claude-sonnet-5
+model: claude-opus-4-8
 effort: high
 description: >
   Infer a local-deployment plan for every custom application of a CO2 project and write it to
@@ -10,7 +10,11 @@ description: >
   method (container vs bare process), build command (e.g. Spring Boot jar vs Docker image),
   start command, stop mechanism, deploy method + command (none / web-server copy / docker run /
   kubectl apply — only when the environment calls for one), port and health-check URL, plus a
-  port for the generated CI/CD app itself. The plan carries a top-level
+  port for the generated CI/CD app itself. It also enumerates the project's supporting
+  infrastructure (3rd-party services from CLAUDE.md's `# Supporting 3rd Party Applications` and
+  ENVIRONMENT.md — host, port and optional console URL) into an `## Infrastructure` section so
+  the generated CI/CD app can surface a status-only Infrastructure page. The plan carries a
+  top-level
   `**Status**: IN PROGRESS` header flipped to `COMPLETED` when done — the studio's watcher reads
   it. This skill NEVER generates the CI/CD app (that is util-gencicdscript, which runs only
   after the studio stamps an **Approved**: line into the plan). Trigger on keywords: "plan
@@ -43,6 +47,7 @@ If the argument is missing or the file does not exist, STOP and tell the user to
 | Dev tools | `DEVTOOL.md` (project root) |
 | Project context | `CLAUDE.md` (project root; `source/CLAUDE.md` fallback) |
 | App specification | `<app_folder>/context/specification/SPECIFICATION.md` |
+| Infrastructure | `CLAUDE.md` `# Supporting 3rd Party Applications` + `ENVIRONMENT.md` |
 | Output plan | `cicd/CICD_PLAN.md` |
 
 ## Phase 1 — Gather
@@ -50,11 +55,18 @@ If the argument is missing or the file does not exist, STOP and tell the user to
 1. Read the plan-request markdown; its `## Applications` list is the authoritative application set.
 2. Read `ENVIRONMENT.md` (registries, credentials, external services) and `DEVTOOL.md`
    (installed tools + paths: node/pnpm/docker/kubectl/python versions).
-3. Read `CLAUDE.md`: `# Custom Applications` (folder names, Depends on) and `# Port Allocation`
-   (per-application ports).
+3. Read `CLAUDE.md`: `# Custom Applications` (folder names, Depends on), `# Port Allocation`
+   (per-application ports), and `# Supporting 3rd Party Applications` (the infrastructure the
+   applications depend on — databases, caches, object storage, SSO, mail, message brokers, etc.).
 4. For each application, read its SPECIFICATION.md tech-stack section if present; otherwise
    infer the stack from build files (`package.json` → node, `pom.xml` → spring-boot,
    `composer.json` → laravel).
+5. Build the **infrastructure list**: one entry per supporting 3rd-party service the project
+   declares. For each, resolve `host` (default `127.0.0.1`), `port` and — when it exposes a web
+   console/UI — a `url`, cross-referencing ENVIRONMENT.md for the actual host/port/endpoint. A
+   service with no host:port to probe (or a purely external SaaS with no local endpoint) is
+   omitted. If the project declares no supporting 3rd-party services, the infrastructure list is
+   empty and the plan's `## Infrastructure` section is written empty.
 
 ## Phase 2 — Decide (per application)
 
@@ -87,6 +99,21 @@ If the argument is missing or the file does not exist, STOP and tell the user to
 - **Health**: `http://127.0.0.1:<port>/` or a documented health endpoint from the spec.
 - **CI/CD app port**: 4100 unless taken in `# Port Allocation`; record it in the plan.
 
+### Infrastructure (status-only)
+
+Supporting 3rd-party services are **not** built/started/deployed by the CI/CD app — they are
+surfaced status-only. For each service resolved in Gather step 5, decide:
+
+- **id**: a stable kebab-case key unique within the plan (e.g. `postgres-main`, `keycloak`).
+- **name**: display name (e.g. `PostgreSQL (skf_main)`, `Keycloak`).
+- **host** / **port**: the address the CI/CD app TCP-probes for reachability; default host
+  `127.0.0.1`. Use the values ENVIRONMENT.md documents.
+- **url**: the web console/UI opened in a new tab, when the service has one (Keycloak admin,
+  MinIO console, Mailcatcher inbox); `-` for headless services (PostgreSQL, Redis).
+- **description**: a short blurb (e.g. `Shared app database`, `S3-compatible object storage`).
+
+Never emit credentials into the infrastructure entries — status and links only.
+
 ## Phase 3 — Write the plan
 
 Create `cicd/` if missing and write `cicd/CICD_PLAN.md`:
@@ -108,6 +135,15 @@ Create `cicd/` if missing and write `cicd/CICD_PLAN.md`:
 |---|---|---|---|---|---|---|---|---|---|
 | <name> | <folder> | process|container | <port> | `<cmd>` | `<cmd>` | process-kill|docker stop | none|web-server|docker|kubernetes | `<cmd or ->` | <url> |
 
+## Infrastructure
+
+Supporting 3rd-party services shown status-only (TCP reachability) on the CI/CD app's
+Infrastructure page. Leave the table body empty when the project declares no supporting services.
+
+| Id | Service | Host | Port | Console URL | Description |
+|---|---|---|---|---|---|
+| <id> | <name> | <host> | <port> | `<url or ->` | <blurb> |
+
 ## Rationale
 
 - <per-application: why this method/commands, citing ENVIRONMENT.md/DEVTOOL.md evidence>