@spfunctions/cli 1.4.4 → 1.4.5

package/dist/commands/telegram.d.ts

@@ -0,0 +1,15 @@
+/**
+ * sf telegram — Start Telegram bot
+ *
+ * Token is saved to ~/.sf/config.json on first use.
+ * --daemon: fork to background, write PID to ~/.sf/telegram.pid
+ * --stop: kill running daemon
+ * --status: check if daemon is running
+ */
+export declare function telegramCommand(opts: {
+    token?: string;
+    chatId?: string;
+    daemon?: boolean;
+    stop?: boolean;
+    status?: boolean;
+}): Promise<void>;

package/dist/commands/telegram.js

@@ -0,0 +1,125 @@
+"use strict";
+/**
+ * sf telegram — Start Telegram bot
+ *
+ * Token is saved to ~/.sf/config.json on first use.
+ * --daemon: fork to background, write PID to ~/.sf/telegram.pid
+ * --stop: kill running daemon
+ * --status: check if daemon is running
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramCommand = telegramCommand;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const config_js_1 = require("../config.js");
+const PID_FILE = path_1.default.join(os_1.default.homedir(), '.sf', 'telegram.pid');
+const LOG_FILE = path_1.default.join(os_1.default.homedir(), '.sf', 'telegram.log');
+function readPid() {
+    try {
+        const pid = parseInt(fs_1.default.readFileSync(PID_FILE, 'utf-8').trim());
+        if (isNaN(pid))
+            return null;
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve token: --token flag > config > env var. Save to config if new. */
+function resolveToken(flagToken) {
+    const config = (0, config_js_1.loadConfig)();
+    // Flag takes priority
+    if (flagToken) {
+        // Save to config for future use
+        const file = (0, config_js_1.loadFileConfig)();
+        if (file.telegramBotToken !== flagToken) {
+            (0, config_js_1.saveConfig)({ ...file, telegramBotToken: flagToken });
+        }
+        return flagToken;
+    }
+    return config.telegramBotToken || null;
+}
+async function telegramCommand(opts) {
+    // ── sf telegram --stop ──
+    if (opts.stop) {
+        const pid = readPid();
+        if (pid) {
+            process.kill(pid, 'SIGTERM');
+            try {
+                fs_1.default.unlinkSync(PID_FILE);
+            }
+            catch { }
+            console.log(`  Telegram bot stopped (PID ${pid})`);
+        }
+        else {
+            console.log('  No running Telegram bot found.');
+        }
+        return;
+    }
+    // ── sf telegram --status ──
+    if (opts.status) {
+        const pid = readPid();
+        if (pid) {
+            console.log(`  Telegram bot running (PID ${pid})`);
+            console.log(`  Log: ${LOG_FILE}`);
+        }
+        else {
+            console.log('  Telegram bot not running.');
+        }
+        return;
+    }
+    // Resolve token (saves to config on first use)
+    const token = resolveToken(opts.token);
+    if (!token) {
+        console.log('  No Telegram bot token configured.\n');
+        console.log('  Setup:');
+        console.log('    1. Message @BotFather on Telegram → /newbot');
+        console.log('    2. Copy the token');
+        console.log('    3. Run: sf telegram --token YOUR_TOKEN\n');
+        console.log('  The token will be saved to ~/.sf/config.json for future use.');
+        return;
+    }
+    // ── sf telegram --daemon ──
+    if (opts.daemon) {
+        const existing = readPid();
+        if (existing) {
+            console.log(`  Bot already running (PID ${existing}). Use --stop first.`);
+            return;
+        }
+        // Daemon doesn't need --token since it's in config now
+        const args = ['telegram'];
+        if (opts.chatId)
+            args.push('--chat-id', opts.chatId);
+        const sfBin = process.argv[1];
+        fs_1.default.mkdirSync(path_1.default.dirname(PID_FILE), { recursive: true });
+        const logStream = fs_1.default.openSync(LOG_FILE, 'a');
+        const child = (0, child_process_1.spawn)(process.execPath, [sfBin, ...args], {
+            detached: true,
+            stdio: ['ignore', logStream, logStream],
+            env: { ...process.env },
+        });
+        child.unref();
+        fs_1.default.writeFileSync(PID_FILE, String(child.pid));
+        console.log(`  Telegram bot started in background (PID ${child.pid})`);
+        console.log(`  Log: ${LOG_FILE}`);
+        console.log(`  Stop: sf telegram --stop`);
+        return;
+    }
+    // ── sf telegram (foreground) ──
+    const { startBot } = await import('../telegram/bot.js');
+    await startBot({
+        token,
+        chatId: opts.chatId ? parseInt(opts.chatId) : undefined,
+    });
+}

