@prktsol/prkt 1.0.0

package/dist/cli/services/activityStore.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityStore = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const storagePaths_1 = require("./storagePaths");
+class ActivityStore {
+    append(record) {
+        const payload = this.read();
+        payload.activities.push(record);
+        this.write(payload);
+    }
+    list(limit = 100) {
+        const activities = this.read().activities;
+        return activities.slice(Math.max(activities.length - limit, 0));
+    }
+    listByAgent(agent, limit = 100) {
+        return this.list(limit).filter((entry) => entry.agent === agent);
+    }
+    read() {
+        const storePath = (0, storagePaths_1.resolveCliDataPath)("cli-activity.json");
+        if (!(0, fs_1.existsSync)(storePath)) {
+            return {
+                activities: []
+            };
+        }
+        const raw = (0, fs_1.readFileSync)(storePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            activities: parsed.activities ?? []
+        };
+    }
+    write(payload) {
+        const storePath = (0, storagePaths_1.resolveCliDataPath)("cli-activity.json");
+        (0, fs_1.mkdirSync)(path_1.default.dirname(storePath), { recursive: true, mode: 0o700 });
+        (0, fs_1.writeFileSync)(storePath, JSON.stringify(payload, null, 2), { mode: 0o600 });
+    }
+}
+exports.ActivityStore = ActivityStore;

package/dist/cli/services/agentRegistry.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRegistryStore = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const walletRegistry_1 = require("./walletRegistry");
+const storagePaths_1 = require("./storagePaths");
+const policyPresets_1 = require("../../config/policyPresets");
+class AgentRegistryStore {
+    walletRegistry;
+    constructor(walletRegistry = new walletRegistry_1.WalletRegistry()) {
+        this.walletRegistry = walletRegistry;
+    }
+    list() {
+        return this.read().agents.slice().sort((a, b) => a.name.localeCompare(b.name));
+    }
+    find(name) {
+        return this.read().agents.find((agent) => agent.name === name);
+    }
+    ensureForWallet(walletName) {
+        const existing = this.find(walletName);
+        if (existing) {
+            return existing;
+        }
+        const wallet = this.walletRegistry.find(walletName);
+        if (!wallet) {
+            throw new Error(`Cannot create agent for wallet '${walletName}': wallet not found.`);
+        }
+        const record = {
+            createdAtIso: new Date().toISOString(),
+            name: walletName,
+            policyMode: "sandbox",
+            policyPreset: policyPresets_1.DEFAULT_POLICY_PRESET,
+            status: "active",
+            strategy: "memo-heartbeat",
+            walletName
+        };
+        this.upsert(record);
+        return record;
+    }
+    createAgent(input) {
+        const existing = this.find(input.agentId);
+        if (existing) {
+            throw new Error(`Agent '${input.agentId}' already exists.`);
+        }
+        const walletName = input.walletName ?? input.agentId;
+        const wallet = this.walletRegistry.find(walletName);
+        if (!wallet) {
+            throw new Error(`Cannot create agent '${input.agentId}': wallet '${walletName}' not found.`);
+        }
+        const record = {
+            createdAtIso: new Date().toISOString(),
+            name: input.agentId,
+            ownerId: input.ownerId,
+            policyMode: "sandbox",
+            policyPreset: policyPresets_1.DEFAULT_POLICY_PRESET,
+            status: "active",
+            strategy: "memo-heartbeat",
+            walletName
+        };
+        this.upsert(record);
+        return record;
+    }
+    upsert(record) {
+        const registry = this.read();
+        const existingIndex = registry.agents.findIndex((agent) => agent.name === record.name);
+        if (existingIndex >= 0) {
+            registry.agents[existingIndex] = record;
+        }
+        else {
+            registry.agents.push(record);
+        }
+        this.write(registry);
+        return record;
+    }
+    patch(name, update) {
+        const existing = this.find(name);
+        if (!existing) {
+            throw new Error(`Agent '${name}' not found.`);
+        }
+        return this.upsert({
+            ...existing,
+            ...update
+        });
+    }
+    synchronizeWithWallets() {
+        for (const wallet of this.walletRegistry.list()) {
+            if (!this.find(wallet.name)) {
+                this.ensureForWallet(wallet.name);
+            }
+        }
+        return this.list();
+    }
+    read() {
+        const registryPath = (0, storagePaths_1.resolveCliDataPath)("cli-agents.json");
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return {
+                agents: []
+            };
+        }
+        const raw = (0, fs_1.readFileSync)(registryPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            agents: (parsed.agents ?? []).map((agent) => this.normalize(agent))
+        };
+    }
+    write(payload) {
+        const registryPath = (0, storagePaths_1.resolveCliDataPath)("cli-agents.json");
+        (0, fs_1.mkdirSync)(path_1.default.dirname(registryPath), { recursive: true, mode: 0o700 });
+        (0, fs_1.writeFileSync)(registryPath, JSON.stringify(payload, null, 2), { mode: 0o600 });
+    }
+    normalize(agent) {
+        return {
+            ...agent,
+            ownerId: agent.ownerId,
+            policyPreset: agent.policyPreset ?? policyPresets_1.DEFAULT_POLICY_PRESET
+        };
+    }
+}
+exports.AgentRegistryStore = AgentRegistryStore;

