@solarains/va-cli 0.1.1

package/dist/features/auth/browser-login.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPkcePair = createPkcePair;
+exports.createCliState = createCliState;
+exports.createCliSessionId = createCliSessionId;
+exports.startLoopbackListener = startLoopbackListener;
+exports.openSystemBrowser = openSystemBrowser;
+exports.renderQrCode = renderQrCode;
+exports.pollForCliRedeemableSession = pollForCliRedeemableSession;
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const loopback_callback_page_1 = require("./loopback-callback-page");
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function createPkcePair() {
+    const codeVerifier = (0, node_crypto_1.randomBytes)(48).toString('base64url');
+    const codeChallenge = (0, node_crypto_1.createHash)('sha256')
+        .update(codeVerifier)
+        .digest('base64url');
+    return {
+        codeVerifier,
+        codeChallenge,
+        method: 'S256',
+    };
+}
+function createCliState() {
+    return (0, node_crypto_1.randomBytes)(24).toString('base64url');
+}
+function createCliSessionId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+async function startLoopbackListener(expectedState, locale = 'en') {
+    let resolveCallback = null;
+    let rejectCallback = null;
+    const callbackPromise = new Promise((resolve, reject) => {
+        resolveCallback = resolve;
+        rejectCallback = reject;
+    });
+    callbackPromise.catch(() => {
+        // Prevent an early callback validation failure from surfacing as an
+        // unhandled rejection before waitForCallback attaches.
+    });
+    const server = (0, node_http_1.createServer)((request, response) => {
+        const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+        if (url.pathname !== '/callback') {
+            const page = (0, loopback_callback_page_1.renderLoopbackCallbackPage)({ kind: 'not-found' }, locale);
+            response.writeHead(page.statusCode, {
+                'content-type': 'text/html; charset=utf-8',
+            });
+            response.end(page.html);
+            return;
+        }
+        const sessionId = url.searchParams.get('session_id');
+        const state = url.searchParams.get('state') ?? undefined;
+        if (!sessionId) {
+            const page = (0, loopback_callback_page_1.renderLoopbackCallbackPage)({ kind: 'missing-session' }, locale);
+            response.writeHead(page.statusCode, {
+                'content-type': 'text/html; charset=utf-8',
+            });
+            response.end(page.html);
+            rejectCallback?.(new Error('Loopback callback is missing session_id.'));
+            return;
+        }
+        if (state !== expectedState) {
+            const page = (0, loopback_callback_page_1.renderLoopbackCallbackPage)({ kind: 'state-mismatch' }, locale);
+            response.writeHead(page.statusCode, {
+                'content-type': 'text/html; charset=utf-8',
+            });
+            response.end(page.html);
+            rejectCallback?.(new Error('Loopback callback state validation failed.'));
+            return;
+        }
+        const page = (0, loopback_callback_page_1.renderLoopbackCallbackPage)({ kind: 'success', sessionId }, locale);
+        response.writeHead(page.statusCode, {
+            'content-type': 'text/html; charset=utf-8',
+        });
+        response.end(page.html);
+        resolveCallback?.({
+            sessionId,
+            state,
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Failed to resolve loopback callback port.');
+    }
+    return {
+        port: address.port,
+        async waitForCallback(timeoutMs) {
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    reject(new Error('Loopback callback timed out.'));
+                }, timeoutMs);
+                callbackPromise
+                    .then((payload) => {
+                    clearTimeout(timer);
+                    resolve(payload);
+                })
+                    .catch((error) => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+            });
+        },
+        async close() {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        },
+    };
+}
+async function openSystemBrowser(url) {
+    const currentPlatform = (0, node_os_1.platform)();
+    const command = currentPlatform === 'darwin'
+        ? {
+            file: 'open',
+            args: [url],
+        }
+        : currentPlatform === 'win32'
+            ? {
+                file: 'cmd',
+                args: ['/c', 'start', '', url],
+            }
+            : {
+                file: 'xdg-open',
+                args: [url],
+            };
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(command.file, command.args, {
+            detached: true,
+            stdio: 'ignore',
+        });
+        let settled = false;
+        child.once('error', () => {
+            if (!settled) {
+                settled = true;
+                resolve(false);
+            }
+        });
+        child.once('spawn', () => {
+            if (!settled) {
+                settled = true;
+                child.unref();
+                resolve(true);
+            }
+        });
+    });
+}
+function renderQrCode(url) {
+    let output = '';
+    qrcode_terminal_1.default.generate(url, { small: true }, (qr) => {
+        output = qr;
+    });
+    return output.trim();
+}
+async function pollForCliRedeemableSession(getSession, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const session = await getSession();
+        if (session.canRedeemInCli) {
+            return session;
+        }
+        if (session.status === 'error') {
+            throw new Error(`Auth session entered ${session.state} state before redemption.`);
+        }
+        await delay(2000);
+    }
+    throw new Error('Timed out while waiting for browser authentication to finish.');
+}