package/dist/config.d.ts

@@ -16,6 +16,7 @@ export interface SFConfig {
     tavilyKey?: string;
     model?: string;
     tradingEnabled?: boolean;
+    telegramBotToken?: string;
     configuredAt?: string;
 }
 /**

package/dist/config.js

@@ -53,6 +53,7 @@ function loadConfig() {
         tavilyKey: process.env.TAVILY_API_KEY || file.tavilyKey,
         model: process.env.SF_MODEL || file.model || DEFAULT_MODEL,
         tradingEnabled: file.tradingEnabled || false,
+        telegramBotToken: process.env.TELEGRAM_BOT_TOKEN || file.telegramBotToken,
     };
 }
 /**

package/dist/config.test.d.ts

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

package/dist/config.test.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('fs', () => ({
+    default: {
+        existsSync: vitest_1.vi.fn(),
+        readFileSync: vitest_1.vi.fn(),
+        writeFileSync: vitest_1.vi.fn(),
+        mkdirSync: vitest_1.vi.fn(),
+        unlinkSync: vitest_1.vi.fn(),
+    },
+    existsSync: vitest_1.vi.fn(),
+    readFileSync: vitest_1.vi.fn(),
+    writeFileSync: vitest_1.vi.fn(),
+    mkdirSync: vitest_1.vi.fn(),
+    unlinkSync: vitest_1.vi.fn(),
+}));
+const fs_1 = __importDefault(require("fs"));
+const config_js_1 = require("./config.js");
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.mocked(fs_1.default.existsSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.readFileSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.writeFileSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.mkdirSync).mockReset();
+    vitest_1.vi.mocked(fs_1.default.unlinkSync).mockReset();
+    // Clear env vars
+    delete process.env.SF_API_KEY;
+    delete process.env.SF_API_URL;
+    delete process.env.OPENROUTER_API_KEY;
+    delete process.env.KALSHI_API_KEY_ID;
+    delete process.env.KALSHI_PRIVATE_KEY_PATH;
+    delete process.env.TAVILY_API_KEY;
+    delete process.env.SF_MODEL;
+    delete process.env.TELEGRAM_BOT_TOKEN;
+});
+(0, vitest_1.describe)('loadFileConfig', () => {
+    (0, vitest_1.it)('returns empty object when no config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({});
+    });
+    (0, vitest_1.it)('reads and parses config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({ apiKey: 'sf_live_test' }));
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({ apiKey: 'sf_live_test' });
+    });
+    (0, vitest_1.it)('returns empty object on corrupt file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue('not json');
+        (0, vitest_1.expect)((0, config_js_1.loadFileConfig)()).toEqual({});
+    });
+});
+(0, vitest_1.describe)('loadConfig', () => {
+    (0, vitest_1.it)('returns defaults when no file and no env', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiUrl).toBe('https://simplefunctions.dev');
+        (0, vitest_1.expect)(config.model).toBe('anthropic/claude-sonnet-4.6');
+        (0, vitest_1.expect)(config.tradingEnabled).toBe(false);
+    });
+    (0, vitest_1.it)('env vars override file values', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            model: 'file_model',
+        }));
+        process.env.SF_API_KEY = 'env_key';
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('env_key');
+        (0, vitest_1.expect)(config.model).toBe('file_model');
+    });
+    (0, vitest_1.it)('file values fill gaps', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            tavilyKey: 'tavily123',
+        }));
+        const config = (0, config_js_1.loadConfig)();
+        (0, vitest_1.expect)(config.apiKey).toBe('file_key');
+        (0, vitest_1.expect)(config.tavilyKey).toBe('tavily123');
+    });
+});
+(0, vitest_1.describe)('saveConfig', () => {
+    (0, vitest_1.it)('writes JSON with configuredAt', () => {
+        (0, config_js_1.saveConfig)({ apiKey: 'test_key' });
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.mkdirSync)).toHaveBeenCalled();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.writeFileSync)).toHaveBeenCalled();
+        const written = JSON.parse(vitest_1.vi.mocked(fs_1.default.writeFileSync).mock.calls[0][1]);
+        (0, vitest_1.expect)(written.apiKey).toBe('test_key');
+        (0, vitest_1.expect)(written.configuredAt).toBeDefined();
+    });
+});
+(0, vitest_1.describe)('applyConfig', () => {
+    (0, vitest_1.it)('sets env vars from file when not already set', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+            openrouterKey: 'or_key',
+        }));
+        (0, config_js_1.applyConfig)();
+        (0, vitest_1.expect)(process.env.SF_API_KEY).toBe('file_key');
+        (0, vitest_1.expect)(process.env.OPENROUTER_API_KEY).toBe('or_key');
+    });
+    (0, vitest_1.it)('does not override existing env vars', () => {
+        process.env.SF_API_KEY = 'existing_key';
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fs_1.default.readFileSync).mockReturnValue(JSON.stringify({
+            apiKey: 'file_key',
+        }));
+        (0, config_js_1.applyConfig)();
+        (0, vitest_1.expect)(process.env.SF_API_KEY).toBe('existing_key');
+    });
+});
+(0, vitest_1.describe)('isConfigured', () => {
+    (0, vitest_1.it)('returns true when apiKey is set', () => {
+        process.env.SF_API_KEY = 'test';
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.isConfigured)()).toBe(true);
+    });
+    (0, vitest_1.it)('returns false when no apiKey', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, vitest_1.expect)((0, config_js_1.isConfigured)()).toBe(false);
+    });
+});
+(0, vitest_1.describe)('resetConfig', () => {
+    (0, vitest_1.it)('deletes config file if exists', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(true);
+        (0, config_js_1.resetConfig)();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.unlinkSync)).toHaveBeenCalled();
+    });
+    (0, vitest_1.it)('does nothing if no config file', () => {
+        vitest_1.vi.mocked(fs_1.default.existsSync).mockReturnValue(false);
+        (0, config_js_1.resetConfig)();
+        (0, vitest_1.expect)(vitest_1.vi.mocked(fs_1.default.unlinkSync)).not.toHaveBeenCalled();
+    });
+});

package/dist/index.js

@@ -52,6 +52,7 @@ const announcements_js_1 = require("./commands/announcements.js");
 const history_js_1 = require("./commands/history.js");
 const performance_js_1 = require("./commands/performance.js");
 const liquidity_js_1 = require("./commands/liquidity.js");
+const telegram_js_1 = require("./commands/telegram.js");
 const utils_js_1 = require("./utils.js");
 // ── Apply ~/.sf/config.json to process.env BEFORE any command ────────────────
 // This means client.ts, kalshi.ts, agent.ts keep reading process.env and just work.
@@ -238,11 +239,12 @@ program
 // ── sf dashboard ──────────────────────────────────────────────────────────────
 program
     .command('dashboard')
-    .description('Portfolio overview — theses, positions, risk, unpositioned edges')
+    .description('Portfolio overview — interactive TUI (default), or one-shot with --once/--json')
     .option('--json', 'JSON output')
+    .option('--once', 'One-time print (no interactive mode)')
     .action(async (opts, cmd) => {
     const g = cmd.optsWithGlobals();
-    await run(() => (0, dashboard_js_1.dashboardCommand)({ json: opts.json, apiKey: g.apiKey, apiUrl: g.apiUrl }));
+    await run(() => (0, dashboard_js_1.dashboardCommand)({ json: opts.json, once: opts.once, apiKey: g.apiKey, apiUrl: g.apiUrl }));
 });
 // ── sf milestones ────────────────────────────────────────────────────────────
 program
@@ -409,6 +411,18 @@ program
     .action(async (opts) => {
     await run(() => (0, liquidity_js_1.liquidityCommand)(opts));
 });
+// ── sf telegram ──────────────────────────────────────────────────────────────
+program
+    .command('telegram')
+    .description('Start Telegram bot for monitoring and trading')
+    .option('--token <token>', 'Telegram bot token (or set TELEGRAM_BOT_TOKEN)')
+    .option('--chat-id <id>', 'Restrict to specific chat ID')
+    .option('--daemon', 'Run in background')
+    .option('--stop', 'Stop background bot')
+    .option('--status', 'Check if bot is running')
+    .action(async (opts) => {
+    await run(() => (0, telegram_js_1.telegramCommand)(opts));
+});
 // ── sf strategies ─────────────────────────────────────────────────────────────
 (0, strategies_js_1.registerStrategies)(program);
 // ── Error wrapper ─────────────────────────────────────────────────────────────

package/dist/telegram/agent-bridge.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Agent bridge — connects Telegram to pi-agent-core
+ *
+ * Uses the SAME tools as sf agent --plain. Multi-turn tool calling
+ * is handled by pi-agent-core's Agent class (not manual OpenRouter calls).
+ */
+import { SFClient } from '../client.js';
+interface SessionState {
+    thesisId: string | null;
+    agentMessages: any[];
+    agent?: any;
+}
+export declare function getOrCreateAgent(sfClient: SFClient, session: SessionState): Promise<any>;
+export declare function runAgentMessage(client: SFClient, session: SessionState, userMessage: string): Promise<string>;
+export {};