@wiimdy/openfunderse 0.1.1 → 0.1.3

package/README.md

@@ -15,9 +15,20 @@ npx @wiimdy/openfunderse@latest list
 # install pack into ~/.codex/skills
 npx @wiimdy/openfunderse@latest install openfunderse
 
+# install strategy-only pack
+npx @wiimdy/openfunderse@latest install openfunderse-strategy
+
+# install participant-only pack
+npx @wiimdy/openfunderse@latest install openfunderse-participant
+
 # install pack + runtime package in one command (recommended)
 npx @wiimdy/openfunderse@latest install openfunderse --with-runtime
 
+# install pack + runtime + strategy env scaffold in one command
+npx @wiimdy/openfunderse@latest install openfunderse \
+  --with-runtime \
+  --env-profile strategy
+
 # install into custom codex home
 npx @wiimdy/openfunderse@latest install openfunderse --codex-home /custom/.codex
 
@@ -25,6 +36,16 @@ npx @wiimdy/openfunderse@latest install openfunderse --codex-home /custom/.codex
 npx @wiimdy/openfunderse@latest install openfunderse \
   --with-runtime \
   --runtime-dir /path/to/project
+
+# initialize bot env + fresh Monad wallet (strategy)
+npx @wiimdy/openfunderse@latest bot-init \
+  --skill-name strategy \
+  --yes
+
+# initialize participant bot env + wallet
+npx @wiimdy/openfunderse@latest bot-init \
+  --skill-name participant \
+  --yes
 ```
 
 ## Notes
@@ -33,5 +54,23 @@ npx @wiimdy/openfunderse@latest install openfunderse \
 - Pack metadata/prompts are copied into `$CODEX_HOME/packs/<pack-name>`.
 - Use `--force` to overwrite existing installed skills.
 - `--with-runtime` installs `@wiimdy/openfunderse-agents` into the current project (`package.json` required).
+- Env scaffold generation is enabled by default (default path: `.env`).
+- `--env-profile` controls scaffold scope: `strategy` | `participant` | `all` (auto-selected by pack when omitted).
+- Use `--no-init-env` to skip env scaffold generation.
+- `--env-path` sets a custom env scaffold path.
 - Optional: `--runtime-package`, `--runtime-dir`, `--runtime-manager`.
-- Default unified bundle is `clawbot-core` (strategy + participant role actions).
+- Available packs: `openfunderse` (unified), `openfunderse-strategy`, `openfunderse-participant`.
+- Split packs (`openfunderse-strategy`, `openfunderse-participant`) are intentionally minimal and centered on the skill payload.
+- Prefer `--env-path` (Node 20+ reserves `--env-file` as a runtime flag).
+- `bot-init` uses `cast wallet new --json` (Foundry) to generate a new wallet for Monad testnet.
+- `bot-init` infers role from `--skill-name`, `--env-path`, or `--wallet-name` when `--role` is omitted.
+- `bot-init` writes to `.env` by default. Use `--env-path` to split strategy/participant env files.
+- It also infers from active skill env hints (`OPENCLAW_SKILL_KEY`, `OPENCLAW_ACTIVE_SKILL`, `SKILL_KEY`, `SKILL_NAME`).
+- `bot-init` writes role-specific key fields:
+  - `strategy`: `STRATEGY_PRIVATE_KEY`, `BOT_ADDRESS`
+  - `participant`: `PARTICIPANT_PRIVATE_KEY`, `PARTICIPANT_BOT_ADDRESS`, `BOT_ADDRESS`
+- `bot-init` stores a wallet backup JSON under `$CODEX_HOME/openfunderse/wallets`.
+- Generated scaffolds include a temporary bootstrap key value. It is public/unsafe and must be rotated via `bot-init` before funding.
+- `bot-init` shows a warning and requires confirmation (`Type YES`) unless `--yes` is passed.
+- If private key already exists in the target env file, `bot-init` requires `--force` to rotate.
+- CLI cannot mutate your parent shell env directly; run the printed `set -a; source ...; set +a` command.

package/bin/openfunderse.mjs

@@ -2,29 +2,85 @@
 
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 
 const THIS_FILE = fileURLToPath(import.meta.url);
 const PACKAGE_ROOT = path.resolve(path.dirname(THIS_FILE), "..");
 const PACKS_ROOT = path.join(PACKAGE_ROOT, "packs");
 const DEFAULT_RUNTIME_PACKAGE = "@wiimdy/openfunderse-agents";
+const SUPPORTED_ENV_PROFILES = new Set(["strategy", "participant", "all"]);
+const SUPPORTED_BOT_INIT_ROLES = new Set(["strategy", "participant"]);
+const DEFAULT_MONAD_CHAIN_ID = "10143";
+const TEMP_PRIVATE_KEY = "0x1111111111111111111111111111111111111111111111111111111111111111";
+
+const STRATEGY_ENV_TEMPLATE = `# OpenFunderse strategy env scaffold
+# Copy values from your relayer + deployed contracts.
+
+RELAYER_URL=https://your-relayer.example.com
+BOT_ID=bot-strategy-1
+BOT_API_KEY=replace_me
+BOT_ADDRESS=0x0000000000000000000000000000000000000000
+CHAIN_ID=10143
+RPC_URL=https://testnet-rpc.monad.xyz
+
+# NadFun / protocol addresses
+INTENT_BOOK_ADDRESS=0x0000000000000000000000000000000000000000
+NADFUN_EXECUTION_ADAPTER_ADDRESS=0x0000000000000000000000000000000000000000
+VAULT_ADDRESS=0x0000000000000000000000000000000000000000
+NADFUN_LENS_ADDRESS=0x0000000000000000000000000000000000000000
+NADFUN_BONDING_CURVE_ROUTER=0x0000000000000000000000000000000000000000
+NADFUN_DEX_ROUTER=0x0000000000000000000000000000000000000000
+NADFUN_WMON_ADDRESS=0x0000000000000000000000000000000000000000
+
+# Strategy signer (EOA)
+# Temporary bootstrap key (public and unsafe). Replace via bot-init before real usage.
+STRATEGY_PRIVATE_KEY=${TEMP_PRIVATE_KEY}
+# STRATEGY_CREATE_MIN_SIGNER_BALANCE_WEI=10000000000000000
+
+# Safety defaults
+STRATEGY_REQUIRE_EXPLICIT_SUBMIT=true
+STRATEGY_AUTO_SUBMIT=false
+# STRATEGY_TRUSTED_RELAYER_HOSTS=openfunderse-relayer.example.com
+# STRATEGY_ALLOW_HTTP_RELAYER=true
+`;
+
+const PARTICIPANT_ENV_TEMPLATE = `# OpenFunderse participant env scaffold
+RELAYER_URL=https://your-relayer.example.com
+BOT_ID=bot-participant-1
+BOT_API_KEY=replace_me
+BOT_ADDRESS=0x0000000000000000000000000000000000000000
+CHAIN_ID=10143
+# Temporary bootstrap key (public and unsafe). Replace via bot-init before real usage.
+PARTICIPANT_PRIVATE_KEY=${TEMP_PRIVATE_KEY}
+CLAIM_ATTESTATION_VERIFIER_ADDRESS=0x0000000000000000000000000000000000000000
+PARTICIPANT_REQUIRE_EXPLICIT_SUBMIT=true
+PARTICIPANT_AUTO_SUBMIT=false
+# PARTICIPANT_TRUSTED_RELAYER_HOSTS=openfunderse-relayer.example.com
+# PARTICIPANT_ALLOW_HTTP_RELAYER=true
+`;
 
 function printUsage() {
   console.log(`openfunderse
 
 Usage:
   openfunderse list
