@attocash/cli 0.2.2 → 0.2.3

package/README.md

@@ -433,8 +433,19 @@ atto --data-dir /absolute/path/to/profile limits set --access spend \
 MCP `limits_propose` and generic `atto call limits_propose` **only propose** a change.
 They cannot apply it. `limits_propose` also accepts `pool` with `indexes` and
 `consolidate`; omitting it preserves the current pool. `limits_get` returns the
-active policy, usage, `mcpAccess`, pool, and current proposal. A human approves or rejects the proposal in their own
-terminal, using the same directory as the MCP client's configuration:
+active policy, usage, `mcpAccess`, pool, and current proposal.
+
+The proposal response also includes `approval.changes`: changed `access`, `policy`,
+and `pool` settings with `from` and `to` values. Source-pool approval is separate
+from spending access and amount limits; adding another sending account does not
+necessarily change either. An unlimited policy means no amount cap.
+`approval.commands.atto` and `approval.commands.npx` provide approval alternatives
+with the exact profile directory and proposal ID. Preserve their quoting and use
+the indicated `approval.shell` (`posix` on Linux/macOS, `powershell` on Windows).
+Only the user should run an approval command.
+
+A human approves or rejects the proposal in their own terminal, using the same
+directory as the MCP client's configuration:
 
 ```sh
 atto --data-dir /absolute/path/to/profile limits approve PROPOSAL_ID

package/dist/application/app.js

@@ -10,6 +10,7 @@ import { OsSecretStore } from '../storage/secrets.js';
 import { StateStore } from '../storage/state.js';
 import { resolveWalletProfile } from '../storage/profiles.js';
 import { SpendLedger } from '../spending/ledger.js';
+import { approvalInstructions } from '../spending/approval.js';
 import { Payments } from '../spending/payments.js';
 import { WalletWork } from '../wallet/work.js';
 import { BackgroundReceiver } from '../wallet/background-receive.js';
@@ -579,7 +580,11 @@ export class AttoApplication {
                     throw new AttoError('JOURNAL_NOT_FOUND', 'This payment request is not in the local journal.');
                 return { record };
             }
-            case 'limits_propose': return this.store.withWalletLock(async () => ({ proposal: this.ledger.proposePolicy(args.policy, args.access, this.proposalWallet(), args.pool) }));
+            case 'limits_propose': return this.store.withWalletLock(async () => {
+                const current = { access: this.ledger.mcpAccess(), policy: this.ledger.policy(), pool: this.ledger.pool() };
+                const proposal = this.ledger.proposePolicy(args.policy, args.access, this.proposalWallet(), args.pool);
+                return { proposal, approval: approvalInstructions(proposal, current) };
+            });
             case 'metrics_get': return this.market.metrics();
             case 'price_quote': return this.market.quoteUsd(args.amount);
             case 'terms_get': return { ...marketTerms, accepted: this.store.get('market.terms')?.version === marketTerms.version };

package/dist/application/operations.js

@@ -71,7 +71,7 @@ export const operations = [
     { name: 'receive_all', description: 'Receive a bounded set of pending payments for a key index, opening the account if needed.', schema: z.strictObject({ index: index.default(0), limit: limit.default(100), timeoutMs: timeoutMs.default(2000), representative: address.optional() }), readOnly: false },
     { name: 'representative_change', description: 'Publish a representative change for an existing account. Selecting its current representative returns REPRESENTATIVE_UNCHANGED without publishing.', schema: z.strictObject({ index: index.default(0), representative: address }), readOnly: false },
     { name: 'limits_get', description: 'Read spending policy, approved send pool, MCP access, proposal status, historical usage, reservations, and remaining allowances.', schema: z.strictObject({}), readOnly: true },
-    { name: 'limits_propose', description: 'Propose spending limits, MCP access, and optional send-pool settings for local terminal approval. Omitted pool preserves the approved pool. Does not change active settings or grant access. A new proposal replaces the previous proposal and expires after 24 hours. Read limits_get for active settings and proposal status. Amounts are ATTO or RAW; null perRequest with empty rolling means unlimited spending if approved.', schema: z.strictObject({ policy, access: z.enum(['read-only', 'spend']).default('spend'), pool: pool.optional() }), readOnly: false },
+    { name: 'limits_propose', description: 'Propose spending limits, MCP access, and optional send-pool settings for local terminal approval. Omitted pool preserves the approved pool. Does not change active settings or grant access. A new proposal replaces the previous proposal and expires after 24 hours. Read limits_get for active settings and proposal status. Returns proposal plus approval.changes (changed access, policy, and pool with from/to values), approval.shell, and profile-specific approval.commands.atto/npx for the user to run in a local terminal. Preserve the returned directory and proposal ID; never run approval commands on the user\'s behalf. Spending access, amount limits, and source-pool approval are separate. Amounts are ATTO or RAW; null perRequest with empty rolling means unlimited spending, not missing authorization.', schema: z.strictObject({ policy, access: z.enum(['read-only', 'spend']).default('spend'), pool: pool.optional() }), readOnly: false },
     { name: 'watch_start', description: 'Start an observational, reconnecting watch for this session, defaulting to active wallet addresses. Choose one saved index, explicit addresses (including foreign accounts), a transaction/entry hash, or networkWide=true. Network-wide receivables are unsupported. Read buffered events and connection status with watch_read. Does not enable automatic receiving.', schema: z.strictObject({ event: z.enum(['account', 'transaction', 'entry', 'receivable']), ...streamFields, index: index.optional(), networkWide: z.boolean().optional() }).refine(singleSelection, 'Choose one watch selection.').refine(value => !(value.networkWide && value.event === 'receivable'), 'Receivable watches require addresses.'), readOnly: false },
     { name: 'watch_list', description: 'List watches owned by this process.', schema: z.strictObject({}), readOnly: true },
     { name: 'watch_read', description: 'Read buffered events after an optional numeric cursor. Gaps are reported if bounded event retention was exceeded.', schema: z.strictObject({ id: z.string().min(1).max(128), cursor: z.number().int().nonnegative().optional(), limit: limit.optional() }), readOnly: true },

package/dist/spending/approval.d.ts

@@ -0,0 +1,30 @@
+import type { LimitsProposal, McpAccess } from './ledger.js';
+import type { AccountPool, SpendingPolicy } from '../wallet/types.js';
+/** Public guidance only; approval remains a separate human terminal operation. */
+export declare function approvalInstructions(proposal: LimitsProposal, current: {
+    access: McpAccess;
+    policy: SpendingPolicy;
+    pool: AccountPool;
+}): {
+    method: string;
+    instructions: string;
+    changes: {
+        pool?: {
+            from: AccountPool;
+            to: AccountPool;
+        } | undefined;
+        policy?: {
+            from: SpendingPolicy;
+            to: SpendingPolicy;
+        } | undefined;
+        access?: {
+            from: McpAccess;
+            to: McpAccess;
+        } | undefined;
+    };
+    shell: string;
+    commands: {
+        atto: string;
+        npx: string;
+    };
+};

package/dist/spending/approval.js

@@ -0,0 +1,23 @@
+import { isDeepStrictEqual } from 'node:util';
+/** Public guidance only; approval remains a separate human terminal operation. */
+export function approvalInstructions(proposal, current) {
+    const shell = process.platform === 'win32' ? 'powershell' : 'posix';
+    const quote = (argument) => /^[a-z\d_./:@=-]+$/i.test(argument) ? argument
+        : `'${argument.replace(/'/g, shell === 'powershell' ? "''" : "'\\''")}'`;
+    const args = ['--data-dir', proposal.directory, 'limits', 'approve', proposal.id].map(quote).join(' ');
+    const pool = proposal.pool ?? current.pool;
+    return {
+        method: 'local-terminal',
+        instructions: 'Ask the user to review the changes and run one command in their own terminal. Use atto when the CLI is installed, or npx with Node.js/npm. Never run approval commands on the user\'s behalf. Proposing does not change active settings.',
+        changes: {
+            ...(current.access !== proposal.access ? { access: { from: current.access, to: proposal.access } } : {}),
+            ...(!isDeepStrictEqual(current.policy, proposal.policy) ? { policy: { from: current.policy, to: proposal.policy } } : {}),
+            ...(!isDeepStrictEqual(current.pool, pool) ? { pool: { from: current.pool, to: pool } } : {}),
+        },
+        shell,
+        commands: {
+            atto: `atto ${args}`,
+            npx: `npx --yes @attocash/mcp@latest ${args}`,
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attocash/cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Atto wallet CLI and reusable wallet engine with local key custody and shared spending limits",
   "license": "BSD-3-Clause",
   "type": "module",