@flowkode/cli 1.0.0

package/dist/commands/utilities.js

@@ -0,0 +1,129 @@
+import { Command } from "commander";
+import { printTable, printError, printJson } from "../output.js";
+export function utilitiesCommands(api) {
+    const contactForms = new Command("contact-forms")
+        .description("Lister les formulaires de contact/devis")
+        .option("-c, --category <cat>", "Filtrer (contact, devis)")
+        .action(async (opts) => {
+        try {
+            const res = (await api.get("/contact-forms", {
+                category: opts.category,
+            }));
+            printTable(res.data, [
+                { key: "id", label: "ID", width: 36 },
+                { key: "name", label: "Nom", width: 25 },
+                { key: "category", label: "Categorie", width: 12 },
+            ]);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    const aiModels = new Command("ai-models")
+        .description("Lister les modeles IA disponibles")
+        .option("-c, --category <cat>", "Filtrer par categorie")
+        .action(async (opts) => {
+        try {
+            const res = await api.get("/ai-models", {
+                category: opts.category,
+            });
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    const legalNotices = new Command("legal-notices")
+        .description("Lister les mentions legales")
+        .action(async () => {
+        try {
+            const res = (await api.get("/legal-notices"));
+            printTable(res.data, [
+                { key: "id", label: "ID", width: 36 },
+                { key: "company_name", label: "Societe", width: 30 },
+            ]);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    const affiliation = new Command("affiliation").description("Gerer les projets d'affiliation");
+    affiliation
+        .command("list")
+        .description("Lister les projets d'affiliation")
+        .action(async () => {
+        try {
+            const res = (await api.get("/affiliation-projects"));
+            printTable(res.data, [
+                { key: "id", label: "ID", width: 36 },
+                { key: "name", label: "Nom", width: 25 },
+                { key: "platform", label: "Plateforme", width: 12 },
+            ]);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    affiliation
+        .command("get <id>")
+        .description("Detail d'un projet d'affiliation")
+        .action(async (id) => {
+        try {
+            const res = await api.get(`/affiliation-projects/${id}`);
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    const searchConsole = new Command("search-console").description("Google Search Console");
+    searchConsole
+        .command("accounts")
+        .description("Lister les comptes connectes")
+        .action(async () => {
+        try {
+            const res = await api.get("/search-console/accounts");
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    searchConsole
+        .command("add-site <projectId>")
+        .description("Enregistrer un site dans Search Console")
+        .action(async (projectId) => {
+        try {
+            const res = await api.post(`/projects/${projectId}/search-console/add-site`);
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    searchConsole
+        .command("status <projectId>")
+        .description("Statut Search Console d'un projet")
+        .action(async (projectId) => {
+        try {
+            const res = await api.get(`/projects/${projectId}/search-console/status`);
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    searchConsole
+        .command("submit-sitemap <projectId>")
+        .description("Soumettre le sitemap d'un projet")
+        .action(async (projectId) => {
+        try {
+            const res = await api.post(`/projects/${projectId}/search-console/submit-sitemap`);
+            printJson(res);
+        }
+        catch (e) {
+            printError(e);
+        }
+    });
+    return [contactForms, aiModels, legalNotices, affiliation, searchConsole];
+}

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface CliConfig {
+    api_key?: string;
+    base_url?: string;
+}
+export declare function loadConfig(): CliConfig;
+export declare function saveConfig(config: CliConfig): void;
+export declare function getApiKey(): string;
+export declare function getBaseUrl(): string;

package/dist/config.js

@@ -0,0 +1,37 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const CONFIG_DIR = join(homedir(), ".flowkode");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+        mode: 0o600,
+    });
+    chmodSync(CONFIG_FILE, 0o600);
+}
+export function getApiKey() {
+    const key = process.env.FLOWKODE_API_KEY || loadConfig().api_key;
+    if (!key) {
+        console.error("API key required. Run `flowkode config --api-key <key>` or set FLOWKODE_API_KEY.");
+        process.exit(1);
+    }
+    return key;
+}
+export function getBaseUrl() {
+    return (process.env.FLOWKODE_BASE_URL ||
+        loadConfig().base_url ||
+        "https://app.flowkode.com");
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { FlowkodeApiClient } from "./api-client.js";
+import { getApiKey, getBaseUrl } from "./config.js";
+import { setJsonMode } from "./output.js";
+import { configCommand } from "./commands/config.js";
+import { loginCommand, logoutCommand } from "./commands/login.js";
+import { projectsCommand } from "./commands/projects.js";
+import { jobsCommand } from "./commands/jobs.js";
+import { deploymentsCommand } from "./commands/deployments.js";
+import { domainsCommand } from "./commands/domains.js";
+import { foldersCommand } from "./commands/folders.js";
+import { blogCommand } from "./commands/blog.js";
+import { utilitiesCommands } from "./commands/utilities.js";
+const program = new Command();
+program
+    .name("flowkode")
+    .description("CLI pour l'API Flowkode — Creer, deployer et gerer vos sites")
+    .version("1.0.0")
+    .option("--json", "Sortie en JSON brut")
+    .hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.json)
+        setJsonMode(true);
+});
+program.addCommand(loginCommand());
+program.addCommand(logoutCommand());
+program.addCommand(configCommand());
+// Commands that need the API client — lazy init to allow `config` without key
+const apiCommands = () => {
+    const api = new FlowkodeApiClient(getBaseUrl(), getApiKey());
+    return { api };
+};
+// Wrap commands to lazily create API client
+function addApiCommand(cmd) {
+    const originalAction = cmd.commands.length > 0 ? null : cmd;
+    // For commands with subcommands, hook into each subcommand
+    const hookAll = (parent) => {
+        for (const sub of parent.commands) {
+            if (sub.commands.length > 0) {
+                hookAll(sub);
+            }
+        }
+    };
+    program.addCommand(cmd);
+    hookAll(cmd);
+}
+// Create a lazy API getter
+let _api = null;
+function getApi() {
+    if (!_api) {
+        _api = new FlowkodeApiClient(getBaseUrl(), getApiKey());
+    }
+    return _api;
+}
+// Pre-subcommand hook: initialize API when any API command runs
+program.hook("preSubcommand", () => {
+    // API will be initialized lazily on first use via getApi()
+});
+// Register all commands with lazy API
+const api = {
+    get: (...args) => getApi().get(...args),
+    post: (...args) => getApi().post(...args),
+    patch: (...args) => getApi().patch(...args),
+    delete: (...args) => getApi().delete(...args),
+};
+program.addCommand(projectsCommand(api));
+program.addCommand(jobsCommand(api));
+program.addCommand(deploymentsCommand(api));
+program.addCommand(domainsCommand(api));
+program.addCommand(foldersCommand(api));
+program.addCommand(blogCommand(api));
+for (const cmd of utilitiesCommands(api)) {
+    program.addCommand(cmd);
+}
+program.parse();

package/dist/output.d.ts

@@ -0,0 +1,13 @@
+export declare function setJsonMode(enabled: boolean): void;
+export declare function printJson(data: unknown): void;
+export declare function printTable(rows: Record<string, unknown>[], columns: {
+    key: string;
+    label: string;
+    width?: number;
+}[]): void;
+export declare function printSuccess(message: string): void;
+export declare function printError(error: unknown): void;
+export declare function printDetail(data: Record<string, unknown>, fields: {
+    key: string;
+    label: string;
+}[]): void;

package/dist/output.js

@@ -0,0 +1,68 @@
+import chalk from "chalk";
+let jsonMode = false;
+export function setJsonMode(enabled) {
+    jsonMode = enabled;
+}
+export function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function printTable(rows, columns) {
+    if (jsonMode) {
+        printJson(rows);
+        return;
+    }
+    if (rows.length === 0) {
+        console.log(chalk.dim("  Aucun resultat."));
+        return;
+    }
+    const widths = columns.map((col) => {
+        const maxData = rows.reduce((max, row) => {
+            const val = String(row[col.key] ?? "");
+            return Math.max(max, val.length);
+        }, 0);
+        return col.width ?? Math.max(col.label.length, Math.min(maxData, 40));
+    });
+    const header = columns
+        .map((col, i) => chalk.bold(col.label.padEnd(widths[i])))
+        .join("  ");
+    console.log(header);
+    console.log(chalk.dim("─".repeat(header.length)));
+    for (const row of rows) {
+        const line = columns
+            .map((col, i) => {
+            const val = String(row[col.key] ?? "—");
+            return val.length > widths[i]
+                ? val.slice(0, widths[i] - 1) + "…"
+                : val.padEnd(widths[i]);
+        })
+            .join("  ");
+        console.log(line);
+    }
+}
+export function printSuccess(message) {
+    if (jsonMode)
+        return;
+    console.log(chalk.green(`✓ ${message}`));
+}
+export function printError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (jsonMode) {
+        printJson({ error: msg });
+    }
+    else {
+        console.error(chalk.red(`✗ ${msg}`));
+    }
+    process.exit(1);
+}
+export function printDetail(data, fields) {
+    if (jsonMode) {
+        printJson(data);
+        return;
+    }
+    const maxLabel = Math.max(...fields.map((f) => f.label.length));
+    for (const field of fields) {
+        const label = chalk.bold(field.label.padEnd(maxLabel));
+        const value = data[field.key] ?? chalk.dim("—");
+        console.log(`  ${label}  ${value}`);
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@flowkode/cli",
+	"version": "1.0.0",
+	"description": "CLI pour l'API Flowkode - Creer, deployer et gerer vos sites web",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"flowkode": "dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsx src/index.ts",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"commander": "^13.1.0",
+		"chalk": "^5.4.1"
+	},
+	"devDependencies": {
+		"tsx": "^4.19.0",
+		"typescript": "^5.7.0",
+		"@types/node": "^22.0.0"
+	},
+	"files": ["dist"],
+	"keywords": ["flowkode", "cli", "website-builder", "deploy"],
+	"license": "MIT"
+}