onflyt-cli 1.0.1-beta.2 → 1.0.1-beta.3

package/dist/commands/init.js

@@ -0,0 +1,422 @@
+import React from "react";
+import { Text, Box, useInput } from "ink";
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
+import { GitDetector } from "../lib/git.js";
+import { FrameworkDetector } from "../lib/framework.js";
+import { hasProjectConfig, saveProjectConfig, } from "../lib/config.js";
+import { initGitRepo } from "../lib/scaffold.js";
+import { FRAMEWORKS, TEMPLATES, getDefaultBuildCommand, getDefaultOutputDirectory, getDefaultStartCommand, getInstallCommand, } from "../shared";
+import { Logo } from "../components/Loading.js";
+const FRAMEWORK_LIST = Object.entries(FRAMEWORKS).map(([id, config]) => ({
+    id,
+    name: config.label,
+}));
+const PACKAGE_MANAGERS = [
+    { id: "npm", name: "npm" },
+    { id: "bun", name: "Bun" },
+    { id: "yarn", name: "Yarn" },
+    { id: "pnpm", name: "pnpm" },
+    { id: "pip", name: "pip" },
+    { id: "poetry", name: "Poetry" },
+];
+const FOOTER = "↑↓ select/navigate • Enter confirm • Esc back • Ctrl+C cancel";
+const Init = ({ name, framework, template, packageManager, git, yes, }) => {
+    const [step, setStep] = React.useState("name");
+    const [history, setHistory] = React.useState(["name"]);
+    const [projectName, setProjectName] = React.useState("");
+    const [isEditingName, setIsEditingName] = React.useState(false);
+    const [useTemplate, setUseTemplate] = React.useState(0);
+    const [selectedTemplate, setSelectedTemplate] = React.useState(0);
+    const [selectedFramework, setSelectedFramework] = React.useState(0);
+    const [selectedPackageManager, setSelectedPackageManager] = React.useState(0);
+    const [connectGit, setConnectGit] = React.useState(true);
+    const [hasGit, setHasGit] = React.useState(false);
+    const [detectedName, setDetectedName] = React.useState("");
+    const [detectedFrameworkId, setDetectedFrameworkId] = React.useState("");
+    const [gitUrl, setGitUrl] = React.useState(null);
+    const [gitBranch, setGitBranch] = React.useState("main");
+    const [remoteUrl, setRemoteUrl] = React.useState("");
+    const [errorMsg, setErrorMsg] = React.useState("");
+    const [savedConfig, setSavedConfig] = React.useState(null);
+    const goTo = (nextStep) => {
+        setHistory([...history, nextStep]);
+        setStep(nextStep);
+    };
+    const goBack = () => {
+        if (history.length > 1) {
+            const newHistory = history.slice(0, -1);
+            setHistory(newHistory);
+            setStep(newHistory[newHistory.length - 1]);
+        }
+    };
+    React.useEffect(() => {
+        detect();
+    }, []);
+    React.useEffect(() => {
+        if (step === "done" || step === "error") {
+            const timer = setTimeout(() => {
+                process.exit(step === "error" ? 1 : 0);
+            }, 100);
+            return () => clearTimeout(timer);
+        }
+    }, [step]);
+    const detect = async () => {
+        const cwd = process.cwd();
+        if (hasProjectConfig(cwd)) {
+            setErrorMsg("Already initialized. Run 'onflyt deploy' to deploy, or delete onflyt.json to reinitialize.");
+            setStep("error");
+            return;
+        }
+        const gitDetector = new GitDetector(cwd);
+        const gitInfo = await gitDetector.detect();
+        const detectedHasGit = gitInfo.isGitRepo && gitInfo.remotes.length > 0;
+        const frameworkDetector = new FrameworkDetector(cwd);
+        const detectedFw = frameworkDetector.detect();
+        const fwId = detectedFw?.id || "node";
+        let detected = cwd
+            .split("/")
+            .pop()
+            ?.replace(/[^a-z0-9-]/g, "-")
+            .toLowerCase() || "my-project";
+        if (detectedHasGit && gitInfo.remotes[0]) {
+            const match = gitInfo.remotes[0].url.match(/\/([^\/]+?)(?:\.git)?$/);
+            if (match) {
+                detected = match[1].replace(/[^a-z0-9-]/g, "-").toLowerCase();
+            }
+        }
+        const fwIndex = FRAMEWORK_LIST.findIndex((f) => f.id === (framework || fwId));
+        const pmIndex = PACKAGE_MANAGERS.findIndex((p) => p.id === packageManager);
+        setDetectedName(detected);
+        setDetectedFrameworkId(fwId);
+        setProjectName(name || detected);
+        setConnectGit(git !== undefined ? git : detectedHasGit && !!gitInfo.remotes[0]);
+        setSelectedFramework(fwIndex >= 0 ? fwIndex : 0);
+        setSelectedPackageManager(pmIndex >= 0 ? pmIndex : 0);
+        setHasGit(detectedHasGit);
+        if (gitInfo.remotes[0]) {
+            setGitUrl(gitInfo.remotes[0].url);
+            setGitBranch(gitInfo.currentBranch || "main");
+        }
+        if (yes) {
+            autoSave();
+        }
+    };
+    const getFinalProjectName = () => {
+        return projectName || detectedName;
+    };
+    const cancel = () => {
+        console.log("\nCancelled.");
+        process.exit(0);
+    };
+    const autoSave = async () => {
+        setStep("saving");
+        let fwId;
+        if (useTemplate === 1) {
+            fwId = TEMPLATES[selectedTemplate].framework;
+        }
+        else {
+            fwId = FRAMEWORK_LIST[selectedFramework].id;
+        }
+        const pmId = PACKAGE_MANAGERS[selectedPackageManager].id;
+        const cwd = process.cwd();
+        const frameworkDetector = new FrameworkDetector(cwd);
+        const detectedOutputDir = frameworkDetector.detectOutputDirectory(fwId);
+        const buildCmd = getDefaultBuildCommand(fwId) || "";
+        const installCmd = getInstallCommand(fwId, pmId);
+        const outputDir = detectedOutputDir || getDefaultOutputDirectory(fwId) || ".";
+        const startCmd = getDefaultStartCommand(fwId) || "";
+        if (connectGit && !hasGit) {
+            initGitRepo(cwd, remoteUrl || undefined);
+            createGitignore(cwd);
+        }
+        const projectConfig = {
+            name: getFinalProjectName(),
+            framework: fwId,
+            buildCommand: buildCmd,
+            outputDirectory: outputDir,
+            installCommand: installCmd,
+            startCommand: startCmd,
+            gitRepoUrl: connectGit ? remoteUrl || gitUrl || undefined : undefined,
+            gitBranch: connectGit ? "main" : undefined,
+        };
+        saveProjectConfig(projectConfig);
+        setSavedConfig(projectConfig);
+        setStep("done");
+    };
+    const createGitignore = (cwd) => {
+        const gitignorePath = join(cwd, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            const defaultGitignore = `node_modules/
+dist/
+build/
+.next/
+.output/
+.env
+.env.local
+*.log
+.DS_Store
+`;
+            writeFileSync(gitignorePath, defaultGitignore);
+        }
+    };
+    useInput((input, key) => {
+        if (key.ctrl && input === "c") {
+            cancel();
+            return;
+        }
+        switch (step) {
+            case "name":
+                if (key.return) {
+                    goTo("setupType");
+                }
+                else if (key.escape) {
+                    setIsEditingName(false);
+                    setProjectName(detectedName);
+                }
+                else if (key.backspace || key.delete) {
+                    setProjectName(projectName.slice(0, -1));
+                }
+                else if (input && input.match(/^[a-zA-Z0-9-_]$/)) {
+                    if (projectName === detectedName && !isEditingName) {
+                        setProjectName(input);
+                    }
+                    else {
+                        setProjectName(projectName + input);
+                    }
+                    setIsEditingName(true);
+                }
+                break;
+            case "setupType":
+                if (key.downArrow || input === "j") {
+                    setUseTemplate(1);
+                }
+                else if (key.upArrow || input === "k") {
+                    setUseTemplate(0);
+                }
+                else if (key.return) {
+                    if (useTemplate === 0) {
+                        goTo("framework");
+                    }
+                    else {
+                        goTo("template");
+                    }
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                break;
+            case "template":
+                if (key.downArrow || input === "j") {
+                    setSelectedTemplate((prev) => Math.min(prev + 1, TEMPLATES.length - 1));
+                }
+                else if (key.upArrow || input === "k") {
+                    setSelectedTemplate((prev) => Math.max(prev - 1, 0));
+                }
+                else if (key.return) {
+                    goTo("git");
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                break;
+            case "framework":
+                if (key.downArrow || input === "j") {
+                    setSelectedFramework((prev) => Math.min(prev + 1, FRAMEWORK_LIST.length - 1));
+                }
+                else if (key.upArrow || input === "k") {
+                    setSelectedFramework((prev) => Math.max(prev - 1, 0));
+                }
+                else if (key.return) {
+                    goTo("packageManager");
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                break;
+            case "packageManager":
+                if (key.downArrow || input === "j") {
+                    setSelectedPackageManager((prev) => Math.min(prev + 1, PACKAGE_MANAGERS.length - 1));
+                }
+                else if (key.upArrow || input === "k") {
+                    setSelectedPackageManager((prev) => Math.max(prev - 1, 0));
+                }
+                else if (key.return) {
+                    goTo("git");
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                break;
+            case "git":
+                if (key.downArrow || input === "j" || input === " ") {
+                    setConnectGit((prev) => !prev);
+                }
+                else if (key.upArrow || input === "k") {
+                    setConnectGit((prev) => !prev);
+                }
+                else if (key.return) {
+                    if (connectGit) {
+                        if (hasGit) {
+                            autoSave();
+                        }
+                        else {
+                            goTo("gitRemote");
+                        }
+                    }
+                    else {
+                        autoSave();
+                    }
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                break;
+            case "gitRemote":
+                if (key.return) {
+                    autoSave();
+                }
+                else if (key.escape) {
+                    goBack();
+                }
+                else if (key.backspace || key.delete) {
+                    setRemoteUrl(remoteUrl.slice(0, -1));
+                }
+                else if (input && input.length > 0) {
+                    setRemoteUrl(remoteUrl + input);
+                }
+                break;
+        }
+    });
+    if (step === "error") {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { bold: true, color: "red" }, "Error"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "red" }, errorMsg))));
+    }
+    if (step === "saving") {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Logo, null),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Saving configuration..."))));
+    }
+    if (step === "done") {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\u2713 Project initialized!"),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "onflyt.json saved to current directory")),
+            savedConfig && (React.createElement(React.Fragment, null,
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true },
+                        "Project: ",
+                        savedConfig.name)),
+                React.createElement(Box, null,
+                    React.createElement(Text, { dimColor: true },
+                        "Framework: ",
+                        FRAMEWORKS[savedConfig.framework]?.label)),
+                savedConfig.gitRepoUrl && (React.createElement(Box, null,
+                    React.createElement(Text, { dimColor: true },
+                        "Git: ",
+                        savedConfig.gitRepoUrl))))),
+            React.createElement(Box, { marginTop: 2 },
+                React.createElement(Text, { bold: true }, "Next steps:")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "1. Run 'onflyt deploy' to deploy")),
+            React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true }, "2. Team selection will happen during deploy"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Logo, null),
+        step === "name" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Project Name")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press keys to edit, Enter to continue")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { bold: true, color: "cyan" },
+                    ">",
+                    " "),
+                React.createElement(Text, null, projectName || detectedName),
+                React.createElement(Text, { bold: true, color: "cyan" }, "_")))),
+        step === "setupType" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Setup Type")),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        useTemplate === 0 ? "❯ " : "  ",
+                        "Use existing files")),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        useTemplate === 1 ? "❯ " : "  ",
+                        "Use a template (scaffold from starter)"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, FOOTER)))),
+        step === "template" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Select Template")),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" }, TEMPLATES.map((t, i) => (React.createElement(Box, { key: t.id },
+                React.createElement(Text, null,
+                    i === selectedTemplate ? "❯ " : "  ",
+                    t.name,
+                    " - ",
+                    t.description))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, FOOTER)))),
+        step === "framework" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Select Framework")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Detected: ",
+                    detectedFrameworkId)),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" }, FRAMEWORK_LIST.map((fw, i) => (React.createElement(Box, { key: fw.id },
+                React.createElement(Text, null,
+                    i === selectedFramework ? "❯ " : "  ",
+                    fw.name))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, FOOTER)))),
+        step === "packageManager" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Select Package Manager")),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" }, PACKAGE_MANAGERS.map((pm, i) => (React.createElement(Box, { key: pm.id },
+                React.createElement(Text, null,
+                    i === selectedPackageManager ? "❯ " : "  ",
+                    pm.name))))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, FOOTER)))),
+        step === "git" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Git Repository")),
+            gitUrl && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Detected: ",
+                    gitUrl,
+                    " (",
+                    gitBranch,
+                    ")"))),
+            React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        connectGit ? "❯ " : "  ",
+                        hasGit ? "Yes, connect git repo" : "Initialize git repo")),
+                React.createElement(Box, null,
+                    React.createElement(Text, null,
+                        !connectGit ? "❯ " : "  ",
+                        "Skip git (manual deploys)"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, FOOTER)))),
+        step === "gitRemote" && (React.createElement(React.Fragment, null,
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null, "Git Remote URL (optional)")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to skip, or enter GitHub repo URL")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, null,
+                    "> ",
+                    remoteUrl),
+                React.createElement(Text, { bold: true }, "_")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Enter paste URL \u2022 Backspace delete \u2022 Enter continue"))))));
+};
+export default Init;

