@promus/cli 0.24.17

package/src/commands/telegram.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'bun:test'
+import { parseTelegramArgs } from './telegram'
+
+describe('parseTelegramArgs', () => {
+  it('errors on missing subcommand', () => {
+    const r = parseTelegramArgs([])
+    expect('error' in r).toBe(true)
+    if ('error' in r) expect(r.error).toContain('usage')
+  })
+
+  it('errors on unknown subcommand', () => {
+    const r = parseTelegramArgs(['nuke'])
+    expect('error' in r).toBe(true)
+    if ('error' in r) expect(r.error).toContain('nuke')
+  })
+
+  it('parses setup', () => {
+    const r = parseTelegramArgs(['setup'])
+    expect('error' in r).toBe(false)
+    if (!('error' in r)) expect(r.sub).toBe('setup')
+  })
+
+  it('parses status', () => {
+    const r = parseTelegramArgs(['status'])
+    if (!('error' in r)) expect(r.sub).toBe('status')
+  })
+
+  it('parses remove without --yes', () => {
+    const r = parseTelegramArgs(['remove'])
+    if (!('error' in r)) {
+      expect(r.sub).toBe('remove')
+      expect(r.yes).toBeFalsy()
+    }
+  })
+
+  it('parses remove --yes', () => {
+    const r = parseTelegramArgs(['remove', '--yes'])
+    if (!('error' in r)) {
+      expect(r.sub).toBe('remove')
+      expect(r.yes).toBe(true)
+    }
+  })
+
+  it('parses remove -y', () => {
+    const r = parseTelegramArgs(['remove', '-y'])
+    if (!('error' in r)) {
+      expect(r.yes).toBe(true)
+    }
+  })
+})

package/src/commands/telegram.ts

@@ -0,0 +1,44 @@
+/**
+ * `promus telegram <subcommand>` — argv dispatcher.
+ *
+ * Subcommands:
+ *   setup    interactive wizard: validate token, encrypt + persist locally
+ *   status   confirm token still valid + show stored config
+ *   remove   delete the encrypted local blob (does NOT revoke at @BotFather)
+ */
+
+export interface TelegramArgs {
+  sub: 'setup' | 'status' | 'remove'
+  yes?: boolean
+}
+
+const VALID_SUBS = ['setup', 'status', 'remove'] as const
+
+export function parseTelegramArgs(argv: string[]): TelegramArgs | { error: string } {
+  const sub = argv[0]
+  if (!sub) return { error: 'usage: promus telegram <setup | status | remove>' }
+  const valid = (VALID_SUBS as readonly string[]).includes(sub)
+  if (!valid) return { error: `unknown subcommand '${sub}' (expected: ${VALID_SUBS.join(' | ')})` }
+  const yes = argv.includes('--yes') || argv.includes('-y')
+  return { sub: sub as TelegramArgs['sub'], yes }
+}
+
+export async function runTelegram(args: TelegramArgs): Promise<void> {
+  switch (args.sub) {
+    case 'setup': {
+      const { runTelegramSetup } = await import('./telegram-setup')
+      await runTelegramSetup()
+      return
+    }
+    case 'status': {
+      const { runTelegramStatus } = await import('./telegram-status')
+      await runTelegramStatus()
+      return
+    }
+    case 'remove': {
+      const { runTelegramRemove } = await import('./telegram-remove')
+      await runTelegramRemove({ yes: args.yes })
+      return
+    }
+  }
+}

package/src/commands/topup.ts