package/dist/cli/services/agentRuntime.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentOnce = runAgentOnce;
+const web3_js_1 = require("@solana/web3.js");
+const AgentRunner_1 = require("../../agent/runner/AgentRunner");
+const env_1 = require("../../config/env");
+const policyPresets_1 = require("../../config/policyPresets");
+const BalanceService_1 = require("../../core/balances/BalanceService");
+const RpcClient_1 = require("../../core/rpc/RpcClient");
+const TokenService_1 = require("../../core/tokens/TokenService");
+const TransactionService_1 = require("../../core/transactions/TransactionService");
+const universal_1 = require("../../defi/universal");
+const shared_1 = require("../../scripts/shared");
+const walletRegistry_1 = require("./walletRegistry");
+const strategyFactory_1 = require("./strategyFactory");
+async function runAgentOnce(input) {
+    const walletRegistry = new walletRegistry_1.WalletRegistry();
+    const walletManager = walletRegistry.toWalletManager(input.agent.walletName);
+    const rpcClient = new RpcClient_1.RpcClient((0, env_1.getRpcUrl)(), "confirmed");
+    const tokenService = new TokenService_1.TokenService(rpcClient);
+    const transactionService = new TransactionService_1.TransactionService(rpcClient);
+    const balanceService = new BalanceService_1.BalanceService(rpcClient, tokenService);
+    const universalDeFi = new universal_1.UniversalDeFiOrchestrator({
+        koraSigner: (0, shared_1.createKoraSigner)(),
+        liveFirst: (0, env_1.isUniversalDeFiLiveFirstEnabled)(),
+        walletManager
+    });
+    const runner = new AgentRunner_1.AgentRunner();
+    const policyConfig = (0, policyPresets_1.resolvePolicyConfig)({
+        agentId: input.agent.name,
+        overrides: input.agent.policyOverrides,
+        presetName: input.agent.policyPreset
+    });
+    runner.registerAgent({
+        context: {
+            id: input.agent.name,
+            walletManager,
+            walletPublicKey: new web3_js_1.PublicKey(walletManager.publicKey.toBase58()),
+            rpcClient,
+            transactionService,
+            tokenService,
+            balanceService,
+            policyConfig: policyConfig,
+            logger: () => undefined,
+            universalDeFiExecutor: universalDeFi
+        },
+        strategy: (0, strategyFactory_1.createStrategy)({
+            name: input.overrideStrategy ?? input.agent.strategy,
+            config: input.agent.strategyConfig
+        }),
+        approvalMode: policyConfig.approvalMode
+    });
+    const [result] = await runner.runOnceParallel();
+    return result;
+}

