clishop 0.1.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "clishop",
+  "version": "0.1.0",
+  "description": "CLISHOP — Order anything from your terminal",
+  "main": "dist/index.js",
+  "bin": {
+    "clishop": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --target node18",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DavooxBv2/CLISHOP.git"
+  },
+  "keywords": [
+    "cli",
+    "shopping",
+    "ordering"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bugs": {
+    "url": "https://github.com/DavooxBv2/CLISHOP/issues"
+  },
+  "homepage": "https://github.com/DavooxBv2/CLISHOP#readme",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "inquirer": "^13.2.4",
+    "keytar": "^7.9.0",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/keytar": "^4.4.0",
+    "@types/node": "^25.2.3",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/api.ts

@@ -0,0 +1,89 @@
+import axios, { AxiosInstance, AxiosError } from "axios";
+import chalk from "chalk";
+import { getToken, getRefreshToken, storeToken } from "./auth.js";
+
+let client: AxiosInstance | null = null;
+
+/**
+ * Get an authenticated Axios client that talks to the backend.
+ * Automatically attaches the Bearer token and handles 401 refresh.
+ */
+const API_BASE_URL = process.env.CLISHOP_API_URL || "https://clishop-backend.vercel.app/api";
+
+export function getApiClient(): AxiosInstance {
+  if (client) return client;
+
+  const baseUrl = API_BASE_URL;
+
+  client = axios.create({
+    baseURL: baseUrl,
+    timeout: 30_000,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+
+  // Attach token to every request
+  client.interceptors.request.use(async (reqConfig) => {
+    const token = await getToken();
+    if (token) {
+      reqConfig.headers.Authorization = `Bearer ${token}`;
+    }
+    return reqConfig;
+  });
+
+  // Handle 401 — try refresh
+  client.interceptors.response.use(
+    (res) => res,
+    async (error: AxiosError) => {
+      if (error.response?.status === 401) {
+        const refreshToken = await getRefreshToken();
+        if (refreshToken) {
+          try {
+            const res = await axios.post(`${baseUrl}/auth/refresh`, { refreshToken });
+            await storeToken(res.data.token);
+            // Retry original request
+            if (error.config) {
+              error.config.headers.Authorization = `Bearer ${res.data.token}`;
+              return axios(error.config);
+            }
+          } catch {
+            // Refresh failed — user needs to login again
+          }
+        }
+        console.error(chalk.red("\n✗ Session expired. Please login again: clishop login\n"));
+        process.exit(1);
+      }
+      throw error;
+    }
+  );
+
+  return client;
+}
+
+/**
+ * Handle API errors consistently.
+ */
+export function handleApiError(error: unknown): never {
+  if (axios.isAxiosError(error)) {
+    const data = error.response?.data;
+    const message = data?.message || data?.error || error.message;
+    const status = error.response?.status;
+
+    if (status === 422 && data?.errors) {
+      console.error(chalk.red("\n✗ Validation errors:"));
+      for (const [field, msgs] of Object.entries(data.errors)) {
+        console.error(chalk.red(`  ${field}: ${(msgs as string[]).join(", ")}`));
+      }
+    } else if (status === 404) {
+      console.error(chalk.red(`\n✗ Not found: ${message}`));
+    } else {
+      console.error(chalk.red(`\n✗ API error (${status || "network"}): ${message}`));
+    }
+  } else if (error instanceof Error) {
+    console.error(chalk.red(`\n✗ ${error.message}`));
+  } else {
+    console.error(chalk.red("\n✗ An unexpected error occurred."));
+  }
+  process.exit(1);
+}

package/src/auth.ts

@@ -0,0 +1,117 @@
+import keytar from "keytar";
+import axios from "axios";
+import { getConfig } from "./config.js";
+
+const SERVICE_NAME = "clishop";
+const ACCOUNT_TOKEN = "auth-token";
+const ACCOUNT_REFRESH = "refresh-token";
+const ACCOUNT_USER = "user-info";
+
+export interface UserInfo {
+  id: string;
+  email: string;
+  name: string;
+}
+
+/**
+ * Store auth token securely in the OS keychain.
+ */
+export async function storeToken(token: string): Promise<void> {
+  await keytar.setPassword(SERVICE_NAME, ACCOUNT_TOKEN, token);
+}
+
+export async function storeRefreshToken(token: string): Promise<void> {
+  await keytar.setPassword(SERVICE_NAME, ACCOUNT_REFRESH, token);
+}
+
+export async function storeUserInfo(user: UserInfo): Promise<void> {
+  await keytar.setPassword(SERVICE_NAME, ACCOUNT_USER, JSON.stringify(user));
+}
+
+export async function getToken(): Promise<string | null> {
+  return keytar.getPassword(SERVICE_NAME, ACCOUNT_TOKEN);
+}
+
+export async function getRefreshToken(): Promise<string | null> {
+  return keytar.getPassword(SERVICE_NAME, ACCOUNT_REFRESH);
+}
+
+export async function getUserInfo(): Promise<UserInfo | null> {
+  const raw = await keytar.getPassword(SERVICE_NAME, ACCOUNT_USER);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw) as UserInfo;
+  } catch {
+    return null;
+  }
+}
+
+export async function clearAuth(): Promise<void> {
+  await keytar.deletePassword(SERVICE_NAME, ACCOUNT_TOKEN);
+  await keytar.deletePassword(SERVICE_NAME, ACCOUNT_REFRESH);
+  await keytar.deletePassword(SERVICE_NAME, ACCOUNT_USER);
+}
+
+export async function isLoggedIn(): Promise<boolean> {
+  const token = await getToken();
+  return !!token;
+}
+
+/**
+ * Login with email + password.
+ * Returns the user info on success.
+ */
+export async function login(email: string, password: string): Promise<UserInfo> {
+  const config = getConfig();
+  const baseUrl = config.get("apiBaseUrl");
+
+  const res = await axios.post(`${baseUrl}/auth/login`, { email, password });
+
+  const { token, refreshToken, user } = res.data;
+
+  await storeToken(token);
+  if (refreshToken) await storeRefreshToken(refreshToken);
+  await storeUserInfo(user);
+
+  return user;
+}
+
+/**
+ * Register a new account.
+ */
+export async function register(email: string, password: string, name: string): Promise<UserInfo> {
+  const config = getConfig();
+  const baseUrl = config.get("apiBaseUrl");
+
+  const res = await axios.post(`${baseUrl}/auth/register`, { email, password, name });
+
+  const { token, refreshToken, user } = res.data;
+
+  await storeToken(token);
+  if (refreshToken) await storeRefreshToken(refreshToken);
+  await storeUserInfo(user);
+
+  return user;
+}
+
+/**
+ * Logout — clear local tokens.
+ */
+export async function logout(): Promise<void> {
+  const config = getConfig();
+  const baseUrl = config.get("apiBaseUrl");
+  const token = await getToken();
+
+  // Best-effort server-side logout
+  if (token) {
+    try {
+      await axios.post(`${baseUrl}/auth/logout`, {}, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+    } catch {
+      // Server might be unreachable — that's fine, we clear locally anyway
+    }
+  }
+
+  await clearAuth();
+}

package/src/commands/address.ts

@@ -0,0 +1,213 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { getApiClient, handleApiError } from "../api.js";
+import { getConfig, getActiveAgent, updateAgent } from "../config.js";
+
+export interface Address {
+  id: string;
+  label: string;
+  recipientName?: string;
+  recipientPhone?: string;
+  companyName?: string;
+  vatNumber?: string;
+  taxId?: string;
+  line1: string;
+  line2?: string;
+  city: string;
+  state?: string;
+  region?: string;
+  postalCode: string;
+  country: string;
+  instructions?: string;
+}
+
+export function registerAddressCommands(program: Command): void {
+  const address = program
+    .command("address")
+    .description("Manage shipping addresses (scoped to the active agent)");
+
+  // ── LIST ───────────────────────────────────────────────────────────
+  address
+    .command("list")
+    .alias("ls")
+    .description("List all addresses for the active agent")
+    .action(async () => {
+      try {
+        const agent = getActiveAgent();
+        const spinner = ora("Fetching addresses...").start();
+        const api = getApiClient();
+        const res = await api.get("/addresses", {
+          params: { agent: agent.name },
+        });
+        spinner.stop();
+
+        const addresses: Address[] = res.data.addresses;
+        if (addresses.length === 0) {
+          console.log(chalk.yellow("\nNo addresses found. Add one with: clishop address add\n"));
+          return;
+        }
+
+        console.log(chalk.bold(`\nAddresses for agent "${agent.name}":\n`));
+        for (const addr of addresses) {
+          const isDefault = addr.id === agent.defaultAddressId;
+          const marker = isDefault ? chalk.green("● ") : "  ";
+          console.log(`${marker}${chalk.bold(addr.label)} ${chalk.dim(`(${addr.id})`)}`);
+          if (addr.recipientName) console.log(`    ${addr.recipientName}`);
+          if (addr.companyName) console.log(`    ${chalk.cyan(addr.companyName)}`);
+          console.log(`    ${addr.line1}`);
+          if (addr.line2) console.log(`    ${addr.line2}`);
+          console.log(`    ${addr.city}${addr.region ? `, ${addr.region}` : ""} ${addr.postalCode}`);
+          console.log(`    ${addr.country}`);
+          if (addr.recipientPhone) console.log(`    ${chalk.dim("Phone:")} ${addr.recipientPhone}`);
+          if (addr.vatNumber) console.log(`    ${chalk.dim("VAT:")} ${addr.vatNumber}`);
+          if (addr.taxId) console.log(`    ${chalk.dim("Tax ID:")} ${addr.taxId}`);
+          if (addr.instructions) console.log(`    ${chalk.dim("Instructions:")} ${addr.instructions}`);
+          console.log();
+        }
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+
+  // ── ADD ────────────────────────────────────────────────────────────
+  address
+    .command("add")
+    .description("Add a new address")
+    .action(async () => {
+      try {
+        const agent = getActiveAgent();
+        const answers = await inquirer.prompt([
+          { type: "input", name: "label", message: "Label (e.g. Home, Office):" },
+          { type: "input", name: "recipientName", message: "Recipient name (optional):" },
+          { type: "input", name: "recipientPhone", message: "Recipient phone (optional):" },
+          {
+            type: "input",
+            name: "line1",
+            message: "Street name and number:",
+            validate: (v: string) => (v.trim() ? true : "Required"),
+          },
+          { type: "input", name: "line2", message: "Apartment, suite, floor, etc. (optional):" },
+          {
+            type: "input",
+            name: "postalCode",
+            message: "Postal / ZIP code:",
+            validate: (v: string) => (v.trim() ? true : "Required"),
+          },
+          {
+            type: "input",
+            name: "city",
+            message: "City:",
+            validate: (v: string) => (v.trim() ? true : "Required"),
+          },
+          { type: "input", name: "region", message: "State / Province / Region (optional):" },
+          {
+            type: "input",
+            name: "country",
+            message: "Country:",
+            validate: (v: string) => (v.trim() ? true : "Required"),
+          },
+          { type: "input", name: "instructions", message: "Delivery instructions (optional):" },
+          {
+            type: "confirm",
+            name: "isCompany",
+            message: "Is this a company/business address?",
+            default: false,
+          },
+        ]);
+
+        let companyAnswers = { companyName: "", vatNumber: "", taxId: "" };
+        if (answers.isCompany) {
+          companyAnswers = await inquirer.prompt([
+            {
+              type: "input",
+              name: "companyName",
+              message: "Company name:",
+              validate: (v: string) => (v.trim() ? true : "Required for company addresses"),
+            },
+            { type: "input", name: "vatNumber", message: "VAT number (optional):" },
+            { type: "input", name: "taxId", message: "Tax ID / EIN (optional):" },
+          ]);
+        }
+
+        const { setDefault } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "setDefault",
+            message: "Set as default address for this agent?",
+            default: true,
+          },
+        ]);
+
+        const spinner = ora("Saving address...").start();
+        const api = getApiClient();
+        const res = await api.post("/addresses", {
+          agent: agent.name,
+          label: answers.label,
+          recipientName: answers.recipientName || undefined,
+          recipientPhone: answers.recipientPhone || undefined,
+          companyName: companyAnswers.companyName || undefined,
+          vatNumber: companyAnswers.vatNumber || undefined,
+          taxId: companyAnswers.taxId || undefined,
+          line1: answers.line1,
+          line2: answers.line2 || undefined,
+          city: answers.city,
+          region: answers.region || undefined,
+          postalCode: answers.postalCode,
+          country: answers.country,
+          instructions: answers.instructions || undefined,
+        });
+
+        if (setDefault) {
+          updateAgent(agent.name, { defaultAddressId: res.data.address.id });
+        }
+
+        spinner.succeed(chalk.green(`Address "${answers.label}" added.`));
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+
+  // ── REMOVE ─────────────────────────────────────────────────────────
+  address
+    .command("remove <id>")
+    .alias("rm")
+    .description("Remove an address by ID")
+    .action(async (id: string) => {
+      try {
+        const { confirm } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: `Delete address ${id}?`,
+            default: false,
+          },
+        ]);
+        if (!confirm) return;
+
+        const spinner = ora("Removing address...").start();
+        const api = getApiClient();
+        await api.delete(`/addresses/${id}`);
+        spinner.succeed(chalk.green("Address removed."));
+
+        // Clear default if it was this one
+        const agent = getActiveAgent();
+        if (agent.defaultAddressId === id) {
+          updateAgent(agent.name, { defaultAddressId: undefined });
+        }
+      } catch (error) {
+        handleApiError(error);
+      }
+    });
+
+  // ── SET-DEFAULT ────────────────────────────────────────────────────
+  address
+    .command("set-default <id>")
+    .description("Set the default address for the active agent")
+    .action((id: string) => {
+      const agent = getActiveAgent();
+      updateAgent(agent.name, { defaultAddressId: id });
+      console.log(chalk.green(`\n✓ Default address for agent "${agent.name}" set to ${id}.`));
+    });
+}