@gonzih/cc-tg 0.9.41 → 0.9.42

package/dist/router.d.ts

@@ -33,10 +33,19 @@ export declare function parseRoutingTag(text: string): RoutingTag | null;
  * Ensure a meta-agent for the given namespace is running.
  *
  * Steps:
- *   1. Check cca:meta-agent:status:{namespace} in Redis — return early if already running.
+ *   1. Check Redis for readiness via two keys (see below) — return early if already ready.
  *   2. Verify the GitHub repo exists; create it (public) if not.
  *   3. Call the start_meta_agent MCP tool via callTool.
- *   4. Poll the Redis status key every 1s until running or META_AGENT_TIMEOUT_MS expires.
+ *   4. Poll both Redis keys every 1s until ready or META_AGENT_TIMEOUT_MS expires.
+ *
+ * Two Redis keys are checked:
+ *   cca:meta-agent:status:{namespace} — live-status key written by writeLiveStatus()
+ *     (only populated after the first message is processed by messageMetaAgent)
+ *   cca:meta:{namespace} — state key written by startMetaAgent() directly via saveState()
+ *     (populated as soon as the workspace is created, with status:"idle")
+ *
+ * Bug context: start_meta_agent writes cca:meta:{namespace} but NOT cca:meta-agent:status:{namespace}.
+ * Polling only the status key caused a 10s timeout on every cold start.
  *
  * Throws on failure (repo creation error, tool call failure, or timeout).
  */

package/dist/router.js

@@ -51,18 +51,29 @@ export function parseRoutingTag(text) {
  * Ensure a meta-agent for the given namespace is running.
  *
  * Steps:
- *   1. Check cca:meta-agent:status:{namespace} in Redis — return early if already running.
+ *   1. Check Redis for readiness via two keys (see below) — return early if already ready.
  *   2. Verify the GitHub repo exists; create it (public) if not.
  *   3. Call the start_meta_agent MCP tool via callTool.
- *   4. Poll the Redis status key every 1s until running or META_AGENT_TIMEOUT_MS expires.
+ *   4. Poll both Redis keys every 1s until ready or META_AGENT_TIMEOUT_MS expires.
+ *
+ * Two Redis keys are checked:
+ *   cca:meta-agent:status:{namespace} — live-status key written by writeLiveStatus()
+ *     (only populated after the first message is processed by messageMetaAgent)
+ *   cca:meta:{namespace} — state key written by startMetaAgent() directly via saveState()
+ *     (populated as soon as the workspace is created, with status:"idle")
+ *
+ * Bug context: start_meta_agent writes cca:meta:{namespace} but NOT cca:meta-agent:status:{namespace}.
+ * Polling only the status key caused a 10s timeout on every cold start.
  *
  * Throws on failure (repo creation error, tool call failure, or timeout).
  */
 export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
     const timeoutMs = parseInt(process.env.META_AGENT_TIMEOUT_MS ?? "10000", 10);
     const statusKey = `cca:meta-agent:status:${namespace}`;
-    console.log(`[router] ensureMetaAgent namespace=${namespace} checking ${statusKey}`);
-    // Fast path: already running or idle (idle = ready to receive messages)
+    // State key written by startMetaAgent() directly — the source of truth for workspace existence.
+    const stateKey = `cca:meta:${namespace}`;
+    console.log(`[router] ensureMetaAgent namespace=${namespace}`);
+    // Fast path: check live-status key (written by messageMetaAgent after first message)
     const statusRaw = await redis.get(statusKey);
     if (statusRaw) {
         try {
@@ -73,7 +84,22 @@ export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
             }
         }
         catch {
-            // Corrupt status value — fall through and restart
+            // Corrupt status value — fall through
+        }
+    }
+    // Fast path: also check state key (written by startMetaAgent, persists 30 days).
+    // Presence of this key means the workspace was already created — no need to re-run start_meta_agent.
+    const stateRaw = await redis.get(stateKey);
+    if (stateRaw) {
+        try {
+            const state = JSON.parse(stateRaw);
+            if (state.status === "idle" || state.status === "running") {
+                console.log(`[router] meta-agent ${namespace} workspace exists (state.status=${state.status})`);
+                return;
+            }
+        }
+        catch {
+            // Corrupt state — fall through and re-initialize
         }
     }
     // Derive "org/repo" from the full URL for gh CLI calls
@@ -92,12 +118,26 @@ export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
             throw new Error(`Failed to create repo ${orgRepo}: ${createErr.message}`);
         }
     }
-    // Start the meta-agent via MCP
+    // Start the meta-agent via MCP (clones workspace if needed, writes cca:meta:{namespace})
     const result = await callTool("start_meta_agent", { namespace, repo_url: repoUrl });
     if (result === null) {
         throw new Error(`start_meta_agent returned null — tool may not be available in cc-agent`);
     }
-    // Poll until the meta-agent reports "running" or "idle" (both mean ready)
+    // Check for explicit failure payload (e.g. git clone error)
+    try {
+        const parsed = JSON.parse(result);
+        if (parsed.ok === false) {
+            throw new Error(`start_meta_agent failed: ${parsed.error ?? "unknown error"}`);
+        }
+    }
+    catch (jsonErr) {
+        if (!(jsonErr instanceof SyntaxError))
+            throw jsonErr;
+        // Non-JSON result (e.g. plain "ok") — not an error, continue to poll
+    }
+    // Poll until ready. Check both keys:
+    //   - statusKey: written by writeLiveStatus() during messageMetaAgent (may not exist yet on cold start)
+    //   - stateKey:  written by startMetaAgent() above — will appear within 1s of the tool call returning
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -105,7 +145,7 @@ export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
         if (raw) {
             try {
                 const s = JSON.parse(raw);
-                console.log(`[router] waiting for meta-agent ${namespace} — current status: ${s.status}`);
+                console.log(`[router] waiting for meta-agent ${namespace} — status key: ${s.status}`);
                 if (s.status === "running" || s.status === "idle")
                     return;
             }
@@ -113,8 +153,21 @@ export async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
                 // ignore parse errors, keep polling
             }
         }
+        // Also check state key — startMetaAgent writes this synchronously before responding
+        const state = await redis.get(stateKey);
+        if (state) {
+            try {
+                const s = JSON.parse(state);
+                console.log(`[router] waiting for meta-agent ${namespace} — state key: ${s.status}`);
+                if (s.status === "idle" || s.status === "running")
+                    return;
+            }
+            catch {
+                // ignore parse errors, keep polling
+            }
+        }
         else {
-            console.log(`[router] waiting for meta-agent ${namespace} — no status key yet`);
+            console.log(`[router] waiting for meta-agent ${namespace} — neither key present yet`);
         }
     }
     throw new Error(`Meta-agent for ${namespace} did not become ready within ${timeoutMs}ms`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-tg",
-  "version": "0.9.41",
+  "version": "0.9.42",
   "description": "Claude Code Telegram bot — chat with Claude Code via Telegram",
   "type": "module",
   "bin": {