package/dist/cli/services/storagePaths.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCliDataDir = getCliDataDir;
+exports.resolveCliDataPath = resolveCliDataPath;
+exports.getCliHomeEnvName = getCliHomeEnvName;
+exports.probeCliDataDir = probeCliDataDir;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CLI_HOME_ENV = "PRKT_CLI_HOME";
+function resolveBaseDir() {
+    const override = process.env[CLI_HOME_ENV]?.trim();
+    if (override) {
+        return path_1.default.resolve(override);
+    }
+    if (process.platform === "win32") {
+        const windowsBase = process.env.APPDATA || process.env.LOCALAPPDATA;
+        if (windowsBase) {
+            return path_1.default.join(windowsBase, "PRKT");
+        }
+    }
+    if (process.platform === "darwin") {
+        return path_1.default.join(os_1.default.homedir(), "Library", "Application Support", "PRKT");
+    }
+    const xdgBase = process.env.XDG_DATA_HOME?.trim();
+    if (xdgBase) {
+        return path_1.default.join(xdgBase, "prkt");
+    }
+    return path_1.default.join(os_1.default.homedir(), ".local", "share", "prkt");
+}
+function getCliDataDir() {
+    const baseDir = resolveBaseDir();
+    (0, fs_1.mkdirSync)(baseDir, { recursive: true, mode: 0o700 });
+    return baseDir;
+}
+function resolveCliDataPath(fileName) {
+    return path_1.default.join(getCliDataDir(), fileName);
+}
+function getCliHomeEnvName() {
+    return CLI_HOME_ENV;
+}
+function probeCliDataDir() {
+    const dataDir = getCliDataDir();
+    const probePath = path_1.default.join(dataDir, ".prkt-write-test");
+    try {
+        (0, fs_1.writeFileSync)(probePath, "ok", { mode: 0o600 });
+        (0, fs_1.rmSync)(probePath, { force: true });
+        return {
+            details: "ok",
+            path: dataDir,
+            writable: true
+        };
+    }
+    catch (error) {
+        return {
+            details: error instanceof Error ? error.message : "unknown write error",
+            path: dataDir,
+            writable: false
+        };
+    }
+}

package/dist/cli/services/strategyFactory.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStrategy = createStrategy;
+const web3_js_1 = require("@solana/web3.js");
+const MemoHeartbeatStrategy_1 = require("../../agent/strategies/MemoHeartbeatStrategy");
+const SimpleScriptedTransferStrategy_1 = require("../../agent/strategies/SimpleScriptedTransferStrategy");
+const UniversalDeFiStrategy_1 = require("../../agent/strategies/UniversalDeFiStrategy");
+function createStrategy(input) {
+    const name = input.name.trim().toLowerCase();
+    if (name === "memo-heartbeat") {
+        return new MemoHeartbeatStrategy_1.MemoHeartbeatStrategy();
+    }
+    if (name === "simple-scripted-transfer") {
+        const to = typeof input.config?.to === "string" ? input.config.to : undefined;
+        const amountSol = typeof input.config?.amountSol === "number" ? input.config.amountSol : 0.001;
+        if (!to) {
+            throw new Error("simple-scripted-transfer requires strategy config key 'to'.");
+        }
+        return new SimpleScriptedTransferStrategy_1.SimpleScriptedTransferStrategy({
+            to,
+            lamports: Math.round(amountSol * web3_js_1.LAMPORTS_PER_SOL),
+            memo: typeof input.config?.memo === "string"
+                ? input.config.memo
+                : "cli simple-scripted-transfer"
+        });
+    }
+    if (name === "universal-defi") {
+        return new UniversalDeFiStrategy_1.UniversalDeFiStrategy([
+            {
+                capability: "trade",
+                snapshot: {
+                    buyThresholdUsd: 100,
+                    solPriceUsd: 95
+                }
+            },
+            {
+                capability: "staking",
+                snapshot: {
+                    idleSolLamports: Math.round(1 * web3_js_1.LAMPORTS_PER_SOL)
+                }
+            },
+            {
+                capability: "lp",
+                snapshot: {
+                    liquidityInRange: true
+                }
+            },
+            {
+                capability: "lending",
+                snapshot: {
+                    healthFactor: 2.1,
+                    idleUsdcAtomic: 5_000_000
+                }
+            },
+            {
+                capability: "borrowing",
+                snapshot: {
+                    borrowDemandUsdcAtomic: 3_000_000,
+                    collateralSolLamports: Math.round(1 * web3_js_1.LAMPORTS_PER_SOL),
+                    healthFactor: 2.3
+                }
+            }
+        ]);
+    }
+    throw new Error(`Unknown strategy '${input.name}'. Supported: memo-heartbeat, simple-scripted-transfer, universal-defi.`);
+}

