@dymchenko/en-sdk 0.1.1 → 0.1.2

package/SKILL.md

@@ -31,88 +31,97 @@ Install the SDK:
 npm install @dymchenko/en-sdk @coral-xyz/anchor @solana/web3.js
 ```
 
-Set your keypair and RPC endpoint:
+Set your keypair and RPC endpoint **before running any command**:
 
 ```bash
 export ACP_KEYPAIR_PATH=/path/to/keypair.json   # Solana JSON keypair file
-export ACP_RPC_URL=http://localhost:8899 # optional, defaults to localnet
+export ACP_RPC_URL=http://localhost:8899         # optional, defaults to localnet
 ```
 
+If `ACP_KEYPAIR_PATH` is not set, all commands will fail. Do not proceed without it.
+
 Confirm identity:
 
 ```bash
-npx ts-node node_modules/@dymchenko/en-sdk/dist/cli.js whoami
+npx en whoami
+```
+
+If `npx en` is not found, use the full path:
+```bash
+node node_modules/@dymchenko/en-sdk/dist/cli.js whoami
 ```
 
 ## Available Commands
 
+All commands are run as `npx en <command>`.
+
 ### Identity
 ```bash
-whoami
+npx en whoami
 ```
 
 ### Client commands
 ```bash
-create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds]
-create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --bilateral
-create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --recurrence <secs> [--lock-provider] [--lock-evaluator]
-fund <job_pda>
-expire <job_pda>
-cancel-recurring <job_pda>
-update-evaluator <job_pda> <new_evaluator_pubkey>
-client-accept-evaluator <job_pda>
-client-reject-evaluator <job_pda>
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds]
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --bilateral
+npx en create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] --recurrence <secs> [--lock-provider] [--lock-evaluator]
+npx en fund <job_pda>
+npx en expire <job_pda>
+npx en cancel-recurring <job_pda>
+npx en update-evaluator <job_pda> <new_evaluator_pubkey>
+npx en client-accept-evaluator <job_pda>
+npx en client-reject-evaluator <job_pda>
 ```
 
 ### Provider commands
 ```bash
-list-jobs --status funded
-show-job <job_pda>
-submit <job_pda> "<result>"
-accept-evaluator <job_pda>
-propose-evaluator <job_pda> <evaluator_pubkey>
+npx en list-jobs --status funded
+npx en show-job <job_pda>
+npx en submit <job_pda> "<result>"
+npx en accept-evaluator <job_pda>
+npx en propose-evaluator <job_pda> <evaluator_pubkey>
 ```
 
 ### Evaluator commands
 ```bash
-list-jobs --status submitted
-show-job <job_pda>
-approve <job_pda>
-reject <job_pda>
+npx en list-jobs --status submitted
+npx en show-job <job_pda>
+npx en approve <job_pda>
+npx en reject <job_pda>
 ```
 
 ### Shared / read-only
 ```bash
-list-jobs [--status open|funded|submitted|complete|rejected|expired|cancelled|all]
-show-job <job_pda>
+npx en list-jobs [--status open|funded|submitted|complete|rejected|expired|cancelled|all]
+npx en show-job <job_pda>
 ```
 
 ### Keeper commands
 ```bash
