towns-agent 2.0.4

package/dist/index.mjs

@@ -0,0 +1,1182 @@
+// 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";
+
+// src/modules/init.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { default as prompts2 } from "prompts";
+import { red, yellow, cyan, green } from "picocolors";
+import * as jsonc from "jsonc-parser";
+
+// src/modules/utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import { default as spawn } from "cross-spawn";
+import { default as prompts } from "prompts";
+import picocolors from "picocolors";
+var getPackageManager = () => {
+  if (process.env.npm_config_user_agent) {
+    const agent = process.env.npm_config_user_agent;
+    if (agent.startsWith("yarn")) return "yarn";
+    if (agent.startsWith("npm")) return "npm";
+    if (agent.startsWith("pnpm")) return "pnpm";
+    if (agent.startsWith("bun")) return "bun";
+  }
+  return "npm";
+};
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "bun":
+      return "bun install";
+    case "yarn":
+      return "yarn";
+    case "pnpm":
+      return "pnpm install";
+    default:
+      return "npm install";
+  }
+}
+function getRunCommand(packageManager, script) {
+  switch (packageManager) {
+    case "bun":
+      return `bun run ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "pnpm":
+      return `pnpm ${script}`;
+    default:
+      return `npm run ${script}`;
+  }
+}
+function getDlxCommand(packageManager) {
+  switch (packageManager) {
+    case "bun":
+      return "bunx";
+    case "yarn":
+      return "yarn dlx";
+    case "pnpm":
+      return "pnpm dlx";
+    default:
+      return "npx";
+  }
+}
+function runCommand(command, args, opts = { cwd: void 0, silent: false }) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, args, {
+      stdio: opts.silent ? "ignore" : "inherit",
+      cwd: opts.cwd,
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`Command failed with exit code ${code}`));
+      } else {
+        resolve3();
+      }
+    });
+    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 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);
+  if (!fs.existsSync(sourceDir)) {
+    console.error(picocolors.red(`
+Template directory not found at ${sourceDir}`));
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    return false;
+  }
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.cpSync(sourceDir, targetDir, {
+    recursive: true,
+    filter: () => {
+      return true;
+    }
+  });
+  fs.rmSync(tempDir, { recursive: true, force: true });
+  console.log(picocolors.green("\u2713"), "Template cloned successfully!");
+  return true;
+}
+function applyReplacements(targetDir, replacements) {
+  function processDirectory(dir) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === "dist") {
+          continue;
+        }
+        processDirectory(fullPath);
+      } else {
+        let content = fs.readFileSync(fullPath, "utf-8");
+        let modified = false;
+        if (entry.name === "package.json" || entry.name.endsWith(".ts") || entry.name.endsWith(".js")) {
+          for (const [search, replace] of replacements) {
+            const regex = new RegExp(search, "g");
+            if (regex.test(content)) {
+              content = content.replace(regex, replace);
+              modified = true;
+            }
+          }
+          if (modified) {
+            fs.writeFileSync(fullPath, content);
+          }
+        }
+      }
+    }
+  }
+  processDirectory(targetDir);
+}
+function printSuccess(projectName, packageManager) {
+  console.log(picocolors.green("\u2713"), "Bot project created successfully!");
+  console.log();
+  console.log("Next steps:");
+  console.log(picocolors.cyan(`  cd ${projectName}`));
+  console.log(picocolors.cyan(`  ${getInstallCommand(packageManager)}`));
+  console.log("Set up your environment variables:");
+  console.log(picocolors.cyan("  cp .env.sample .env"));
+  console.log("  Edit .env with your bot credentials");
+  console.log("Start your bot:");
+  console.log(picocolors.cyan(`  ${getRunCommand(packageManager, "dev")}`));
+}
+async function initializeGitRepository(targetDir) {
+  try {
+    await runCommand("git", ["init"], { cwd: targetDir, silent: true });
+    await runCommand("git", ["add", "."], { cwd: targetDir, silent: true });
+    await runCommand("git", ["commit", "-m", "feat: towns bot scaffolding"], {
+      cwd: targetDir,
+      silent: true
+    });
+    return true;
+  } catch (error) {
+    console.log(
+      picocolors.yellow("\u26A0"),
+      "Failed to initialize git repository:",
+      error instanceof Error ? error.message : "Unknown error"
+    );
+    console.log(picocolors.yellow("  You can manually initialize git later with: git init"));
+    return false;
+  }
+}
+var TOWNS_SKILL_REPO = "https://github.com/towns-protocol/skills.git";
+var AGENTS_SKILL_FOLDERS = [".claude/skills", ".codex/skills"];
+async function installTownsSkills(projectDir) {
+  const tempDir = `${projectDir}-skills-temp`;
+  try {
+    const cloneResult = spawn.sync(
+      "git",
+      ["clone", "--depth", "1", "--filter=blob:none", "--sparse", TOWNS_SKILL_REPO, 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", "skills"], {
+      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 sourceSkillsDir = path.join(tempDir, "skills");
+    if (!fs.existsSync(sourceSkillsDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      return false;
+    }
+    const skillDirs = fs.readdirSync(sourceSkillsDir, { withFileTypes: true });
+    for (const skillFolder of AGENTS_SKILL_FOLDERS) {
+      const targetDir = path.join(projectDir, skillFolder);
+      if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+      }
+      for (const skillDir of skillDirs) {
+        if (skillDir.isDirectory()) {
+          const sourcePath = path.join(sourceSkillsDir, skillDir.name);
+          const destPath = path.join(targetDir, skillDir.name);
+          fs.cpSync(sourcePath, destPath, { recursive: true });
+        }
+      }
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    console.error(
+      picocolors.red("Error installing skills:"),
+      error instanceof Error ? error.message : error
+    );
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    return false;
+  }
+}
+async function downloadAgentsMd(projectDir) {
+  const tempDir = `${projectDir}-agents-md-temp`;
+  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;
+  }
+}
+async function promptAuth() {
+  const { method } = await prompts({
+    type: "select",
+    name: "method",
+    message: "Login method",
+    choices: [
+      { title: "Bearer Token", value: "bearerToken" },
+      { title: "Private Key", value: "privateKey" }
+    ]
+  });
+  if (method === void 0) return void 0;
+  const promptMessage = method === "bearerToken" ? "Enter your bearer token" : "Enter your private key";
+  const { value } = await prompts({
+    type: "password",
+    name: "value",
+    message: promptMessage,
+    validate: (v) => v.trim() ? true : "This field is required"
+  });
+  if (!value) return void 0;
+  return { method, value };
+}
+
+// src/modules/init.ts
+var TEMPLATES = {
+  quickstart: {
+    name: "Agent Quickstart",
+    description: "Simple starter agent with basic commands",
+    packagePath: "agent-quickstart"
+  }
+};
+async function init(argv) {
+  const projectName = argv._[1];
+  const template = argv.template || "quickstart";
+  if (!projectName) {
+    console.error(red("Error: Please provide a project name"));
+    console.log(yellow("Usage: towns-agent init <project-name>"));
+    process.exit(1);
+  }
+  if (!TEMPLATES[template]) {
+    console.error(red(`Error: Unknown template "${template}"`));
+    console.log(yellow("Available templates:"), Object.keys(TEMPLATES).join(", "));
+    process.exit(1);
+  }
+  const targetDir = path2.resolve(process.cwd(), projectName);
+  if (fs2.existsSync(targetDir)) {
+    const { overwrite } = await prompts2({
+      type: "confirm",
+      name: "overwrite",
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      initial: false
+    });
+    if (!overwrite) {
+      console.log(yellow("Operation cancelled"));
+      process.exit(0);
+    }
+    fs2.rmSync(targetDir, { recursive: true, force: true });
+  }
+  console.log(cyan(`Creating a new Towns Protocol agent in ${targetDir}`));
+  if (template !== "quickstart") {
+    console.log(cyan(`Using template: ${TEMPLATES[template].name}`));
+  }
+  const packageManager = getPackageManager();
+  const selectedTemplate = TEMPLATES[template];
+  try {
+    const success = await cloneTemplate(selectedTemplate.packagePath, targetDir);
+    if (!success) {
+      console.error(red("Failed to clone template"));
+      process.exit(1);
+    }
+    const latestVersion = await getLatestTownsProtocolVersion();
+    const replacements = /* @__PURE__ */ new Map([
+      ["workspace:\\^", `^${latestVersion}`],
+      ["workspace:\\*", `^${latestVersion}`]
+    ]);
+    applyReplacements(targetDir, replacements);
+    const packageJsonPath = path2.join(targetDir, "package.json");
+    if (fs2.existsSync(packageJsonPath)) {
+      const content = fs2.readFileSync(packageJsonPath, "utf-8");
+      const edits = [
+        jsonc.modify(content, ["name"], projectName, {}),
+        jsonc.modify(content, ["version"], "0.0.1", {})
+      ];
+      let modifiedContent = jsonc.applyEdits(content, edits.flat());
+      const parsed = jsonc.parse(modifiedContent);
+      delete parsed.private;
+      modifiedContent = JSON.stringify(parsed, null, 2);
+      fs2.writeFileSync(packageJsonPath, modifiedContent);
+    }
+    console.log(cyan("Installing Towns Agent Skills..."));
+    try {
+      const skillSuccess = await installTownsSkills(targetDir);
+      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(`  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`));
+    }
+    await initializeGitRepository(targetDir);
+    printSuccess(projectName, packageManager);
+  } catch (error) {
+    console.error(red("Error:"), error instanceof Error ? error.message : error);
+    console.error(red(`Please delete the directory ${targetDir} and try again.`));
+    process.exit(1);
+  }
+}
+
+// src/modules/update.ts
+import fs3 from "fs";
+import path3 from "path";
+import { green as green2, red as red2, yellow as yellow2, cyan as cyan2 } from "picocolors";
+function getTownsVersions(packageJson) {
+  const versions = {};
+  for (const deps of [packageJson.dependencies, packageJson.devDependencies]) {
+    if (deps) {
+      for (const [pkg, version] of Object.entries(deps)) {
+        if (pkg.startsWith("@towns-labs/") || pkg.startsWith("@towns-protocol/")) {
+          versions[pkg] = version;
+        }
+      }
+    }
+  }
+  return versions;
+}
+async function update(_argv) {
+  const packageJsonPath = path3.join(process.cwd(), "package.json");
+  if (!fs3.existsSync(packageJsonPath)) {
+    console.error(red2("Error: No package.json found in the current directory"));
+    console.log(yellow2("Please run this command from a Towns Protocol bot project directory"));
+    process.exit(1);
+  }
+  const packageManager = getPackageManager();
+  const dlxCommand = getDlxCommand(packageManager);
+  console.log(cyan2("Checking for @towns-protocol updates..."));
+  try {
+    const [dlxBin, ...dlxArgs] = dlxCommand.split(" ");
+    const packageJsonBefore = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    const versionsBefore = getTownsVersions(packageJsonBefore);
+    await runCommand(dlxBin, [...dlxArgs, "npm-check-updates", "-u", "-f", "@towns-labs/*"], {
+      silent: true
+    });
+    await runCommand(
+      dlxBin,
+      [...dlxArgs, "npm-check-updates", "-u", "-f", "@towns-protocol/*"],
+      {
+        silent: true
+      }
+    );
+    const packageJsonAfter = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
+    const versionsAfter = getTownsVersions(packageJsonAfter);
+    const updates = [];
+    for (const [pkg, newVersion] of Object.entries(versionsAfter)) {
+      const oldVersion = versionsBefore[pkg];
+      if (oldVersion && oldVersion !== newVersion) {
+        updates.push({ package: pkg, from: oldVersion, to: newVersion });
+      }
+    }
+    if (updates.length === 0) {
+      console.log(green2("\u2713"), "All @towns-protocol and @towns-labs packages are up to date!");
+    } else {
+      console.log();
+      for (const update2 of updates) {
+        console.log(green2("\u2713"), `${update2.package} ${update2.from} \u2192 ${update2.to}`);
+      }
+      console.log();
+      console.log(cyan2(`Installing dependencies with ${packageManager}...`));
+      const installCmd = getInstallCommand(packageManager);
+      const [installBin, ...installArgs] = installCmd.split(" ");
+      await runCommand(installBin, installArgs.length > 0 ? installArgs : []);
+      console.log();
+      console.log(green2("\u2713"), "Dependencies updated successfully!");
+    }
+    const projectDir = process.cwd();
+    const claudeSkillsDir = path3.join(projectDir, ".claude", "skills");
+    const codexSkillsDir = path3.join(projectDir, ".codex", "skills");
+    if (fs3.existsSync(claudeSkillsDir) || fs3.existsSync(codexSkillsDir)) {
+      console.log();
+      console.log(cyan2("Updating Towns Agent Skills..."));
+      try {
+        const skillSuccess = await installTownsSkills(projectDir);
+        if (skillSuccess) {
+          console.log(green2("\u2713"), "Towns Agent Skills updated successfully!");
+        } else {
+          console.log(
+            yellow2("\u26A0"),
+            "Failed to update skills. You can reinstall them with: towns-agent install-skill"
+          );
+        }
+      } catch (error) {
+        console.log(
+          yellow2("\u26A0"),
+          "Error updating skills:",
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+    if (!_argv.skipAgentsMd) {
+      console.log();
+      console.log(cyan2("Updating AGENTS.md..."));
+      try {
+        const agentsMdSuccess = await downloadAgentsMd(projectDir);
+        if (agentsMdSuccess) {
+          console.log(green2("\u2713"), "AGENTS.md updated successfully!");
+        } else {
+          console.log(
+            yellow2("\u26A0"),
+            "Failed to update AGENTS.md. You can update it manually or run update again."
+          );
+        }
+      } catch (error) {
+        console.log(
+          yellow2("\u26A0"),
+          "Error updating AGENTS.md:",
+          error instanceof Error ? error.message : error
+        );
+      }
+    }
+  } catch {
+    console.error(red2("Error:"), "Failed to update dependencies");
+    process.exit(1);
+  }
+}
+
+// src/modules/install-skill.ts
+import { red as red3, cyan as cyan3, green as green3 } from "picocolors";
+async function skill(_argv) {
+  const cwd = process.cwd();
+  await installSkill(cwd);
+}
+async function installSkill(projectDir) {
+  console.log(cyan3("Installing Towns Agent Skills..."));
+  try {
+    const success = await installTownsSkills(projectDir);
+    if (success) {
+      console.log(green3("\u2713"), "Towns Agent Skills installed successfully!");
+      console.log();
+      console.log("Skills have been installed to .claude/skills/ and .codex/skills/");
+      console.log("They will be available when you open this project in your AI assistant");
+    } else {
+      console.error(red3("Failed to install Towns Agent Skills"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(red3("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// src/modules/create.ts
+import { default as prompts3 } from "prompts";
+import { red as red4 } from "picocolors";
+import { createPublicClient, http } from "viem";
+import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
+import { relayerActions } from "@towns-labs/relayer-client";
+import {
+  createApp,
+  makeSignerContextFromBearerToken,
+  makeSignerContextFromViem,
+  townsEnv
+} from "@towns-labs/sdk";
+import { getAddressesWithFallback } from "@towns-labs/contracts/deployments";
+async function create(argv) {
+  let ownerPrivateKey = argv.ownerPrivateKey;
+  let bearerToken = argv.bearerToken;
+  if (!ownerPrivateKey && !bearerToken) {
+    const auth = await promptAuth();
+    if (!auth) {
+      console.error(red4("Authentication is required."));
+      process.exit(1);
+    }
+    if (auth.method === "privateKey") {
+      ownerPrivateKey = auth.value;
+    } else {
+      bearerToken = auth.value;
+    }
+  }
+  const username = argv.username ?? await promptText("Bot username");
+  if (!username) {
+    console.error(red4("Username is required."));
+    process.exit(1);
+  }
+  const displayName = argv.displayName ?? await promptText("Bot display name");
+  if (!displayName) {
+    console.error(red4("Display name is required."));
+    process.exit(1);
+  }
+  const description = argv.description ?? await promptText("Bot description");
+  if (!description) {
+    console.error(red4("Description is required."));
+    process.exit(1);
+  }
+  const imageUrl = argv.imageUrl ?? await promptText("Bot image URL (optional)", true);
+  const owner = ownerPrivateKey ? await makeSignerContextFromViem(
+    privateKeyToAccount(ownerPrivateKey),
+    generatePrivateKey(),
+    { days: 1 }
+  ) : await makeSignerContextFromBearerToken(bearerToken);
+  const townsConfig = townsEnv().makeTownsConfig();
+  const chainId = townsConfig.base.chainConfig.chainId;
+  const addresses = getAddressesWithFallback(townsConfig.environmentId, chainId);
+  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 relayerClient = createPublicClient({
+    chain: {
+      id: chainId,
+      name: "Local",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [townsConfig.base.rpcUrl] } }
+    },
+    transport: http(townsConfig.base.rpcUrl)
+  }).extend(relayerActions({ relayerUrl }));
+  const result = await createApp({
+    owner,
+    metadata: {
+      username,
+      displayName,
+      description,
+      imageUrl: imageUrl || ""
+    },
+    relayerClient,
+    accountProxy: addresses.accountProxy,
+    townsConfig
+  });
+  console.log(`APP_ADDRESS=${result.appAddress}`);
+  console.log(`APP_PRIVATE_KEY=${result.appPrivateKey}`);
+  console.log(`APP_PRIVATE_DATA=${result.appPrivateData}`);
+  console.log(`JWT_SECRET=${result.jwtSecretBase64}`);
+  process.exit(0);
+}
+async function promptText(message, optional = false) {
+  const { value } = await prompts3({
+    type: "text",
+    name: "value",
+    message,
+    validate: optional ? void 0 : (v) => v.trim() ? true : "This field is required"
+  });
+  return value;
+}
+
+// src/modules/metadata.ts
+import { default as prompts4 } from "prompts";
+import { red as red5, dim } from "picocolors";
+import { privateKeyToAccount as privateKeyToAccount2, generatePrivateKey as generatePrivateKey2 } from "viem/accounts";
+import {
+  AppRegistryService,
+  makeAppRegistryRpcClient,
+  makeSignerContextFromBearerToken as makeSignerContextFromBearerToken2,
+  makeSignerContextFromViem as makeSignerContextFromViem2,
+  townsEnv as townsEnv2
+} from "@towns-labs/sdk";
+import { bin_fromHexString } from "@towns-labs/utils";
+var FIELD_DEFS = [
+  { flag: "username", label: "USERNAME", mask: "username", prompt: "Username" },
+  { flag: "displayName", label: "DISPLAY_NAME", mask: "display_name", prompt: "Display name" },
+  { flag: "description", label: "DESCRIPTION", mask: "description", prompt: "Description" },
+  { flag: "imageUrl", label: "IMAGE_URL", mask: "image_url", prompt: "Image URL" },
+  { flag: "avatarUrl", label: "AVATAR_URL", mask: "avatar_url", prompt: "Avatar URL" },
+  {
+    flag: "externalUrl",
+    label: "EXTERNAL_URL",
+    mask: "external_url",
+    prompt: "External URL"
+  },
+  { flag: "motto", label: "MOTTO", mask: "motto", prompt: "Motto" }
+];
+async function metadata(argv) {
+  const subcommand = argv._[1];
+  const appAddress = argv._[2];
+  if (!subcommand || !["view", "update"].includes(subcommand)) {
+    console.error(red5("Usage: towns-agent metadata <view|update> <appAddress> [options]"));
+    process.exit(1);
+  }
+  if (!appAddress) {
+    console.error(red5("App address is required."));
+    process.exit(1);
+  }
+  const env = townsEnv2();
+  const townsConfig = env.makeTownsConfig();
+  const appRegistryUrl = env.getAppRegistryUrl(townsConfig.environmentId);
+  const appId = bin_fromHexString(appAddress);
+  if (subcommand === "view") {
+    const client = makeAppRegistryRpcClient(appRegistryUrl, "");
+    const { metadata: meta } = await client.getAppMetadata({ appId });
+    if (!meta) {
+      console.error(red5("No metadata found for this app."));
+      process.exit(1);
+    }
+    console.log();
+    for (const field of FIELD_DEFS) {
+      const value = meta[field.flag] ?? "";
+      console.log(`  ${dim(field.prompt.padEnd(14))} ${value || dim("\u2014")}`);
+    }
+    console.log();
+    process.exit(0);
+  }
+  let ownerPrivateKey = argv.ownerPrivateKey;
+  let bearerToken = ownerPrivateKey ? void 0 : argv.bearerToken;
+  if (!ownerPrivateKey && !bearerToken) {
+    const auth = await promptAuth();
+    if (!auth) {
+      console.error(red5("Authentication is required for update."));
+      process.exit(1);
+    }
+    if (auth.method === "privateKey") {
+      ownerPrivateKey = auth.value;
+    } else {
+      bearerToken = auth.value;
+    }
+  }
+  const signerContext = ownerPrivateKey ? await makeSignerContextFromViem2(
+    privateKeyToAccount2(ownerPrivateKey),
+    generatePrivateKey2(),
+    { days: 1 }
+  ) : await makeSignerContextFromBearerToken2(bearerToken);
+  const { appRegistryRpcClient } = await AppRegistryService.authenticate(
+    signerContext,
+    appRegistryUrl
+  );
+  const hasAnyFlag = FIELD_DEFS.some((f) => argv[f.flag] !== void 0);
+  let values;
+  if (hasAnyFlag) {
+    values = {};
+    for (const field of FIELD_DEFS) {
+      if (argv[field.flag] !== void 0) {
+        values[field.flag] = argv[field.flag];
+      }
+    }
+  } else {
+    const unauthClient = makeAppRegistryRpcClient(appRegistryUrl, "");
+    const { metadata: current } = await unauthClient.getAppMetadata({ appId });
+    values = {};
+    for (const field of FIELD_DEFS) {
+      const { value } = await prompts4({
+        type: "text",
+        name: "value",
+        message: field.prompt,
+        initial: current?.[field.flag] ?? ""
+      });
+      if (value === void 0) {
+        process.exit(1);
+      }
+      if (value !== (current?.[field.flag] ?? "")) {
+        values[field.flag] = value;
+      }
+    }
+    if (Object.keys(values).length === 0) {
+      console.log("No changes.");
+      process.exit(0);
+    }
+  }
+  const updateMask = [];
+  const metadataUpdate = {};
+  for (const field of FIELD_DEFS) {
+    if (values[field.flag] !== void 0) {
+      updateMask.push(field.mask);
+      metadataUpdate[field.flag] = values[field.flag];
+    }
+  }
+  await appRegistryRpcClient.updateAppMetadata({
+    appId,
+    updateMask,
+    metadata: metadataUpdate
+  });
+  for (const field of FIELD_DEFS) {
+    if (values[field.flag] !== void 0) {
+      console.log(`  ${dim(field.prompt.padEnd(14))} ${values[field.flag]}`);
+    }
+  }
+  console.log();
+  process.exit(0);
+}
+
+// src/modules/setup.ts
+import { default as prompts5 } from "prompts";
+import { red as red6, dim as dim2, green as green4 } from "picocolors";
+import { privateKeyToAccount as privateKeyToAccount3, generatePrivateKey as generatePrivateKey3 } from "viem/accounts";
+import {
+  AppRegistryService as AppRegistryService2,
+  makeSignerContextFromBearerToken as makeSignerContextFromBearerToken3,
+  makeSignerContextFromViem as makeSignerContextFromViem3,
+  townsEnv as townsEnv3
+} from "@towns-labs/sdk";
+import { ForwardSettingValue } from "@towns-labs/proto";
+import { bin_fromHexString as bin_fromHexString2 } from "@towns-labs/utils";
+var NOTIFY_MAP = {
+  ALL: ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES,
+  NONE: ForwardSettingValue.FORWARD_SETTING_NO_MESSAGES,
+  MENTION_REPLY_REACTION: ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS
+};
+var NOTIFY_LABELS = {
+  ALL: "All messages",
+  MENTION_REPLY_REACTION: "Mentions, replies & reactions",
+  NONE: "No messages"
+};
+async function setup(argv) {
+  const appAddress = argv._[1];
+  if (!appAddress) {
+    console.error(red6("Usage: towns-agent setup <appAddress> [options]"));
+    process.exit(1);
+  }
+  let ownerPrivateKey = argv.ownerPrivateKey;
+  let bearerToken = argv.bearerToken;
+  if (!ownerPrivateKey && !bearerToken) {
+    const auth = await promptAuth();
+    if (!auth) {
+      console.error(red6("Authentication is required."));
+      process.exit(1);
+    }
+    if (auth.method === "privateKey") {
+      ownerPrivateKey = auth.value;
+    } else {
+      bearerToken = auth.value;
+    }
+  }
+  const webhookUrl = argv.webhookUrl ?? await promptWebhookUrl();
+  if (!webhookUrl) {
+    console.error(red6("Webhook URL is required."));
+    process.exit(1);
+  }
+  let notifyKey;
+  if (argv.notify) {
+    notifyKey = argv.notify.toUpperCase();
+  } else if (argv.webhookUrl) {
+    notifyKey = "ALL";
+  } else {
+    notifyKey = await promptNotify();
+  }
+  const forwardSetting = NOTIFY_MAP[notifyKey];
+  if (forwardSetting === void 0) {
+    console.error(
+      red6(`Invalid --notify value: ${notifyKey}. Use ALL, NONE, or MENTION_REPLY_REACTION.`)
+    );
+    process.exit(1);
+  }
+  const env = townsEnv3();
+  const townsConfig = env.makeTownsConfig();
+  const appRegistryUrl = env.getAppRegistryUrl(townsConfig.environmentId);
+  const appId = bin_fromHexString2(appAddress);
+  const signerContext = ownerPrivateKey ? await makeSignerContextFromViem3(
+    privateKeyToAccount3(ownerPrivateKey),
+    generatePrivateKey3(),
+    { days: 1 }
+  ) : await makeSignerContextFromBearerToken3(bearerToken);
+  const { appRegistryRpcClient } = await AppRegistryService2.authenticate(
+    signerContext,
+    appRegistryUrl
+  );
+  await appRegistryRpcClient.registerWebhook({ appId, webhookUrl });
+  await appRegistryRpcClient.setAppSettings({
+    appId,
+    settings: { forwardSetting }
+  });
+  console.log();
+  console.log(green4("Setup complete!"));
+  console.log();
+  console.log(`  ${dim2("Webhook URL".padEnd(14))} ${webhookUrl}`);
+  console.log(`  ${dim2("Notify".padEnd(14))} ${NOTIFY_LABELS[notifyKey] ?? notifyKey}`);
+  console.log();
+  process.exit(0);
+}
+async function promptWebhookUrl() {
+  const { value } = await prompts5({
+    type: "text",
+    name: "value",
+    message: "Webhook URL",
+    validate: (v) => v.trim() ? true : "Webhook URL is required"
+  });
+  return value;
+}
+async function promptNotify() {
+  const { value } = await prompts5({
+    type: "select",
+    name: "value",
+    message: "Notify setting",
+    choices: [
+      { title: "All messages", value: "ALL" },
+      { title: "Mentions, replies & reactions", value: "MENTION_REPLY_REACTION" },
+      { title: "No messages", value: "NONE" }
+    ],
+    initial: 0
+  });
+  if (value === void 0) {
+    process.exit(1);
+  }
+  return value;
+}
+
+// src/parser.ts
+import minimist from "minimist";
+var COMMAND_CONFIGS = {
+  init: {
+    string: ["template"],
+    alias: { t: "template" },
+    default: { template: "quickstart" }
+  },
+  update: {
+    boolean: ["skipAgentsMd"],
+    alias: { "skip-agents-md": "skipAgentsMd" }
+  },
+  "install-skill": {},
+  create: {
+    string: [
+      "bearerToken",
+      "ownerPrivateKey",
+      "username",
+      "displayName",
+      "description",
+      "imageUrl"
+    ],
+    alias: {
+      b: "bearerToken",
+      k: "ownerPrivateKey",
+      u: "username",
+      n: "displayName",
+      d: "description",
+      i: "imageUrl"
+    }
+  },
+  metadata: {
+    string: [
+      "_",
+      "ownerPrivateKey",
+      "bearerToken",
+      "username",
+      "displayName",
+      "description",
+      "imageUrl",
+      "avatarUrl",
+      "externalUrl",
+      "motto"
+    ],
+    alias: {
+      k: "ownerPrivateKey",
+      b: "bearerToken",
+      u: "username",
+      n: "displayName",
+      d: "description",
+      i: "imageUrl",
+      a: "avatarUrl",
+      e: "externalUrl",
+      m: "motto"
+    }
+  },
+  setup: {
+    string: ["_", "ownerPrivateKey", "bearerToken", "webhookUrl", "notify"],
+    alias: {
+      k: "ownerPrivateKey",
+      b: "bearerToken",
+      w: "webhookUrl"
+    }
+  }
+};
+function parseArgs(args) {
+  const initial = minimist(args, {
+    stopEarly: true,
+    boolean: ["help"],
+    alias: { h: "help" }
+  });
+  const command = initial._[0];
+  if (!command || initial.help) {
+    return initial;
+  }
+  const commandConfig = COMMAND_CONFIGS[command] || {};
+  const booleanOptions = Array.isArray(commandConfig.boolean) ? ["help", ...commandConfig.boolean] : ["help"];
+  const parsed = minimist(args, {
+    ...commandConfig,
+    boolean: booleanOptions,
+    alias: {
+      ...commandConfig.alias,
+      h: "help"
+    }
+  });
+  return parsed;
+}
+function isInitArgs(args) {
+  return args._[0] === "init";
+}
+function isUpdateArgs(args) {
+  return args._[0] === "update";
+}
+function isSkillArgs(args) {
+  return args._[0] === "install-skill";
+}
+function isCreateArgs(args) {
+  return args._[0] === "create";
+}
+function isMetadataArgs(args) {
+  return args._[0] === "metadata";
+}
+function isSetupArgs(args) {
+  return args._[0] === "setup";
+}
+
+// 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];
+  if (args.help || !command) {
+    showHelp();
+    return;
+  }
+  try {
+    switch (command) {
+      case "init":
+        if (isInitArgs(args)) {
+          await init(args);
+        }
+        break;
+      case "update":
+        if (isUpdateArgs(args)) {
+          await update(args);
+        }
+        break;
+      case "install-skill":
+        if (isSkillArgs(args)) {
+          await skill(args);
+        }
+        break;
+      case "create":
+        if (isCreateArgs(args)) {
+          await create(args);
+        }
+        break;
+      case "metadata":
+        if (isMetadataArgs(args)) {
+          await metadata(args);
+        }
+        break;
+      case "setup":
+        if (isSetupArgs(args)) {
+          await setup(args);
+        }
+        break;
+      default:
+        console.error(red7(`Unknown command: ${command}`));
+        showHelp();
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(red7("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+function showHelp() {
+  console.log(`
+${cyan4("towns-agent")} - CLI for creating and managing Towns Protocol agent projects
+
+${yellow3("Usage:")}
+  towns-agent <command> [options]
+
+${yellow3("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("update")}                  Update @towns-labs dependencies and skills
+  ${green5("install-skill")}           Install Towns Agent Skills to current project
+
+${yellow3("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:")}
+  -f, --file <path>        Path to commands file
+
+${yellow3("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:")}
+  -h, --help               Show this help message
+
+${yellow3("Examples:")}
+  ${cyan4("# Create a new agent project")}
+  towns-agent init my-agent
+  towns-agent init my-ai-agent --template quickstart
+
+  ${cyan4("# Update dependencies")}
+  towns-agent update
+`);
+}
+main().catch((error) => {
+  console.error(red7("Unexpected error:"), error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.mjs.map