package/dist/cli/services/walletCrypto.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptSecretKeyForPlatform = encryptSecretKeyForPlatform;
+exports.decryptSecretKeyForPlatform = decryptSecretKeyForPlatform;
+exports.createRecoveryPackage = createRecoveryPackage;
+exports.decryptSecretKeyWithRecovery = decryptSecretKeyWithRecovery;
+exports.getPlatformMasterKeySource = getPlatformMasterKeySource;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const storagePaths_1 = require("./storagePaths");
+const MASTER_KEY_ENV = "PRKT_WALLET_MASTER_KEY";
+const KEY_BYTES = 32;
+function encryptSecretKeyForPlatform(secretKey) {
+    const { key } = resolvePlatformMasterKey({ allowCreate: true });
+    return encryptBytes(secretKey, key);
+}
+function decryptSecretKeyForPlatform(payload) {
+    const { key } = resolvePlatformMasterKey({ allowCreate: false });
+    return decryptBytes(payload, key);
+}
+function createRecoveryPackage(secretKey) {
+    const recoveryKey = encodeRecoveryKey((0, crypto_1.randomBytes)(KEY_BYTES));
+    const salt = (0, crypto_1.randomBytes)(16);
+    const key = (0, crypto_1.scryptSync)(recoveryKey, salt, KEY_BYTES);
+    const encrypted = encryptBytes(secretKey, key);
+    return {
+        recoveryKey,
+        recoveryPackage: {
+            algorithm: "scrypt-aes-256-gcm",
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            kdf: "scrypt",
+            salt: salt.toString("base64"),
+            tag: encrypted.tag
+        }
+    };
+}
+function decryptSecretKeyWithRecovery(input) {
+    const key = (0, crypto_1.scryptSync)(input.recoveryKey, Buffer.from(input.recoveryPackage.salt, "base64"), KEY_BYTES);
+    return decryptBytes({
+        algorithm: "aes-256-gcm",
+        ciphertext: input.recoveryPackage.ciphertext,
+        iv: input.recoveryPackage.iv,
+        tag: input.recoveryPackage.tag
+    }, key);
+}
+function getPlatformMasterKeySource() {
+    return resolvePlatformMasterKey({ allowCreate: true }).source;
+}
+function resolvePlatformMasterKey(input) {
+    const masterKeyPath = (0, storagePaths_1.resolveCliDataPath)("platform-wallet-master.key");
+    const envValue = process.env[MASTER_KEY_ENV]?.trim();
+    if (envValue) {
+        return {
+            key: parseConfiguredKey(envValue),
+            source: "env"
+        };
+    }
+    if ((0, fs_1.existsSync)(masterKeyPath)) {
+        return {
+            key: readStoredKey(masterKeyPath),
+            source: "local-file"
+        };
+    }
+    if (!input.allowCreate) {
+        throw new Error(`Wallet master key is not configured. Set ${MASTER_KEY_ENV} or create ${masterKeyPath}.`);
+    }
+    const generated = (0, crypto_1.randomBytes)(KEY_BYTES);
+    (0, fs_1.mkdirSync)(path_1.default.dirname(masterKeyPath), { recursive: true, mode: 0o700 });
+    (0, fs_1.writeFileSync)(masterKeyPath, generated.toString("base64"), { mode: 0o600 });
+    return {
+        key: generated,
+        source: "local-file"
+    };
+}
+function parseConfiguredKey(value) {
+    if (/^[0-9a-f]{64}$/iu.test(value)) {
+        return Buffer.from(value, "hex");
+    }
+    const base64 = Buffer.from(value, "base64");
+    if (base64.length === KEY_BYTES) {
+        return base64;
+    }
+    throw new Error(`${MASTER_KEY_ENV} must be a 32-byte key encoded as base64 or 64 hex characters.`);
+}
+function readStoredKey(filePath) {
+    const raw = (0, fs_1.readFileSync)(filePath, "utf8").trim();
+    const parsed = Buffer.from(raw, "base64");
+    if (parsed.length !== KEY_BYTES) {
+        throw new Error(`Stored wallet master key at ${filePath} is invalid.`);
+    }
+    return parsed;
+}
+function encryptBytes(value, key) {
+    const iv = (0, crypto_1.randomBytes)(12);
+    const cipher = (0, crypto_1.createCipheriv)("aes-256-gcm", key, iv);
+    const ciphertext = Buffer.concat([cipher.update(Buffer.from(value)), cipher.final()]);
+    return {
+        algorithm: "aes-256-gcm",
+        ciphertext: ciphertext.toString("base64"),
+        iv: iv.toString("base64"),
+        tag: cipher.getAuthTag().toString("base64")
+    };
+}
+function decryptBytes(payload, key) {
+    const decipher = (0, crypto_1.createDecipheriv)(payload.algorithm, key, Buffer.from(payload.iv, "base64"));
+    decipher.setAuthTag(Buffer.from(payload.tag, "base64"));
+    const plaintext = Buffer.concat([
+        decipher.update(Buffer.from(payload.ciphertext, "base64")),
+        decipher.final()
+    ]);
+    return Uint8Array.from(plaintext);
+}
+function encodeRecoveryKey(bytes) {
+    return `prkt_recovery_${bytes.toString("base64url")}`;
+}