package/dist/features/auth/installation-state.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureInstallationState = ensureInstallationState;
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = require("node:os");
+const CLI_VERSION = '0.1.0';
+function exportPublicKeyPem(publicKey) {
+    return publicKey.export({
+        type: 'spki',
+        format: 'pem',
+    });
+}
+function exportPrivateKeyPem(privateKey) {
+    return privateKey.export({
+        type: 'pkcs8',
+        format: 'pem',
+    });
+}
+function hasUsableKeys(installation) {
+    return Boolean(installation?.installationId &&
+        installation.publicKey &&
+        installation.privateKey &&
+        installation.keyFingerprint &&
+        installation.clientPlatform &&
+        installation.clientArch &&
+        installation.cliVersion &&
+        installation.createdAt &&
+        installation.updatedAt);
+}
+async function ensureInstallationState(installationStore) {
+    const existing = await installationStore.read();
+    const now = new Date().toISOString();
+    if (hasUsableKeys(existing)) {
+        const nextState = {
+            ...existing,
+            clientPlatform: (0, node_os_1.platform)(),
+            clientArch: (0, node_os_1.arch)(),
+            cliVersion: existing.cliVersion ?? CLI_VERSION,
+            deviceName: existing.deviceName ?? (0, node_os_1.hostname)(),
+            updatedAt: now,
+        };
+        await installationStore.save(nextState);
+        return nextState;
+    }
+    const { publicKey, privateKey } = (0, node_crypto_1.generateKeyPairSync)('ed25519');
+    const publicKeyPem = exportPublicKeyPem(publicKey);
+    const privateKeyPem = exportPrivateKeyPem(privateKey);
+    const keyFingerprint = (0, node_crypto_1.createHash)('sha256')
+        .update(publicKeyPem)
+        .digest('hex');
+    const installation = {
+        installationId: (0, node_crypto_1.randomUUID)(),
+        publicKey: publicKeyPem,
+        privateKey: privateKeyPem,
+        keyFingerprint,
+        clientPlatform: (0, node_os_1.platform)(),
+        clientArch: (0, node_os_1.arch)(),
+        cliVersion: CLI_VERSION,
+        deviceName: (0, node_os_1.hostname)(),
+        createdAt: now,
+        updatedAt: now,
+    };
+    await installationStore.save(installation);
+    return installation;
+}