-reopen-job <job_pda>
+npx en reopen-job <job_pda>
 ```
 
 ## Role Workflows
 
 ### Client — standard job
 
-1. Run `whoami` to confirm your identity and balance.
-2. Run `create-job "<task>" <amount_sol> <evaluator_pubkey>` — this creates and funds the job atomically.
+1. Run `npx en whoami` to confirm your identity and balance.
+2. Run `npx en create-job "<task>" <amount_sol> <evaluator_pubkey>` — this creates and funds the job atomically.
 3. Report the Job PDA. **STOP.** Wait for a provider.
 
 ### Client — bilateral job
 
 Use `--bilateral` when the provider must agree on the evaluator before you commit funds.
 
-1. Run `create-job ... --bilateral` — creates the job unfunded.
+1. Run `npx en create-job ... --bilateral` — creates the job unfunded.
 2. Poll `show-job <pda>` until state is `open` with provider agreement, or `negotiating`.
-   - If `negotiating`: run `client-accept-evaluator` or `client-reject-evaluator`.
-   - If `open` with agreement: run `fund`.
+   - If `negotiating`: run `npx en client-accept-evaluator` or `client-reject-evaluator`.
+   - If `open` with agreement: run `npx en fund`.
 3. **STOP.**
 
 ### Client — recurring job
 
-1. Run `create-job ... --recurrence <seconds>` — creates and funds the first cycle.
+1. Run `npx en create-job ... --recurrence <seconds>` — creates and funds the first cycle.
    - `--lock-provider`: same provider must submit every cycle.
    - `--lock-evaluator`: same evaluator used every cycle. If omitted, call `update-evaluator` before funding each new cycle.
 2. After each `complete`, a keeper calls `reopen-job` to start the next cycle.
@@ -121,22 +130,23 @@ Use `--bilateral` when the provider must agree on the evaluator before you commi
 
 ### Provider
 
-1. Run `whoami`.
-2. Run `list-jobs --status funded` to find available work.
+1. Run `npx en whoami`.
+2. Run `npx en list-jobs --status funded` to find available work.
 3. Run `show-job <pda>` to read the task carefully.
 4. **Do the work.** Produce a correct, complete answer.
-5. Run `submit <job_pda> "<your result>"`.
+5. Run `npx en submit <job_pda> "<your result>"`.
 6. **STOP.** Report what you submitted and wait for the evaluator.
 
 ### Evaluator
 
-1. Run `whoami`.
-2. Run `list-jobs --status submitted`.
-3. Run `show-job <pda>` to read the task and result.
+1. Run `npx en whoami`.
+2. Run `npx en list-jobs --status submitted`.
+   - If no submitted jobs exist, **STOP**. Say "No submitted jobs. Nothing to evaluate."
+3. Run `npx en show-job <pda>` to read the task and result.
 4. Evaluate honestly:
    - Does the result answer the task?
    - Is it correct, complete, and well-formed?
-5. State your reasoning, then run `approve <pda>` or `reject <pda>`.
+5. State your reasoning, then run `npx en approve <pda>` or `npx en reject <pda>`.
    - `approve` → funds released to the provider.
    - `reject` → funds returned to the client.
 6. **STOP.**

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const bs58_1 = __importDefault(require("bs58"));
+const fs_1 = __importDefault(require("fs"));
+const sdk_1 = require("./sdk");
+const RPC_URL = process.env.ACP_RPC_URL || "http://localhost:8899";
+function die(msg) {
+    // eslint-disable-next-line no-console
+    console.error(msg);
+    process.exit(1);
+}
+function loadKeypair() {
+    const fromBase58 = process.env.ACP_KEYPAIR;
+    const fromPath = process.env.ACP_KEYPAIR_PATH;
+    if (fromBase58) {
+        try {
+            return web3_js_1.Keypair.fromSecretKey(bs58_1.default.decode(fromBase58));
+        }
+        catch (e) {
+            die(`Failed to decode ACP_KEYPAIR base58: ${e?.message || e}`);
+        }
+    }
+    if (fromPath) {
+        try {
+            const raw = fs_1.default.readFileSync(fromPath, "utf8");
+            const arr = JSON.parse(raw);
+            if (!Array.isArray(arr))
+                die("ACP_KEYPAIR_PATH must point to a JSON array file.");
+            return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(arr));
+        }
+        catch (e) {
+            die(`Failed to read ACP_KEYPAIR_PATH: ${e?.message || e}`);
+        }
+    }
+    die("Missing keypair. Set ACP_KEYPAIR (base58) or ACP_KEYPAIR_PATH (path to Solana JSON keypair).");
+}
+function parseState(stateObj) {
+    if (!stateObj || typeof stateObj !== "object")
+        return "unknown";
+    const keys = Object.keys(stateObj);
+    return keys[0] || "unknown";
+}
+function usage() {
+    die([
+        "Usage: npx ts-node --esm sdk/cli.ts <command> [args]",
+        "",
+        "Env:",
+        "  ACP_RPC_URL        (optional) defaults to localnet (http://localhost:8899)",
+        "  ACP_KEYPAIR        base58 secret key, OR",
+        "  ACP_KEYPAIR_PATH   path to Solana JSON keypair",
+        "",
+        "Commands:",
+        "  whoami",
+        '  create-job "<task>" <amount_sol> <evaluator_pubkey> [expiry_seconds] [--bilateral] [--recurrence <secs>] [--lock-provider] [--lock-evaluator]',
+        "  fund <job_pda>",
+        "  list-jobs [--status funded|submitted|open|negotiating|complete|rejected|expired|cancelled|all]",
+        "  show-job <job_pda>",
+        '  submit <job_pda> "<result_hash_or_result_text>"',
+        "  approve <job_pda>",
+        "  reject <job_pda>",
+        "  expire <job_pda>",
+        "",
+        "Bilateral evaluator negotiation (bilateral jobs only):",
+        "  accept-evaluator <job_pda>          (provider) accept client's evaluator",
+        "  propose-evaluator <job_pda> <addr>  (provider) counter-propose a different evaluator",
+        "  client-accept-evaluator <job_pda>   (client) accept provider's counter-proposal",
+        "  client-reject-evaluator <job_pda>   (client) reject provider's counter-proposal",
+        "",
+        "Recurring jobs:",
+        "  reopen-job <job_pda>                (keeper) reopen a complete recurring job",
+        "  cancel-recurring <job_pda>          (client) cancel a recurring job",
+        "  update-evaluator <job_pda> <addr>   (client) set evaluator for next cycle",
+    ].join("\n"));
+}
+async function cmdWhoami(connection, wallet) {
+    const bal = await connection.getBalance(wallet.publicKey, "confirmed");
+    // eslint-disable-next-line no-console
+    console.log([
+        "Wallet:",
+        `  Pubkey:  ${wallet.publicKey.toBase58()}`,
+        `  Balance: ${(bal / web3_js_1.LAMPORTS_PER_SOL).toFixed(4)} SOL`,
+        "",
+        "Program:",
+        `  ProgramID: ${sdk_1.PROGRAM_ID.toBase58()}`,
+        `  RPC:       ${RPC_URL}`,
+    ].join("\n"));
+}
+async function cmdCreateJob(connection, wallet, argv) {
+    // Parse boolean flags
+    const bilateralIdx = argv.indexOf("--bilateral");
+    const bilateral = bilateralIdx !== -1;
+    if (bilateral)
+        argv.splice(bilateralIdx, 1);
+    const lockProviderIdx = argv.indexOf("--lock-provider");
+    const lockProvider = lockProviderIdx !== -1;
+    if (lockProvider)
+        argv.splice(lockProviderIdx, 1);
+    const lockEvaluatorIdx = argv.indexOf("--lock-evaluator");
+    const lockEvaluator = lockEvaluatorIdx !== -1;
+    if (lockEvaluator)
+        argv.splice(lockEvaluatorIdx, 1);
+    // Parse --recurrence <secs>
+    const recurrenceIdx = argv.indexOf("--recurrence");
+    let recurrenceInterval = new anchor.BN(0);
+    if (recurrenceIdx !== -1) {
+        const recurrenceStr = argv[recurrenceIdx + 1];
+        if (!recurrenceStr || !Number.isFinite(Number(recurrenceStr))) {
+            die("--recurrence requires a positive integer (seconds).");
+        }
+        recurrenceInterval = new anchor.BN(recurrenceStr);
+        argv.splice(recurrenceIdx, 2);
+    }
+    const task = argv[0];
+    const amountSolStr = argv[1];
+    const evaluatorStr = argv[2];
+    const expirySecondsStr = argv[3];
+    if (!task || !amountSolStr || !evaluatorStr)
+        usage();
+    const amountSol = Number(amountSolStr);
+    if (!Number.isFinite(amountSol) || amountSol <= 0)
+        die("amount_sol must be a positive number.");
+    let evaluator;
+    try {
+        evaluator = new web3_js_1.PublicKey(evaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const expirySeconds = expirySecondsStr ? Number(expirySecondsStr) : 300;
+    if (!Number.isFinite(expirySeconds) || expirySeconds <= 0)
+        die("expiry_seconds must be a positive number.");
+    const { txSig, jobPda, jobId } = await (0, sdk_1.createJob)(connection, wallet, task, amountSol, evaluator, expirySeconds, bilateral, recurrenceInterval, lockProvider, lockEvaluator);
+    // eslint-disable-next-line no-console
+    console.log([
+        bilateral ? "Job created (awaiting evaluator agreement)!" : "Job created and funded!",
+        `  Job ID:    #${jobId.toString()}`,
+        `  PDA:       ${jobPda.toBase58()}`,
+        `  Task:      ${JSON.stringify(task)}`,
+        `  Amount:    ${amountSol} SOL`,
+        `  Evaluator: ${evaluator.toBase58()}`,
+        `  Bilateral: ${bilateral}`,
+        `  Expiry:    ${expirySeconds}s from now`,
+        ...(recurrenceInterval.gtn(0)
+            ? [
+                `  Recurrence: every ${recurrenceInterval.toString()}s`,
+                `  Lock provider: ${lockProvider}`,
+                `  Lock evaluator: ${lockEvaluator}`,
+            ]
+            : []),
+        `  TX:        ${txSig}`,
+        ...(bilateral ? ["", "  Waiting for provider to accept or propose an evaluator before you can fund."] : []),
+    ].join("\n"));
+}
+async function cmdFund(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.fundJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Funded. TX: ${tx}`);
+}
+async function cmdAcceptEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.acceptEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Evaluator accepted. TX: ${tx}`);
+}
+async function cmdProposeEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const newEvaluatorStr = argv[1];
+    if (!pdaStr || !newEvaluatorStr)
+        usage();
+    let newEvaluator;
+    try {
+        newEvaluator = new web3_js_1.PublicKey(newEvaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const tx = await (0, sdk_1.proposeEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr), newEvaluator);
+    // eslint-disable-next-line no-console
+    console.log(`Counter-evaluator proposed. TX: ${tx}`);
+}
+async function cmdClientAcceptEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.clientAcceptEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Counter-proposal accepted. Evaluator updated. TX: ${tx}`);
+}
+async function cmdClientRejectEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.clientRejectEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Counter-proposal rejected. Job reset to Open. TX: ${tx}`);
+}
+async function cmdListJobs(connection, wallet, argv) {
+    const statusIdx = argv.findIndex((a) => a === "--status");
+    const status = statusIdx >= 0 ? argv[statusIdx + 1] : "all";
+    const all = await (0, sdk_1.getAllJobs)(connection, wallet);
+    const rows = all.map((j) => {
+        const acct = j.account;
+        const state = parseState(acct.state);
+        return {
+            jobId: acct.jobId?.toString?.() ?? "—",
+            pda: j.publicKey.toBase58(),
+            state,
+            amountSol: (acct.amountLamports?.toNumber?.() ?? 0) / web3_js_1.LAMPORTS_PER_SOL,
+            task: acct.task ?? "",
+            client: acct.client?.toBase58?.() ?? "",
+            provider: acct.provider?.toBase58?.() ?? "",
+            evaluator: acct.evaluator?.toBase58?.() ?? "",
+            resultHash: acct.resultHash ?? "",
+            expiry: acct.expiry?.toNumber?.() ?? 0,
+            recurrenceInterval: acct.recurrenceInterval?.toNumber?.() ?? 0,
+            recurrenceCount: acct.recurrenceCount?.toNumber?.() ?? 0,
+        };
+    });
+    const filtered = !status || status === "all"
+        ? rows
+        : rows.filter((r) => r.state.toLowerCase() === String(status).toLowerCase());
+    filtered.sort((a, b) => Number(b.jobId) - Number(a.jobId));
+    // eslint-disable-next-line no-console
+    console.log([
+        `Jobs (${filtered.length}/${rows.length})`,
+        "",
+        ...filtered.map((r) => {
+            const provider = r.provider === "11111111111111111111111111111111" ? "—" : r.provider;
+            const recurringLine = r.recurrenceInterval > 0
+                ? `\n  Recurrence: every ${r.recurrenceInterval}s (cycle #${r.recurrenceCount})`
+                : "";
+            return [
+                `#${r.jobId}  ${r.state.padEnd(11)}  ${r.amountSol.toFixed(4)} SOL`,
+                `  PDA:       ${r.pda}`,
+                `  Client:    ${r.client}`,
+                `  Provider:  ${provider}`,
+                `  Evaluator: ${r.evaluator}`,
+                `  Result:    ${r.resultHash || "—"}`,
+                `  Task:      ${r.task.length > 120 ? r.task.slice(0, 117) + "..." : r.task}${recurringLine}`,
+            ].join("\n");
+        }),
+    ].join("\n"));
+}
+async function cmdShowJob(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const jobPda = new web3_js_1.PublicKey(pdaStr);
+    const program = (0, sdk_1.getProgram)(connection, wallet);
+    const job = await program.account.job.fetch(jobPda);
+    const state = parseState(job.state);
+    const recurrenceInterval = job.recurrenceInterval?.toNumber?.() ?? 0;
+    // eslint-disable-next-line no-console
+    console.log([
+        "Job:",
+        `  PDA:      ${jobPda.toBase58()}`,
+        `  ID:       ${job.jobId.toString()}`,
+        `  State:    ${state}`,
+        `  Task:     ${JSON.stringify(job.task)}`,
+        `  Amount:   ${Number(job.amountLamports.toString()) / web3_js_1.LAMPORTS_PER_SOL} SOL`,
+        `  Client:   ${job.client.toBase58()}`,
+        `  Provider: ${job.provider.toBase58()}`,
+        `  Evaluator:${job.evaluator.toBase58()}`,
+        `  Expiry:   ${job.expiry.toString()}`,
+        `  Result:   ${JSON.stringify(job.resultHash || "")}`,
+        ...(recurrenceInterval > 0
+            ? [
+                `  Recurrence: every ${recurrenceInterval}s`,
+                `  Cycle:      #${job.recurrenceCount?.toString()}`,
+                `  CompletedAt:${job.completedAt?.toString()}`,
+                `  LockProvider: ${job.lockProvider}`,
+                `  LockEvaluator: ${job.lockEvaluator}`,
+            ]
+            : []),
+    ].join("\n"));
+}
+async function cmdSubmit(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const result = argv[1];
+    if (!pdaStr || !result)
+        usage();
+    const tx = await (0, sdk_1.submitResult)(connection, wallet, new web3_js_1.PublicKey(pdaStr), result);
+    // eslint-disable-next-line no-console
+    console.log(`Submitted. TX: ${tx}`);
+}
+async function cmdApprove(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.approveJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Approved. TX: ${tx}`);
+}
+async function cmdReject(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.rejectJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Rejected. TX: ${tx}`);
+}
+async function cmdExpire(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.expireJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Expired. TX: ${tx}`);
+}
+async function cmdReopenJob(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.reopenJob)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Reopened. TX: ${tx}`);
+}
+async function cmdCancelRecurring(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    if (!pdaStr)
+        usage();
+    const tx = await (0, sdk_1.cancelRecurring)(connection, wallet, new web3_js_1.PublicKey(pdaStr));
+    // eslint-disable-next-line no-console
+    console.log(`Recurring job cancelled. TX: ${tx}`);
+}
+async function cmdUpdateEvaluator(connection, wallet, argv) {
+    const pdaStr = argv[0];
+    const newEvaluatorStr = argv[1];
+    if (!pdaStr || !newEvaluatorStr)
+        usage();
+    let newEvaluator;
+    try {
+        newEvaluator = new web3_js_1.PublicKey(newEvaluatorStr);
+    }
+    catch {
+        die("Invalid evaluator pubkey.");
+    }
+    const tx = await (0, sdk_1.updateEvaluator)(connection, wallet, new web3_js_1.PublicKey(pdaStr), newEvaluator);
+    // eslint-disable-next-line no-console
+    console.log(`Evaluator updated. TX: ${tx}`);
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    if (!command)
+        usage();
+    const wallet = loadKeypair();
+    const connection = new web3_js_1.Connection(RPC_URL, "confirmed");
+    switch (command) {
+        case "whoami":
+            await cmdWhoami(connection, wallet);
+            return;
+        case "create-job":
+            await cmdCreateJob(connection, wallet, rest);
+            return;
+        case "fund":
+            await cmdFund(connection, wallet, rest);
+            return;
+        case "list-jobs":
+            await cmdListJobs(connection, wallet, rest);
+            return;
+        case "show-job":
+            await cmdShowJob(connection, wallet, rest);
+            return;
+        case "submit":
+            await cmdSubmit(connection, wallet, rest);
+            return;
+        case "approve":
+            await cmdApprove(connection, wallet, rest);
+            return;
+        case "reject":
+            await cmdReject(connection, wallet, rest);
+            return;
+        case "expire":
+            await cmdExpire(connection, wallet, rest);
+            return;
+        case "accept-evaluator":
+            await cmdAcceptEvaluator(connection, wallet, rest);
+            return;
+        case "propose-evaluator":
+            await cmdProposeEvaluator(connection, wallet, rest);
+            return;
+        case "client-accept-evaluator":
+            await cmdClientAcceptEvaluator(connection, wallet, rest);
+            return;
+        case "client-reject-evaluator":
+            await cmdClientRejectEvaluator(connection, wallet, rest);
+            return;
+        case "reopen-job":
+            await cmdReopenJob(connection, wallet, rest);
+            return;
+        case "cancel-recurring":
+            await cmdCancelRecurring(connection, wallet, rest);
+            return;
+        case "update-evaluator":
+            await cmdUpdateEvaluator(connection, wallet, rest);
+            return;
+        default:
+            usage();
+    }
+}
+main().catch((e) => die(e?.message || String(e)));

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@dymchenko/en-sdk",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript SDK for the En Protocol — trustless agent commerce on Solana",
   "main": "dist/sdk.js",
   "types": "dist/sdk.d.ts",
+  "bin": {
+    "en": "dist/cli.js"
+  },
   "exports": {
     ".": {
       "require": "./dist/sdk.js",