@terminusagents/agents 0.1.2 → 0.1.3

package/README.md

@@ -53,6 +53,8 @@ npx terminus-agent init
 `init` uses production-safe defaults:
 - testnet: `wss://cp-sepolia.termn.xyz/ws`
 - mainnet: `wss://cp-mainnet.termn.xyz/ws`
+- if `TERMINUS_WALLET_PRIVATE_KEY` is set, wallet is derived automatically
+- if your wallet already has a Terminus identity NFT, agent type is auto-detected from chain
 
 3. Export required runtime secrets:
 
@@ -89,8 +91,6 @@ npx terminus-agent init \
   --yes \
   --force \
   --profile testnet \
-  --agent-type travel-planner \
-  --wallet 0x1234567890abcdef1234567890abcdef12345678 \
   --llm-provider openai \
   --llm-model gpt-4o-mini
 ```

package/dist/cli/init.js

@@ -3,6 +3,7 @@
 // =============================================================================
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import { ethers } from 'ethers';
 import { saveConfig, generateNodeId, getConfigPath, configExists, loadConfig } from '../config/store.js';
 import { checkOllamaAvailable, listOllamaModels } from '../llm/provider.js';
 import { AGENTS } from '../agents/index.js';
@@ -44,6 +45,15 @@ const NETWORK_LABELS = {
 };
 const DEFAULT_TESTNET_CONTROL_PLANE_URL = 'wss://cp-sepolia.termn.xyz/ws';
 const DEFAULT_MAINNET_CONTROL_PLANE_URL = 'wss://cp-mainnet.termn.xyz/ws';
+const DEFAULT_TESTNET_REGISTRY_CONTRACT = '0x1439F2c1Fb1B3F99efe2aB02A90B377BaE5D2B02';
+const DEFAULT_TESTNET_RPC_URL = 'https://sepolia.base.org';
+const DEFAULT_MAINNET_RPC_URL = 'https://mainnet.base.org';
+const AGENT_IDENTITY_REGISTRY_ABI = [
+    'function balanceOf(address owner) view returns (uint256)',
+    'function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)',
+    'function getAgentType(uint256 tokenId) view returns (string)',
+    'function getCollectionTokenId(uint256 tokenId) view returns (uint256)',
+];
 const NETWORK_URL_PRESETS = {
     local: process.env.TERMINUS_CONTROL_PLANE_URL_LOCAL?.trim() || 'ws://localhost:8084/ws',
     testnet: process.env.TERMINUS_CONTROL_PLANE_URL_TESTNET?.trim() ||
@@ -183,6 +193,145 @@ function providerDefaultModel(provider) {
         return 'claude-3-5-haiku-latest';
     return 'gemini-2.0-flash';
 }
+function getWalletFromRuntimePrivateKey() {
+    const privateKey = process.env.TERMINUS_WALLET_PRIVATE_KEY?.trim();
+    if (!privateKey)
+        return undefined;
+    try {
+        const normalizedPk = privateKey.startsWith('0x') ? privateKey : `0x${privateKey}`;
+        return new ethers.Wallet(normalizedPk).address;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveRegistryAddress(profile) {
+    if (profile === 'testnet') {
+        const candidate = (process.env.TERMINUS_AGENT_IDENTITY_REGISTRY_CONTRACT_TESTNET?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT_TESTNET?.trim()
+            || process.env.NEXT_PUBLIC_SEPOLIA_REGISTRY_CONTRACT?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT?.trim()
+            || DEFAULT_TESTNET_REGISTRY_CONTRACT);
+        return isValidWallet(candidate) ? candidate : undefined;
+    }
+    if (profile === 'mainnet') {
+        const candidate = (process.env.TERMINUS_AGENT_IDENTITY_REGISTRY_CONTRACT_MAINNET?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT_MAINNET?.trim()
+            || process.env.NEXT_PUBLIC_MAINNET_REGISTRY_CONTRACT?.trim()
+            || process.env.AGENT_IDENTITY_REGISTRY_CONTRACT?.trim());
+        return candidate && isValidWallet(candidate) ? candidate : undefined;
+    }
+    return undefined;
+}
+function resolveRpcUrl(profile) {
+    if (profile === 'testnet') {
+        return (process.env.TERMINUS_BASE_SEPOLIA_RPC?.trim()
+            || process.env.BASE_SEPOLIA_RPC?.trim()
+            || DEFAULT_TESTNET_RPC_URL);
+    }
+    if (profile === 'mainnet') {
+        return (process.env.TERMINUS_BASE_MAINNET_RPC?.trim()
+            || process.env.BASE_MAINNET_RPC?.trim()
+            || DEFAULT_MAINNET_RPC_URL);
+    }
+    return undefined;
+}
+function resolveRequiredCollectionTokenId(profile) {
+    if (profile === 'testnet') {
+        return (process.env.TERMINUS_COLLECTION_TOKEN_ID_TESTNET?.trim()
+            || process.env.NEXT_PUBLIC_SEPOLIA_COLLECTION_TOKEN_ID?.trim()
+            || process.env.TERMINUS_COLLECTION_TOKEN_ID?.trim()
+            || undefined);
+    }
+    if (profile === 'mainnet') {
+        return (process.env.TERMINUS_COLLECTION_TOKEN_ID_MAINNET?.trim()
+            || process.env.NEXT_PUBLIC_MAINNET_COLLECTION_TOKEN_ID?.trim()
+            || process.env.TERMINUS_COLLECTION_TOKEN_ID?.trim()
+            || undefined);
+    }
+    return undefined;
+}
+async function detectAgentIdentitiesFromChain(profile, wallet) {
+    const registryAddress = resolveRegistryAddress(profile);
+    const rpcUrl = resolveRpcUrl(profile);
+    if (!registryAddress || !rpcUrl || profile === 'local') {
+        return { identities: [], registryAddress, rpcUrl };
+    }
+    const requiredCollectionTokenId = resolveRequiredCollectionTokenId(profile);
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const contract = new ethers.Contract(registryAddress, AGENT_IDENTITY_REGISTRY_ABI, provider);
+    const balance = await contract.balanceOf(wallet);
+    if (balance === 0n) {
+        return { identities: [], registryAddress, rpcUrl };
+    }
+    const identities = [];
+    for (let i = 0n; i < balance; i++) {
+        const tokenId = await contract.tokenOfOwnerByIndex(wallet, i);
+        const agentTypeRaw = await contract.getAgentType(tokenId);
+        const agentType = agentTypeRaw.trim();
+        if (!AGENTS.some((agent) => agent.id === agentType)) {
+            continue;
+        }
+        let collectionTokenId;
+        try {
+            const rawCollectionTokenId = await contract.getCollectionTokenId(tokenId);
+            collectionTokenId = rawCollectionTokenId.toString();
+        }
+        catch {
+            collectionTokenId = undefined;
+        }
+        if (requiredCollectionTokenId && collectionTokenId && collectionTokenId !== requiredCollectionTokenId) {
+            continue;
+        }
+        identities.push({
+            tokenId: tokenId.toString(),
+            agentType,
+            collectionTokenId,
+        });
+    }
+    identities.sort((a, b) => {
+        const tokenA = BigInt(a.tokenId);
+        const tokenB = BigInt(b.tokenId);
+        if (tokenA < tokenB)
+            return -1;
+        if (tokenA > tokenB)
+            return 1;
+        return 0;
+    });
+    return { identities, registryAddress, rpcUrl };
+}
+async function autoSelectAgentType(profile, wallet, nonInteractive) {
+    if (profile === 'local') {
+        return {};
+    }
+    try {
+        const { identities } = await detectAgentIdentitiesFromChain(profile, wallet);
+        if (identities.length === 0) {
+            return {};
+        }
+        if (identities.length === 1 || nonInteractive) {
+            return { agentType: identities[0].agentType, identity: identities[0] };
+        }
+        const { selectedTokenId } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedTokenId',
+                message: 'Multiple agent identities detected. Select one:',
+                choices: identities.map((item) => ({
+                    name: `${item.agentType} ${chalk.gray(`(tokenId=${item.tokenId}${item.collectionTokenId ? `, collection=${item.collectionTokenId}` : ''})`)}`,
+                    value: item.tokenId,
+                })),
+                loop: false,
+            },
+        ]);
+        const selected = identities.find((item) => item.tokenId === selectedTokenId) || identities[0];
+        return { agentType: selected.agentType, identity: selected };
+    }
+    catch (error) {
+        console.log(chalk.yellow(`⚠ Could not auto-detect agent identity: ${error.message}`));
+        return {};
+    }
+}
 async function promptForAgentType(initialValue, nonInteractive) {
     if (initialValue) {
         if (!AGENTS.some((agent) => agent.id === initialValue)) {
@@ -480,11 +629,25 @@ export async function initCommand(rawOptions = {}) {
         console.log(chalk.gray('○ Ollama not detected'));
     }
     console.log();
-    const agentType = await promptForAgentType(options.agentType, nonInteractive);
-    const wallet = await promptForWallet(options.wallet, nonInteractive);
+    const profile = await selectNetworkProfile(options.profile, nonInteractive);
+    const derivedWallet = getWalletFromRuntimePrivateKey();
+    const wallet = await promptForWallet(options.wallet || derivedWallet, nonInteractive);
+    if (!options.wallet && derivedWallet) {
+        console.log(chalk.green(`✓ Wallet auto-detected from TERMINUS_WALLET_PRIVATE_KEY: ${wallet}`));
+    }
+    let detectedIdentity;
+    let selectedAgentType = options.agentType;
+    if (!selectedAgentType) {
+        const detection = await autoSelectAgentType(profile, wallet, nonInteractive);
+        if (detection.agentType) {
+            selectedAgentType = detection.agentType;
+            detectedIdentity = detection.identity;
+            console.log(chalk.green(`✓ Agent type auto-detected: ${selectedAgentType}${detectedIdentity ? ` (tokenId=${detectedIdentity.tokenId})` : ''}`));
+        }
+    }
+    const agentType = await promptForAgentType(selectedAgentType, nonInteractive);
     const llmProvider = await promptForProvider(options.llmProvider, nonInteractive);
     const providerConfig = await configureProvider(llmProvider, options, nonInteractive, ollamaModels);
-    const profile = await selectNetworkProfile(options.profile, nonInteractive);
     const controlPlaneUrl = await selectControlPlaneUrl(profile, options.controlPlaneUrl, nonInteractive);
     const nodeId = generateNodeId(agentType, wallet);
     const config = {
@@ -502,6 +665,12 @@ export async function initCommand(rawOptions = {}) {
     const selectedAgent = AGENTS.find((item) => item.id === agentType);
     console.log(chalk.green.bold('\nSetup complete.\n'));
     printInfo('Agent', `${AGENT_EMOJIS[agentType] || '🤖'} ${selectedAgent?.name || agentType}`);
+    if (detectedIdentity) {
+        printInfo('Identity Token', detectedIdentity.tokenId);
+        if (detectedIdentity.collectionTokenId) {
+            printInfo('Collection Token', detectedIdentity.collectionTokenId);
+        }
+    }
     printInfo('Node ID', nodeId);
     printInfo('Wallet', `${wallet.slice(0, 10)}...${wallet.slice(-8)}`);
     printInfo('Provider', llmProvider);

package/dist/cli/run.js

@@ -80,10 +80,14 @@ export async function runCommand() {
         console.log(chalk.cyan('   npx terminus-agent init --profile mainnet\n'));
         process.exit(1);
     }
-    printStartupBanner(config);
-    if (!process.env.TERMINUS_WALLET_PRIVATE_KEY) {
-        console.log(chalk.yellow('   ⚠ TERMINUS_WALLET_PRIVATE_KEY is not set. Challenge-signature auth will fail in strict remote mode.\n'));
+    const runtimePrivateKey = process.env.TERMINUS_WALLET_PRIVATE_KEY?.trim();
+    if ((config.networkProfile === 'testnet' || config.networkProfile === 'mainnet') && !runtimePrivateKey) {
+        console.log(chalk.red('\n   ❌ TERMINUS_WALLET_PRIVATE_KEY is required for testnet/mainnet challenge-signature auth.\n'));
+        console.log(chalk.gray('   Set it and retry:'));
+        console.log(chalk.cyan('   export TERMINUS_WALLET_PRIVATE_KEY=0x...\n'));
+        process.exit(1);
     }
+    printStartupBanner(config);
     const client = new AgentClient(config);
     // Handle graceful shutdown
     process.on('SIGINT', () => {

package/dist/index.js

@@ -19,7 +19,7 @@ async function withCliErrorHandling(task) {
 program
     .name('terminus-agent')
     .description('Standalone agent runner for Terminus network')
-    .version('0.1.0');
+    .version('0.1.3');
 program
     .command('init')
     .description('Initialize agent configuration')

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@terminusagents/agents",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "Standalone agent runner for Terminus network",
     "type": "module",
     "main": "dist/index.js",