@@ -0,0 +1,303 @@
+import { cancel, intro, isCancel, outro, password, select, spinner } from '@clack/prompts'
+import {
+  SANDBOX_BURN_RATE_OG_PER_HOUR,
+  SANDBOX_PROVIDER_GALILEO,
+  SandboxSettlementClient,
+  VISION_PROVIDER_DEFAULTS,
+  agentPaths,
+  depositToLedger,
+  explorerTxUrl,
+  fetchAndDecryptKeystore,
+  getGasPriceWithFloor,
+  getLedgerBalance,
+  iNFTAgentId,
+  transferFundToProvider,
+  waitForReceiptResilient,
+} from '@promus/core'
+import { type Address, formatEther, getAddress, parseEther } from 'viem'
+import { findAndLoadConfig } from '../config/load'
+import { withSilencedConsole } from '../util/silence-console'
+import { loadOrPickOperatorSigner } from './init/operator-picker'
+
+export interface TopupOpts {
+  /** Top up the agent EOA from operator wallet, amount in ETH. */
+  agent?: number
+  /** Top up the compute ledger from agent EOA, amount in ETH. */
+  compute?: number
+  /**
+   * v0.21.5: top up the Galileo SandboxBilling deposit from operator wallet, amount in ETH.
+   * Was: `provider` in v0.17.1+; renamed to disambiguate from "compute provider".
+   */
+  sandbox?: number
+  /**
+   * @deprecated Use `sandbox` instead. v0.17.1 named this `provider` (matching
+   * the SandboxBilling smart-contract field name) which collided with "compute
+   * provider". Kept as an alias for backwards compat with existing runbooks;
+   * will be removed in a future release.
+   */
+  provider?: number
+  /**
+   * Transfer N ETH from the main ledger into the vision provider sub-account.
+   * Without this, `vision.analyze` + `browser.vision` fail with "Sub-account
+   * not found" on fresh agents (init wizard only seeds the inference
+   * provider). Mainnet-only — no vision provider exists on testnet.
+   */
+  vision?: number
+}
+
+export async function runTopup(opts: TopupOpts): Promise<void> {
+  intro('promus topup')
+
+  const loaded = await findAndLoadConfig()
+  if (!loaded) {
+    cancel('No promus.config.ts found. Run `promus init` first.')
+    return
+  }
+  const { config } = loaded
+  if (!config.identity.iNFT || !config.identity.agent) {
+    cancel('Config has no iNFT or agent. Run `promus init` first.')
+    return
+  }
+
+  const agentAddress = config.identity.agent as Address
+  const network = config.network
+  const finalAgentId = iNFTAgentId({
+    contractAddress: config.identity.iNFT.contract as Address,
+    tokenId: BigInt(config.identity.iNFT.tokenId),
+  })
+  const paths = agentPaths.agent(finalAgentId)
+
+  // 'sandbox' is the canonical mode discriminant (was 'provider' in v0.17.1+).
+  // `opts.provider` is accepted as a backwards-compat alias.
+  let mode: 'agent' | 'compute' | 'sandbox' | 'vision' | null = null
+  let amount = 0
+  if (opts.agent !== undefined) {
+    mode = 'agent'
+    amount = opts.agent
+  } else if (opts.compute !== undefined) {
+    mode = 'compute'
+    amount = opts.compute
+  } else if (opts.sandbox !== undefined) {
+    mode = 'sandbox'
+    amount = opts.sandbox
+  } else if (opts.provider !== undefined) {
+    mode = 'sandbox'
+    amount = opts.provider
+  } else if (opts.vision !== undefined) {
+    mode = 'vision'
+    amount = opts.vision
+  }
+
+  if (!mode) {
+    const choice = (await select({
+      message: 'What do you want to top up?',
+      options: [
+        {
+          value: 'agent' as const,
+          label: 'Agent wallet (infra gas)',
+          hint: 'operator sends ETH to agent EOA',
+        },
+        {
+          value: 'compute' as const,
+          label: 'Compute ledger (inference credits)',
+          hint: 'agent deposits ETH into compute ledger (mainnet)',
+        },
+        {
+          value: 'vision' as const,
+          label: 'Vision provider sub-account (vision.analyze + browser.vision)',
+          hint: 'transfer from main ledger into vision provider envelope (mainnet)',
+        },
+        {
+          value: 'sandbox' as const,
+          label: 'Sandbox billing deposit (Galileo testnet runtime fees)',
+          hint: 'operator deposits ETH into SandboxBilling for harness burn',
+        },
+      ],
+    })) as 'agent' | 'compute' | 'sandbox' | 'vision' | symbol
+    if (isCancel(choice)) {
+      cancel('Aborted.')
+      return
+    }
+    mode = choice
+
+    const amtRaw = (await password({
+      message: `Amount in ETH to move to ${mode}`,
+      validate: v => {
+        const n = Number(v)
+        if (!Number.isFinite(n) || n <= 0) return 'Positive number required.'
+        return undefined
+      },
+    })) as string | symbol
+    if (isCancel(amtRaw)) {
+      cancel('Aborted.')
+      return
+    }
+    amount = Number(amtRaw)
+  }
+
+  if (mode === 'sandbox') {
+    const operator = await loadOrPickOperatorSigner({ network, hint: config.operator })
+    if (!operator) return
+    const operatorAccount = await operator.account()
+    const galileoPub = await operator.publicClient('0g-testnet')
+    const galileoWallet = await operator.walletClient('0g-testnet')
+    const settle = new SandboxSettlementClient({
+      publicClient: galileoPub,
+      walletClient: galileoWallet,
+    })
+    const wei = parseEther(String(amount))
+
+    const sBefore = spinner()
+    sBefore.start('Reading current Galileo deposit')
+    let before = 0n
+    try {
+      before = await settle.getBalance(operatorAccount.address, SANDBOX_PROVIDER_GALILEO)
+      sBefore.stop(
+        `current deposit ${formatEther(before)} ETH (~${(Number(before) / 1e18 / SANDBOX_BURN_RATE_OG_PER_HOUR).toFixed(1)}h runway)`,
+      )
+    } catch (e) {
+      sBefore.stop(`balance read failed: ${(e as Error).message.slice(0, 120)}`)
+    }
+
+    const sDep = spinner()
+    sDep.start(`Depositing ${amount} ETH to Galileo provider`)
+    try {
+      const tx = await settle.deposit({
+        recipient: operatorAccount.address,
+        provider: SANDBOX_PROVIDER_GALILEO,
+        amountWei: wei,
+      })
+      await waitForReceiptResilient(galileoPub, tx, { tries: 60, delayMs: 2000 })
+      const after = await settle.getBalance(operatorAccount.address, SANDBOX_PROVIDER_GALILEO)
+      sDep.stop(
+        `deposit confirmed → ${explorerTxUrl('0g-testnet', tx)} (new balance ${formatEther(after)} ETH ≈ ${(Number(after) / 1e18 / SANDBOX_BURN_RATE_OG_PER_HOUR).toFixed(1)}h)`,
+      )
+      outro(`Galileo deposit topped up by ${amount} ETH`)
+    } catch (e) {
+      sDep.stop(`deposit failed: ${(e as Error).message.slice(0, 120)}`)
+    } finally {
+      await operator.close?.()
+    }
+    return
+  }
+
+  if (mode === 'agent') {
+    const operator = await loadOrPickOperatorSigner({ network, hint: config.operator })
+    if (!operator) return
+
+    const s = spinner()
+    s.start(`Sending ${amount} ETH from operator to agent ${agentAddress}`)
+    try {
+      const opWc = await operator.walletClient(network)
+      const opAccount = opWc.account
+      if (!opAccount) throw new Error('walletClient is missing default account')
+      const pub = await operator.publicClient(network)
+      const fundGasPrice = await getGasPriceWithFloor(pub)
+      const tx = await withSilencedConsole(() =>
+        opWc.sendTransaction({
+          to: agentAddress,
+          value: parseEther(String(amount)),
+          chain: operator.chain(network),
+          account: opAccount,
+          maxFeePerGas: fundGasPrice,
+          maxPriorityFeePerGas: fundGasPrice,
+        }),
+      )
+      await waitForReceiptResilient(pub, tx)
+      s.stop(`funded → ${explorerTxUrl(network, tx)}`)
+      outro(`agent ${agentAddress} balance refreshed`)
+    } catch (e) {
+      s.stop(`fund failed: ${(e as Error).message.slice(0, 120)}`)
+    } finally {
+      await operator.close?.()
+    }
+    return
+  }
+
+  // mode === 'compute' or 'vision' — both need the agent's privkey since
+  // they're agent-signed broker calls (depositFund vs transferFund).
+  if (mode === 'vision' && network !== '0g-mainnet') {
+    cancel('Vision provider is mainnet-only; no testnet provider exists yet.')
+    return
+  }
+  const operator = await loadOrPickOperatorSigner({ network, hint: config.operator })
+  if (!operator) return
+
+  const inftContract = config.identity.iNFT.contract as Address
+  const inftTokenId = BigInt(config.identity.iNFT.tokenId)
+
+  const sUnlock = spinner()
+  sUnlock.start('Fetching encrypted keystore + decrypting via operator wallet')
+  let agentPrivkey: `0x${string}`
+  try {
+    const decrypted = await withSilencedConsole(() =>
+      fetchAndDecryptKeystore({
+        network,
+        contractAddress: inftContract,
+        tokenId: inftTokenId,
+        signer: operator,
+        agentAddress,
+        cachePath: paths.keystore,
+      }),
+    )
+    agentPrivkey = decrypted.privkeyHex
+    sUnlock.stop(`unlocked (keystore source: ${decrypted.source})`)
+  } catch (e) {
+    sUnlock.stop(`unlock failed: ${(e as Error).message.slice(0, 160)}`)
+    await operator.close?.()
+    return
+  }
+
+  const sBal = spinner()
+  sBal.start('Reading current ledger balance')
+  try {
+    const bal = await withSilencedConsole(() =>
+      getLedgerBalance({ network, privkeyHex: agentPrivkey }),
+    )
+    sBal.stop(
+      bal
+        ? `current ledger ${formatEther(bal.totalBalance)} ETH total / ${formatEther(bal.availableBalance)} ETH available`
+        : 'no ledger yet — depositing will open one',
+    )
+  } catch (e) {
+    sBal.stop(`balance read failed: ${(e as Error).message.slice(0, 120)}`)
+  }
+
+  if (mode === 'vision') {
+    const providerRaw = VISION_PROVIDER_DEFAULTS[network as '0g-mainnet']
+    if (!providerRaw) {
+      console.error(`Vision provider not configured for network ${network}`)
+      await operator.close?.()
+      return
+    }
+    const provider = getAddress(providerRaw)
+    const sVis = spinner()
+    sVis.start(`Transferring ${amount} ETH from main ledger to vision provider sub-account`)
+    try {
+      await withSilencedConsole(() =>
+        transferFundToProvider({ network, privkeyHex: agentPrivkey, provider, amount }),
+      )
+      sVis.stop(`vision sub-account seeded (${provider.slice(0, 8)}...${provider.slice(-4)})`)
+      outro(
+        `vision provider has ${amount} ETH allocated. vision.analyze + browser.vision should work now.`,
+      )
+    } catch (e) {
+      sVis.stop(`transfer failed: ${(e as Error).message.slice(0, 160)}`)
+    } finally {
+      await operator.close?.()
+    }
+    return
+  }
+
+  const sDep = spinner()
+  sDep.start(`Depositing ${amount} ETH into compute ledger`)
+  try {
+    await withSilencedConsole(() => depositToLedger({ network, privkeyHex: agentPrivkey, amount }))
+    sDep.stop('deposit complete')
+    outro(`ledger topped up by ${amount} ETH`)
+  } catch (e) {
+    sDep.stop(`deposit failed: ${(e as Error).message.slice(0, 120)}`)
+  } finally {
+    await operator.close?.()
+  }
+}