package/dist/features/auth/loopback-callback-page.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderLoopbackCallbackPage = renderLoopbackCallbackPage;
+const CALLBACK_PAGE_COPY = {
+    en: {
+        brand: 'VAOne',
+        closeAction: 'Close page',
+        success: {
+            title: 'Login successful',
+            description: 'You can return to the terminal. The CLI is finishing setup.',
+        },
+        errors: {
+            'missing-session': {
+                title: 'Callback data is incomplete',
+                description: 'The localhost callback did not include the session identifier required to finish CLI login.',
+            },
+            'state-mismatch': {
+                title: 'Callback validation failed',
+                description: 'The localhost callback did not match the expected CLI login state.',
+            },
+            'not-found': {
+                title: 'Callback path was not found',
+                description: 'This local VAOne listener only serves the CLI auth callback endpoint.',
+            },
+        },
+    },
+    'zh-CN': {
+        brand: 'VAOne',
+        closeAction: '关闭页面',
+        success: {
+            title: '登录成功',
+            description: '现在可以返回终端，CLI 正在完成剩余设置。',
+        },
+        errors: {
+            'missing-session': {
+                title: '回调数据不完整',
+                description: '本地回调没有包含完成 CLI 登录所需的 session identifier。',
+            },
+            'state-mismatch': {
+                title: '回调校验失败',
+                description: '本地回调与预期的 CLI 登录状态不匹配。',
+            },
+            'not-found': {
+                title: '未找到回调路径',
+                description: '这个本地 VAOne 监听器只服务于 CLI 登录回调端点。',
+            },
+        },
+    },
+};
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}
+function getTitle(copy, state) {
+    return state.kind === 'success'
+        ? copy.success.title
+        : copy.errors[state.kind].title;
+}
+function getStatusCode(state) {
+    switch (state.kind) {
+        case 'success':
+            return 200;
+        case 'not-found':
+            return 404;
+        default:
+            return 400;
+    }
+}
+function renderBody(copy, state) {
+    if (state.kind === 'success') {
+        return `
+      <h1>${escapeHtml(copy.success.title)}</h1>
+      <p class="description">${escapeHtml(copy.success.description)}</p>
+      <div class="actions">
+        <button type="button" onclick="closeCurrentPage()">${escapeHtml(copy.closeAction)}</button>
+      </div>
+    `;
+    }
+    const errorCopy = copy.errors[state.kind];
+    return `
+    <h1>${escapeHtml(errorCopy.title)}</h1>
+    <p class="description">${escapeHtml(errorCopy.description)}</p>
+    <div class="actions">
+      <button type="button" onclick="closeCurrentPage()">${escapeHtml(copy.closeAction)}</button>
+    </div>
+  `;
+}
+function renderLoopbackCallbackPage(state, locale = 'en') {
+    const copy = CALLBACK_PAGE_COPY[locale];
+    const title = getTitle(copy, state);
+    return {
+        statusCode: getStatusCode(state),
+        html: `<!doctype html>
+<html lang="${locale}">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(copy.brand)} | ${escapeHtml(title)}</title>
+    <script>
+      function closeCurrentPage() {
+        try {
+          window.close();
+        } catch {}
+
+        setTimeout(() => {
+          try {
+            window.open('', '_self');
+          } catch {}
+
+          try {
+            window.close();
+          } catch {}
+
+          setTimeout(() => {
+            if (!document.hidden) {
+              window.location.replace('about:blank');
+            }
+          }, 120);
+        }, 80);
+      }
+    </script>
+    <style>
+      :root {
+        color-scheme: dark;
+        --color-bg-base: #111315;
+        --color-bg-surface: #121821;
+        --color-border-subtle: #2b3644;
+        --color-text-primary: #eff5fb;
+        --color-text-secondary: #a2b2c4;
+        --color-brand: #6cb6ff;
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+        background:
+          radial-gradient(circle at top, rgb(108 182 255 / 16%), transparent 24%),
+          linear-gradient(180deg, #0c1117 0%, #0a0f14 58%, #080c11 100%);
+        color: var(--color-text-primary);
+        font-family: "IBM Plex Sans", "Segoe UI", sans-serif;
+      }
+
+      .panel {
+        width: min(100%, 560px);
+        border: 1px solid var(--color-border-subtle);
+        border-radius: 22px;
+        background: var(--color-bg-surface);
+        box-shadow: 0 20px 60px rgb(0 0 0 / 28%);
+        padding: 28px 28px 30px;
+      }
+
+      .brand {
+        margin: 0 0 24px;
+        font-family: "JetBrains Mono", "SFMono-Regular", monospace;
+        font-size: 13px;
+        font-weight: 700;
+        letter-spacing: 0.16em;
+        text-transform: uppercase;
+        color: var(--color-brand);
+      }
+
+      h1 {
+        margin: 0;
+        font-size: 34px;
+        line-height: 1.05;
+      }
+
+      .description {
+        margin: 16px 0 0;
+        max-width: 28rem;
+        line-height: 1.6;
+        color: var(--color-text-secondary);
+      }
+
+      .actions {
+        margin-top: 24px;
+      }
+
+      button {
+        appearance: none;
+        border: 1px solid var(--color-border-subtle);
+        border-radius: 999px;
+        background: #1b2532;
+        color: var(--color-text-primary);
+        padding: 10px 18px;
+        font: inherit;
+        font-weight: 600;
+        cursor: pointer;
+      }
+
+      button:hover {
+        background: #243243;
+      }
+
+      @media (max-width: 640px) {
+        body {
+          padding: 16px;
+        }
+
+        .panel {
+          padding: 22px;
+          border-radius: 20px;
+        }
+
+        h1 {
+          font-size: 30px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main class="panel">
+      <p class="brand">${escapeHtml(copy.brand)}</p>
+      ${renderBody(copy, state)}
+    </main>
+  </body>
+</html>`,
+    };
+}

package/dist/features/daily-reports/daily-reports-api-client.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listDailyReports = listDailyReports;
+exports.getDailyReportDetail = getDailyReportDetail;
+const authenticated_api_client_1 = require("../auth/authenticated-api-client");
+function createQueryString(query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined) {
+            continue;
+        }
+        searchParams.set(key, String(value));
+    }
+    const encoded = searchParams.toString();
+    return encoded ? `?${encoded}` : '';
+}
+async function listDailyReports(context, query) {
+    return (0, authenticated_api_client_1.requestAuthenticatedJson)(context, `/v1/asset-intelligence/daily-reports${createQueryString(query)}`);
+}
+async function getDailyReportDetail(context, assetId, query) {
+    return (0, authenticated_api_client_1.requestAuthenticatedJson)(context, `/v1/asset-intelligence/daily-reports/${encodeURIComponent(assetId)}${createQueryString(query)}`);
+}