package/dist/cli/services/walletRegistry.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletRegistry = void 0;
+exports.generateTemporaryWalletName = generateTemporaryWalletName;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const web3_js_1 = require("@solana/web3.js");
+const WalletManager_1 = require("../../core/wallet/WalletManager");
+const walletCrypto_1 = require("./walletCrypto");
+const storagePaths_1 = require("./storagePaths");
+class WalletRegistry {
+    list() {
+        return this.read().wallets.slice().sort((a, b) => a.name.localeCompare(b.name));
+    }
+    find(name) {
+        return this.read().wallets.find((wallet) => wallet.name === name);
+    }
+    create(name) {
+        const existing = this.find(name);
+        if (existing) {
+            throw new Error(`Wallet '${name}' already exists.`);
+        }
+        return this.provision({
+            name,
+            secretKey: web3_js_1.Keypair.generate().secretKey
+        });
+    }
+    toWalletManager(name) {
+        const record = this.requireRecord(name);
+        return WalletManager_1.WalletManager.fromSecretKey(this.resolveSecretKey(record), "generated");
+    }
+    ensureFromEnv(name) {
+        const existing = this.find(name);
+        if (existing) {
+            return {
+                created: false,
+                record: existing,
+                recoveryKey: null
+            };
+        }
+        const fromEnv = WalletManager_1.WalletManager.loadFromEnv();
+        return this.provision({
+            name,
+            secretKey: fromEnv.payer.secretKey
+        });
+    }
+    exportSecretKeyWithRecovery(input) {
+        const record = this.requireRecord(input.name);
+        if (!record.recoveryPackage) {
+            throw new Error(`Wallet '${input.name}' does not have a recovery package.`);
+        }
+        return (0, walletCrypto_1.decryptSecretKeyWithRecovery)({
+            recoveryKey: input.recoveryKey,
+            recoveryPackage: record.recoveryPackage
+        });
+    }
+    provision(input) {
+        const wallet = WalletManager_1.WalletManager.fromSecretKey(input.secretKey, "generated");
+        const recovery = (0, walletCrypto_1.createRecoveryPackage)(input.secretKey);
+        const record = {
+            createdAtIso: new Date().toISOString(),
+            encryptedSecretKey: (0, walletCrypto_1.encryptSecretKeyForPlatform)(input.secretKey),
+            name: input.name,
+            publicKey: wallet.publicKey.toBase58(),
+            recoveryPackage: recovery.recoveryPackage,
+            version: 2
+        };
+        const registry = this.read();
+        registry.wallets.push(record);
+        this.write(registry);
+        return {
+            created: true,
+            record,
+            recoveryKey: recovery.recoveryKey
+        };
+    }
+    requireRecord(name) {
+        const registry = this.read();
+        const record = registry.wallets.find((wallet) => wallet.name === name);
+        if (!record) {
+            throw new Error(`Wallet '${name}' not found.`);
+        }
+        const migrated = this.maybeMigrateLegacyRecord(registry, record);
+        return migrated ?? record;
+    }
+    read() {
+        const registryPath = (0, storagePaths_1.resolveCliDataPath)("cli-wallets.json");
+        if (!(0, fs_1.existsSync)(registryPath)) {
+            return {
+                wallets: []
+            };
+        }
+        const raw = (0, fs_1.readFileSync)(registryPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            wallets: (parsed.wallets ?? []).map((wallet) => this.normalize(wallet))
+        };
+    }
+    write(payload) {
+        const registryPath = (0, storagePaths_1.resolveCliDataPath)("cli-wallets.json");
+        (0, fs_1.mkdirSync)(path_1.default.dirname(registryPath), { recursive: true, mode: 0o700 });
+        (0, fs_1.writeFileSync)(registryPath, JSON.stringify(payload, null, 2), { mode: 0o600 });
+    }
+    maybeMigrateLegacyRecord(registry, record) {
+        if (!record.secretKey || record.encryptedSecretKey) {
+            return null;
+        }
+        const secretKey = Uint8Array.from(record.secretKey);
+        const recovery = (0, walletCrypto_1.createRecoveryPackage)(secretKey);
+        const migrated = {
+            createdAtIso: record.createdAtIso,
+            encryptedSecretKey: (0, walletCrypto_1.encryptSecretKeyForPlatform)(secretKey),
+            name: record.name,
+            publicKey: record.publicKey,
+            recoveryPackage: recovery.recoveryPackage,
+            version: 2
+        };
+        const index = registry.wallets.findIndex((entry) => entry.name === record.name);
+        registry.wallets[index] = migrated;
+        this.write(registry);
+        return migrated;
+    }
+    normalize(wallet) {
+        return {
+            ...wallet,
+            version: wallet.version ?? (wallet.encryptedSecretKey ? 2 : 1)
+        };
+    }
+    resolveSecretKey(record) {
+        if (record.encryptedSecretKey) {
+            return (0, walletCrypto_1.decryptSecretKeyForPlatform)(record.encryptedSecretKey);
+        }
+        if (record.secretKey) {
+            return Uint8Array.from(record.secretKey);
+        }
+        throw new Error(`Wallet '${record.name}' does not contain recoverable key material.`);
+    }
+}
+exports.WalletRegistry = WalletRegistry;
+function generateTemporaryWalletName() {
+    return `wallet-${web3_js_1.Keypair.generate().publicKey.toBase58().slice(0, 8)}`;
+}