package/src/commands/transfer.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'bun:test'
+import { parseTransferArgs } from './transfer'
+
+const REF = 'eip155:16661:0x9e71d79f06f956d4d2666b5c93dafab721c84721:7'
+const TO = '0x06B74fe8070C96D92e3a2A8A871849Ac81e4c09e'
+const KEY = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d'
+
+describe('parseTransferArgs', () => {
+  test('minimum: ref + --to', () => {
+    const r = parseTransferArgs([REF, '--to', TO])
+    expect('error' in r).toBe(false)
+    if ('error' in r) return
+    expect(r.ref).toBe(REF)
+    expect(r.to.toLowerCase()).toBe(TO.toLowerCase())
+    expect(r.dryRun).toBeUndefined()
+    expect(r.yes).toBeUndefined()
+    expect(r.noPurge).toBeUndefined()
+  })
+
+  test('--dry-run flag', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--dry-run'])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.dryRun).toBe(true)
+  })
+
+  test('--yes shorthand -y', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '-y'])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.yes).toBe(true)
+  })
+
+  test('--no-purge', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--no-purge'])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.noPurge).toBe(true)
+  })
+
+  test('--recipient-key with 0x prefix', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--recipient-key', KEY])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.recipientKey).toBe(KEY)
+  })
+
+  test('--recipient-key without 0x prefix gets normalized', () => {
+    const stripped = KEY.slice(2)
+    const r = parseTransferArgs([REF, '--to', TO, '--recipient-key', stripped])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.recipientKey).toBe(KEY)
+  })
+
+  test('--oracle-key with 0x prefix', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--oracle-key', KEY])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.oracleKey).toBe(KEY)
+  })
+
+  test('--oracle-key without 0x prefix gets normalized', () => {
+    const stripped = KEY.slice(2)
+    const r = parseTransferArgs([REF, '--to', TO, '--oracle-key', stripped])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.oracleKey).toBe(KEY)
+  })
+
+  test('error: missing ref', () => {
+    const r = parseTransferArgs(['--to', TO])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: missing --to', () => {
+    const r = parseTransferArgs([REF])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: invalid --to address', () => {
+    const r = parseTransferArgs([REF, '--to', '0xnotanaddress'])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: invalid --recipient-key length', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--recipient-key', '0xdeadbeef'])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: invalid --oracle-key length', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--oracle-key', '0xdeadbeef'])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: --oracle-key without value', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--oracle-key'])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: unknown flag', () => {
+    const r = parseTransferArgs([REF, '--to', TO, '--bogus'])
+    expect('error' in r).toBe(true)
+  })
+
+  test('error: unexpected positional', () => {
+    const r = parseTransferArgs([REF, 'bonus-arg', '--to', TO])
+    expect('error' in r).toBe(true)
+  })
+
+  test('flag order does not matter', () => {
+    const r = parseTransferArgs(['--dry-run', '--to', TO, REF, '--yes'])
+    if ('error' in r) throw new Error(r.error)
+    expect(r.ref).toBe(REF)
+    expect(r.dryRun).toBe(true)
+    expect(r.yes).toBe(true)
+  })
+})