towns-agent 2.0.4 → 2.0.6

package/dist/index.mjs

@@ -1,7 +1,5 @@
 // src/index.ts
-import { resolve as resolve2 } from "path";
-import { config as dotenvConfig } from "dotenv";
-import { green as green5, red as red7, yellow as yellow3, cyan as cyan4 } from "picocolors";
+import { green as green5, red as red7, yellow as yellow4, cyan as cyan4 } from "picocolors";
 
 // src/modules/init.ts
 import * as fs2 from "fs";
@@ -13,9 +11,17 @@ import * as jsonc from "jsonc-parser";
 // src/modules/utils.ts
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "url";
 import { default as spawn } from "cross-spawn";
 import { default as prompts } from "prompts";
 import picocolors from "picocolors";
+import { config as dotenvConfig } from "dotenv";
+import { parseAppPrivateData } from "@towns-labs/sdk";
+
+// package.json
+var version = "2.0.6";
+
+// src/modules/utils.ts
 var getPackageManager = () => {
   if (process.env.npm_config_user_agent) {
     const agent = process.env.npm_config_user_agent;
@@ -79,112 +85,52 @@ function runCommand(command, args, opts = { cwd: void 0, silent: false }) {
     child.on("error", reject);
   });
 }
-async function getLatestTownsProtocolVersion() {
-  return new Promise((resolve3, reject) => {
-    const child = spawn("npm", ["view", "@towns-labs/agent", "version"], {
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    let output = "";
-    child.stdout?.on("data", (data) => {
-      output += data.toString();
-    });
-    child.on("close", (code) => {
-      if (code !== 0) {
-        reject(new Error("Failed to fetch latest @towns-labs/agent version"));
-      } else {
-        resolve3(output.trim());
-      }
-    });
-    child.on("error", reject);
-  });
+function getTemplatesDir() {
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+  const fromDist = path.resolve(currentDir, "..", "templates");
+  if (fs.existsSync(fromDist)) return fromDist;
+  const fromSrc = path.resolve(currentDir, "..", "..", "templates");
+  if (fs.existsSync(fromSrc)) return fromSrc;
+  throw new Error("Templates directory not found");
 }
-function getLatestSdkTag() {
-  const tagsResult = spawn.sync(
-    "git",
-    ["ls-remote", "--tags", "https://github.com/HereNotThere/chat.git", "@towns-labs/sdk@*"],
-    { encoding: "utf8" }
-  );
-  if (tagsResult.status !== 0 || !tagsResult.stdout) return null;
-  const tags = tagsResult.stdout.split("\n").filter(Boolean).map((line) => {
-    const [_hash, ref] = line.split("	");
-    const tag = ref.replace("refs/tags/", "").replace(/\^{}$/, "");
-    const match = tag.match(/^@towns-protocol\/sdk@(\d+)\.(\d+)\.(\d+)$/);
-    if (!match) return null;
-    return {
-      tag,
-      version: [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])]
-    };
-  }).filter(
-    (item) => item !== null && Array.isArray(item.version) && item.version.length === 3
-  ).sort((a, b) => {
-    for (let i = 0; i < 3; i++) {
-      if (a.version[i] !== b.version[i]) {
-        return b.version[i] - a.version[i];
-      }
-    }
-    return 0;
-  });
-  return tags.length > 0 ? tags[0].tag : null;
-}
-async function cloneTemplate(packagePath, targetDir) {
-  console.log(picocolors.blue("Cloning template from GitHub..."));
-  const tempDir = `${targetDir}-temp`;
-  const fullTemplatePath = `packages/examples/${packagePath}`;
-  const latestSdkTag = getLatestSdkTag();
-  if (!latestSdkTag) {
-    console.error(picocolors.red("Failed to get latest SDK tag."));
-    return false;
-  }
-  const cloneResult = spawn.sync(
-    "git",
-    [
-      "clone",
-      "--no-checkout",
-      "--depth",
-      "1",
-      "--sparse",
-      "--branch",
-      latestSdkTag,
-      "https://github.com/towns-protocol/towns.git",
-      tempDir
-    ],
-    { stdio: "pipe" }
-  );
-  if (cloneResult.status !== 0) return false;
-  const sparseResult = spawn.sync("git", ["sparse-checkout", "set", fullTemplatePath], {
-    stdio: "pipe",
-    cwd: tempDir
-  });
-  if (sparseResult.status !== 0) {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    return false;
-  }
-  const checkoutResult = spawn.sync("git", ["checkout"], {
-    stdio: "pipe",
-    cwd: tempDir
-  });
-  if (checkoutResult.status !== 0) {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    return false;
-  }
-  const sourceDir = path.join(tempDir, fullTemplatePath);
+function copyTemplate(templateName, targetDir) {
+  console.log(picocolors.blue("Copying template..."));
+  const templatesDir = getTemplatesDir();
+  const sourceDir = path.join(templatesDir, templateName);
   if (!fs.existsSync(sourceDir)) {
-    console.error(picocolors.red(`
-Template directory not found at ${sourceDir}`));
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    console.error(picocolors.red(`Template "${templateName}" not found at ${sourceDir}`));
     return false;
   }
   fs.mkdirSync(targetDir, { recursive: true });
   fs.cpSync(sourceDir, targetDir, {
     recursive: true,
-    filter: () => {
-      return true;
+    filter: (source) => {
+      const basename2 = path.basename(source);
+      return basename2 !== "node_modules" && basename2 !== "dist";
     }
   });
-  fs.rmSync(tempDir, { recursive: true, force: true });
-  console.log(picocolors.green("\u2713"), "Template cloned successfully!");
+  const gitignoreSrc = path.join(targetDir, "_gitignore");
+  const gitignoreDest = path.join(targetDir, ".gitignore");
+  if (fs.existsSync(gitignoreSrc)) {
+    fs.renameSync(gitignoreSrc, gitignoreDest);
+  }
+  console.log(picocolors.green("\u2713"), "Template copied successfully!");
   return true;
 }
+function copyAgentsMd(projectDir) {
+  try {
+    const templatesDir = getTemplatesDir();
+    const sourceFile = path.join(templatesDir, "quickstart", "AGENTS.md");
+    if (!fs.existsSync(sourceFile)) {
+      return false;
+    }
+    const destFile = path.join(projectDir, "AGENTS.md");
+    fs.copyFileSync(sourceFile, destFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function applyReplacements(targetDir, replacements) {
   function processDirectory(dir) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -310,71 +256,35 @@ async function installTownsSkills(projectDir) {
     return false;
   }
 }
-async function downloadAgentsMd(projectDir) {
-  const tempDir = `${projectDir}-agents-md-temp`;
+function parseDotenv() {
+  return dotenvConfig({ override: false }).parsed;
+}
+function envFromAppPrivateData(parsed) {
+  const appPrivateData = parsed?.APP_PRIVATE_DATA;
+  if (!appPrivateData) {
+    return void 0;
+  }
   try {
-    const agentsMdPath = "packages/examples/agent-quickstart/AGENTS.md";
-    const latestSdkTag = getLatestSdkTag();
-    if (!latestSdkTag) {
-      return false;
-    }
-    const cloneResult = spawn.sync(
-      "git",
-      [
-        "clone",
-        "--no-checkout",
-        "--depth",
-        "1",
-        "--sparse",
-        "--branch",
-        latestSdkTag,
-        "https://github.com/towns-protocol/towns.git",
-        tempDir
-      ],
-      { stdio: "pipe" }
-    );
-    if (cloneResult.status !== 0) {
-      if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-      }
-      return false;
-    }
-    const sparseResult = spawn.sync("git", ["sparse-checkout", "set", agentsMdPath], {
-      stdio: "pipe",
-      cwd: tempDir
-    });
-    if (sparseResult.status !== 0) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      return false;
-    }
-    const checkoutResult = spawn.sync("git", ["checkout"], {
-      stdio: "pipe",
-      cwd: tempDir
-    });
-    if (checkoutResult.status !== 0) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      return false;
-    }
-    const sourceFile = path.join(tempDir, agentsMdPath);
-    if (!fs.existsSync(sourceFile)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      return false;
-    }
-    const destFile = path.join(projectDir, "AGENTS.md");
-    fs.copyFileSync(sourceFile, destFile);
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    return true;
-  } catch (error) {
-    console.error(
-      picocolors.red("Error downloading AGENTS.md:"),
-      error instanceof Error ? error.message : error
-    );
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    return false;
+    return parseAppPrivateData(appPrivateData);
+  } catch {
+    return void 0;
   }
 }
+function resolveAppAddress(positionalArg) {
+  if (positionalArg) {
+    return positionalArg;
+  }
+  const parsed = parseDotenv();
+  const appAddress = parsed?.APP_ADDRESS;
+  if (appAddress) {
+    return appAddress;
+  }
+  return envFromAppPrivateData(parsed)?.appAddress;
+}
+function resolveRiverEnv() {
+  const parsed = parseDotenv();
+  return parsed?.RIVER_ENV ?? envFromAppPrivateData(parsed)?.env;
+}
 async function promptAuth() {
   const { method } = await prompts({
     type: "select",
@@ -402,7 +312,7 @@ var TEMPLATES = {
   quickstart: {
     name: "Agent Quickstart",
     description: "Simple starter agent with basic commands",
-    packagePath: "agent-quickstart"
+    packagePath: "quickstart"
   }
 };
 async function init(argv) {
@@ -439,12 +349,12 @@ async function init(argv) {
   const packageManager = getPackageManager();
   const selectedTemplate = TEMPLATES[template];
   try {
-    const success = await cloneTemplate(selectedTemplate.packagePath, targetDir);
+    const success = copyTemplate(selectedTemplate.packagePath, targetDir);
     if (!success) {
-      console.error(red("Failed to clone template"));
+      console.error(red("Failed to copy template"));
       process.exit(1);
     }
-    const latestVersion = await getLatestTownsProtocolVersion();
+    const latestVersion = version;
     const replacements = /* @__PURE__ */ new Map([
       ["workspace:\\^", `^${latestVersion}`],
       ["workspace:\\*", `^${latestVersion}`]
@@ -469,19 +379,12 @@ async function init(argv) {
       if (skillSuccess) {
         console.log(green("\u2713"), "Towns Agent Skills installed successfully!");
       } else {
-        console.log(
-          yellow("\u26A0"),
-          "Failed to install Towns Agent Skills. You can install them later with:"
-        );
+        console.log(yellow("\u26A0"), "Skipping Towns Agent Skills. Install later with:");
         console.log(yellow(`  cd ${projectName} && towns-agent install-skill`));
       }
-    } catch (error) {
-      console.log(
-        yellow("\u26A0"),
-        "Error installing skills:",
-        error instanceof Error ? error.message : error
-      );
-      console.log(yellow(`  You can install them later with: towns-agent install-skill`));
+    } catch {
+      console.log(yellow("\u26A0"), "Skipping Towns Agent Skills. Install later with:");
+      console.log(yellow(`  cd ${projectName} && towns-agent install-skill`));
     }
     await initializeGitRepository(targetDir);
     printSuccess(projectName, packageManager);
@@ -500,9 +403,9 @@ function getTownsVersions(packageJson) {
   const versions = {};
   for (const deps of [packageJson.dependencies, packageJson.devDependencies]) {
     if (deps) {
-      for (const [pkg, version] of Object.entries(deps)) {
+      for (const [pkg, version2] of Object.entries(deps)) {
         if (pkg.startsWith("@towns-labs/") || pkg.startsWith("@towns-protocol/")) {
-          versions[pkg] = version;
+          versions[pkg] = version2;
         }
       }
     }
@@ -585,7 +488,7 @@ async function update(_argv) {
       console.log();
       console.log(cyan2("Updating AGENTS.md..."));
       try {
-        const agentsMdSuccess = await downloadAgentsMd(projectDir);
+        const agentsMdSuccess = copyAgentsMd(projectDir);
         if (agentsMdSuccess) {
           console.log(green2("\u2713"), "AGENTS.md updated successfully!");
         } else {
@@ -688,7 +591,7 @@ async function create(argv) {
   if (!addresses?.accountProxy) {
     throw new Error(`No accountProxy address found for ${townsConfig.environmentId}/${chainId}`);
   }
-  const relayerUrl = process.env.RELAYER_URL ?? "http://127.0.0.1:8787";
+  const relayerUrl = townsConfig.services.relayer.url;
   const relayerClient = createPublicClient({
     chain: {
       id: chainId,
@@ -754,13 +657,17 @@ var FIELD_DEFS = [
 ];
 async function metadata(argv) {
   const subcommand = argv._[1];
-  const appAddress = argv._[2];
+  const appAddress = resolveAppAddress(argv._[2]);
   if (!subcommand || !["view", "update"].includes(subcommand)) {
-    console.error(red5("Usage: towns-agent metadata <view|update> <appAddress> [options]"));
+    console.error(red5("Usage: towns-agent metadata <view|update> [appAddress] [options]"));
     process.exit(1);
   }
   if (!appAddress) {
-    console.error(red5("App address is required."));
+    console.error(
+      red5(
+        "App address is required. Provide it as an argument, or set APP_ADDRESS or APP_PRIVATE_DATA in .env."
+      )
+    );
     process.exit(1);
   }
   const env = townsEnv2();
@@ -861,7 +768,7 @@ async function metadata(argv) {
 
 // src/modules/setup.ts
 import { default as prompts5 } from "prompts";
-import { red as red6, dim as dim2, green as green4 } from "picocolors";
+import { red as red6, dim as dim2, green as green4, yellow as yellow3 } from "picocolors";
 import { privateKeyToAccount as privateKeyToAccount3, generatePrivateKey as generatePrivateKey3 } from "viem/accounts";
 import {
   AppRegistryService as AppRegistryService2,
@@ -882,9 +789,13 @@ var NOTIFY_LABELS = {
   NONE: "No messages"
 };
 async function setup(argv) {
-  const appAddress = argv._[1];
+  const appAddress = resolveAppAddress(argv._[1]);
   if (!appAddress) {
-    console.error(red6("Usage: towns-agent setup <appAddress> [options]"));
+    console.error(
+      red6(
+        "App address is required. Provide it as an argument, or set APP_ADDRESS or APP_PRIVATE_DATA in .env."
+      )
+    );
     process.exit(1);
   }
   let ownerPrivateKey = argv.ownerPrivateKey;
@@ -901,11 +812,18 @@ async function setup(argv) {
       bearerToken = auth.value;
     }
   }
-  const webhookUrl = argv.webhookUrl ?? await promptWebhookUrl();
+  let webhookUrl = argv.webhookUrl ?? await promptWebhookUrl();
   if (!webhookUrl) {
     console.error(red6("Webhook URL is required."));
     process.exit(1);
   }
+  if (argv.webhookUrl) {
+    const urlError = validateWebhookUrl(webhookUrl);
+    if (urlError !== true) {
+      console.error(red6(urlError));
+      process.exit(1);
+    }
+  }
   let notifyKey;
   if (argv.notify) {
     notifyKey = argv.notify.toUpperCase();
@@ -934,7 +852,26 @@ async function setup(argv) {
     signerContext,
     appRegistryUrl
   );
-  await appRegistryRpcClient.registerWebhook({ appId, webhookUrl });
+  try {
+    await appRegistryRpcClient.registerWebhook({ appId, webhookUrl });
+  } catch (error) {
+    if (!hasWebhookPath(webhookUrl)) {
+      const webhookUrlWithPath = appendWebhookPath(webhookUrl);
+      try {
+        await appRegistryRpcClient.registerWebhook({
+          appId,
+          webhookUrl: webhookUrlWithPath
+        });
+        console.log();
+        console.log(yellow3(`Registration succeeded with ${webhookUrlWithPath}`));
+        webhookUrl = webhookUrlWithPath;
+      } catch {
+        throw error;
+      }
+    } else {
+      throw error;
+    }
+  }
   await appRegistryRpcClient.setAppSettings({
     appId,
     settings: { forwardSetting }
@@ -947,12 +884,48 @@ async function setup(argv) {
   console.log();
   process.exit(0);
 }
+function hasWebhookPath(url) {
+  const trimmed = url.trim();
+  try {
+    const parsed = new URL(trimmed);
+    const normalizedPath = parsed.pathname.endsWith("/") ? parsed.pathname.slice(0, -1) : parsed.pathname;
+    return normalizedPath.endsWith("/webhook");
+  } catch {
+    return trimmed.replace(/\s*$/, "").endsWith("/webhook");
+  }
+}
+function appendWebhookPath(url) {
+  const trimmed = url.trim();
+  const parsed = new URL(trimmed);
+  const normalizedPath = parsed.pathname.endsWith("/") ? parsed.pathname.slice(0, -1) : parsed.pathname;
+  parsed.pathname = normalizedPath === "/" ? "/webhook" : `${normalizedPath}/webhook`;
+  return parsed.toString();
+}
+function validateWebhookUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    return "Webhook URL is required";
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "0.0.0.0";
+    if (isLocalhost && parsed.protocol === "http:") {
+      return "Local bots must use HTTPS. Use https:// instead of http://";
+    }
+    if (isLocalhost && !parsed.port) {
+      return "Localhost URL is missing a port. Example: https://localhost:3000";
+    }
+    return true;
+  } catch {
+    return "Invalid URL format. Example: https://localhost:3000/webhook";
+  }
+}
 async function promptWebhookUrl() {
   const { value } = await prompts5({
     type: "text",
     name: "value",
     message: "Webhook URL",
-    validate: (v) => v.trim() ? true : "Webhook URL is required"
+    validate: validateWebhookUrl
   });
   return value;
 }
@@ -974,6 +947,9 @@ async function promptNotify() {
   return value;
 }
 
+// src/index.ts
+import { townsEnv as townsEnv4 } from "@towns-labs/sdk";
+
 // src/parser.ts
 import minimist from "minimist";
 var COMMAND_CONFIGS = {
@@ -1042,6 +1018,7 @@ var COMMAND_CONFIGS = {
 function parseArgs(args) {
   const initial = minimist(args, {
     stopEarly: true,
+    string: ["env"],
     boolean: ["help"],
     alias: { h: "help" }
   });
@@ -1051,8 +1028,10 @@ function parseArgs(args) {
   }
   const commandConfig = COMMAND_CONFIGS[command] || {};
   const booleanOptions = Array.isArray(commandConfig.boolean) ? ["help", ...commandConfig.boolean] : ["help"];
+  const stringOptions = Array.isArray(commandConfig.string) ? ["env", ...commandConfig.string] : ["env"];
   const parsed = minimist(args, {
     ...commandConfig,
+    string: stringOptions,
     boolean: booleanOptions,
     alias: {
       ...commandConfig.alias,
@@ -1081,8 +1060,6 @@ function isSetupArgs(args) {
 }
 
 // src/index.ts
-dotenvConfig({ path: resolve2(__dirname, "../../generated/deployments/local_dev/.env") });
-dotenvConfig({ path: resolve2(__dirname, "../../contracts/deployments/envs/local/.env") });
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const command = args._[0];
@@ -1090,6 +1067,32 @@ async function main() {
     showHelp();
     return;
   }
+  const requiresEnv = ["create", "setup", "metadata"].includes(command);
+  if (requiresEnv) {
+    if (args.env) {
+      process.env.RIVER_ENV = args.env;
+    }
+    if (!process.env.RIVER_ENV) {
+      const resolvedEnv = resolveRiverEnv();
+      if (resolvedEnv) {
+        process.env.RIVER_ENV = resolvedEnv;
+      }
+    }
+    if (!process.env.RIVER_ENV) {
+      console.error(
+        red7(
+          "Environment is required. Use --env <local_dev|stage|prod>, set RIVER_ENV, or set APP_PRIVATE_DATA in .env."
+        )
+      );
+      process.exit(1);
+    }
+    try {
+      townsEnv4().makeTownsConfig();
+    } catch {
+      console.error(red7(`Invalid environment: ${process.env.RIVER_ENV}`));
+      process.exit(1);
+    }
+  }
   try {
     switch (command) {
       case "init":
@@ -1136,37 +1139,40 @@ function showHelp() {
   console.log(`
 ${cyan4("towns-agent")} - CLI for creating and managing Towns Protocol agent projects
 
-${yellow3("Usage:")}
+${yellow4("Usage:")}
   towns-agent <command> [options]
 
-${yellow3("Commands:")}
+${yellow4("Commands:")}
   ${green5("init")} [project-name]     Create a new agent project
   ${green5("create")}                  Create a new bot/app account interactively
-  ${green5("setup")} <appAddress>      Register webhook and notification settings
-  ${green5("metadata")} <view|update>  View or update app metadata
+  ${green5("setup")} [appAddress]       Register webhook and notification settings
+  ${green5("metadata")} <view|update> [appAddress]  View or update app metadata
   ${green5("update")}                  Update @towns-labs dependencies and skills
   ${green5("install-skill")}           Install Towns Agent Skills to current project
 
-${yellow3("Init Options:")}
+${yellow4("Init Options:")}
   -t, --template <name>    Template to use:
 ${Object.entries(TEMPLATES).map(
     ([key, template]) => `                             ${key} - ${template.description}`
   ).join("\n")}
                            Default: quickstart
 
-${yellow3("List Commands Options:")}
+${yellow4("List Commands Options:")}
   -f, --file <path>        Path to commands file
 
-${yellow3("Update Commands Options:")}
+${yellow4("Update Commands Options:")}
   -f, --file <path>         Path to commands file
   -t, --bearerToken <token>  Bearer token for authentication
   -e, --envFile <path>       Path to .env file (default: .env)
   --skip-agents-md           Skip updating AGENTS.md file
 
-${yellow3("Global Options:")}
+${yellow4("Environment Options (create, setup, metadata):")}
+  --env <name>             Environment to use: local_dev, stage, prod
+
+${yellow4("Global Options:")}
   -h, --help               Show this help message
 
-${yellow3("Examples:")}
+${yellow4("Examples:")}
   ${cyan4("# Create a new agent project")}
   towns-agent init my-agent
   towns-agent init my-ai-agent --template quickstart