package/dist/features/daily-reports/daily-reports-output.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDailyReportList = renderDailyReportList;
+exports.renderDailyReportDetail = renderDailyReportDetail;
+const output_1 = require("../../shared/output");
+function formatAssetName(report) {
+    return report.assetNameZh || report.assetNameEn || report.assetId;
+}
+function renderDailyReportList(logger, reports, selectionSummary) {
+    (0, output_1.printSection)(logger, 'Daily report selection');
+    (0, output_1.printKeyValue)(logger, 'Status', selectionSummary.statusLabel);
+    if (selectionSummary.selectedReportKey) {
+        (0, output_1.printKeyValue)(logger, 'Locked report', selectionSummary.selectedReportKey);
+    }
+    (0, output_1.printSection)(logger, 'Available reports');
+    if (!reports.length) {
+        logger.info('No reports matched the current filters.');
+        return;
+    }
+    reports.forEach((report, index) => {
+        if (index > 0) {
+            logger.plain('');
+        }
+        (0, output_1.printKeyValue)(logger, 'Asset', `${formatAssetName(report)} (${report.assetId})`);
+        (0, output_1.printKeyValue)(logger, 'Date', report.date);
+        (0, output_1.printKeyValue)(logger, 'Category', report.category || 'unknown');
+        (0, output_1.printKeyValue)(logger, 'Sentiment', `bullish ${report.sentimentCount.bullish}, neutral ${report.sentimentCount.neutral}, bearish ${report.sentimentCount.bearish}`);
+        (0, output_1.printList)(logger, [report.summary || 'No summary available.']);
+    });
+}
+function renderDailyReportDetail(logger, report, selectionMessage) {
+    (0, output_1.printSection)(logger, 'Daily report');
+    (0, output_1.printKeyValue)(logger, 'Asset', `${formatAssetName(report)} (${report.assetId})`);
+    (0, output_1.printKeyValue)(logger, 'Date', report.date);
+    (0, output_1.printKeyValue)(logger, 'Category', report.category || 'unknown');
+    (0, output_1.printKeyValue)(logger, 'Selection', selectionMessage);
+    (0, output_1.printSection)(logger, 'Summary');
+    (0, output_1.printList)(logger, [report.summary || 'No summary available.']);
+    (0, output_1.printSection)(logger, 'Content');
+    const paragraphs = report.content
+        .split(/\n\s*\n/g)
+        .map((paragraph) => paragraph.trim())
+        .filter(Boolean);
+    if (!paragraphs.length) {
+        logger.info('No report content is available.');
+        return;
+    }
+    paragraphs.forEach((paragraph, index) => {
+        if (index > 0) {
+            logger.plain('');
+        }
+        logger.plain(paragraph);
+    });
+}

package/dist/features/init/detect-targets.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAgentTargets = detectAgentTargets;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const target_registry_1 = require("./target-registry");
+async function exists(path) {
+    try {
+        await (0, promises_1.access)(path, node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function detectAgentTargets(input) {
+    const projectCodex = await exists((0, node_path_1.join)(input.cwd, '.codex'));
+    const userCodex = await exists((0, node_path_1.join)(input.homeDir, '.codex'));
+    const projectClaude = await exists((0, node_path_1.join)(input.cwd, '.claude'));
+    const userClaude = await exists((0, node_path_1.join)(input.homeDir, '.claude'));
+    const projectOpenClaw = await exists((0, node_path_1.join)(input.cwd, 'skills'));
+    const userOpenClaw = await exists((0, node_path_1.join)(input.homeDir, '.openclaw'));
+    return (0, target_registry_1.getAgentTargetRegistry)().map((target) => {
+        const detectedIn = [];
+        if (target.id === 'codex') {
+            if (projectCodex) {
+                detectedIn.push('workspace');
+            }
+            if (userCodex) {
+                detectedIn.push('user');
+            }
+        }
+        if (target.id === 'claude') {
+            if (projectClaude) {
+                detectedIn.push('workspace');
+            }
+            if (userClaude) {
+                detectedIn.push('user');
+            }
+        }
+        if (target.id === 'openclaw') {
+            if (projectOpenClaw) {
+                detectedIn.push('workspace');
+            }
+            if (userOpenClaw) {
+                detectedIn.push('user');
+            }
+        }
+        return {
+            targetId: target.id,
+            displayName: target.displayName,
+            detected: detectedIn.length > 0,
+            detectedIn,
+        };
+    });
+}