@pulse-editor/cli 0.0.1 → 0.1.0-beta.0

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Result } from 'meow';
+import { Flags } from './lib/cli-flags.js';
+export default function App({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/app.js

@@ -0,0 +1,21 @@
+import React, { useEffect, useState } from 'react';
+import Login from './components/commands/login.js';
+import Publish from './components/commands/publish.js';
+import Help from './components/commands/help.js';
+import Chat from './components/commands/chat.js';
+import Logout from './components/commands/logout.js';
+import Create from './components/commands/create.js';
+export default function App({ cli }) {
+    const [command, setCommand] = useState(undefined);
+    useEffect(() => {
+        const cmd = cli.input[0] ?? 'help';
+        setCommand(cmd);
+    }, [cli.input]);
+    return (React.createElement(React.Fragment, null,
+        command === 'help' && React.createElement(Help, { cli: cli }),
+        command === 'chat' && React.createElement(Chat, { cli: cli }),
+        command === 'login' && React.createElement(Login, { cli: cli }),
+        command === 'logout' && React.createElement(Logout, { cli: cli }),
+        command === 'publish' && React.createElement(Publish, { cli: cli }),
+        command === 'create' && React.createElement(Create, { cli: cli })));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import App from './app.js';
+import { commandsManual } from './lib/manual.js';
+import { flags } from './lib/cli-flags.js';
+const cli = meow(`\
+Usage
+  pulse [command] [flags]
+
+Commands
+${Object.entries(commandsManual)
+    .map(([_, description]) => `${description}`)
+    .join('')}
+Examples
+  pulse help publish
+`, {
+    importMeta: import.meta,
+    flags: flags,
+});
+render(React.createElement(App, { cli: cli }));

package/dist/components/commands/chat.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'meow';
+import { Flags } from '../../lib/cli-flags.js';
+import React from 'react';
+export default function Chat({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/chat.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Text } from 'ink';
+export default function Chat({ cli }) {
+    const message = cli.input[1];
+    return (React.createElement(React.Fragment, null,
+        React.createElement(Text, null,
+            "Hello, ",
+            React.createElement(Text, { color: "green" }, message))));
+}

package/dist/components/commands/create.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'meow';
+import React from 'react';
+import { Flags } from '../../lib/cli-flags.js';
+export default function Create({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/create.js

@@ -0,0 +1,93 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { $ } from 'execa';
+import SelectInput from 'ink-select-input';
+import { UncontrolledTextInput } from 'ink-text-input';
+import fs from 'fs';
+import path from 'path';
+export default function Create({ cli }) {
+    const [framework, setFramework] = useState(undefined);
+    const [projectName, setProjectName] = useState(undefined);
+    const [isCreated, setIsCreated] = useState(false);
+    const [isFrameworkSelected, setIsFrameworkSelected] = useState(false);
+    const [isPathValid, setIsPathValid] = useState(true);
+    const [isCloneFailed, setIsCloneFailed] = useState(false);
+    const frameworkItems = [
+        {
+            label: 'React',
+            value: 'react',
+        },
+        {
+            label: 'Modern.js (WIP)',
+            value: 'modernjs',
+        },
+        {
+            label: 'Vue (WIP)',
+            value: 'vue',
+        },
+        {
+            label: 'Angular (WIP)',
+            value: 'angular',
+        },
+    ];
+    useEffect(() => {
+        const framework = cli.flags.framework;
+        setFramework(framework);
+    }, [cli]);
+    useEffect(() => {
+        async function createFromTemplate(name) {
+            if (framework === 'react') {
+                // Clone the template repository
+                try {
+                    await $ `git clone https://github.com/ClayPulse/pulse-editor-extension-template.git ${name}`;
+                    setIsCreated(true);
+                }
+                catch (error) {
+                    setIsCloneFailed(true);
+                    return;
+                }
+                // Modify the package.json file to update the name
+                const packageJsonPath = path.join(process.cwd(), name, 'package.json');
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                packageJson.name = name;
+                // Write the modified package.json back to the file
+                fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+            }
+        }
+        if (projectName) {
+            // Check if the project already exists
+            const projectPath = path.join(process.cwd(), projectName);
+            if (fs.existsSync(projectPath)) {
+                setIsPathValid(false);
+                return;
+            }
+            createFromTemplate(projectName);
+        }
+    }, [projectName]);
+    useEffect(() => {
+        setTimeout(() => {
+            setIsFrameworkSelected(framework !== undefined);
+        }, 0);
+    }, [framework]);
+    return (React.createElement(React.Fragment, null,
+        !cli.flags.framework && (React.createElement(React.Fragment, null,
+            React.createElement(Text, null, "\uD83D\uDEA9Create a new Pulse Editor app using your favorite web framework!"),
+            React.createElement(SelectInput, { items: frameworkItems, onSelect: item => {
+                    setFramework(item.value);
+                }, isFocused: framework === undefined }),
+            React.createElement(Text, null, " "))),
+        isFrameworkSelected && (React.createElement(React.Fragment, null,
+            React.createElement(Box, null,
+                React.createElement(Text, null, "Enter your project name: "),
+                React.createElement(UncontrolledTextInput, { onSubmit: value => setProjectName(value), focus: projectName === undefined })),
+            projectName && (React.createElement(React.Fragment, null,
+                framework === 'react' &&
+                    (!isPathValid ? (React.createElement(Text, { color: "redBright" }, "\u274C A project with same name already exists in current path.")) : isCloneFailed ? (React.createElement(Text, { color: "redBright" }, "\u274C Failed to clone the template. Please check your internet connection and try again.")) : isCreated ? (React.createElement(Text, null, "\uD83D\uDE80 Pulse Editor React app project created successfully!")) : (React.createElement(React.Fragment, null,
+                        React.createElement(Box, null,
+                            React.createElement(Spinner, { type: "dots" }),
+                            React.createElement(Text, null,
+                                ' ',
+                                "Creating a new Pulse Editor app using React template..."))))),
+                framework !== 'react' && (React.createElement(Text, null, "\uD83D\uDEA7 Currently not available. We'd like to invite you to work on these frameworks if you are interested in! Check out our tutorial to integrate your favorite web framework with Pulse Editor using Module Federation."))))))));
+}

package/dist/components/commands/help.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'meow';
+import React from 'react';
+import { Flags } from '../../lib/cli-flags.js';
+export default function Help({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/help.js

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Text } from 'ink';
+import { commandsManual } from '../../lib/manual.js';
+import Header from '../header.js';
+export default function Help({ cli }) {
+    const subCommand = cli.input[1];
+    return (React.createElement(React.Fragment, null, subCommand ? (React.createElement(Text, null, commandsManual[subCommand])) : (React.createElement(React.Fragment, null,
+        React.createElement(Header, null),
+        React.createElement(Text, null, cli.help)))));
+}

package/dist/components/commands/login.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Flags } from '../../lib/cli-flags.js';
+import { Result } from 'meow';
+export default function Login({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/login.js

@@ -0,0 +1,108 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text, useApp } from 'ink';
+import SelectInput from 'ink-select-input';
+import TextInput from 'ink-text-input';
+import Spinner from 'ink-spinner';
+import os from 'os';
+import path from 'path';
+import { checkToken, getToken, isTokenInEnv, saveToken, } from '../../lib/token.js';
+export default function Login({ cli }) {
+    const [loginMethod, setLoginMethod] = useState(undefined);
+    const [isShowLoginMethod, setIsShowLoginMethod] = useState(false);
+    const [isMethodSelected, setIsMethodSelected] = useState(false);
+    const [isCheckingAuth, setIsCheckingAuth] = useState(true);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [token, setToken] = useState('');
+    const [isTokenSaved, setIsTokenSaved] = useState(false);
+    const [tokenInput, setTokenInput] = useState('');
+    const [saveTokenInput, setSaveTokenInput] = useState('');
+    const loginMethodItems = [
+        {
+            label: 'Login using access token',
+            value: 'token',
+        },
+        {
+            label: '(WIP) Login in browser',
+            value: 'flow',
+        },
+    ];
+    const { exit } = useApp();
+    // Check login method
+    useEffect(() => {
+        const savedToken = getToken();
+        setIsShowLoginMethod(!savedToken && !cli.flags.token && !cli.flags.flow);
+        if (savedToken) {
+            setLoginMethod('token');
+            setToken(savedToken);
+            return;
+        }
+        else if (cli.flags.token) {
+            setLoginMethod('token');
+        }
+        else if (cli.flags.flow) {
+            setLoginMethod('flow');
+        }
+    }, [cli]);
+    // Check token validity
+    useEffect(() => {
+        // Only check token validity when it is set
+        if (loginMethod === 'token' && token.length > 0) {
+            checkToken(token, cli.flags.dev).then(isValid => {
+                setIsAuthenticated(isValid);
+                setIsCheckingAuth(false);
+            });
+        }
+    }, [token, loginMethod]);
+    useEffect(() => {
+        setTimeout(() => {
+            setIsMethodSelected(loginMethod !== undefined);
+        }, 0);
+    }, [loginMethod]);
+    return (React.createElement(React.Fragment, null,
+        isShowLoginMethod && (React.createElement(React.Fragment, null,
+            React.createElement(Text, null, "Login to the Pulse Editor Platform"),
+            React.createElement(SelectInput, { items: loginMethodItems, onSelect: item => {
+                    setLoginMethod(item.value);
+                }, isFocused: loginMethod === undefined }),
+            React.createElement(Text, null, " "))),
+        isMethodSelected &&
+            loginMethod === 'token' &&
+            (token.length === 0 ? (React.createElement(React.Fragment, null,
+                React.createElement(Text, null, "Enter your Pulse Editor access token:"),
+                React.createElement(TextInput, { mask: "*", value: tokenInput, onChange: setTokenInput, onSubmit: value => {
+                        if (value.length === 0) {
+                            return;
+                        }
+                        setToken(value);
+                    } }))) : isCheckingAuth ? (React.createElement(Box, null,
+                React.createElement(Spinner, { type: "dots" }),
+                React.createElement(Text, null, " Checking authentication..."))) : isAuthenticated ? (React.createElement(React.Fragment, null,
+                React.createElement(Text, null, "\u2705 You are signed in successfully."),
+                !isTokenInEnv() && getToken() !== token && (React.createElement(React.Fragment, null,
+                    React.createElement(Text, null, "\uD83D\uDFE2 It is recommended to save your access token as an environment variable PE_ACCESS_TOKEN."),
+                    React.createElement(Box, null,
+                        React.createElement(Text, null,
+                            "\u26A0\uFE0F (NOT recommended) Or, do you want to save access token to user home directory? (y/n)",
+                            ' '),
+                        React.createElement(TextInput, { value: saveTokenInput, onChange: setSaveTokenInput, onSubmit: value => {
+                                if (value.length === 0) {
+                                    return;
+                                }
+                                if (value === 'y') {
+                                    saveToken(token);
+                                    setIsTokenSaved(true);
+                                    setTimeout(() => {
+                                        exit();
+                                    }, 0);
+                                }
+                                else {
+                                    exit();
+                                }
+                            } })))),
+                isTokenSaved && (React.createElement(Text, null,
+                    "Token saved to ",
+                    path.join(os.homedir(), '.pulse-editor'))))) : (React.createElement(Text, null, "Authentication error: please enter valid credentials."))),
+        isMethodSelected && loginMethod === 'flow' && (React.createElement(React.Fragment, null,
+            React.createElement(Text, null, "(WIP) Open the following URL in your browser:"),
+            React.createElement(Text, null, "https://pulse-editor.com/login")))));
+}

package/dist/components/commands/logout.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'meow';
+import { Flags } from '../../lib/cli-flags.js';
+import React from 'react';
+export default function Logout({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/logout.js

@@ -0,0 +1,14 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { saveToken } from '../../lib/token.js';
+import Spinner from 'ink-spinner';
+export default function Logout({ cli }) {
+    const [isLoggedOut, setIsLoggedOut] = useState(false);
+    useEffect(() => {
+        saveToken(undefined);
+        setIsLoggedOut(true);
+    }, []);
+    return (React.createElement(React.Fragment, null, isLoggedOut ? (React.createElement(Text, null, "\uD83D\uDE80 Successfully logged out!")) : (React.createElement(Box, null,
+        React.createElement(Spinner, { type: "dots" }),
+        React.createElement(Text, null, " Logging out...")))));
+}

package/dist/components/commands/publish.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Result } from 'meow';
+import { Flags } from '../../lib/cli-flags.js';
+export default function Publish({ cli }: {
+    cli: Result<Flags>;
+}): React.JSX.Element;

package/dist/components/commands/publish.js

@@ -0,0 +1,125 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { checkToken, getToken } from '../../lib/token.js';
+import Spinner from 'ink-spinner';
+import fs from 'fs';
+import { $ } from 'execa';
+export default function Publish({ cli }) {
+    const [isInProjectDir, setIsInProjectDir] = useState(false);
+    const [isCheckingAuth, setIsCheckingAuth] = useState(true);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [isBuilding, setIsBuilding] = useState(false);
+    const [isBuildingError, setIsBuildingError] = useState(false);
+    const [isPublishing, setIsPublishing] = useState(false);
+    const [isPublishingError, setIsPublishingError] = useState(false);
+    const [isPublished, setIsPublished] = useState(false);
+    const [failureMessage, setFailureMessage] = useState(undefined);
+    useEffect(() => {
+        // Check if the current dir contains pulse.config.ts
+        const currentDir = process.cwd();
+        const pulseConfigPath = `${currentDir}/pulse.config.ts`;
+        if (fs.existsSync(pulseConfigPath)) {
+            setIsInProjectDir(true);
+        }
+    }, []);
+    // Check if the user is authenticated
+    useEffect(() => {
+        async function checkAuth() {
+            const token = getToken();
+            if (token) {
+                const isValid = await checkToken(token, cli.flags.dev);
+                if (isValid) {
+                    setIsAuthenticated(true);
+                }
+            }
+            setIsCheckingAuth(false);
+        }
+        if (isInProjectDir) {
+            checkAuth();
+        }
+    }, [isInProjectDir]);
+    // Build the extension
+    useEffect(() => {
+        async function buildExtension() {
+            try {
+                setIsBuilding(true);
+                await $ `npm run build`;
+                // Zip the dist folder
+                await $({ cwd: 'dist' }) `zip -r ../node_modules/@pulse-editor/dist.zip *`;
+            }
+            catch (error) {
+                setIsBuildingError(true);
+                return;
+            }
+            finally {
+                setIsBuilding(false);
+            }
+            await publishExtension();
+        }
+        async function publishExtension() {
+            setIsPublishing(true);
+            // Upload the zip file to the server
+            try {
+                const formData = new FormData();
+                const buffer = fs.readFileSync('./node_modules/@pulse-editor/dist.zip');
+                const blob = new Blob([buffer], {
+                    type: 'application/zip',
+                });
+                formData.append('file', blob, 'dist.zip');
+                // Send the file to the server
+                const res = await fetch(cli.flags.dev
+                    ? 'http://localhost:3000/api/extension/publish'
+                    : 'https://pulse-editor.com/api/extension/publish', {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${getToken()}`,
+                    },
+                    body: formData,
+                });
+                if (res.status === 200) {
+                    setIsPublished(true);
+                }
+                else {
+                    setIsPublishingError(true);
+                    const msg = await res.json();
+                    if (msg.error) {
+                        setFailureMessage(msg.error);
+                    }
+                    else {
+                        setFailureMessage('Unknown error occurred while publishing.');
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error uploading the file:', error);
+                setIsPublishingError(true);
+                return;
+            }
+            finally {
+                setIsPublishing(false);
+            }
+        }
+        if (isAuthenticated) {
+            buildExtension();
+        }
+    }, [isAuthenticated]);
+    return (React.createElement(React.Fragment, null, !isInProjectDir ? (React.createElement(Text, { color: 'redBright' }, "\u26D4 The current directory does not contain a Pulse Editor project.")) : isCheckingAuth ? (React.createElement(Box, null,
+        React.createElement(Spinner, { type: "dots" }),
+        React.createElement(Text, null, " Checking authentication..."))) : isAuthenticated ? (React.createElement(React.Fragment, null,
+        isBuilding && (React.createElement(Box, null,
+            React.createElement(Spinner, { type: "dots" }),
+            React.createElement(Text, null, " Building..."))),
+        isBuildingError && (React.createElement(Text, { color: 'redBright' }, "\u274C Error building the extension. Please run `npm run build` to see the error.")),
+        isPublishing && (React.createElement(Box, null,
+            React.createElement(Spinner, { type: "dots" }),
+            React.createElement(Text, null, " Publishing..."))),
+        isPublishingError && (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: 'redBright' }, "\u274C Failed to publish extension."),
+            failureMessage && (React.createElement(Text, { color: 'redBright' },
+                "Error: ",
+                failureMessage)))),
+        isPublished && (React.createElement(Text, { color: 'greenBright' }, "\u2705 Extension published successfully.")))) : (React.createElement(Text, null,
+        "You are not authenticated or your access token is invalid. Publishing to Extension Marketplace is in Beta access. Please visit",
+        React.createElement(Text, { color: 'blueBright' }, " https://pulse-editor.com/beta "),
+        "to apply for Beta access."))));
+}

package/dist/components/header.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function Header(): React.JSX.Element;

package/dist/components/header.js

@@ -0,0 +1,8 @@
+import { Box, Text } from 'ink';
+import React from 'react';
+export default function Header() {
+    return (React.createElement(Box, { flexDirection: "column", alignItems: "center" },
+        React.createElement(Text, { color: 'whiteBright' }, "Pulse Editor CLI"),
+        React.createElement(Text, null, "Version: 0.0.1"),
+        React.createElement(Text, { color: 'blueBright' }, "https://pulse-editor.com")));
+}

package/dist/lib/cli-flags.d.ts

@@ -0,0 +1,17 @@
+export declare const flags: {
+    token: {
+        type: "boolean";
+    };
+    flow: {
+        type: "boolean";
+    };
+    framework: {
+        type: "string";
+        shortFlag: string;
+    };
+    dev: {
+        type: "boolean";
+        default: false;
+    };
+};
+export type Flags = typeof flags;

package/dist/lib/cli-flags.js

@@ -0,0 +1,20 @@
+// Helper to preserve literal types *and* validate against AnyFlags
+function defineFlags(flags) {
+    return flags;
+}
+export const flags = defineFlags({
+    token: {
+        type: 'boolean',
+    },
+    flow: {
+        type: 'boolean',
+    },
+    framework: {
+        type: 'string',
+        shortFlag: 'f',
+    },
+    dev: {
+        type: 'boolean',
+        default: false,
+    },
+});

package/dist/lib/manual.d.ts

@@ -0,0 +1 @@
+export declare const commandsManual: Record<string, string>;

package/dist/lib/manual.js

@@ -0,0 +1,44 @@
+const help = `\
+  help [command]  Show help for a command.
+`;
+const chat = `\
+  chat [message]  (WIP) Chat with the Pulse Editor AI assistant.
+
+                  Flags:
+                    --interactive, -i
+                      Start an interactive chat session
+
+`;
+const login = `\
+  login           Login to the Pulse Editor Platform.
+
+                  Flags:
+                    --token [token]
+                      Login using an access token. This is the default if the
+                      token is set in the environment variable PE_ACCESS_TOKEN.
+                    --flow
+                      Login using a browser flow.
+
+`;
+const logout = `\
+  logout          Logout from the Pulse Editor Platform.
+`;
+const publish = `\
+  publish         Publish Pulse Editor Extension in current directory to the Pulse Editor Platform.
+`;
+const create = `\
+  create          Create a new Pulse App using the starter template.
+                  Flags:
+                    --framework, -f [framework]
+                      The framework to use for the new app.
+                      Currently available options: react.
+                      Future options: vue, angular, etc.
+`;
+export const commandsManual = {
+    help,
+    chat,
+    login,
+    logout,
+    publish,
+    create,
+};

package/dist/lib/token.d.ts

@@ -0,0 +1,4 @@
+export declare function saveToken(token: string | undefined): void;
+export declare function getToken(): string | undefined;
+export declare function isTokenInEnv(): boolean;
+export declare function checkToken(token: string, devMode: boolean): Promise<boolean>;

package/dist/lib/token.js

@@ -0,0 +1,65 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+export function saveToken(token) {
+    // Save the token to .pulse-editor/config.json in user home directory
+    const configDir = path.join(os.homedir(), '.pulse-editor');
+    const configFile = path.join(configDir, 'config.json');
+    const config = {
+        accessToken: token,
+    };
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+export function getToken() {
+    // First try to get the token from the environment variable
+    const tokenEnv = process.env['PE_ACCESS_TOKEN'];
+    if (tokenEnv) {
+        return tokenEnv;
+    }
+    // If not found, try to get the token from the config file
+    const configDir = path.join(os.homedir(), '.pulse-editor');
+    const configFile = path.join(configDir, 'config.json');
+    if (fs.existsSync(configFile)) {
+        try {
+            const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+            if (config.accessToken) {
+                return config.accessToken;
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse config.json:', error);
+            // Return undefined if JSON parsing fails
+            return undefined;
+        }
+    }
+    // If not found, return undefined
+    return undefined;
+}
+export function isTokenInEnv() {
+    // Check if the token is set in the environment variable
+    const tokenEnv = process.env['PE_ACCESS_TOKEN'];
+    if (tokenEnv) {
+        return true;
+    }
+    return false;
+}
+export async function checkToken(token, devMode) {
+    const res = await fetch(devMode
+        ? 'http://localhost:3000/api/api-keys/check'
+        : 'https://pulse-editor.com/api/api-keys/check', {
+        body: JSON.stringify({ token }),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        method: 'POST',
+    });
+    if (res.status === 200) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,5 @@
+export type Item<V> = {
+    key?: string;
+    label: string;
+    value: V;
+};

package/dist/lib/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pulse-editor/cli",
-	"version": "0.0.1",
+	"version": "0.1.0-beta.0",
 	"license": "MIT",
 	"bin": {
 		"pulse": "./dist/cli.js"

package/readme.md

@@ -1,25 +1,43 @@
-# cli
-
-> This readme is automatically generated by [create-ink-app](https://github.com/vadimdemedes/create-ink-app)
-
+# Pulse CLI
 ## Install
 
 ```bash
-$ npm install --global cli
+$ npm install --global @pulse-editor/cli
 ```
 
-## CLI
+## CLI Manual
 
 ```
-$ cli --help
-
   Usage
-    $ cli
-
-  Options
-    --name  Your name
+    pulse [command] [flags]
+
+  Commands
+    help [command]  Show help for a command.
+    chat [message]  (WIP) Chat with the Pulse Editor AI assistant.
+
+                    Flags:
+                      --interactive, -i
+                        Start an interactive chat session
+
+    login           Login to the Pulse Editor Platform.
+
+                    Flags:
+                      --token [token]
+                        Login using an access token. This is the default if the
+                        token is set in the environment variable PE_ACCESS_TOKEN.
+                      --flow
+                        Login using a browser flow.
+
+    logout          Logout from the Pulse Editor Platform.
+    publish         Publish Pulse Editor Extension in current directory to the Pulse Editor Platform.
+    create          Create a new Pulse App using the starter template.
+                    Flags:
+                      --framework, -f [framework]
+                        The framework to use for the new app.
+                        Currently available options: react.
+                        Future options: vue, angular, etc.
 
   Examples
-    $ cli --name=Jane
-    Hello, Jane
+    pulse help publish
+
 ```