package/dist/commands/login.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+interface LoginProps {
+    openBrowser?: boolean;
+}
+declare const Login: React.FC<LoginProps>;
+export default Login;

package/dist/commands/login.js

@@ -0,0 +1,150 @@
+import React from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import open from "open";
+import { API_URL, getConfig, saveConfig } from "../lib/config.js";
+import { Logo } from "../components/Loading.js";
+const LoadingSpinner = () => (React.createElement(Box, null,
+    React.createElement(Spinner, { type: "dots" }),
+    React.createElement(Text, null, " Starting login...")));
+const AlreadyLoggedIn = ({ user, }) => (React.createElement(Box, { flexDirection: "column", padding: 1 },
+    React.createElement(Text, { bold: true, color: "green" },
+        "\u2713 Welcome back, ",
+        user.name,
+        "!"),
+    React.createElement(Box, { marginTop: 1 },
+        React.createElement(Text, { dimColor: true },
+            "Email: ",
+            user.email)),
+    React.createElement(Box, { marginTop: 1 },
+        React.createElement(Text, { dimColor: true }, "Run \"onflyt logout\" to sign out"))));
+const LoginSuccess = ({ user }) => (React.createElement(Box, { flexDirection: "column", padding: 1 },
+    React.createElement(Text, { bold: true, color: "green" }, "\u2713 Logged in successfully!"),
+    React.createElement(Box, { marginTop: 1 },
+        React.createElement(Text, null,
+            "Welcome, ",
+            user.name,
+            "!"))));
+const LoginError = ({ error }) => (React.createElement(Box, { flexDirection: "column", padding: 1 },
+    React.createElement(Text, { bold: true, color: "red" }, "\u2716 Login failed"),
+    React.createElement(Text, { color: "red" }, error)));
+const Login = ({ openBrowser = true }) => {
+    const [deviceData, setDeviceData] = React.useState(null);
+    const [error, setError] = React.useState(null);
+    const [successUser, setSuccessUser] = React.useState(null);
+    const [checkedLogin, setCheckedLogin] = React.useState(false);
+    const [wasAlreadyLoggedIn, setWasAlreadyLoggedIn] = React.useState(false);
+    const browserOpened = React.useRef(false);
+    // Check if already logged in
+    React.useEffect(() => {
+        const config = getConfig();
+        if (config.token && config.user) {
+            setSuccessUser(config.user);
+            setWasAlreadyLoggedIn(true);
+        }
+        setCheckedLogin(true);
+    }, []);
+    React.useEffect(() => {
+        if (browserOpened.current || !checkedLogin || successUser)
+            return;
+        browserOpened.current = true;
+        const startAuth = async () => {
+            try {
+                // Step 1: Get device code from our API
+                const deviceRes = await fetch(`${API_URL}/auth/device/code`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                });
+                const deviceData = await deviceRes.json();
+                if (!deviceRes.ok || !deviceData.success) {
+                    setError(deviceData.error || "Failed to get device code");
+                    return;
+                }
+                setDeviceData({
+                    user_code: deviceData.user_code,
+                    verification_uri: deviceData.verification_uri,
+                    device_code: deviceData.device_code,
+                    interval: deviceData.interval || 5,
+                });
+                // Open browser if enabled
+                if (openBrowser) {
+                    try {
+                        await open(deviceData.verification_uri, { wait: true });
+                    }
+                    catch {
+                        // Browser might not open in headless environment
+                    }
+                }
+                // Step 2: Poll for token
+                let currentInterval = (deviceData.interval || 5) * 1000;
+                let remainingAttempts = 150;
+                while (remainingAttempts > 0) {
+                    await new Promise((resolve) => setTimeout(resolve, currentInterval));
+                    remainingAttempts--;
+                    const tokenRes = await fetch(`${API_URL}/auth/device/token`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ device_code: deviceData.device_code }),
+                    });
+                    const tokenData = await tokenRes.json();
+                    if (tokenData.success &&
+                        tokenData.status === "authorized" &&
+                        tokenData.token) {
+                        saveConfig({
+                            ...getConfig(),
+                            token: tokenData.token,
+                            user: tokenData.user,
+                            lastLogin: new Date().toISOString(),
+                        });
+                        setSuccessUser(tokenData.user);
+                        return;
+                    }
+                    if (!tokenData.success && tokenData.error) {
+                        if (tokenData.error === "authorization_pending") {
+                            continue;
+                        }
+                        else if (tokenData.error === "slow_down") {
+                            currentInterval += 5000;
+                            continue;
+                        }
+                        else {
+                            setError(tokenData.error);
+                            return;
+                        }
+                    }
+                }
+                setError("Authorization timeout");
+            }
+            catch (err) {
+                setError(err.message || "Failed to start login");
+            }
+        };
+        startAuth();
+    }, [checkedLogin, successUser]);
+    if (!checkedLogin)
+        return React.createElement(LoadingSpinner, null);
+    if (successUser && wasAlreadyLoggedIn)
+        return React.createElement(AlreadyLoggedIn, { user: successUser });
+    if (successUser)
+        return React.createElement(LoginSuccess, { user: successUser });
+    if (error)
+        return React.createElement(LoginError, { error: error });
+    if (!deviceData)
+        return React.createElement(LoadingSpinner, null);
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Logo, null),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true }, "Login to Onflyt")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, null, "Visit: "),
+            React.createElement(Text, { color: "cyan", underline: true }, deviceData.verification_uri)),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, null, "Enter code: "),
+            React.createElement(Text, { bold: true, color: "green" }, deviceData.user_code)),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Spinner, { type: "dots" }),
+            React.createElement(Text, null, " Waiting for authorization...")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Ctrl+C to cancel"))));
+};
+export default Login;

package/dist/commands/logout.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+declare const Logout: React.FC;
+export default Logout;

package/dist/commands/logout.js

@@ -0,0 +1,19 @@
+import React from "react";
+import { Text, Box } from "ink";
+import { getConfig, saveConfig } from "../lib/config.js";
+import { Logo, ErrorDisplay } from "../components/Loading.js";
+const Logout = () => {
+    const config = getConfig();
+    if (!config.token) {
+        return React.createElement(ErrorDisplay, { message: "Not logged in. Nothing to logout from." });
+    }
+    // Clear config
+    saveConfig({});
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Logo, null),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\u2713 Logged out successfully")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Token cleared from ~/.onflyt/config.json"))));
+};
+export default Logout;

package/dist/commands/logs.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+interface LogsProps {
+    deploymentId?: string;
+    live?: boolean;
+}
+declare const Logs: React.FC<LogsProps>;
+export default Logs;