jfl 0.2.2 → 0.2.4

package/dist/commands/session.js

@@ -1,53 +1,197 @@
 import chalk from "chalk";
 import ora from "ora";
 import * as p from "@clack/prompts";
-import { existsSync } from "fs";
+import { execSync, spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import Conf from "conf";
-import { ensureDayPass, isTrialMode } from "../utils/auth-guard.js";
 import { ensureContextHub, getContextHubConfig } from "../utils/ensure-context-hub.js";
-import { isRunning as getContextHubStatus } from "./context-hub.js";
+import { isRunning as getContextHubStatus, ensureDaemonInstalled } from "./context-hub.js";
 import { initCommand } from "./init.js";
+import { authenticateWithGitHub, discoverJflProjects, cloneRepository, } from "../utils/github-auth.js";
+import { renderBanner, showHowItWorksNotice, theme } from "../ui/index.js";
 import axios from "axios";
+import { telemetry } from "../lib/telemetry.js";
 const config = new Conf({ projectName: "jfl" });
+const AUTONOMOUS_FLAGS = {
+    claude: "--dangerously-skip-permissions",
+    codex: "--full-auto",
+    aider: "--yes-always",
+    pi: "--yolo",
+    none: undefined,
+};
+const CHROME_FLAG = "--chrome";
 export async function sessionCommand(options = {}) {
     const cwd = process.cwd();
-    // Check if in a JFL project
     const hasJflConfig = existsSync(join(cwd, "CLAUDE.md")) || existsSync(join(cwd, "knowledge"));
     if (!hasJflConfig) {
         await onboardNewUser(cwd);
         return;
     }
-    // Check day pass for paid users (trial mode is free)
-    if (!isTrialMode()) {
-        console.log(chalk.yellow("\n💳 Payment required (teammates detected)\n"));
-        const dayPass = await ensureDayPass();
-        if (!dayPass) {
-            console.log(chalk.red("\n❌ Cannot start session without active Day Pass\n"));
-            console.log(chalk.gray("Run: jfl login --x402"));
-            console.log();
-            return;
-        }
-        console.log(chalk.green("✓ Day Pass verified\n"));
-    }
-    else {
-        console.log(chalk.green("🎁 Trial Mode") + chalk.gray(" - Free until foundation complete\n"));
-    }
     // Track this project
     const projects = config.get("projects") || [];
     if (!projects.includes(cwd)) {
         projects.push(cwd);
         config.set("projects", projects);
     }
-    // Show JFL Gateway Dashboard
-    await showGatewayDashboard();
+    // Auto-install daemon (fire-and-forget, silent)
+    ensureDaemonInstalled({ quiet: true }).catch(() => { });
+    // Check for saved CLI preference
+    let preferredCLI = config.get("aiCLI");
+    // Detect available CLIs
+    const available = detectAICLIs();
+    if (available.length === 0) {
+        await onboardAICLI();
+        return;
+    }
+    // If preference is set and still available, use it
+    if (preferredCLI) {
+        const preferred = available.find(cli => cli.command === preferredCLI);
+        if (preferred) {
+            await launchCLI(preferred, cwd);
+            return;
+        }
+    }
+    // If only one option, use it
+    if (available.length === 1) {
+        config.set("aiCLI", available[0].command);
+        await launchCLI(available[0], cwd);
+        return;
+    }
+    // Multiple options - let them choose
+    console.log(chalk.bold("\n🤖 JFL - AI Session\n"));
+    console.log(chalk.gray("Multiple AI CLIs detected:\n"));
+    const selected = await p.select({
+        message: "Which AI do you want to use?",
+        options: available.map(cli => ({
+            label: `${cli.name}${cli.version ? ` (${cli.version})` : ""}`,
+            value: cli.command,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Session cancelled.");
+        return;
+    }
+    const remember = await p.confirm({
+        message: "Remember this choice?",
+        initialValue: true,
+    });
+    if (!p.isCancel(remember) && remember) {
+        config.set("aiCLI", selected);
+    }
+    const cli = available.find(c => c.command === selected);
+    await launchCLI(cli, cwd);
+}
+function detectAICLIs() {
+    const clis = [];
+    try {
+        const version = execSync("claude --version 2>/dev/null", { encoding: "utf-8" }).trim();
+        clis.push({
+            name: "Claude Code",
+            command: "claude",
+            provider: "claude",
+            version: version.split("\n")[0],
+        });
+    }
+    catch { }
+    try {
+        const version = execSync("codex --version 2>/dev/null", { encoding: "utf-8" }).trim();
+        clis.push({
+            name: "Codex CLI",
+            command: "codex",
+            provider: "codex",
+            version,
+        });
+    }
+    catch { }
+    try {
+        const version = execSync("aider --version 2>/dev/null", { encoding: "utf-8" }).trim();
+        clis.push({
+            name: "Aider",
+            command: "aider",
+            provider: "aider",
+            version,
+        });
+    }
+    catch { }
+    try {
+        const version = execSync("pi --version 2>/dev/null", { encoding: "utf-8" }).trim();
+        clis.push({
+            name: "Pi",
+            command: "pi",
+            provider: "pi",
+            version: version.split("\n")[0],
+        });
+    }
+    catch { }
+    return clis;
+}
+async function promptAutonomousMode(cli) {
+    const savedPref = config.get(`autonomous_${cli.provider}`);
+    if (savedPref !== undefined)
+        return savedPref;
+    const flag = AUTONOMOUS_FLAGS[cli.provider];
+    if (!flag)
+        return false;
+    console.log();
+    const autonomous = await p.confirm({
+        message: `Run in autonomous mode? (${flag})`,
+        initialValue: false,
+    });
+    if (p.isCancel(autonomous))
+        return false;
+    if (autonomous) {
+        console.log(chalk.yellow("\n⚠️  Autonomous mode: AI can execute without asking permission."));
+    }
+    const remember = await p.confirm({
+        message: "Remember this choice?",
+        initialValue: true,
+    });
+    if (!p.isCancel(remember) && remember) {
+        config.set(`autonomous_${cli.provider}`, autonomous);
+    }
+    return autonomous;
+}
+async function promptChromeMode(cli) {
+    if (cli.provider !== "claude")
+        return false;
+    const savedPref = config.get("chrome_claude");
+    if (savedPref !== undefined)
+        return savedPref;
+    console.log();
+    const chrome = await p.confirm({
+        message: `Enable browser capabilities? (${CHROME_FLAG})`,
+        initialValue: false,
+    });
+    if (p.isCancel(chrome))
+        return false;
+    if (chrome) {
+        console.log(chalk.cyan("\n🌐 Chrome mode: Claude can browse and interact with web pages."));
+    }
+    const remember = await p.confirm({
+        message: "Remember this choice?",
+        initialValue: true,
+    });
+    if (!p.isCancel(remember) && remember) {
+        config.set("chrome_claude", chrome);
+    }
+    return chrome;
+}
+function showBanner() {
+    let version;
+    try {
+        const pkgPath = new URL("../../package.json", import.meta.url);
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        version = pkg.version;
+    }
+    catch { }
+    console.log(renderBanner({ version }));
 }
 async function showGatewayDashboard() {
     console.log(chalk.bold.cyan("\n┌─────────────────────────────────────────┐"));
     console.log(chalk.bold.cyan("│        JFL Gateway Dashboard            │"));
     console.log(chalk.bold.cyan("└─────────────────────────────────────────┘\n"));
-    // 1. Ensure and check Context Hub
     const spinner1 = ora("Checking Context Hub...").start();
     await ensureContextHub();
     const contextHubConfig = getContextHubConfig();
@@ -59,7 +203,6 @@ async function showGatewayDashboard() {
     else {
         spinner1.fail(chalk.red("Context Hub not running"));
     }
-    // 2. Check Service Manager
     const spinner2 = ora("Checking Service Manager...").start();
     const serviceManagerStatus = await checkServiceManager();
     if (serviceManagerStatus.running) {
@@ -70,31 +213,12 @@ async function showGatewayDashboard() {
         spinner2.warn(chalk.yellow("Service Manager not running"));
         console.log(chalk.gray("   Start with: pm2 start ~/.jfl/service-manager/ecosystem.config.js"));
     }
-    // 3. Show connection info
     console.log();
     console.log(chalk.bold("Gateway Endpoints:"));
     console.log(chalk.gray("  Context Hub:     ") + chalk.cyan(`http://localhost:${contextHubConfig.port}`));
     console.log(chalk.gray("  Service Manager: ") + chalk.cyan("http://localhost:3401"));
     console.log(chalk.gray("  MCP Server:      ") + chalk.cyan("Connected via MCP"));
-    // 4. Show how to connect
-    console.log();
-    console.log(chalk.bold("AI Tools Connection:"));
-    console.log(chalk.gray("  Claude Code connects via MCP automatically"));
-    console.log(chalk.gray("  Cursor connects via MCP automatically"));
-    console.log(chalk.gray("  Custom tools can use HTTP API"));
-    // 5. Show available commands
-    console.log();
-    console.log(chalk.bold("Manage Services:"));
-    console.log(chalk.gray("  jfl-services list       ") + "# List all services");
-    console.log(chalk.gray("  jfl-services start <id> ") + "# Start a service");
-    console.log(chalk.gray("  jfl-services logs <id>  ") + "# View service logs");
     console.log();
-    console.log(chalk.bold("View Status:"));
-    console.log(chalk.gray("  jfl status              ") + "# Project status");
-    console.log(chalk.gray("  jfl hud                 ") + "# Campaign dashboard");
-    console.log();
-    console.log(chalk.green("✓ JFL Gateway is ready!"));
-    console.log(chalk.gray("  Open Claude Code or Cursor to connect via MCP\n"));
 }
 async function checkServiceManager() {
     try {
@@ -102,20 +226,366 @@ async function checkServiceManager() {
         const services = response.data.stats?.total_services || 0;
         return { running: true, services };
     }
-    catch (err) {
+    catch {
         return { running: false };
     }
 }
+async function launchCLI(cli, cwd) {
+    const autonomous = await promptAutonomousMode(cli);
+    let chrome = false;
+    if (cli.provider === "claude") {
+        chrome = await promptChromeMode(cli);
+    }
+    // Ensure Context Hub is running and show dashboard before launch
+    await showGatewayDashboard();
+    // Build args
+    const args = [];
+    if (autonomous && AUTONOMOUS_FLAGS[cli.provider]) {
+        args.push(AUTONOMOUS_FLAGS[cli.provider]);
+    }
+    if (chrome) {
+        args.push(CHROME_FLAG);
+    }
+    // Show banner + mode indicators
+    showBanner();
+    const modes = [];
+    if (autonomous)
+        modes.push("autonomous");
+    if (chrome)
+        modes.push("chrome");
+    const modeStr = modes.length > 0 ? theme.dim(` (${modes.join(", ")})`) : "";
+    console.log(theme.accent(`Launching ${cli.name}`) + modeStr);
+    console.log(theme.dim("Context loaded from CLAUDE.md + knowledge/\n"));
+    console.log(theme.dimmer("─".repeat(50)));
+    console.log();
+    const sessionStart = Date.now();
+    telemetry.track({
+        category: 'session',
+        event: 'session:started',
+        session_event: 'start',
+        ai_cli: cli.provider,
+    });
+    const child = spawn(cli.command, args, {
+        cwd,
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            JFL_PROJECT: cwd,
+        },
+    });
+    child.on("error", (err) => {
+        console.error(chalk.red(`\nFailed to launch ${cli.name}:`), err.message);
+        telemetry.track({
+            category: 'session',
+            event: 'session:crash',
+            session_event: 'crash',
+            ai_cli: cli.provider,
+            error_type: err.constructor.name,
+        });
+    });
+    child.on("exit", (code) => {
+        telemetry.track({
+            category: 'session',
+            event: 'session:ended',
+            session_event: 'end',
+            ai_cli: cli.provider,
+            session_duration_s: Math.floor((Date.now() - sessionStart) / 1000),
+            success: code === 0 || code === null,
+        });
+        if (code !== 0 && code !== null) {
+            console.log(chalk.yellow(`\n${cli.name} exited with code ${code}`));
+        }
+        console.log(chalk.gray("\nJFL session ended.\n"));
+    });
+}
 async function onboardNewUser(cwd) {
-    console.log(chalk.yellow("\n⚠️  Not in a JFL project\n"));
-    const shouldInit = await p.confirm({
-        message: "Initialize this directory as a JFL project?",
-        initialValue: true,
+    showBanner();
+    showHowItWorksNotice();
+    const knownProjects = config.get("projects") || [];
+    const existingProjects = knownProjects.filter((proj) => existsSync(join(proj, "CLAUDE.md")) || existsSync(join(proj, "knowledge")));
+    p.intro(chalk.hex("#FFD700")("┌  JFL onboarding"));
+    if (existingProjects.length > 0) {
+        const selected = await p.select({
+            message: "Open a project or create new?",
+            options: [
+                ...existingProjects.map((proj) => ({
+                    label: proj.replace(process.env.HOME || "", "~"),
+                    value: proj,
+                })),
+                { label: "Join existing project (I was invited)", value: "__join__" },
+                { label: "Create new project", value: "__new__" },
+            ],
+        });
+        if (p.isCancel(selected)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        if (selected === "__join__") {
+            await joinExistingProject();
+            return;
+        }
+        if (selected !== "__new__") {
+            config.set("projects", existingProjects);
+            process.chdir(selected);
+            p.outro(chalk.hex("#FFA500")(`Opening ${selected.replace(process.env.HOME || "", "~")}`));
+            const available = detectAICLIs();
+            if (available.length > 0) {
+                await launchCLI(available[0], selected);
+            }
+            else {
+                await onboardAICLI();
+            }
+            return;
+        }
+    }
+    const action = await p.select({
+        message: "What do you want to do?",
+        options: [
+            { label: "Join existing project (I was invited)", value: "join" },
+            { label: "Create a new project", value: "create" },
+        ],
     });
-    if (p.isCancel(shouldInit) || !shouldInit) {
-        console.log(chalk.gray("\nRun 'jfl init' when ready\n"));
+    if (p.isCancel(action)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    if (action === "join") {
+        await joinExistingProject();
         return;
     }
+    p.outro(chalk.hex("#FFA500")("Launching project setup..."));
     await initCommand();
 }
+async function joinExistingProject() {
+    console.log(chalk.cyan("\n🔗 Join Existing Project\n"));
+    let username;
+    try {
+        username = await authenticateWithGitHub();
+    }
+    catch (error) {
+        console.error(chalk.red("\nGitHub authentication failed"));
+        console.error(chalk.gray(error instanceof Error ? error.message : String(error)));
+        return;
+    }
+    let projects;
+    try {
+        projects = await discoverJflProjects();
+    }
+    catch (error) {
+        console.error(chalk.red("\nFailed to discover projects"));
+        console.error(chalk.gray(error instanceof Error ? error.message : String(error)));
+        return;
+    }
+    if (projects.length === 0) {
+        console.log(chalk.yellow("\nNo JFL projects found that you have access to.\n"));
+        console.log(chalk.gray("Ask the project owner to add you as a collaborator."));
+        console.log(chalk.gray("The project needs a CLAUDE.md file or .jfl/ directory.\n"));
+        return;
+    }
+    const selectedProject = await p.select({
+        message: "Which project do you want to join?",
+        options: projects.map((proj) => ({
+            label: `${proj.fullName}${proj.hasUserSuggestions ? chalk.green(" (you're invited)") : ""}${proj.description ? chalk.gray(` - ${proj.description}`) : ""}`,
+            value: proj,
+        })),
+    });
+    if (p.isCancel(selectedProject)) {
+        p.cancel("Cancelled.");
+        return;
+    }
+    const project = selectedProject;
+    // Check if already cloned locally
+    const trackedProjects = config.get("projects") || [];
+    const existingLocal = trackedProjects.find((proj) => {
+        const projectName = proj.split("/").pop();
+        return projectName === project.name &&
+            (existsSync(join(proj, "CLAUDE.md")) || existsSync(join(proj, ".jfl")));
+    });
+    const commonPaths = [
+        join(process.env.HOME || "", "Projects", project.name),
+        join(process.env.HOME || "", project.name),
+        join(process.cwd(), project.name),
+    ];
+    const existingAtCommonPath = commonPaths.find((proj) => existsSync(proj) && (existsSync(join(proj, "CLAUDE.md")) || existsSync(join(proj, ".jfl"))));
+    const alreadyCloned = existingLocal || existingAtCommonPath;
+    if (alreadyCloned) {
+        console.log(chalk.green(`\n✓ Already have ${project.name} at ${alreadyCloned}\n`));
+        const openExisting = await p.confirm({
+            message: "Open it?",
+            initialValue: true,
+        });
+        if (!p.isCancel(openExisting) && openExisting) {
+            if (!trackedProjects.includes(alreadyCloned)) {
+                trackedProjects.push(alreadyCloned);
+                config.set("projects", trackedProjects);
+            }
+            process.chdir(alreadyCloned);
+            const available = detectAICLIs();
+            if (available.length > 0) {
+                await launchCLI(available[0], alreadyCloned);
+            }
+            else {
+                await onboardAICLI();
+            }
+        }
+        return;
+    }
+    // Show project info
+    console.log();
+    console.log(chalk.bold(`Project: ${project.fullName}`));
+    if (project.description) {
+        console.log(chalk.gray(project.description));
+    }
+    if (project.projectConfig?.wallet) {
+        console.log(chalk.gray(`Wallet: ${project.projectConfig.wallet.slice(0, 10)}...`));
+    }
+    if (project.hasUserSuggestions) {
+        console.log(chalk.green(`✓ Your suggestions file exists (suggestions/${username}.md)`));
+    }
+    console.log();
+    const defaultPath = join(process.env.HOME || "", "Projects", project.name);
+    const clonePath = await p.text({
+        message: "Where to clone?",
+        defaultValue: defaultPath,
+        placeholder: defaultPath,
+    });
+    if (p.isCancel(clonePath)) {
+        p.cancel("Cancelled.");
+        return;
+    }
+    const expandedPath = clonePath.replace(/^~/, process.env.HOME || "");
+    let clonedPath;
+    try {
+        clonedPath = await cloneRepository(project, expandedPath);
+    }
+    catch (error) {
+        console.error(chalk.red("\nClone failed"));
+        console.error(chalk.gray(error instanceof Error ? error.message : String(error)));
+        return;
+    }
+    // Track this project
+    const allProjects = config.get("projects") || [];
+    if (!allProjects.includes(clonedPath)) {
+        allProjects.push(clonedPath);
+        config.set("projects", allProjects);
+    }
+    config.set("hasOnboarded", true);
+    console.log(chalk.green(`\n✓ Joined ${project.name}!\n`));
+    if (project.projectConfig?.wallet) {
+        console.log(chalk.gray("Project Configuration:"));
+        console.log(chalk.gray(`  Owner: ${project.projectConfig.walletOwner || project.owner}`));
+        console.log(chalk.gray(`  Wallet: ${project.projectConfig.wallet} (configured)`));
+        console.log(chalk.gray(`  Your role: Contributor`));
+        console.log();
+    }
+    console.log(chalk.gray(`Location: ${clonedPath}`));
+    console.log(chalk.cyan(`\nTo start working:\n`));
+    console.log(chalk.white(`  cd ${clonedPath}`));
+    console.log(chalk.white(`  jfl\n`));
+    const launchNow = await p.confirm({
+        message: "Open project now?",
+        initialValue: true,
+    });
+    if (!p.isCancel(launchNow) && launchNow) {
+        process.chdir(clonedPath);
+        const available = detectAICLIs();
+        if (available.length > 0) {
+            await launchCLI(available[0], clonedPath);
+        }
+        else {
+            await onboardAICLI();
+        }
+    }
+}
+async function onboardAICLI() {
+    console.log(chalk.bold("\n🤖 JFL - Setup AI Assistant\n"));
+    console.log(chalk.gray("JFL works with your AI of choice. Let's get you set up.\n"));
+    const experience = await p.select({
+        message: "How technical are you?",
+        options: [
+            { label: "I'm a developer - comfortable with terminal", value: "dev" },
+            { label: "Somewhat technical - can follow instructions", value: "some" },
+            { label: "Not technical - need the easy path", value: "none" },
+        ],
+    });
+    if (p.isCancel(experience))
+        return;
+    if (experience === "none") {
+        console.log(chalk.cyan("\n📱 Easiest options for you:\n"));
+        console.log(chalk.bold("1. Claude.ai (browser)"));
+        console.log(chalk.gray("   Go to claude.ai, sign up, and chat directly"));
+        console.log(chalk.gray("   You can paste your project files into the chat\n"));
+        console.log(chalk.bold("2. Claude Desktop App"));
+        console.log(chalk.gray("   Download from claude.ai/download"));
+        console.log(chalk.gray("   Works like ChatGPT but with Claude\n"));
+        console.log(chalk.bold("3. Cursor (AI-powered code editor)"));
+        console.log(chalk.gray("   Download from cursor.com"));
+        console.log(chalk.gray("   Like VS Code but with AI built in\n"));
+        console.log(chalk.yellow("For the full JFL experience, Claude Code is best."));
+        console.log(chalk.gray("But start with what's comfortable.\n"));
+        return;
+    }
+    console.log(chalk.yellow("\nNo AI CLI detected.\n"));
+    const choice = await p.select({
+        message: "Which AI do you want to use?",
+        options: [
+            { label: "Claude Code (recommended for JFL)", value: "claude" },
+            { label: "Codex CLI (OpenAI)", value: "codex" },
+            { label: "Aider (works with multiple models)", value: "aider" },
+            { label: "I'll set it up myself", value: "manual" },
+        ],
+    });
+    if (p.isCancel(choice))
+        return;
+    if (choice === "manual") {
+        console.log(chalk.gray("\nSupported AI CLIs:"));
+        console.log("  • Claude Code: npm install -g @anthropic-ai/claude-code");
+        console.log("  • Codex CLI:   npm install -g @openai/codex");
+        console.log("  • Aider:       pip install aider-chat");
+        console.log(chalk.gray("\nRun 'jfl' again after installing.\n"));
+        return;
+    }
+    const installCommands = {
+        claude: { cmd: "npm install -g @anthropic-ai/claude-code", name: "Claude Code" },
+        codex: { cmd: "npm install -g @openai/codex", name: "Codex CLI" },
+        aider: { cmd: "pip install aider-chat", name: "Aider" },
+    };
+    const install = installCommands[choice];
+    console.log(chalk.cyan(`\nInstalling ${install.name}...\n`));
+    console.log(chalk.gray(`$ ${install.cmd}\n`));
+    const proceed = await p.confirm({
+        message: "Run this command?",
+        initialValue: true,
+    });
+    if (p.isCancel(proceed) || !proceed) {
+        console.log(chalk.gray(`\nRun manually: ${install.cmd}`));
+        console.log(chalk.gray("Then run 'jfl' again.\n"));
+        return;
+    }
+    try {
+        execSync(install.cmd, { stdio: "inherit" });
+        console.log(chalk.green(`\n✓ ${install.name} installed!\n`));
+        if (choice === "claude") {
+            console.log(chalk.gray("Set your Anthropic API key:"));
+            console.log(chalk.white("  export ANTHROPIC_API_KEY=your-key-here\n"));
+            console.log(chalk.gray("Or run 'claude' to authenticate interactively.\n"));
+        }
+        else if (choice === "codex") {
+            console.log(chalk.gray("Set your OpenAI API key:"));
+            console.log(chalk.white("  export OPENAI_API_KEY=your-key-here\n"));
+        }
+        else if (choice === "aider") {
+            console.log(chalk.gray("Set your API key (Anthropic or OpenAI):"));
+            console.log(chalk.white("  export ANTHROPIC_API_KEY=your-key-here"));
+            console.log(chalk.white("  # or"));
+            console.log(chalk.white("  export OPENAI_API_KEY=your-key-here\n"));
+        }
+        console.log(chalk.cyan("Run 'jfl' to start your AI session.\n"));
+    }
+    catch {
+        console.error(chalk.red("\nInstallation failed."));
+        console.log(chalk.gray(`\nTry manually: ${install.cmd}\n`));
+    }
+}
+export { showGatewayDashboard };
 //# sourceMappingURL=session.js.map