@vincentai/cli 0.1.1

package/dist/commands/brave/news.js

@@ -0,0 +1,25 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('brave news', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'q', description: 'Search query', required: true },
+            { name: 'count', description: 'Number of results (1-20)' },
+            { name: 'freshness', description: 'Time filter: pd, pw, pm, py' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const params = { q: getRequired(flags, 'q') };
+    const count = getOptional(flags, 'count');
+    if (count)
+        params.count = count;
+    const freshness = getOptional(flags, 'freshness');
+    if (freshness)
+        params.freshness = freshness;
+    const res = await vincentGet('/api/data-sources/brave/news', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/brave/web.js

@@ -0,0 +1,33 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('brave web', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'q', description: 'Search query', required: true },
+            { name: 'count', description: 'Number of results (1-20)' },
+            { name: 'offset', description: 'Pagination offset (0-9)' },
+            { name: 'freshness', description: 'Time filter: pd, pw, pm, py' },
+            { name: 'country', description: '2-letter country code' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const params = { q: getRequired(flags, 'q') };
+    const count = getOptional(flags, 'count');
+    if (count)
+        params.count = count;
+    const offset = getOptional(flags, 'offset');
+    if (offset)
+        params.offset = offset;
+    const freshness = getOptional(flags, 'freshness');
+    if (freshness)
+        params.freshness = freshness;
+    const country = getOptional(flags, 'country');
+    if (country)
+        params.country = country;
+    const res = await vincentGet('/api/data-sources/brave/web', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/balance.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket balance', [{ name: 'key-id', description: 'API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentGet('/api/skills/polymarket/balance', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/bet.js

@@ -0,0 +1,27 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket bet', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'token-id', description: 'Outcome token ID', required: true },
+            { name: 'side', description: 'BUY or SELL', required: true },
+            { name: 'amount', description: 'USD amount (BUY) or shares (SELL)', required: true },
+            { name: 'price', description: 'Limit price 0.01-0.99 (omit for market order)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const body = {
+        tokenId: getRequired(flags, 'token-id'),
+        side: getRequired(flags, 'side'),
+        amount: Number(getRequired(flags, 'amount')),
+    };
+    const price = getOptional(flags, 'price');
+    if (price)
+        body.price = Number(price);
+    const res = await vincentPost('/api/skills/polymarket/bet', apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/cancel-all.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentDelete } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket cancel-all', [{ name: 'key-id', description: 'API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentDelete('/api/skills/polymarket/orders', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/cancel-order.js

@@ -0,0 +1,17 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentDelete } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket cancel-order', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'order-id', description: 'Order ID to cancel', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const orderId = getRequired(flags, 'order-id');
+    const res = await vincentDelete(`/api/skills/polymarket/orders/${orderId}`, apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/holdings.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket holdings', [{ name: 'key-id', description: 'API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentGet('/api/skills/polymarket/holdings', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/market.js

@@ -0,0 +1,17 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket market', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'condition-id', description: 'Market condition ID', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const conditionId = getRequired(flags, 'condition-id');
+    const res = await vincentGet(`/api/skills/polymarket/market/${conditionId}`, apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/markets.js

@@ -0,0 +1,31 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket markets', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'query', description: 'Search query' },
+            { name: 'slug', description: 'Market slug or Polymarket URL' },
+            { name: 'active', description: 'Only active markets (flag)' },
+            { name: 'limit', description: 'Max results (default: 20)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const params = {};
+    const query = getOptional(flags, 'query');
+    if (query)
+        params.query = query;
+    const slug = getOptional(flags, 'slug');
+    if (slug)
+        params.slug = slug;
+    if (flags['active'] === true || flags['active'] === 'true')
+        params.active = 'true';
+    const limit = getOptional(flags, 'limit');
+    if (limit)
+        params.limit = limit;
+    const res = await vincentGet('/api/skills/polymarket/markets', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/open-orders.js

@@ -0,0 +1,20 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket open-orders', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'market', description: 'Filter by market condition ID' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const params = {};
+    const market = getOptional(flags, 'market');
+    if (market)
+        params.market = market;
+    const res = await vincentGet('/api/skills/polymarket/open-orders', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/orderbook.js

@@ -0,0 +1,17 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket orderbook', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'token-id', description: 'Outcome token ID', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const tokenId = getRequired(flags, 'token-id');
+    const res = await vincentGet(`/api/skills/polymarket/orderbook/${tokenId}`, apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/redeem.js

@@ -0,0 +1,20 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket redeem', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'condition-ids', description: 'Comma-separated condition IDs (omit to redeem all)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const body = {};
+    const conditionIds = getOptional(flags, 'condition-ids');
+    if (conditionIds)
+        body.conditionIds = conditionIds.split(',');
+    const res = await vincentPost('/api/skills/polymarket/redeem', apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/polymarket/trades.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('polymarket trades', [{ name: 'key-id', description: 'API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentGet('/api/skills/polymarket/trades', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/raw-signer/addresses.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('raw-signer addresses', [{ name: 'key-id', description: 'API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'RAW_SIGNER');
+    const res = await vincentGet('/api/skills/raw-signer/addresses', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/raw-signer/sign.js

@@ -0,0 +1,20 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('raw-signer sign', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'message', description: 'Hex-encoded message to sign (0x...)', required: true },
+            { name: 'curve', description: 'Signing curve: ethereum or solana', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'RAW_SIGNER');
+    const res = await vincentPost('/api/skills/raw-signer/sign', apiKey, {
+        message: getRequired(flags, 'message'),
+        curve: getRequired(flags, 'curve'),
+    });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/secret/create.js

@@ -0,0 +1,41 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { vincentPost } from '../../lib/client.js';
+import { storeKey } from '../../lib/keystore.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('secret create', [
+            {
+                name: 'type',
+                description: 'Secret type (EVM_WALLET, RAW_SIGNER, POLYMARKET_WALLET, DATA_SOURCES)',
+                required: true,
+            },
+            { name: 'memo', description: 'Description for this secret', required: true },
+            { name: 'chain-id', description: 'Chain ID (for EVM_WALLET)' },
+        ]);
+        return;
+    }
+    const type = getRequired(flags, 'type');
+    const memo = getRequired(flags, 'memo');
+    const chainId = getOptional(flags, 'chain-id');
+    const body = { type, memo };
+    if (chainId)
+        body.chainId = Number(chainId);
+    const res = (await vincentPost('/api/secrets', null, body));
+    const apiKey = res.apiKey;
+    const keyId = res.apiKeyId || res.id;
+    storeKey({
+        id: keyId,
+        apiKey,
+        type,
+        memo,
+        secretId: res.secretId || res.id,
+        createdAt: new Date().toISOString(),
+    });
+    console.log(JSON.stringify({
+        keyId,
+        claimUrl: res.claimUrl,
+        address: res.address,
+        secretId: res.secretId || res.id,
+    }, null, 2));
+}

package/dist/commands/secret/list.js

@@ -0,0 +1,17 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { listKeys } from '../../lib/keystore.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('secret list', [
+            {
+                name: 'type',
+                description: 'Filter by type (EVM_WALLET, RAW_SIGNER, POLYMARKET_WALLET, DATA_SOURCES)',
+            },
+        ]);
+        return;
+    }
+    const type = getOptional(flags, 'type');
+    const keys = listKeys(type);
+    console.log(JSON.stringify(keys.map((k) => ({ id: k.id, type: k.type, memo: k.memo, createdAt: k.createdAt })), null, 2));
+}

package/dist/commands/secret/relink.js

@@ -0,0 +1,35 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { vincentPost } from '../../lib/client.js';
+import { storeKey } from '../../lib/keystore.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('secret relink', [
+            { name: 'token', description: 'Re-link token from the wallet owner', required: true },
+        ]);
+        return;
+    }
+    const token = getRequired(flags, 'token');
+    const res = (await vincentPost('/api/secrets/relink', null, {
+        relinkToken: token,
+        apiKeyName: 'Re-linked API Key',
+    }));
+    const secret = res.secret;
+    const apiKeyObj = res.apiKey;
+    const apiKey = apiKeyObj.key;
+    const keyId = apiKeyObj.id;
+    const type = secret.type;
+    storeKey({
+        id: keyId,
+        apiKey,
+        type,
+        memo: `Re-linked ${type}`,
+        secretId: secret.id,
+        createdAt: new Date().toISOString(),
+    });
+    console.log(JSON.stringify({
+        keyId,
+        secretId: secret.id,
+        type,
+    }, null, 2));
+}

package/dist/commands/trade-manager/create-rule.js

@@ -0,0 +1,34 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager create-rule', [
+            { name: 'key-id', description: 'Polymarket API key ID' },
+            { name: 'market-id', description: 'Market condition ID', required: true },
+            { name: 'token-id', description: 'Outcome token ID', required: true },
+            {
+                name: 'rule-type',
+                description: 'STOP_LOSS, TAKE_PROFIT, or TRAILING_STOP',
+                required: true,
+            },
+            { name: 'trigger-price', description: 'Trigger price (0-1)', required: true },
+            { name: 'trailing-percent', description: 'Trailing percent (TRAILING_STOP only)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const body = {
+        marketId: getRequired(flags, 'market-id'),
+        tokenId: getRequired(flags, 'token-id'),
+        ruleType: getRequired(flags, 'rule-type'),
+        triggerPrice: Number(getRequired(flags, 'trigger-price')),
+        action: { type: 'SELL_ALL' },
+    };
+    const trailingPercent = getOptional(flags, 'trailing-percent');
+    if (trailingPercent)
+        body.trailingPercent = Number(trailingPercent);
+    const res = await vincentPost('/api/rules', apiKey, body, { baseUrl: getTradeManagerBaseUrl() });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/delete-rule.js

@@ -0,0 +1,19 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentDelete, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager delete-rule', [
+            { name: 'key-id', description: 'Polymarket API key ID' },
+            { name: 'rule-id', description: 'Rule ID to delete', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const ruleId = getRequired(flags, 'rule-id');
+    const res = await vincentDelete(`/api/rules/${ruleId}`, apiKey, {
+        baseUrl: getTradeManagerBaseUrl(),
+    });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/events.js

@@ -0,0 +1,30 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager events', [
+            { name: 'key-id', description: 'Polymarket API key ID' },
+            { name: 'rule-id', description: 'Filter by rule ID' },
+            { name: 'limit', description: 'Max results (1-1000, default: 100)' },
+            { name: 'offset', description: 'Pagination offset' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const params = {};
+    const ruleId = getOptional(flags, 'rule-id');
+    if (ruleId)
+        params.ruleId = ruleId;
+    const limit = getOptional(flags, 'limit');
+    if (limit)
+        params.limit = limit;
+    const offset = getOptional(flags, 'offset');
+    if (offset)
+        params.offset = offset;
+    const res = await vincentGet('/api/events', apiKey, params, {
+        baseUrl: getTradeManagerBaseUrl(),
+    });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/health.js

@@ -0,0 +1,11 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { vincentGet, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager health', []);
+        return;
+    }
+    const res = await vincentGet('/health', null, undefined, { baseUrl: getTradeManagerBaseUrl() });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/list-rules.js

@@ -0,0 +1,20 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager list-rules', [
+            { name: 'key-id', description: 'Polymarket API key ID' },
+            { name: 'status', description: 'Filter by status (ACTIVE, TRIGGERED, CANCELED, FAILED)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const params = {};
+    const status = getOptional(flags, 'status');
+    if (status)
+        params.status = status;
+    const res = await vincentGet('/api/rules', apiKey, params, { baseUrl: getTradeManagerBaseUrl() });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/positions.js

@@ -0,0 +1,15 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager positions', [{ name: 'key-id', description: 'Polymarket API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentGet('/api/positions', apiKey, undefined, {
+        baseUrl: getTradeManagerBaseUrl(),
+    });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/status.js

@@ -0,0 +1,13 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager status', [{ name: 'key-id', description: 'Polymarket API key ID' }]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const res = await vincentGet('/status', apiKey, undefined, { baseUrl: getTradeManagerBaseUrl() });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/trade-manager/update-rule.js

@@ -0,0 +1,20 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPatch, getTradeManagerBaseUrl } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('trade-manager update-rule', [
+            { name: 'key-id', description: 'Polymarket API key ID' },
+            { name: 'rule-id', description: 'Rule ID to update', required: true },
+            { name: 'trigger-price', description: 'New trigger price', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'POLYMARKET_WALLET');
+    const ruleId = getRequired(flags, 'rule-id');
+    const res = await vincentPatch(`/api/rules/${ruleId}`, apiKey, {
+        triggerPrice: Number(getRequired(flags, 'trigger-price')),
+    }, { baseUrl: getTradeManagerBaseUrl() });
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/twitter/search.js

@@ -0,0 +1,29 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('twitter search', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'q', description: 'Search query', required: true },
+            { name: 'max-results', description: 'Max results (default: 10)' },
+            { name: 'start-time', description: 'Start time (ISO 8601)' },
+            { name: 'end-time', description: 'End time (ISO 8601)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const params = { q: getRequired(flags, 'q') };
+    const maxResults = getOptional(flags, 'max-results');
+    if (maxResults)
+        params.max_results = maxResults;
+    const startTime = getOptional(flags, 'start-time');
+    if (startTime)
+        params.start_time = startTime;
+    const endTime = getOptional(flags, 'end-time');
+    if (endTime)
+        params.end_time = endTime;
+    const res = await vincentGet('/api/data-sources/twitter/search', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/twitter/tweet.js

@@ -0,0 +1,17 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('twitter tweet', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'tweet-id', description: 'Tweet ID', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const tweetId = getRequired(flags, 'tweet-id');
+    const res = await vincentGet(`/api/data-sources/twitter/tweets/${tweetId}`, apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/twitter/user-tweets.js

@@ -0,0 +1,22 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('twitter user-tweets', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'user-id', description: 'Twitter user ID', required: true },
+            { name: 'max-results', description: 'Max results' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const userId = getRequired(flags, 'user-id');
+    const params = {};
+    const maxResults = getOptional(flags, 'max-results');
+    if (maxResults)
+        params.max_results = maxResults;
+    const res = await vincentGet(`/api/data-sources/twitter/users/${userId}/tweets`, apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/twitter/user.js

@@ -0,0 +1,17 @@
+import { parseArgs, getRequired, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('twitter user', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'username', description: 'Twitter username', required: true },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'DATA_SOURCES');
+    const username = getRequired(flags, 'username');
+    const res = await vincentGet(`/api/data-sources/twitter/users/${username}`, apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/address.js

@@ -0,0 +1,18 @@
+import { parseArgs, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('wallet address', [
+            {
+                name: 'key-id',
+                description: 'API key ID (auto-discovered if only one EVM_WALLET key exists)',
+            },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    const res = await vincentGet('/api/skills/evm-wallet/address', apiKey);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/balances.js

@@ -0,0 +1,20 @@
+import { parseArgs, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('wallet balances', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'chain-ids', description: 'Comma-separated chain IDs to filter' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    const params = {};
+    const chainIds = getOptional(flags, 'chain-ids');
+    if (chainIds)
+        params.chainIds = chainIds;
+    const res = await vincentGet('/api/skills/evm-wallet/balances', apiKey, params);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/send-tx.js

@@ -0,0 +1,25 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('wallet send-tx', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'to', description: 'Contract address', required: true },
+            { name: 'data', description: 'Hex-encoded calldata', required: true },
+            { name: 'value', description: 'ETH value to send (default: 0)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    const body = {
+        to: getRequired(flags, 'to'),
+        data: getRequired(flags, 'data'),
+    };
+    const value = getOptional(flags, 'value');
+    if (value)
+        body.value = value;
+    const res = await vincentPost('/api/skills/evm-wallet/send-transaction', apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/swap.js

@@ -0,0 +1,36 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags, positional } = parseArgs(argv);
+    const subcommand = positional[0];
+    if (hasFlag(flags, 'help') || !subcommand) {
+        showHelp('wallet swap <preview|execute>', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'sell-token', description: 'Token address to sell', required: true },
+            { name: 'buy-token', description: 'Token address to buy', required: true },
+            { name: 'sell-amount', description: 'Amount to sell', required: true },
+            { name: 'chain-id', description: 'Chain ID', required: true },
+            { name: 'slippage', description: 'Slippage tolerance in basis points (execute only)' },
+        ]);
+        return;
+    }
+    if (subcommand !== 'preview' && subcommand !== 'execute') {
+        console.error(`Unknown subcommand: ${subcommand}. Use "preview" or "execute".`);
+        process.exit(1);
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    const body = {
+        sellToken: getRequired(flags, 'sell-token'),
+        buyToken: getRequired(flags, 'buy-token'),
+        sellAmount: getRequired(flags, 'sell-amount'),
+        chainId: Number(getRequired(flags, 'chain-id')),
+    };
+    if (subcommand === 'execute') {
+        const slippage = getOptional(flags, 'slippage');
+        if (slippage)
+            body.slippageBps = Number(slippage);
+    }
+    const res = await vincentPost(`/api/skills/evm-wallet/swap/${subcommand}`, apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/transfer-between.js

@@ -0,0 +1,57 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost, vincentGet } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags, positional } = parseArgs(argv);
+    const subcommand = positional[0];
+    if (hasFlag(flags, 'help') || !subcommand) {
+        showHelp('wallet transfer-between <preview|execute|status>', [
+            { name: 'key-id', description: 'API key ID' },
+            {
+                name: 'to-secret-id',
+                description: 'Destination secret ID (preview/execute)',
+                required: true,
+            },
+            { name: 'from-chain', description: 'Source chain ID (preview/execute)', required: true },
+            { name: 'to-chain', description: 'Destination chain ID (preview/execute)', required: true },
+            {
+                name: 'token-in',
+                description: 'Input token address or ETH (preview/execute)',
+                required: true,
+            },
+            { name: 'amount', description: 'Amount to transfer (preview/execute)', required: true },
+            {
+                name: 'token-out',
+                description: 'Output token address or ETH (preview/execute)',
+                required: true,
+            },
+            { name: 'slippage', description: 'Slippage in basis points' },
+            { name: 'relay-id', description: 'Relay request ID (status only)' },
+        ]);
+        return;
+    }
+    if (subcommand !== 'preview' && subcommand !== 'execute' && subcommand !== 'status') {
+        console.error(`Unknown subcommand: ${subcommand}. Use "preview", "execute", or "status".`);
+        process.exit(1);
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    if (subcommand === 'status') {
+        const relayId = getRequired(flags, 'relay-id');
+        const res = await vincentGet(`/api/skills/evm-wallet/transfer-between-secrets/status/${relayId}`, apiKey);
+        console.log(JSON.stringify(res, null, 2));
+        return;
+    }
+    const body = {
+        toSecretId: getRequired(flags, 'to-secret-id'),
+        fromChainId: Number(getRequired(flags, 'from-chain')),
+        toChainId: Number(getRequired(flags, 'to-chain')),
+        tokenIn: getRequired(flags, 'token-in'),
+        tokenInAmount: getRequired(flags, 'amount'),
+        tokenOut: getRequired(flags, 'token-out'),
+    };
+    const slippage = getOptional(flags, 'slippage');
+    if (slippage)
+        body.slippage = Number(slippage);
+    const res = await vincentPost(`/api/skills/evm-wallet/transfer-between-secrets/${subcommand}`, apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/commands/wallet/transfer.js

@@ -0,0 +1,25 @@
+import { parseArgs, getRequired, getOptional, hasFlag, showHelp } from '../../lib/args.js';
+import { resolveApiKey } from '../../lib/keystore.js';
+import { vincentPost } from '../../lib/client.js';
+export async function run(argv) {
+    const { flags } = parseArgs(argv);
+    if (hasFlag(flags, 'help')) {
+        showHelp('wallet transfer', [
+            { name: 'key-id', description: 'API key ID' },
+            { name: 'to', description: 'Recipient address', required: true },
+            { name: 'amount', description: 'Amount to transfer', required: true },
+            { name: 'token', description: 'ERC-20 token contract address (omit for native ETH)' },
+        ]);
+        return;
+    }
+    const apiKey = resolveApiKey(flags, 'EVM_WALLET');
+    const body = {
+        to: getRequired(flags, 'to'),
+        amount: getRequired(flags, 'amount'),
+    };
+    const token = getOptional(flags, 'token');
+    if (token)
+        body.token = token;
+    const res = await vincentPost('/api/skills/evm-wallet/transfer', apiKey, body);
+    console.log(JSON.stringify(res, null, 2));
+}

package/dist/index.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+const COMMANDS = {
+    secret: {
+        create: () => import('./commands/secret/create.js'),
+        relink: () => import('./commands/secret/relink.js'),
+        list: () => import('./commands/secret/list.js'),
+    },
+    wallet: {
+        address: () => import('./commands/wallet/address.js'),
+        balances: () => import('./commands/wallet/balances.js'),
+        transfer: () => import('./commands/wallet/transfer.js'),
+        swap: () => import('./commands/wallet/swap.js'),
+        'send-tx': () => import('./commands/wallet/send-tx.js'),
+        'transfer-between': () => import('./commands/wallet/transfer-between.js'),
+    },
+    'raw-signer': {
+        addresses: () => import('./commands/raw-signer/addresses.js'),
+        sign: () => import('./commands/raw-signer/sign.js'),
+    },
+    polymarket: {
+        balance: () => import('./commands/polymarket/balance.js'),
+        markets: () => import('./commands/polymarket/markets.js'),
+        market: () => import('./commands/polymarket/market.js'),
+        orderbook: () => import('./commands/polymarket/orderbook.js'),
+        bet: () => import('./commands/polymarket/bet.js'),
+        holdings: () => import('./commands/polymarket/holdings.js'),
+        'open-orders': () => import('./commands/polymarket/open-orders.js'),
+        trades: () => import('./commands/polymarket/trades.js'),
+        'cancel-order': () => import('./commands/polymarket/cancel-order.js'),
+        'cancel-all': () => import('./commands/polymarket/cancel-all.js'),
+        redeem: () => import('./commands/polymarket/redeem.js'),
+    },
+    twitter: {
+        search: () => import('./commands/twitter/search.js'),
+        tweet: () => import('./commands/twitter/tweet.js'),
+        user: () => import('./commands/twitter/user.js'),
+        'user-tweets': () => import('./commands/twitter/user-tweets.js'),
+    },
+    brave: {
+        web: () => import('./commands/brave/web.js'),
+        news: () => import('./commands/brave/news.js'),
+    },
+    'trade-manager': {
+        health: () => import('./commands/trade-manager/health.js'),
+        status: () => import('./commands/trade-manager/status.js'),
+        'create-rule': () => import('./commands/trade-manager/create-rule.js'),
+        'list-rules': () => import('./commands/trade-manager/list-rules.js'),
+        'update-rule': () => import('./commands/trade-manager/update-rule.js'),
+        'delete-rule': () => import('./commands/trade-manager/delete-rule.js'),
+        positions: () => import('./commands/trade-manager/positions.js'),
+        events: () => import('./commands/trade-manager/events.js'),
+    },
+};
+function printHelp() {
+    console.log(`Usage: vincent <group> <command> [options]
+
+Groups and commands:
+`);
+    for (const [group, commands] of Object.entries(COMMANDS)) {
+        console.log(`  ${group}`);
+        for (const cmd of Object.keys(commands)) {
+            console.log(`    ${cmd}`);
+        }
+        console.log();
+    }
+    console.log('Options:');
+    console.log('  --help     Show help for a command');
+    console.log('  --version  Show version');
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+        printHelp();
+        process.exit(0);
+    }
+    if (argv[0] === '--version' || argv[0] === '-v') {
+        console.log('0.1.0');
+        process.exit(0);
+    }
+    const group = argv[0];
+    const command = argv[1];
+    const rest = argv.slice(2);
+    const groupCommands = COMMANDS[group];
+    if (!groupCommands) {
+        console.error(`Unknown group: ${group}`);
+        console.error(`Run "vincent --help" for available groups.`);
+        process.exit(1);
+    }
+    if (!command || command === '--help' || command === '-h') {
+        console.log(`Available commands for "${group}":\n`);
+        for (const cmd of Object.keys(groupCommands)) {
+            console.log(`  vincent ${group} ${cmd}`);
+        }
+        console.log(`\nRun "vincent ${group} <command> --help" for command-specific help.`);
+        process.exit(0);
+    }
+    const loader = groupCommands[command];
+    if (!loader) {
+        console.error(`Unknown command: ${group} ${command}`);
+        console.error(`Run "vincent ${group} --help" for available commands.`);
+        process.exit(1);
+    }
+    const mod = await loader();
+    await mod.run(rest);
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+});
+export {};

package/dist/lib/args.js

@@ -0,0 +1,71 @@
+export function parseArgs(argv) {
+    const flags = {};
+    const positional = [];
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            const next = argv[i + 1];
+            if (next === undefined || next.startsWith('--')) {
+                flags[key] = true;
+                i++;
+            }
+            else {
+                flags[key] = next;
+                i += 2;
+            }
+        }
+        else {
+            positional.push(arg);
+            i++;
+        }
+    }
+    return { flags, positional };
+}
+export function getRequired(flags, name) {
+    const val = flags[name];
+    if (typeof val !== 'string') {
+        console.error(`Missing required option: --${name}`);
+        process.exit(1);
+    }
+    return val;
+}
+export function getOptional(flags, name) {
+    const val = flags[name];
+    if (typeof val !== 'string')
+        return undefined;
+    return val;
+}
+export function getNumber(flags, name) {
+    const val = getOptional(flags, name);
+    if (val === undefined)
+        return undefined;
+    const n = Number(val);
+    if (isNaN(n)) {
+        console.error(`Invalid number for --${name}: ${val}`);
+        process.exit(1);
+    }
+    return n;
+}
+export function getRequiredNumber(flags, name) {
+    const val = getRequired(flags, name);
+    const n = Number(val);
+    if (isNaN(n)) {
+        console.error(`Invalid number for --${name}: ${val}`);
+        process.exit(1);
+    }
+    return n;
+}
+export function hasFlag(flags, name) {
+    return flags[name] === true || flags[name] !== undefined;
+}
+export function showHelp(command, args) {
+    console.log(`Usage: vincent ${command} [options]\n`);
+    console.log('Options:');
+    for (const arg of args) {
+        const req = arg.required ? ' (required)' : '';
+        console.log(`  --${arg.name.padEnd(20)} ${arg.description}${req}`);
+    }
+    console.log(`  --${'help'.padEnd(20)} Show this help message`);
+}

package/dist/lib/client.js

@@ -0,0 +1,61 @@
+const DEFAULT_BASE_URL = 'https://heyvincent.ai';
+const TRADE_MANAGER_BASE_URL = 'http://localhost:19000';
+function getBaseUrl() {
+    return process.env.VINCENT_BASE_URL || DEFAULT_BASE_URL;
+}
+export function getTradeManagerBaseUrl() {
+    return process.env.VINCENT_TRADE_MANAGER_URL || TRADE_MANAGER_BASE_URL;
+}
+async function request(method, path, apiKey, body, opts) {
+    const base = opts?.baseUrl || getBaseUrl();
+    const url = `${base}${path}`;
+    const headers = {};
+    if (apiKey) {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        data = text;
+    }
+    if (!res.ok) {
+        const msg = typeof data === 'object' && data !== null
+            ? data.message ||
+                data.error ||
+                text
+            : text;
+        console.error(`API error (${res.status}): ${msg}`);
+        process.exit(1);
+    }
+    return data;
+}
+export function vincentGet(path, apiKey, params, opts) {
+    let fullPath = path;
+    if (params) {
+        const entries = Object.entries(params).filter(([, v]) => v !== undefined && v !== '');
+        if (entries.length > 0) {
+            fullPath += '?' + new URLSearchParams(entries).toString();
+        }
+    }
+    return request('GET', fullPath, apiKey, undefined, opts);
+}
+export function vincentPost(path, apiKey, body, opts) {
+    return request('POST', path, apiKey, body, opts);
+}
+export function vincentDelete(path, apiKey, opts) {
+    return request('DELETE', path, apiKey, undefined, opts);
+}
+export function vincentPatch(path, apiKey, body, opts) {
+    return request('PATCH', path, apiKey, body, opts);
+}

package/dist/lib/keystore.js

@@ -0,0 +1,99 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const TYPE_DIRS = {
+    EVM_WALLET: 'agentwallet',
+    POLYMARKET_WALLET: 'agentwallet',
+    RAW_SIGNER: 'agentwallet',
+    DATA_SOURCES: 'datasources',
+};
+function getCredentialsRoot() {
+    const stateDir = process.env.OPENCLAW_STATE_DIR || join(homedir(), '.openclaw');
+    return join(stateDir, 'credentials');
+}
+function getDirForType(type) {
+    const subdir = TYPE_DIRS[type];
+    if (!subdir) {
+        throw new Error(`Unknown secret type: ${type}`);
+    }
+    return join(getCredentialsRoot(), subdir);
+}
+export function storeKey(keyData) {
+    const dir = getDirForType(keyData.type);
+    mkdirSync(dir, { recursive: true });
+    const filePath = join(dir, `${keyData.id}.json`);
+    writeFileSync(filePath, JSON.stringify(keyData, null, 2) + '\n');
+}
+export function getKey(keyId) {
+    const root = getCredentialsRoot();
+    for (const subdir of ['agentwallet', 'datasources']) {
+        const filePath = join(root, subdir, `${keyId}.json`);
+        if (existsSync(filePath)) {
+            const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+            return data.apiKey;
+        }
+    }
+    console.error(`Key not found: ${keyId}`);
+    console.error(`Searched in: ${root}/agentwallet/ and ${root}/datasources/`);
+    process.exit(1);
+}
+export function getKeyData(keyId) {
+    const root = getCredentialsRoot();
+    for (const subdir of ['agentwallet', 'datasources']) {
+        const filePath = join(root, subdir, `${keyId}.json`);
+        if (existsSync(filePath)) {
+            return JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+    }
+    console.error(`Key not found: ${keyId}`);
+    console.error(`Searched in: ${root}/agentwallet/ and ${root}/datasources/`);
+    process.exit(1);
+}
+export function listKeys(type) {
+    const root = getCredentialsRoot();
+    const keys = [];
+    const subdirs = type ? [TYPE_DIRS[type]] : ['agentwallet', 'datasources'];
+    for (const subdir of subdirs) {
+        if (!subdir)
+            continue;
+        const dir = join(root, subdir);
+        if (!existsSync(dir))
+            continue;
+        for (const file of readdirSync(dir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(readFileSync(join(dir, file), 'utf-8'));
+                if (!type || data.type === type) {
+                    keys.push(data);
+                }
+            }
+            catch {
+                // skip malformed files
+            }
+        }
+    }
+    return keys;
+}
+export function findKey(type) {
+    const keys = listKeys(type);
+    if (keys.length === 0) {
+        console.error(`No ${type} key found. Create one with: vincent secret create --type ${type}`);
+        process.exit(1);
+    }
+    if (keys.length > 1) {
+        console.error(`Multiple ${type} keys found. Specify one with --key-id:`);
+        for (const k of keys) {
+            console.error(`  ${k.id} — ${k.memo}`);
+        }
+        process.exit(1);
+    }
+    return keys[0].apiKey;
+}
+export function resolveApiKey(flags, type) {
+    const keyId = flags['key-id'];
+    if (typeof keyId === 'string') {
+        return getKey(keyId);
+    }
+    return findKey(type);
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@vincentai/cli",
+  "version": "0.1.1",
+  "description": "CLI for Vincent AI agent skills",
+  "type": "module",
+  "bin": {
+    "vincent": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "vincent",
+    "ai-agent",
+    "wallet",
+    "cli"
+  ],
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  }
+}