+  openfunderse bot-init [--role <strategy|participant>] [--skill-name <name>] [--env-path <path>] [--wallet-dir <dir>] [--wallet-name <name>] [--force] [--yes]
   openfunderse install <pack-name> [--dest <skills-dir>] [--codex-home <dir>] [--force] [--with-runtime]
+                     [--no-init-env] [--env-path <path>] [--env-profile <strategy|participant|all>]
                      [--runtime-package <name>] [--runtime-dir <dir>] [--runtime-manager <npm|pnpm|yarn|bun>]
 
 Examples:
   openfunderse list
   openfunderse install openfunderse
   openfunderse install openfunderse --with-runtime
+  openfunderse install openfunderse-strategy --with-runtime
   openfunderse install openfunderse --codex-home /tmp/codex-home
+  openfunderse bot-init --skill-name participant --wallet-name participant-bot --yes
+  openfunderse bot-init --skill-name strategy --force
 `);
 }
 
@@ -36,9 +92,19 @@ function parseArgs(argv) {
     dest: "",
     codexHome: "",
     withRuntime: false,
+    initEnv: true,
+    initEnvExplicit: false,
+    envFile: "",
+    envProfile: "",
+    envProfileExplicit: false,
     runtimePackage: "",
     runtimeDir: "",
-    runtimeManager: ""
+    runtimeManager: "",
+    role: "",
+    skillName: "",
+    walletDir: "",
+    walletName: "",
+    yes: false
   };
   const positionals = [];
 
@@ -52,6 +118,10 @@ function parseArgs(argv) {
       options.force = true;
       continue;
     }
+    if (token === "--yes") {
+      options.yes = true;
+      continue;
+    }
     if (token === "--dest") {
       options.dest = args[i + 1] ?? "";
       i += 1;
@@ -66,6 +136,27 @@ function parseArgs(argv) {
       options.withRuntime = true;
       continue;
     }
+    if (token === "--init-env") {
+      options.initEnv = true;
+      options.initEnvExplicit = true;
+      continue;
+    }
+    if (token === "--no-init-env") {
+      options.initEnv = false;
+      options.initEnvExplicit = true;
+      continue;
+    }
+    if (token === "--env-file" || token === "--env-path") {
+      options.envFile = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--env-profile") {
+      options.envProfile = args[i + 1] ?? "";
+      options.envProfileExplicit = true;
+      i += 1;
+      continue;
+    }
     if (token === "--runtime-package") {
       options.runtimePackage = args[i + 1] ?? "";
       i += 1;
@@ -81,6 +172,26 @@ function parseArgs(argv) {
       i += 1;
       continue;
     }
+    if (token === "--role") {
+      options.role = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--skill-name") {
+      options.skillName = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--wallet-dir") {
+      options.walletDir = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--wallet-name") {
+      options.walletName = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
     if (token.startsWith("--")) {
       throw new Error(`unknown option: ${token}`);
     }
@@ -120,6 +231,403 @@ async function listPacks() {
   }
 }
 
+function normalizeEnvProfile(rawProfile) {
+  const profile = (rawProfile || "").trim().toLowerCase();
+  if (SUPPORTED_ENV_PROFILES.has(profile)) {
+    return profile;
+  }
+  throw new Error(
+    `invalid --env-profile value: ${rawProfile} (expected strategy|participant|all)`
+  );
+}
+
+function defaultEnvProfileForPack(packName) {
+  const normalized = String(packName || "").trim().toLowerCase();
+  if (normalized.includes("participant")) {
+    return "participant";
+  }
+  if (normalized.includes("strategy")) {
+    return "strategy";
+  }
+  return "all";
+}
+
+function normalizeBotInitRole(rawRole) {
+  const role = (rawRole || "").trim().toLowerCase();
+  if (SUPPORTED_BOT_INIT_ROLES.has(role)) {
+    return role;
+  }
+  throw new Error(
+    `invalid --role value: ${rawRole} (expected strategy|participant)`
+  );
+}
+
+function inferRoleFromHint(hint) {
+  const normalized = (hint || "").trim().toLowerCase();
+  if (!normalized) return "";
+  if (normalized.includes("participant")) return "participant";
+  if (normalized.includes("strategy")) return "strategy";
+  return "";
+}
+
+function resolveBotInitRole(options) {
+  if (options.role && options.role.trim().length > 0) {
+    return normalizeBotInitRole(options.role);
+  }
+
+  const envSkillHints = [
+    process.env.OPENCLAW_SKILL_KEY,
+    process.env.OPENCLAW_ACTIVE_SKILL,
+    process.env.SKILL_KEY,
+    process.env.SKILL_NAME
+  ];
+
+  const hints = [
+    options.skillName,
+    options.envFile ? path.basename(options.envFile) : "",
+    options.walletName,
+    ...envSkillHints
+  ].filter((entry) => Boolean(entry && entry.trim().length > 0));
+
+  const inferredRoles = new Set();
+  for (const hint of hints) {
+    const inferred = inferRoleFromHint(hint);
+    if (inferred) {
+      inferredRoles.add(inferred);
+    }
+  }
+
+  if (inferredRoles.size === 1) {
+    return [...inferredRoles][0];
+  }
+
+  if (inferredRoles.size > 1) {
+    throw new Error(
+      "conflicting role hints found. pass explicit --role <strategy|participant>."
+    );
+  }
+
+  throw new Error(
+    "cannot infer bot role. pass --role or include strategy/participant in --skill-name, --env-path, --wallet-name, or OPENCLAW_SKILL_KEY."
+  );
+}
+
+function runtimeEnvExamplePath(runtimeDir, runtimePackage) {
+  return path.join(runtimeDir, "node_modules", ...runtimePackage.split("/"), ".env.example");
+}
+
+async function buildEnvScaffold(profile, runtimeDir, runtimePackage) {
+  if (profile === "strategy") {
+    return STRATEGY_ENV_TEMPLATE;
+  }
+  if (profile === "participant") {
+    return PARTICIPANT_ENV_TEMPLATE;
+  }
+
+  const runtimeTemplate = runtimeEnvExamplePath(runtimeDir, runtimePackage);
+  if (existsSync(runtimeTemplate)) {
+    return readFile(runtimeTemplate, "utf8");
+  }
+
+  return `${STRATEGY_ENV_TEMPLATE}\n\n${PARTICIPANT_ENV_TEMPLATE}`;
+}
+
+async function writeEnvScaffold(options) {
+  const runtimeDir = options.runtimeDir ? path.resolve(options.runtimeDir) : process.cwd();
+  const runtimePackage = options.runtimePackage || DEFAULT_RUNTIME_PACKAGE;
+  const rawProfile =
+    typeof options.envProfile === "string" && options.envProfile.trim().length > 0
+      ? options.envProfile
+      : "all";
+  const profile = normalizeEnvProfile(rawProfile);
+  const envTarget = options.envFile
+    ? path.resolve(options.envFile)
+    : path.join(runtimeDir, ".env");
+
+  const alreadyExists = existsSync(envTarget);
+  if (alreadyExists && !options.force) {
+    return {
+      written: false,
+      envFile: envTarget,
+      profile
+    };
+  }
+
+  if (alreadyExists && options.force) {
+    await rm(envTarget, { force: true });
+  }
+
+  const scaffold = await buildEnvScaffold(profile, runtimeDir, runtimePackage);
+  await mkdir(path.dirname(envTarget), { recursive: true });
+  await writeFile(envTarget, scaffold.endsWith("\n") ? scaffold : `${scaffold}\n`);
+
+  return {
+    written: true,
+    envFile: envTarget,
+    profile
+  };
+}
+
+function defaultEnvPathForRole(role) {
+  return path.join(process.cwd(), ".env");
+}
+
+function readAssignedEnvValue(content, key) {
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+    if (!match) continue;
+    if (match[1] !== key) continue;
+    return match[2];
+  }
+  return "";
+}
+
+function isPlaceholderEnvValue(value) {
+  const normalized = (value || "").trim();
+  if (!normalized) return true;
+  if (normalized === "replace_me") return true;
+  if (normalized.toLowerCase() === TEMP_PRIVATE_KEY.toLowerCase()) return true;
+  if (/^0xYOUR_/i.test(normalized)) return true;
+  if (/^YOUR_/i.test(normalized)) return true;
+  if (/^0x0+$/i.test(normalized)) return true;
+  if (normalized === "0x0000000000000000000000000000000000000000") return true;
+  return false;
+}
+
+function upsertEnvValues(content, updates) {
+  const lines = content.split(/\r?\n/);
+  const applied = new Set();
+
+  const patched = lines.map((line) => {
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+    if (!match) return line;
+    const key = match[1];
+    if (!(key in updates)) return line;
+    applied.add(key);
+    return `${key}=${updates[key]}`;
+  });
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (applied.has(key)) continue;
+    patched.push(`${key}=${value}`);
+  }
+
+  return `${patched.join("\n").replace(/\n+$/g, "")}\n`;
+}
+
+function shellQuote(input) {
+  return `'${input.replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCommandCapture(cmd, args, cwd = process.cwd()) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+
+    const stdout = [];
+    const stderr = [];
+
+    child.stdout.on("data", (chunk) => {
+      stdout.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr.push(chunk);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve({
+          stdout: Buffer.concat(stdout).toString("utf8"),
+          stderr: Buffer.concat(stderr).toString("utf8")
+        });
+        return;
+      }
+      const stderrText = Buffer.concat(stderr).toString("utf8").trim();
+      reject(
+        new Error(
+          `command failed: ${cmd} ${args.join(" ")} (exit ${code})${stderrText ? ` - ${stderrText}` : ""}`
+        )
+      );
+    });
+  });
+}
+
+async function confirmBotInit({ role, envFile, privateKeyKey, isRotation, assumeYes }) {
+  const mode = isRotation ? "wallet rotation" : "new wallet bootstrap";
+  console.log("WARNING: bot-init will generate a new wallet and update your env private key.");
+  console.log(`- Mode: ${mode}`);
+  console.log(`- Role: ${role}`);
+  console.log(`- Env file: ${envFile}`);
+  console.log(`- Key field: ${privateKeyKey}`);
+  console.log("- Existing funds tied to old key are not moved automatically.");
+
+  if (assumeYes) {
+    return;
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("bot-init requires confirmation in TTY. Re-run with --yes to confirm non-interactively.");
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question("Type YES to continue: ");
+    if (answer.trim().toUpperCase() !== "YES") {
+      throw new Error("bot-init cancelled by user.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function generateMonadWalletWithCast() {
+  let output;
+  try {
+    output = await runCommandCapture("cast", ["wallet", "new", "--json"]);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("ENOENT")) {
+      throw new Error(
+        "cast is not installed. Install Foundry first (https://book.getfoundry.sh/getting-started/installation)."
+      );
+    }
+    throw error;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(output.stdout);
+  } catch {
+    throw new Error(`failed to parse cast output as JSON: ${output.stdout}`);
+  }
+
+  const first = Array.isArray(parsed) ? parsed[0] : parsed;
+  const address = String(first?.address ?? "");
+  const privateKey = String(first?.private_key ?? first?.privateKey ?? "");
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    throw new Error(`invalid wallet address from cast: ${address}`);
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(privateKey)) {
+    throw new Error("invalid private key from cast output");
+  }
+
+  return {
+    address,
+    privateKey
+  };
+}
+
+function roleEnvUpdates(role, wallet) {
+  if (role === "strategy") {
+    return {
+      CHAIN_ID: DEFAULT_MONAD_CHAIN_ID,
+      STRATEGY_PRIVATE_KEY: wallet.privateKey,
+      BOT_ADDRESS: wallet.address
+    };
+  }
+  return {
+    CHAIN_ID: DEFAULT_MONAD_CHAIN_ID,
+    PARTICIPANT_PRIVATE_KEY: wallet.privateKey,
+    PARTICIPANT_BOT_ADDRESS: wallet.address,
+    BOT_ADDRESS: wallet.address
+  };
+}
+
+async function persistWallet(role, wallet, options) {
+  const walletDir = options.walletDir
+    ? path.resolve(options.walletDir)
+    : path.join(defaultCodexHome(), "openfunderse", "wallets");
+  const timestamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+$/, "");
+  const rawName = (options.walletName || `${role}-${timestamp}`).trim();
+  if (!rawName) {
+    throw new Error("--wallet-name must not be empty");
+  }
+  if (rawName.includes("/") || rawName.includes("\\")) {
+    throw new Error("--wallet-name must be a file name, not a path");
+  }
+  const fileName = rawName.endsWith(".json") ? rawName : `${rawName}.json`;
+  const walletPath = path.join(walletDir, fileName);
+  if (existsSync(walletPath) && !options.force) {
+    throw new Error(`wallet file already exists: ${walletPath} (use --force to overwrite)`);
+  }
+
+  const payload = {
+    createdAt: new Date().toISOString(),
+    role,
+    chainId: DEFAULT_MONAD_CHAIN_ID,
+    address: wallet.address,
+    privateKey: wallet.privateKey
+  };
+  await mkdir(walletDir, { recursive: true, mode: 0o700 });
+  await writeFile(walletPath, `${JSON.stringify(payload, null, 2)}\n`, {
+    mode: 0o600
+  });
+  await chmod(walletPath, 0o600);
+  return walletPath;
+}
+
+function assertPrivateKeyRotationAllowed(envContent, role, force) {
+  const privateKeyKey = role === "strategy" ? "STRATEGY_PRIVATE_KEY" : "PARTICIPANT_PRIVATE_KEY";
+  const existing = readAssignedEnvValue(envContent, privateKeyKey);
+  if (!existing) return;
+  if (isPlaceholderEnvValue(existing)) return;
+  if (force) return;
+  throw new Error(
+    `${privateKeyKey} already has a value. bot-init creates a new wallet and will replace it; rerun with --force to rotate.`
+  );
+}
+
+async function runBotInit(options) {
+  const role = resolveBotInitRole(options);
+  const envFile = options.envFile ? path.resolve(options.envFile) : defaultEnvPathForRole(role);
+  const runtimeDir = options.runtimeDir ? path.resolve(options.runtimeDir) : process.cwd();
+  const runtimePackage = options.runtimePackage || DEFAULT_RUNTIME_PACKAGE;
+
+  let envContent;
+  if (existsSync(envFile)) {
+    envContent = await readFile(envFile, "utf8");
+  } else {
+    envContent = await buildEnvScaffold(role, runtimeDir, runtimePackage);
+  }
+
+  const privateKeyKey = role === "strategy" ? "STRATEGY_PRIVATE_KEY" : "PARTICIPANT_PRIVATE_KEY";
+  const existingPrivateKey = readAssignedEnvValue(envContent, privateKeyKey);
+  const isRotation = Boolean(existingPrivateKey) && !isPlaceholderEnvValue(existingPrivateKey);
+
+  assertPrivateKeyRotationAllowed(envContent, role, options.force);
+  await confirmBotInit({
+    role,
+    envFile,
+    privateKeyKey,
+    isRotation,
+    assumeYes: options.yes
+  });
+
+  const wallet = await generateMonadWalletWithCast();
+  const walletPath = await persistWallet(role, wallet, options);
+  const updates = roleEnvUpdates(role, wallet);
+  const nextEnvContent = upsertEnvValues(envContent, updates);
+
+  await mkdir(path.dirname(envFile), { recursive: true });
+  await writeFile(envFile, nextEnvContent);
+  await chmod(envFile, 0o600);
+  const sourceCommand = `set -a; source ${shellQuote(envFile)}; set +a`;
+
+  console.log(`Initialized ${role} bot wallet for Monad testnet (${DEFAULT_MONAD_CHAIN_ID}).`);
+  console.log(`Address: ${wallet.address}`);
+  console.log(`Env file updated: ${envFile}`);
+  console.log(`Wallet backup (keep secret): ${walletPath}`);
+  console.log(`Load env now: ${sourceCommand}`);
+}
+
 async function loadManifest(packDir) {
   const candidates = [
     path.join(packDir, "manifest.json"),
@@ -271,6 +779,20 @@ async function installPack(packName, options) {
     runtimeInstallMeta = await installRuntimePackage(options);
   }
 
+  let envScaffoldMeta = null;
+  if (options.initEnv) {
+    const resolvedEnvProfile = options.envProfileExplicit
+      ? options.envProfile
+      : defaultEnvProfileForPack(packName);
+    const envOptions = {
+      ...options,
+      envProfile: resolvedEnvProfile,
+      runtimeDir: runtimeInstallMeta?.runtimeDir ?? options.runtimeDir,
+      runtimePackage: runtimeInstallMeta?.runtimePackage ?? options.runtimePackage
+    };
+    envScaffoldMeta = await writeEnvScaffold(envOptions);
+  }
+
   console.log(`Installed pack: ${packName}`);
   console.log(`Skills root: ${skillsRoot}`);
   console.log(`Installed skills: ${installed.join(", ")}`);
@@ -281,6 +803,15 @@ async function installPack(packName, options) {
     );
     console.log(`Runtime install dir: ${runtimeInstallMeta.runtimeDir}`);
   }
+  if (envScaffoldMeta) {
+    if (envScaffoldMeta.written) {
+      console.log(`Generated env scaffold (${envScaffoldMeta.profile}): ${envScaffoldMeta.envFile}`);
+    } else {
+      console.log(
+        `Env scaffold already exists (use --force to overwrite): ${envScaffoldMeta.envFile}`
+      );
+    }
+  }
   console.log("Restart Codex to pick up new skills.");
 }
 
@@ -306,6 +837,11 @@ async function main() {
     return;
   }
 
+  if (command === "bot-init") {
+    await runBotInit(options);
+    return;
+  }
+
   throw new Error(`unknown command: ${command}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiimdy/openfunderse",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Install OpenFunderse skill packs into Codex",
   "type": "module",
   "bin": {