seclaw 0.1.2 → 0.1.4

package/dist/cli.js

@@ -61,14 +61,12 @@ async function fetchTunnelUrlFromLogs(cwd) {
   try {
     const result = await execa(
       "docker",
-      ["compose", "logs", "cloudflared", "--no-log-prefix"],
-      { cwd, env: { ...process.env, COMPOSE_PROJECT_NAME: "seclaw" } }
+      ["compose", "logs", "cloudflared", "--no-log-prefix", "--tail", "50"],
+      { cwd }
     );
     const combined = result.stdout + "\n" + result.stderr;
-    const match = combined.match(
-      /https:\/\/[a-z0-9-]+\.trycloudflare\.com/
-    );
-    return match ? match[0] : null;
+    const matches = [...combined.matchAll(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/g)];
+    return matches.length > 0 ? matches[matches.length - 1][0] : null;
   } catch {
     return null;
   }
@@ -315,9 +313,9 @@ function openUrl(url) {
   });
 }
 function discoverInstalledTemplates(targetDir) {
-  const templates2 = [];
+  const templates = [];
   const templatesDir = join(targetDir, "templates");
-  if (!existsSync2(templatesDir)) return templates2;
+  if (!existsSync2(templatesDir)) return templates;
   try {
     const entries = readdirSync(templatesDir);
     for (const entry of entries) {
@@ -326,7 +324,7 @@ function discoverInstalledTemplates(targetDir) {
       if (!existsSync2(manifestPath)) continue;
       try {
         const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-        templates2.push({
+        templates.push({
           id: manifest.id || entry,
           name: manifest.name || entry,
           description: manifest.description || "",
@@ -337,7 +335,7 @@ function discoverInstalledTemplates(targetDir) {
     }
   } catch {
   }
-  return templates2;
+  return templates;
 }
 function readComposioLocalKey() {
   try {
@@ -1915,120 +1913,19 @@ function openBrowser(url) {
   });
 }
 
-// src/commands/templates.ts
+// src/commands/status.ts
 import { resolve as resolve8 } from "path";
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile5, readdir } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import * as p5 from "@clack/prompts";
-import pc5 from "picocolors";
-var TEMPLATES = [
-  { id: "productivity-agent", name: "Productivity Agent", price: 0, tier: "free", description: "Personal assistant \u2014 task management, daily reports, email drafting, file organization", hook: "npx seclaw add productivity-agent" },
-  { id: "data-analyst", name: "Data Analyst", price: 0, tier: "free", description: "Privacy-first local data analysis \u2014 drop CSV/JSON files, ask questions, get Python-powered insights", hook: "npx seclaw add data-analyst" },
-  { id: "inbox-agent", name: "Inbox Agent", price: 19, tier: "paid", description: "AI inbox manager that categorizes, summarizes, and triages your email", hook: "3 urgent, 5 action needed, 12 FYI, 8 newsletter" },
-  { id: "reddit-hn-digest", name: "Reddit & HN Digest", price: 19, tier: "paid", description: "Daily curated digest from Reddit and Hacker News", hook: "Never miss what matters on Reddit and HN" },
-  { id: "youtube-digest", name: "YouTube Digest", price: 19, tier: "paid", description: "Morning summary of new videos from favorite channels", hook: "Your YouTube feed, distilled to what matters" },
-  { id: "health-tracker", name: "Health Tracker", price: 29, tier: "paid", description: "Food & symptom tracking with weekly correlation analysis", hook: "Understand what your body is telling you" },
-  { id: "earnings-tracker", name: "Earnings Tracker", price: 29, tier: "paid", description: "Tech/AI earnings reports with beat/miss analysis", hook: "Every earnings call, analyzed in minutes" },
-  { id: "research-agent", name: "Research Agent", price: 39, tier: "paid", description: "AI research analyst that monitors competitors, trends, and industry news", hook: "Know when competitors change anything -- in 5 minutes" },
-  { id: "knowledge-base", name: "Knowledge Base", price: 39, tier: "paid", description: "Personal knowledge management from URLs, articles, tweets", hook: "Your second brain, always organized" },
-  { id: "family-calendar", name: "Family Calendar", price: 39, tier: "paid", description: "Household coordination with calendar aggregation", hook: "Everyone in sync, nothing forgotten" },
-  { id: "content-agent", name: "Content Agent", price: 49, tier: "paid", description: "AI content strategist that researches trends, drafts posts in your voice, and tracks engagement", hook: "Your X account grows while you sleep" },
-  { id: "personal-crm", name: "Personal CRM", price: 49, tier: "paid", description: "Contact management with auto-discovery from email", hook: "Never lose touch with anyone important" },
-  { id: "youtube-creator", name: "YouTube Creator", price: 69, tier: "paid", description: "Content pipeline for YouTube creators", hook: "From idea to upload, fully assisted" },
-  { id: "devops-agent", name: "DevOps Agent", price: 79, tier: "paid", description: "Infrastructure monitoring + self-healing", hook: "Sleep through incidents, wake up to fixes" },
-  { id: "customer-service", name: "Customer Service", price: 79, tier: "paid", description: "Multi-channel customer support with knowledge base", hook: "24/7 support without the headcount" },
-  { id: "sales-agent", name: "Sales Agent", price: 79, tier: "paid", description: "AI-powered B2B sales development representative", hook: "Find leads overnight, inbox full by morning" },
-  { id: "six-agent-company", name: "Six Agent Company", price: 149, tier: "paid", description: "6 AI agents running your company: CEO, Engineer, QA, Data, Marketing, Growth", hook: "6 AI agents running your company for $8/month" }
-];
-async function templates() {
-  p5.intro(`${pc5.bgCyan(pc5.black(" seclaw "))} Available Templates`);
-  const all = await loadManifests();
-  if (all.length === 0) {
-    p5.log.warn("No templates found. Try updating: npm i -g seclaw");
-    return;
-  }
-  const free = all.filter((t) => t.tier === "free");
-  const paid = all.filter((t) => t.tier === "paid");
-  if (free.length > 0) {
-    p5.log.info(pc5.bold("Free"));
-    for (const t of free) {
-      p5.log.message(
-        `  ${pc5.green(t.id)}
-  ${t.description}
-  ${pc5.dim(t.hook)}`
-      );
-    }
-  }
-  if (paid.length > 0) {
-    p5.log.info(pc5.bold("Paid"));
-    for (const t of paid) {
-      p5.log.message(
-        `  ${pc5.yellow(t.id)} ${pc5.dim(`$${t.price}`)}
-  ${t.description}
-  ${pc5.dim(t.hook)}`
-      );
-    }
-  }
-  p5.log.info("");
-  p5.log.info(pc5.bold("Usage:"));
-  p5.log.message(`  ${pc5.cyan("npx seclaw add productivity-agent")}          ${pc5.dim("free")}`);
-  p5.log.message(`  ${pc5.cyan("npx seclaw add content-agent --key KEY")}     ${pc5.dim("paid")}`);
-  p5.outro(`${pc5.dim("Browse:")} https://seclawai.com/templates`);
-}
-async function loadManifests() {
-  const manifests = [];
-  const seen = /* @__PURE__ */ new Set();
-  const searchRoots = [
-    resolve8(import.meta.dirname, "templates"),
-    resolve8(process.cwd(), "packages", "cli", "templates")
-  ];
-  for (const root of searchRoots) {
-    for (const tier of ["free", "paid"]) {
-      const base = resolve8(root, tier);
-      if (!existsSync8(base)) continue;
-      let entries;
-      try {
-        entries = await readdir(base, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        if (seen.has(entry.name)) continue;
-        const manifestPath = resolve8(base, entry.name, "manifest.json");
-        if (!existsSync8(manifestPath)) continue;
-        try {
-          const raw = await readFile5(manifestPath, "utf-8");
-          manifests.push(JSON.parse(raw));
-          seen.add(entry.name);
-        } catch {
-        }
-      }
-    }
-  }
-  for (const t of TEMPLATES) {
-    if (!seen.has(t.id)) {
-      manifests.push(t);
-      seen.add(t.id);
-    }
-  }
-  manifests.sort((a, b) => a.price - b.price);
-  return manifests;
-}
-
-// src/commands/status.ts
-import { resolve as resolve9 } from "path";
-import { readFile as readFile6 } from "fs/promises";
-import * as p6 from "@clack/prompts";
 import { execa as execa5 } from "execa";
-import pc6 from "picocolors";
+import pc5 from "picocolors";
 async function status() {
-  p6.intro(`${pc6.bgCyan(pc6.black(" seclaw "))} Status`);
+  p5.intro(`${pc5.bgCyan(pc5.black(" seclaw "))} Status`);
   const projectDir = findProjectDir();
   if (!projectDir) {
-    p6.log.warn("No seclaw project found.");
-    p6.log.info(`  Start one with: ${pc6.cyan("npx seclaw my-agent")}`);
-    p6.outro("");
+    p5.log.warn("No seclaw project found.");
+    p5.log.info(`  Start one with: ${pc5.cyan("npx seclaw my-agent")}`);
+    p5.outro("");
     return;
   }
   try {
@@ -2041,15 +1938,15 @@ async function status() {
       (l) => JSON.parse(l)
     );
     if (services.length === 0) {
-      p6.log.warn("Services are not running.");
-      p6.log.info(`  Start with: ${pc6.cyan("npx seclaw")} in ${pc6.dim(projectDir)}`);
-      p6.outro("");
+      p5.log.warn("Services are not running.");
+      p5.log.info(`  Start with: ${pc5.cyan("npx seclaw")} in ${pc5.dim(projectDir)}`);
+      p5.outro("");
       return;
     }
     for (const svc of services) {
-      const icon = svc.State === "running" ? pc6.green("\u25CF") : pc6.red("\u25CF");
-      const health = svc.Status.includes("healthy") ? pc6.green("healthy") : svc.Status.includes("starting") ? pc6.yellow("starting") : pc6.dim(svc.Status);
-      p6.log.info(`${icon} ${pc6.bold(svc.Service.padEnd(20))} ${health}`);
+      const icon = svc.State === "running" ? pc5.green("\u25CF") : pc5.red("\u25CF");
+      const health = svc.Status.includes("healthy") ? pc5.green("healthy") : svc.Status.includes("starting") ? pc5.yellow("starting") : pc5.dim(svc.Status);
+      p5.log.info(`${icon} ${pc5.bold(svc.Service.padEnd(20))} ${health}`);
     }
     const infoLines = [];
     let agentOk = false;
@@ -2070,16 +1967,16 @@ async function status() {
     } catch {
     }
     infoLines.push(
-      `${pc6.white(pc6.bold("Agent:"))}     ${agentOk ? pc6.green("healthy") : pc6.yellow("starting...")}`
+      `${pc5.white(pc5.bold("Agent:"))}     ${agentOk ? pc5.green("healthy") : pc5.yellow("starting...")}`
     );
     const tunnelUrl = await getTunnelUrl(projectDir, 3);
     if (tunnelUrl) {
-      infoLines.push(`${pc6.white(pc6.bold("Public URL:"))} ${pc6.cyan(tunnelUrl)}`);
+      infoLines.push(`${pc5.white(pc5.bold("Public URL:"))} ${pc5.cyan(tunnelUrl)}`);
     } else {
-      infoLines.push(`${pc6.white(pc6.bold("Public URL:"))} ${pc6.yellow("not detected yet")}`);
+      infoLines.push(`${pc5.white(pc5.bold("Public URL:"))} ${pc5.yellow("not detected yet")}`);
     }
     try {
-      const env = await readFile6(resolve9(projectDir, ".env"), "utf-8");
+      const env = await readFile5(resolve8(projectDir, ".env"), "utf-8");
       const tokenMatch = env.match(/TELEGRAM_BOT_TOKEN=(.+)/);
       if (tokenMatch && tokenMatch[1].includes(":")) {
         const botToken = tokenMatch[1].trim();
@@ -2087,50 +1984,50 @@ async function status() {
           const res = await fetch(`https://api.telegram.org/bot${botToken}/getMe`);
           const data = await res.json();
           if (data.ok && data.result) {
-            infoLines.push(`${pc6.white(pc6.bold("Telegram:"))}   ${pc6.green("@" + data.result.username)}`);
+            infoLines.push(`${pc5.white(pc5.bold("Telegram:"))}   ${pc5.green("@" + data.result.username)}`);
           }
         } catch {
-          infoLines.push(`${pc6.white(pc6.bold("Telegram:"))}   ${pc6.green("configured")}`);
+          infoLines.push(`${pc5.white(pc5.bold("Telegram:"))}   ${pc5.green("configured")}`);
         }
       }
     } catch {
     }
     try {
-      const env = await readFile6(resolve9(projectDir, ".env"), "utf-8");
+      const env = await readFile5(resolve8(projectDir, ".env"), "utf-8");
       if (env.includes("COMPOSIO_API_KEY=")) {
-        infoLines.push(`${pc6.white(pc6.bold("Composio:"))}   ${pc6.green("configured")}`);
+        infoLines.push(`${pc5.white(pc5.bold("Composio:"))}   ${pc5.green("configured")}`);
       }
     } catch {
     }
     let wsPath = "shared";
     try {
-      const envContent = await readFile6(resolve9(projectDir, ".env"), "utf-8");
+      const envContent = await readFile5(resolve8(projectDir, ".env"), "utf-8");
       const wsMatch = envContent.match(/WORKSPACE_HOST_PATH=(.+)/);
       if (wsMatch?.[1]?.trim()) wsPath = wsMatch[1].trim();
     } catch {
     }
-    infoLines.push(`${pc6.white(pc6.bold("Workspace:"))}  ${resolve9(projectDir, wsPath)}`);
-    infoLines.push(`${pc6.white(pc6.bold("Project:"))}   ${projectDir}`);
-    p6.note(infoLines.join("\n"), "seclaw");
+    infoLines.push(`${pc5.white(pc5.bold("Workspace:"))}  ${resolve8(projectDir, wsPath)}`);
+    infoLines.push(`${pc5.white(pc5.bold("Project:"))}   ${projectDir}`);
+    p5.note(infoLines.join("\n"), "seclaw");
   } catch {
-    p6.log.error("Could not check status. Is Docker running?");
+    p5.log.error("Could not check status. Is Docker running?");
   }
-  p6.outro(`${pc6.white("Manage:")} npx seclaw stop | integrations | upgrade`);
+  p5.outro(`${pc5.white("Manage:")} npx seclaw stop | integrations | upgrade`);
 }
 
 // src/commands/stop.ts
-import * as p7 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import { execa as execa6 } from "execa";
-import pc7 from "picocolors";
+import pc6 from "picocolors";
 async function stop() {
-  p7.intro(`${pc7.bgCyan(pc7.black(" seclaw "))} Stopping services...`);
+  p6.intro(`${pc6.bgCyan(pc6.black(" seclaw "))} Stopping services...`);
   const projectDir = findProjectDir();
   if (!projectDir) {
-    p7.log.warn("No seclaw project found. Nothing to stop.");
-    p7.outro("");
+    p6.log.warn("No seclaw project found. Nothing to stop.");
+    p6.outro("");
     return;
   }
-  const s = p7.spinner();
+  const s = p6.spinner();
   s.start("Stopping containers...");
   try {
     await execa6("docker", ["compose", "down"], {
@@ -2140,26 +2037,26 @@ async function stop() {
     s.stop("All services stopped.");
   } catch {
     s.stop("Failed to stop services.");
-    p7.log.error(`Try manually: cd ${projectDir} && docker compose down`);
+    p6.log.error(`Try manually: cd ${projectDir} && docker compose down`);
   }
-  p7.outro(`Restart anytime: ${pc7.cyan("npx seclaw")} in ${pc7.dim(projectDir)}`);
+  p6.outro(`Restart anytime: ${pc6.cyan("npx seclaw")} in ${pc6.dim(projectDir)}`);
 }
 
 // src/commands/reconnect.ts
-import { resolve as resolve10 } from "path";
-import { readFile as readFile7 } from "fs/promises";
+import { resolve as resolve9 } from "path";
+import { readFile as readFile6 } from "fs/promises";
 import { execa as execa7 } from "execa";
-import * as p8 from "@clack/prompts";
-import pc8 from "picocolors";
+import * as p7 from "@clack/prompts";
+import pc7 from "picocolors";
 async function reconnect() {
   const projectDir = findProjectDir();
   if (!projectDir) {
-    p8.intro(`${pc8.bgCyan(pc8.black(" seclaw "))}`);
-    p8.log.error("No seclaw project found. Run from your project directory.");
+    p7.intro(`${pc7.bgCyan(pc7.black(" seclaw "))}`);
+    p7.log.error("No seclaw project found. Run from your project directory.");
     return;
   }
-  p8.intro(`${pc8.bgCyan(pc8.black(" seclaw "))} Reconnect`);
-  const s = p8.spinner();
+  p7.intro(`${pc7.bgCyan(pc7.black(" seclaw "))} Reconnect`);
+  const s = p7.spinner();
   const env = { ...process.env, COMPOSE_PROJECT_NAME: "seclaw" };
   s.start("Restarting all services...");
   await clearTunnelCache(projectDir);
@@ -2168,7 +2065,7 @@ async function reconnect() {
     await execa7("docker", ["compose", "up", "-d"], { cwd: projectDir, env });
   } catch {
     s.stop("Failed to restart services.");
-    p8.log.error("Is Docker running? Try: npx seclaw status");
+    p7.log.error("Is Docker running? Try: npx seclaw status");
     return;
   }
   s.stop("Services restarted.");
@@ -2179,12 +2076,12 @@ async function reconnect() {
   const tunnelUrl = await getTunnelUrl(projectDir, 30);
   if (!tunnelUrl) {
     s.stop("Could not detect tunnel URL.");
-    p8.log.error("Tunnel may still be starting. Try again in a minute.");
+    p7.log.error("Tunnel may still be starting. Try again in a minute.");
     return;
   }
-  s.stop(`Tunnel ready: ${pc8.cyan(tunnelUrl)}`);
+  s.stop(`Tunnel ready: ${pc7.cyan(tunnelUrl)}`);
   try {
-    const envContent = await readFile7(resolve10(projectDir, ".env"), "utf-8");
+    const envContent = await readFile6(resolve9(projectDir, ".env"), "utf-8");
     const tokenMatch = envContent.match(/TELEGRAM_BOT_TOKEN=(.+)/);
     if (tokenMatch && tokenMatch[1].includes(":")) {
       s.start("Setting Telegram webhook...");
@@ -2193,27 +2090,27 @@ async function reconnect() {
     }
   } catch {
   }
-  p8.note(
-    `${pc8.white(pc8.bold("Tunnel:"))} ${pc8.cyan(tunnelUrl)}`,
+  p7.note(
+    `${pc7.white(pc7.bold("Tunnel:"))} ${pc7.cyan(tunnelUrl)}`,
     "seclaw"
   );
-  p8.outro("Reconnected! Send a message on Telegram to test.");
+  p7.outro("Reconnected! Send a message on Telegram to test.");
 }
 
 // src/commands/doctor.ts
-import { resolve as resolve11 } from "path";
-import { existsSync as existsSync9 } from "fs";
-import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve10 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile7 } from "fs/promises";
 import { execa as execa8 } from "execa";
-import * as p9 from "@clack/prompts";
-import pc9 from "picocolors";
-var PASS = pc9.green("PASS");
-var FAIL = pc9.red("FAIL");
-var FIX = pc9.cyan("FIX ");
+import * as p8 from "@clack/prompts";
+import pc8 from "picocolors";
+var PASS = pc8.green("PASS");
+var FAIL = pc8.red("FAIL");
+var FIX = pc8.cyan("FIX ");
 async function doctor() {
-  p9.intro(`${pc9.bgCyan(pc9.black(" seclaw "))} Doctor`);
+  p8.intro(`${pc8.bgCyan(pc8.black(" seclaw "))} Doctor`);
   const results = [];
-  const s = p9.spinner();
+  const s = p8.spinner();
   s.start("Checking Docker...");
   const dockerCheck = await checkDockerHealth();
   results.push(dockerCheck);
@@ -2224,7 +2121,7 @@ async function doctor() {
   }
   s.start("Finding project...");
   const projectDir = findProjectDir();
-  const projectCheck = projectDir ? { name: "Project", ok: true, message: `Found at ${pc9.dim(projectDir)}` } : { name: "Project", ok: false, message: "No seclaw project found. Run from your project directory." };
+  const projectCheck = projectDir ? { name: "Project", ok: true, message: `Found at ${pc8.dim(projectDir)}` } : { name: "Project", ok: false, message: "No seclaw project found. Run from your project directory." };
   results.push(projectCheck);
   s.stop(formatCheck(projectCheck));
   if (!projectDir) {
@@ -2260,21 +2157,18 @@ async function doctor() {
   if (fixable.length > 0) {
     let shouldFix = false;
     try {
-      const answer = await p9.confirm({
+      const answer = await p8.confirm({
         message: `Found ${fixable.length} fixable issue(s). Auto-fix?`,
         initialValue: true
       });
-      shouldFix = !p9.isCancel(answer) && !!answer;
+      shouldFix = !p8.isCancel(answer) && !!answer;
     } catch {
       shouldFix = true;
     }
     if (!shouldFix) {
-      p9.outro("Run again after fixing manually.");
+      p8.outro("Run again after fixing manually.");
       return;
     }
-    s.start("Stopping conflicting containers...");
-    await stopExistingSeclaw();
-    s.stop(`${FIX} Cleared conflicting containers`);
     for (const check of fixable) {
       s.start(`Fixing: ${check.name}...`);
       try {
@@ -2284,10 +2178,10 @@ async function doctor() {
         s.stop(`${FAIL} ${check.name} \u2014 ${err instanceof Error ? err.message : "unknown error"}`);
       }
     }
-    p9.outro("Fixes applied! Run doctor again to verify.");
+    p8.outro("Fixes applied! Run doctor again to verify.");
   } else {
     const allOk = results.every((r) => r.ok);
-    p9.outro(allOk ? "All checks passed!" : "Some issues need manual intervention.");
+    p8.outro(allOk ? "All checks passed!" : "Some issues need manual intervention.");
   }
 }
 async function checkDockerHealth() {
@@ -2423,12 +2317,12 @@ async function checkTunnel(projectDir) {
   try {
     const result = await execa8(
       "docker",
-      ["compose", "logs", "cloudflared", "--no-log-prefix"],
+      ["compose", "logs", "cloudflared", "--no-log-prefix", "--tail", "50"],
       { cwd: projectDir, env: { ...process.env, COMPOSE_PROJECT_NAME: getProjectName(projectDir) } }
     );
     const combined = result.stdout + "\n" + result.stderr;
-    const match = combined.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
-    if (!match) {
+    const matches = [...combined.matchAll(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/g)];
+    if (matches.length === 0) {
       return {
         name: "Tunnel",
         ok: false,
@@ -2442,7 +2336,7 @@ async function checkTunnel(projectDir) {
         }
       };
     }
-    const tunnelUrl = match[0];
+    const tunnelUrl = matches[matches.length - 1][0];
     try {
       const res = await fetch(`${tunnelUrl}/health`, {
         signal: AbortSignal.timeout(1e4)
@@ -2460,8 +2354,15 @@ async function checkTunnel(projectDir) {
       return {
         name: "Tunnel",
         ok: false,
-        message: `URL found (${pc9.dim(tunnelUrl)}) but not reachable`,
-        tunnelUrl
+        message: `URL found (${pc8.dim(tunnelUrl)}) but not reachable`,
+        tunnelUrl,
+        fix: async () => {
+          await clearTunnelCache(projectDir);
+          const env = { ...process.env, COMPOSE_PROJECT_NAME: getProjectName(projectDir) };
+          await execa8("docker", ["compose", "restart", "cloudflared"], { cwd: projectDir, env });
+          const newUrl = await getTunnelUrl(projectDir, 20);
+          return newUrl ? `New tunnel: ${newUrl}` : "Restarted cloudflared \u2014 run doctor again";
+        }
       };
     }
   } catch {
@@ -2469,13 +2370,13 @@ async function checkTunnel(projectDir) {
   }
 }
 async function checkTelegram(projectDir, tunnelCheck) {
-  const envPath = resolve11(projectDir, ".env");
-  if (!existsSync9(envPath)) {
+  const envPath = resolve10(projectDir, ".env");
+  if (!existsSync8(envPath)) {
     return { name: "Telegram", ok: false, message: ".env not found" };
   }
   let botToken = "";
   try {
-    const envContent = await readFile8(envPath, "utf-8");
+    const envContent = await readFile7(envPath, "utf-8");
     const match = envContent.match(/TELEGRAM_BOT_TOKEN=(.+)/);
     botToken = match?.[1]?.trim() || "";
   } catch {
@@ -2498,15 +2399,18 @@ async function checkTelegram(projectDir, tunnelCheck) {
     }
     const wh = whData.result;
     const tunnelUrl = tunnelCheck.tunnelUrl || "";
+    const webhookFix = async () => {
+      const freshUrl = await getTunnelUrl(projectDir, 5);
+      if (!freshUrl) return "No tunnel URL available \u2014 fix tunnel first";
+      const ok = await setTelegramWebhook(botToken, freshUrl);
+      return ok ? `Webhook set to ${freshUrl}` : "Could not set webhook";
+    };
     if (!wh.url) {
       return {
         name: `Telegram (${botName})`,
         ok: false,
         message: "Webhook not set",
-        fix: tunnelUrl ? async () => {
-          const ok = await setTelegramWebhook(botToken, tunnelUrl);
-          return ok ? "Webhook set" : "Could not set webhook";
-        } : void 0
+        fix: webhookFix
       };
     }
     if (tunnelUrl && !wh.url.includes(tunnelUrl.replace("https://", ""))) {
@@ -2514,10 +2418,7 @@ async function checkTelegram(projectDir, tunnelCheck) {
         name: `Telegram (${botName})`,
         ok: false,
         message: "Webhook points to old tunnel",
-        fix: async () => {
-          const ok = await setTelegramWebhook(botToken, tunnelUrl);
-          return ok ? "Webhook updated" : "Could not update webhook";
-        }
+        fix: webhookFix
       };
     }
     if (wh.last_error_message) {
@@ -2525,7 +2426,13 @@ async function checkTelegram(projectDir, tunnelCheck) {
       return {
         name: `Telegram (${botName})`,
         ok: false,
-        message: `Error ${age}m ago: ${wh.last_error_message}`
+        message: `Error ${age}m ago: ${wh.last_error_message}`,
+        fix: async () => {
+          const freshUrl = await getTunnelUrl(projectDir, 5);
+          if (!freshUrl) return "No tunnel URL available \u2014 fix tunnel first";
+          const ok = await setTelegramWebhook(botToken, freshUrl);
+          return ok ? `Webhook re-set to ${freshUrl}` : "Could not set webhook";
+        }
       };
     }
     return {
@@ -2539,13 +2446,13 @@ async function checkTelegram(projectDir, tunnelCheck) {
 }
 async function checkComposio(projectDir) {
   try {
-    const env = await readFile8(resolve11(projectDir, ".env"), "utf-8");
+    const env = await readFile7(resolve10(projectDir, ".env"), "utf-8");
     const match = env.match(/COMPOSIO_API_KEY=(\S+)/);
     if (!match) {
       return {
         name: "Composio",
         ok: false,
-        message: `Not configured \u2014 run ${pc9.cyan("npx seclaw integrations")}`
+        message: `Not configured \u2014 run ${pc8.cyan("npx seclaw integrations")}`
       };
     }
     return { name: "Composio", ok: true, message: "API key configured" };
@@ -2555,46 +2462,46 @@ async function checkComposio(projectDir) {
 }
 function formatCheck(check) {
   const status2 = check.ok ? PASS : FAIL;
-  const fixable = !check.ok && check.fix ? pc9.dim(" (auto-fixable)") : "";
+  const fixable = !check.ok && check.fix ? pc8.dim(" (auto-fixable)") : "";
   return `${status2} ${check.name} \u2014 ${check.message}${fixable}`;
 }
 function showSummary(results) {
   const passed = results.filter((r) => r.ok).length;
   const failed = results.filter((r) => !r.ok).length;
   const fixable = results.filter((r) => !r.ok && r.fix).length;
-  p9.log.message("");
-  p9.log.message(
-    `${pc9.bold("Summary:")} ${pc9.green(`${passed} passed`)}, ${failed > 0 ? pc9.red(`${failed} failed`) : pc9.green("0 failed")}` + (fixable > 0 ? `, ${pc9.cyan(`${fixable} auto-fixable`)}` : "")
+  p8.log.message("");
+  p8.log.message(
+    `${pc8.bold("Summary:")} ${pc8.green(`${passed} passed`)}, ${failed > 0 ? pc8.red(`${failed} failed`) : pc8.green("0 failed")}` + (fixable > 0 ? `, ${pc8.cyan(`${fixable} auto-fixable`)}` : "")
   );
 }
 
 // src/commands/upgrade.ts
-import * as p10 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 import { execa as execa9 } from "execa";
-import pc10 from "picocolors";
-import { readFile as readFile9 } from "fs/promises";
-import { resolve as resolve12 } from "path";
+import pc9 from "picocolors";
+import { readFile as readFile8 } from "fs/promises";
+import { resolve as resolve11 } from "path";
 async function upgrade() {
-  p10.intro(`${pc10.bgCyan(pc10.black(" seclaw "))} Upgrading...`);
+  p9.intro(`${pc9.bgCyan(pc9.black(" seclaw "))} Upgrading...`);
   const projectDir = findProjectDir();
   if (!projectDir) {
-    p10.log.warn("No seclaw project found.");
-    p10.log.info(`  Start one with: ${pc10.cyan("npx seclaw my-agent")}`);
-    p10.outro("");
+    p9.log.warn("No seclaw project found.");
+    p9.log.info(`  Start one with: ${pc9.cyan("npx seclaw my-agent")}`);
+    p9.outro("");
     return;
   }
   const opts = {
     cwd: projectDir,
     env: { ...process.env, COMPOSE_PROJECT_NAME: "seclaw" }
   };
-  const s = p10.spinner();
+  const s = p9.spinner();
   s.start("Pulling latest images...");
   try {
     await execa9("docker", ["compose", "pull"], opts);
     s.stop("Images updated.");
   } catch {
     s.stop("Failed to pull images.");
-    p10.log.error("Check your internet connection and try again.");
+    p9.log.error("Check your internet connection and try again.");
     return;
   }
   s.start("Restarting services...");
@@ -2603,15 +2510,15 @@ async function upgrade() {
     s.stop("Services restarted.");
   } catch {
     s.stop("Failed to restart.");
-    p10.log.error(`Try manually: cd ${projectDir} && docker compose up -d`);
+    p9.log.error(`Try manually: cd ${projectDir} && docker compose up -d`);
     return;
   }
   s.start("Reconnecting tunnel...");
   const tunnelUrl = await getTunnelUrl(projectDir);
   if (tunnelUrl) {
-    s.stop(`Tunnel ready: ${pc10.cyan(tunnelUrl)}`);
+    s.stop(`Tunnel ready: ${pc9.cyan(tunnelUrl)}`);
     try {
-      const env = await readFile9(resolve12(projectDir, ".env"), "utf-8");
+      const env = await readFile8(resolve11(projectDir, ".env"), "utf-8");
       const tokenMatch = env.match(/TELEGRAM_BOT_TOKEN=(.+)/);
       if (tokenMatch && tokenMatch[1].includes(":")) {
         s.start("Updating Telegram webhook...");
@@ -2623,7 +2530,7 @@ async function upgrade() {
   } else {
     s.stop("Tunnel starting...");
   }
-  p10.outro("Upgrade complete!");
+  p9.outro("Upgrade complete!");
 }
 
 // src/cli.ts
@@ -2631,7 +2538,6 @@ program.name("seclaw").description("Secure autonomous AI agents in 60 seconds").
 program.command("create", { isDefault: true }).alias("init").description("Set up a new seclaw project").argument("[directory]", "Project directory", ".").action(create);
 program.command("add <template>").description("Add a template to your project").option("--key <license>", "License key for paid templates").action(add);
 program.command("integrations").description("Manage integrations (Gmail, GitHub, Notion...)").action(integrations);
-program.command("templates").alias("list").description("List available templates").action(templates);
 program.command("status").description("Check running services").action(status);
 program.command("stop").description("Stop all services").action(stop);
 program.command("reconnect").description("Reconnect tunnel + Telegram webhook").action(reconnect);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seclaw",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Secure autonomous AI agents in 60 seconds",
   "type": "module",
   "bin": {