@ollie-shop/cli 0.1.1

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+
+> @ollie-shop/cli@0.1.1 build /home/runner/work/ollie-shop/ollie-shop/packages/cli
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.0
+CLI Using tsup config: /home/runner/work/ollie-shop/ollie-shop/packages/cli/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+CJS Build start
+CJS dist/index.js 7.47 KB
+CJS ⚡️ Build success in 470ms

package/README.md

@@ -0,0 +1,15 @@
+# Ollie Shop CLI [WIP]
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+`ollie-shop` is a development dependency package that provides a command-line interface (CLI) for local development of Ollie Shop templates and components. This package is currently a work in progress (WIP) and aims to streamline the development workflow for Ollie Shop projects.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/index.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var child_process = require('child_process');
+var crypto = require('crypto');
+var fs = require('fs/promises');
+var http = require('http');
+var os = require('os');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var DEFAULT_CALLBACK_PORT = 7777;
+var AUTH_ENDPOINT = "https://admin.ollie.shop/auth/login";
+function configureLoginCommand(program) {
+  return program.command("login").description("Log in to your Ollie Shop account").option(
+    "-p, --port <port>",
+    "Port to use for the local callback server",
+    DEFAULT_CALLBACK_PORT.toString()
+  ).option("--auth-url <url>", "Custom authorization URL", AUTH_ENDPOINT).action(async (options) => {
+    console.log("\u{1F510} Initiating Ollie Shop login flow...");
+    try {
+      const token = await startWebAuthFlow(options);
+      if (token) {
+        await saveCredentials(token);
+        console.log("\u2705 Successfully logged in!");
+        return;
+      }
+      console.error("\u274C Authentication failed. Please try again.");
+      process.exit(1);
+    } catch (error) {
+      console.error(
+        `\u274C Login failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+}
+async function handleAuthCallback(req, res, state, resolve, reject) {
+  const socket = req.socket;
+  const url = new URL(
+    req.url || "/",
+    `http://localhost:${socket.localPort || 3e3}`
+  );
+  const params = url.searchParams;
+  const returnedState = params.get("state");
+  if (returnedState !== state) {
+    sendErrorResponse(
+      res,
+      400,
+      "Invalid state parameter",
+      "Authentication failed. Please try again."
+    );
+    reject(new Error("Invalid state parameter"));
+    return;
+  }
+  let formData = "";
+  req.on("data", (chunk) => {
+    formData += chunk.toString();
+  });
+  await new Promise((formResolve) => {
+    req.on("end", () => {
+      formResolve();
+    });
+  });
+  const formParams = new URLSearchParams(formData);
+  const accessToken = formParams.get("access_token");
+  const refreshToken = formParams.get("refresh_token") || "";
+  const expiresAt = formParams.get("expires_at") || new Date(Date.now() + 36e5).toISOString();
+  if (!accessToken) {
+    sendErrorResponse(
+      res,
+      400,
+      "Missing authentication token",
+      "Authentication failed. Please try again."
+    );
+    reject(new Error("Missing authentication token"));
+    return;
+  }
+  try {
+    const token = {
+      accessToken,
+      refreshToken,
+      expiresAt
+    };
+    sendSuccessResponse(res);
+    resolve(token);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    sendErrorResponse(
+      res,
+      500,
+      "Authentication failed",
+      `Error: ${errorMessage}`
+    );
+    reject(new Error(errorMessage));
+  }
+}
+function sendErrorResponse(res, statusCode, title, message) {
+  res.writeHead(statusCode, { "Content-Type": "text/html" });
+  res.end(`<h1>${title}</h1><p>${message}</p>`);
+}
+function sendSuccessResponse(res) {
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end(
+    "<h1>Authentication successful!</h1><p>You can now close this window and return to the CLI.</p>"
+  );
+}
+function sendWaitingResponse(res) {
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end(
+    "<h1>Ollie Shop CLI Authentication</h1><p>Waiting for authentication response...</p>"
+  );
+}
+async function startWebAuthFlow(options) {
+  const state = crypto.randomBytes(16).toString("hex");
+  const port = Number.parseInt(options.port, 10);
+  const baseUrl = options.authUrl;
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      try {
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+        if (url.pathname === "/callback") {
+          await handleAuthCallback(
+            req,
+            res,
+            state,
+            (token) => {
+              server.close(() => {
+                console.log("\u{1F510} Local authentication server closed");
+                resolve(token);
+              });
+            },
+            (error) => {
+              server.close(() => {
+                console.log("\u{1F510} Local authentication server closed");
+                reject(error);
+              });
+            }
+          );
+        } else {
+          sendWaitingResponse(res);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        sendErrorResponse(res, 500, "Server Error", errorMessage);
+        server.close(() => {
+          console.log("\u{1F510} Local authentication server closed");
+          reject(new Error(errorMessage));
+        });
+      }
+    });
+    server.listen(port, () => {
+      const redirectUrl = `http://localhost:${port}/callback`;
+      const authUrl = new URL(baseUrl);
+      authUrl.searchParams.set("flow", "cli");
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("redirect_to", redirectUrl);
+      console.log("\n\u{1F512} Please authenticate in your browser...\n");
+      console.log(`Opening: ${authUrl}
+`);
+      openBrowser(authUrl.toString());
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${port} is already in use. Please specify a different port using the --port option.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+      server.close();
+    });
+    const timeoutId = setTimeout(
+      () => {
+        server.close(() => {
+          console.log("\u{1F510} Local authentication server closed due to timeout");
+          reject(new Error("Authentication timed out. Please try again."));
+        });
+      },
+      5 * 60 * 1e3
+    );
+    server.on("close", () => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  child_process.spawn(command, [url], { detached: true }).unref();
+}
+async function saveCredentials(token) {
+  console.log("Saving credentials...");
+  const configDir = path__default.default.join(os.homedir(), ".ollie-shop");
+  const credentialsPath = path__default.default.join(configDir, "credentials.json");
+  try {
+    await fs__default.default.mkdir(configDir, { recursive: true });
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) {
+      throw error;
+    }
+  }
+  await fs__default.default.writeFile(credentialsPath, JSON.stringify(token, null, 2));
+  return true;
+}
+
+// src/commands/index.ts
+function registerCommands(program) {
+  configureLoginCommand(program);
+}
+
+// src/index.ts
+function createProgram() {
+  const program = new commander.Command();
+  program.name("ollie").description("Ollie Shop CLI tools").version("0.1.0");
+  registerCommands(program);
+  return program;
+}
+if (__require.main === module) {
+  const program = createProgram();
+  program.parse();
+}
+
+exports.createProgram = createProgram;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@ollie-shop/cli",
+  "version": "0.1.1",
+  "description": "CLI tools for Ollie Shop",
+  "bin": {
+    "ollie-shop": "./dist/index.js"
+  },
+  "dependencies": {
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.23",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest",
+    "dev": "tsup --watch"
+  }
+}

package/src/commands/index.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import { configureLoginCommand } from "./login";
+
+/**
+ * Register all CLI commands with the program
+ * @param program The commander program instance
+ */
+export function registerCommands(program: Command): void {
+  // Register individual commands
+  configureLoginCommand(program);
+
+  // Add more commands here as they are implemented
+}

package/src/commands/login.ts

@@ -0,0 +1,340 @@
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import path from "node:path";
+import type { Command } from "commander";
+
+/**
+ * Default port for the local callback server
+ */
+const DEFAULT_CALLBACK_PORT = 7777;
+
+/**
+ * Default Ollie Shop authorization endpoint
+ */
+const AUTH_ENDPOINT = "https://admin.ollie.shop/auth/login";
+
+/**
+ * Configure the login command
+ * @param program The commander program instance
+ * @returns The configured command
+ */
+export function configureLoginCommand(program: Command): Command {
+  return program
+    .command("login")
+    .description("Log in to your Ollie Shop account")
+    .option(
+      "-p, --port <port>",
+      "Port to use for the local callback server",
+      DEFAULT_CALLBACK_PORT.toString(),
+    )
+    .option("--auth-url <url>", "Custom authorization URL", AUTH_ENDPOINT)
+    .action(async (options) => {
+      console.log("🔐 Initiating Ollie Shop login flow...");
+
+      try {
+        const token = await startWebAuthFlow(options);
+
+        if (token) {
+          await saveCredentials(token);
+
+          console.log("✅ Successfully logged in!");
+          // Process continues normally after login
+          return;
+        }
+
+        console.error("❌ Authentication failed. Please try again.");
+        process.exit(1);
+      } catch (error) {
+        console.error(
+          `❌ Login failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        );
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Authentication response type
+ */
+type AuthToken = {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+};
+
+/**
+ * Handle the callback endpoint for web authentication flow
+ *
+ * This now expects to receive tokens directly from the Next.js app with Supabase auth
+ */
+async function handleAuthCallback(
+  req: IncomingMessage,
+  res: ServerResponse,
+  state: string,
+  resolve: (token: AuthToken | null) => void,
+  reject: (err: Error) => void,
+): Promise<void> {
+  // TypeScript doesn't know the socket will always have localPort, so we cast
+  const socket = req.socket as { localPort?: number };
+  const url = new URL(
+    req.url || "/",
+    `http://localhost:${socket.localPort || 3000}`,
+  );
+  const params = url.searchParams;
+
+  // Verify state from query parameters to prevent CSRF attacks
+  const returnedState = params.get("state");
+  if (returnedState !== state) {
+    sendErrorResponse(
+      res,
+      400,
+      "Invalid state parameter",
+      "Authentication failed. Please try again.",
+    );
+    reject(new Error("Invalid state parameter"));
+    return;
+  }
+
+  // Parse the request body to get the access_token from form data
+  let formData = "";
+  req.on("data", (chunk) => {
+    formData += chunk.toString();
+  });
+
+  await new Promise<void>((formResolve) => {
+    req.on("end", () => {
+      formResolve();
+    });
+  });
+
+  // Parse form data
+  const formParams = new URLSearchParams(formData);
+  const accessToken = formParams.get("access_token");
+  const refreshToken = formParams.get("refresh_token") || "";
+  const expiresAt =
+    formParams.get("expires_at") ||
+    new Date(Date.now() + 3600000).toISOString();
+
+  if (!accessToken) {
+    sendErrorResponse(
+      res,
+      400,
+      "Missing authentication token",
+      "Authentication failed. Please try again.",
+    );
+    reject(new Error("Missing authentication token"));
+    return;
+  }
+
+  try {
+    // Create token object
+    const token: AuthToken = {
+      accessToken,
+      refreshToken,
+      expiresAt,
+    };
+
+    // Send success response to browser
+    sendSuccessResponse(res);
+
+    // Resolve the promise with the token
+    resolve(token);
+  } catch (error) {
+    const errorMessage =
+      error instanceof Error ? error.message : "Unknown error";
+    sendErrorResponse(
+      res,
+      500,
+      "Authentication failed",
+      `Error: ${errorMessage}`,
+    );
+    reject(new Error(errorMessage));
+  }
+}
+
+/**
+ * Send HTML error response
+ */
+function sendErrorResponse(
+  res: ServerResponse,
+  statusCode: number,
+  title: string,
+  message: string,
+): void {
+  res.writeHead(statusCode, { "Content-Type": "text/html" });
+  res.end(`<h1>${title}</h1><p>${message}</p>`);
+}
+
+/**
+ * Send HTML success response
+ */
+function sendSuccessResponse(res: ServerResponse): void {
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end(
+    "<h1>Authentication successful!</h1><p>You can now close this window and return to the CLI.</p>",
+  );
+}
+
+/**
+ * Send HTML waiting page response
+ */
+function sendWaitingResponse(res: ServerResponse): void {
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end(
+    "<h1>Ollie Shop CLI Authentication</h1><p>Waiting for authentication response...</p>",
+  );
+}
+
+/**
+ * Start the web-based authentication flow
+ */
+async function startWebAuthFlow(options: {
+  port: string;
+  authUrl: string;
+}): Promise<AuthToken | null> {
+  const state = randomBytes(16).toString("hex");
+  const port = Number.parseInt(options.port, 10);
+  const baseUrl = options.authUrl;
+
+  return new Promise<AuthToken | null>((resolve, reject) => {
+    // Create a local server to receive the callback
+    const server = createServer(async (req, res) => {
+      try {
+        // Parse the URL and query parameters
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+
+        // Check if this is a callback from the Next.js app
+        if (url.pathname === "/callback") {
+          await handleAuthCallback(
+            req,
+            res,
+            state,
+            (token) => {
+              // Wrap the resolve to ensure server is closed
+              server.close(() => {
+                console.log("🔐 Local authentication server closed");
+                resolve(token);
+              });
+            },
+            (error) => {
+              // Wrap the reject to ensure server is closed
+              server.close(() => {
+                console.log("🔐 Local authentication server closed");
+                reject(error);
+              });
+            },
+          );
+        } else {
+          // Serve a simple page for any other path
+          sendWaitingResponse(res);
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : "Unknown error";
+        sendErrorResponse(res, 500, "Server Error", errorMessage);
+        server.close(() => {
+          console.log("🔐 Local authentication server closed");
+          reject(new Error(errorMessage));
+        });
+      }
+    });
+
+    // Start the server
+    server.listen(port, () => {
+      // Build the URL to your Next.js app with necessary parameters
+      const redirectUrl = `http://localhost:${port}/callback`;
+
+      const authUrl = new URL(baseUrl);
+
+      authUrl.searchParams.set("flow", "cli");
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("redirect_to", redirectUrl);
+
+      console.log("\n🔒 Please authenticate in your browser...\n");
+      console.log(`Opening: ${authUrl}\n`);
+
+      // Open the browser with the authorization URL
+      openBrowser(authUrl.toString());
+    });
+
+    // Handle server errors
+    server.on("error", (err: Error) => {
+      if ((err as NodeJS.ErrnoException).code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${port} is already in use. Please specify a different port using the --port option.`,
+          ),
+        );
+      } else {
+        reject(err);
+      }
+      server.close();
+    });
+
+    // Set a timeout to prevent hanging indefinitely
+    const timeoutId = setTimeout(
+      () => {
+        server.close(() => {
+          console.log("🔐 Local authentication server closed due to timeout");
+          reject(new Error("Authentication timed out. Please try again."));
+        });
+      },
+      5 * 60 * 1000,
+    ); // 5 minutes timeout
+
+    // Clean up the timeout if the server closes for other reasons
+    server.on("close", () => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+
+/**
+ * Open the default browser with the given URL
+ */
+function openBrowser(url: string) {
+  const command =
+    process.platform === "darwin"
+      ? "open"
+      : process.platform === "win32"
+        ? "start"
+        : "xdg-open";
+
+  spawn(command, [url], { detached: true }).unref();
+}
+
+/**
+ * Save authentication credentials locally
+ *
+ * @todo Use a more secure storage method like OS keychain
+ */
+async function saveCredentials(token: {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+}) {
+  console.log("Saving credentials...");
+
+  const configDir = path.join(homedir(), ".ollie-shop");
+  const credentialsPath = path.join(configDir, "credentials.json");
+
+  // Create the .ollie-shop directory if it doesn't exist
+  try {
+    await fs.mkdir(configDir, { recursive: true });
+  } catch (error) {
+    // Ignore error if directory already exists
+    if (
+      !(error instanceof Error && "code" in error && error.code === "EEXIST")
+    ) {
+      throw error;
+    }
+  }
+
+  await fs.writeFile(credentialsPath, JSON.stringify(token, null, 2));
+
+  return true;
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { registerCommands } from "./commands";
+
+/**
+ * Create and configure the CLI program
+ */
+export function createProgram() {
+  const program = new Command();
+  program.name("ollie").description("Ollie Shop CLI tools").version("0.1.0");
+
+  // Register all commands
+  registerCommands(program);
+
+  return program;
+}
+
+// If this file is run directly, execute the CLI
+if (require.main === module) {
+  const program = createProgram();
+  program.parse();
+}

package/src/utils/constants.ts

@@ -0,0 +1,7 @@
+export const SRC_DIR = "src";
+export const COMPONENTS_DIR = "components";
+export const DIST_DIR = "dist";
+export const META_FILE = "meta.json";
+export const CONFIG_FILE = "ollie.json";
+export const OLLIE_SHOP_ASSETS_DIR = "node_modules/.ollie-shop";
+export const TEMPLATES_DIR = "templates";

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "module": "ESNext",
+    "target": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "declaration": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "types": ["node", "vitest/globals"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["./src/index.ts"],
+  bundle: true,
+  splitting: false,
+  minify: false,
+  sourcemap: false,
+  platform: "node",
+  format: "cjs",
+  clean: true,
+  treeshake: true,
+  dts: false,
+  banner: { js: "#!/usr/bin/env node" },
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+  },
+});