package/dist/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/utils/completion.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionWords = completionWords;
+exports.buildBashCompletion = buildBashCompletion;
+exports.buildZshCompletion = buildZshCompletion;
+exports.buildPowerShellCompletion = buildPowerShellCompletion;
+const TOP_LEVEL_COMMANDS = [
+    "wallet",
+    "token",
+    "policy",
+    "agent",
+    "monitor",
+    "demo",
+    "audit",
+    "config",
+    "doctor",
+    "completion"
+];
+function completionWords() {
+    return TOP_LEVEL_COMMANDS.join(" ");
+}
+function buildBashCompletion() {
+    return `# bash completion for prkt
+_prkt_completion() {
+  local cur cword
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  cword=$COMP_CWORD
+  local commands="${completionWords()}"
+  if [[ $cword -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
+    return
+  fi
+}
+complete -F _prkt_completion prkt
+`;
+}
+function buildZshCompletion() {
+    return `#compdef prkt
+_prkt() {
+  local -a commands
+  commands=(${completionWords()})
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+}
+compdef _prkt prkt
+`;
+}
+function buildPowerShellCompletion() {
+    return `Register-ArgumentCompleter -Native -CommandName prkt -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $commands = @(${completionWords()
+        .split(" ")
+        .map((word) => `'${word}'`)
+        .join(", ")})
+  $commands | Where-Object { $_ -like \"$wordToComplete*\" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+  }
+}
+`;
+}