npm - zako - Versions diffs - 0.1.0 - Mend

zako 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/cli.mjs +682 -0
package/package.json +23 -0

package/dist/cli.mjs ADDED Viewed

@@ -0,0 +1,682 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { createServer } from "node:http";
+import { exec } from "node:child_process";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readFile, unlink, mkdir, writeFile, chmod, access } from "node:fs/promises";
+import { z } from "zod";
+import { createInterface } from "node:readline/promises";
+const CONFIG_DIR = join(homedir(), ".config", "zakoducthunt");
+const CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+const getCredentialsPath = () => CREDENTIALS_FILE;
+const loadCredentials = async () => {
+  try {
+    const raw = await readFile(CREDENTIALS_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiKey || !parsed.apiBaseUrl) {
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    console.debug("[credential-store]", error instanceof Error ? error.message : error);
+    return null;
+  }
+};
+const saveCredentials = async (credentials) => {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), "utf-8");
+  await chmod(CREDENTIALS_FILE, 384);
+};
+const deleteCredentials = async () => {
+  try {
+    await unlink(CREDENTIALS_FILE);
+    return true;
+  } catch (error) {
+    console.debug("[credential-store] delete failed:", error instanceof Error ? error.message : error);
+    return false;
+  }
+};
+const loginCommand = async ({ apiUrl, webUrl }) => {
+  console.log("Logging in to zakoducthunt...");
+  const port = await startCallbackServer(apiUrl);
+  const loginUrl = `${webUrl}/me/cli-auth?port=${port}`;
+  console.log(`
+Opening browser: ${loginUrl}`);
+  console.log("If the browser doesn't open, visit the URL above manually.\n");
+  const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${openCmd} ${JSON.stringify(loginUrl)}`);
+};
+const startCallbackServer = (apiUrl) => {
+  return new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost`);
+      if (url.pathname === "/callback") {
+        const key = url.searchParams.get("key");
+        if (!key) {
+          clearTimeout(timeout);
+          server.close();
+          console.error("Error: No API key received from browser.");
+          process.exit(1);
+        }
+        saveCredentials({ apiKey: key, apiBaseUrl: apiUrl }).then(() => {
+          clearTimeout(timeout);
+          setTimeout(() => {
+            server.close();
+            console.log("Login successful! Credentials saved.");
+            process.exit(0);
+          }, 100);
+        });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h2>Login successful!</h2><p>You can close this tab and return to the terminal.</p></body></html>"
+        );
+        return;
+      }
+      res.writeHead(404);
+      res.end("Not found");
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out after 120 seconds."));
+    }, 12e4);
+    server.listen(0, () => {
+      const addr = server.address();
+      resolve(addr.port);
+    });
+  });
+};
+const logoutCommand = async () => {
+  const deleted = await deleteCredentials();
+  if (deleted) {
+    console.log(`Logged out. Credentials removed from ${getCredentialsPath()}`);
+  } else {
+    console.log("Not logged in (no credentials found).");
+  }
+};
+const PRODUCTS_PATHS = {
+  list: "/api/public/products",
+  batch: "/api/public/products/batch",
+  search: "/api/public/products/search",
+  create: "/api/user/products",
+  update: (id) => `/api/user/products/items/${id}`
+};
+const USER_PRODUCTS_PATHS = {
+  list: "/api/user/products"
+};
+const OGP_PATHS = {
+  preview: "/api/public/ogp/preview"
+};
+const USERS_PATHS = {
+  me: "/api/user/me"
+};
+const searchCommand = async ({ query, apiUrl, json }) => {
+  const params = new URLSearchParams({ q: query, limit: "20" });
+  const url = `${apiUrl}${PRODUCTS_PATHS.search}?${params}`;
+  const response = await fetch(url, {
+    headers: { "Content-Type": "application/json" }
+  });
+  const result = await response.json();
+  if (!result.success) {
+    console.error("Search failed:", "error" in result ? result.error : "Unknown error");
+    process.exit(1);
+  }
+  const items = result.data.items;
+  if (json) {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  if (items.length === 0) {
+    console.log(`No products found for "${query}".`);
+    return;
+  }
+  console.log(`Found ${items.length} product(s) for "${query}":
+`);
+  for (const item of items) {
+    console.log(`  ${item.name}`);
+    console.log(`    ${item.tagline}`);
+    console.log(`    Categories: ${item.categories.join(", ")}`);
+    console.log("");
+  }
+};
+const PRODUCT_CATEGORIES = [
+  "saas",
+  "developer_tools",
+  "ai",
+  "productivity",
+  "design",
+  "business",
+  "finance",
+  "social",
+  "entertainment",
+  "game",
+  "education",
+  "health_fitness",
+  "lifestyle",
+  "ecommerce",
+  "utility",
+  "other"
+];
+const PLATFORMS = [
+  "web",
+  "ios",
+  "android",
+  "windows",
+  "mac",
+  "linux",
+  "chrome_extension",
+  "firefox_extension",
+  "cli",
+  "api"
+];
+const productCategorySchema = z.enum(PRODUCT_CATEGORIES);
+const platformSchema = z.enum(PLATFORMS);
+const zakoducthuntConfigSchema = z.object({
+  $schema: z.string().optional(),
+  product: z.object({
+    url: z.string().url("url must be a valid URL"),
+    name: z.string().min(1, "name is required").max(100, "name must be 100 characters or less"),
+    tagline: z.string().min(1, "tagline is required").max(200, "tagline must be 200 characters or less"),
+    description: z.string().max(5e3, "description must be 5000 characters or less").optional(),
+    categories: z.array(productCategorySchema).min(1, "at least one category is required").max(3, "at most 3 categories allowed"),
+    platforms: z.array(platformSchema).max(5, "at most 5 platforms allowed").optional(),
+    visibility: z.enum(["active", "draft"]).default("active")
+  })
+});
+const CONFIG_FILENAME = "zakoducthunt.config.json";
+const loadConfig = async (dir) => {
+  const filePath = join(dir, CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Config file not found: ${filePath} (${message})
+Run \`zako init\` to create one.`);
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in ${filePath}: ${message}`);
+  }
+  const result = zakoducthuntConfigSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid config in ${filePath}:
+${issues}`);
+  }
+  return result.data;
+};
+const resolveAuth = async (options) => {
+  if (options.apiKey) {
+    return {
+      apiKey: options.apiKey,
+      apiBaseUrl: options.apiUrl ?? options.defaultApiUrl
+    };
+  }
+  const envKey = process.env.ZAKODUCTHUNT_API_KEY;
+  if (envKey) {
+    return {
+      apiKey: envKey,
+      apiBaseUrl: options.apiUrl ?? process.env.ZAKODUCTHUNT_API_URL ?? options.defaultApiUrl
+    };
+  }
+  const creds = await loadCredentials();
+  if (creds) {
+    return {
+      apiKey: creds.apiKey,
+      apiBaseUrl: options.apiUrl ?? creds.apiBaseUrl
+    };
+  }
+  throw new Error("Not authenticated. Run `zako login` first, or pass --api-key.");
+};
+const createFetcher = (options) => {
+  return async (endpoint, init) => {
+    const url = `${options.baseUrl}${endpoint}`;
+    const response = await fetch(url, {
+      ...init,
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": options.apiKey,
+        ...init?.headers
+      }
+    });
+    if (response.status === 204) {
+      return { success: true, data: void 0 };
+    }
+    return await response.json();
+  };
+};
+const createCliApiClient = (options) => {
+  const fetcher = createFetcher(options);
+  return {
+    me: () => fetcher(USERS_PATHS.me),
+    listMyProducts: () => fetcher(USER_PRODUCTS_PATHS.list),
+    batchGetProducts: (ids) => fetcher(PRODUCTS_PATHS.batch, {
+      method: "POST",
+      body: JSON.stringify({ ids })
+    }),
+    searchProducts: (query, limit = 20) => {
+      const params = new URLSearchParams({ q: query, limit: String(limit) });
+      return fetcher(`${PRODUCTS_PATHS.search}?${params}`);
+    },
+    createProduct: (input) => fetcher(PRODUCTS_PATHS.create, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }),
+    updateProduct: (id, input) => fetcher(PRODUCTS_PATHS.update(id), {
+      method: "PATCH",
+      body: JSON.stringify(input)
+    }),
+    ogpPreview: (url) => fetcher(OGP_PATHS.preview, {
+      method: "POST",
+      body: JSON.stringify({ url })
+    })
+  };
+};
+const publishCommand = async (options) => {
+  const config = await loadConfig(process.cwd());
+  console.log(`Publishing "${config.product.name}"...`);
+  const auth = await resolveAuth({
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    defaultApiUrl: options.defaultApiUrl
+  });
+  const client = createCliApiClient({ baseUrl: auth.apiBaseUrl, apiKey: auth.apiKey });
+  const myProductsResult = await client.listMyProducts();
+  if (!myProductsResult.success) {
+    console.error("Failed to fetch your products.");
+    process.exit(1);
+  }
+  const productListItems = myProductsResult.data.products;
+  let existingProductId;
+  if (productListItems.length > 0) {
+    const ids = productListItems.map((p) => p.id);
+    const batchResult = await client.batchGetProducts(ids);
+    if (batchResult.success) {
+      const match = batchResult.data.items.find((p) => p.url === config.product.url);
+      existingProductId = match?.id;
+    }
+  }
+  const productInput = {
+    url: config.product.url,
+    name: config.product.name,
+    tagline: config.product.tagline,
+    ...config.product.description !== void 0 && { description: config.product.description },
+    categories: config.product.categories,
+    ...config.product.platforms !== void 0 && { platforms: config.product.platforms },
+    visibility: config.product.visibility
+  };
+  if (existingProductId) {
+    console.log(`Updating existing product (id: ${existingProductId})...`);
+    const result = await client.updateProduct(existingProductId, productInput);
+    if (!result.success) {
+      console.error("Update failed:", "error" in result ? result.error : "Unknown error");
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result.data, null, 2));
+    } else {
+      console.log(`Updated: ${result.data.name} (${result.data.id})`);
+    }
+  } else {
+    console.log("Creating new product...");
+    const result = await client.createProduct(productInput);
+    if (!result.success) {
+      console.error("Create failed:", "error" in result ? result.error : "Unknown error");
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result.data, null, 2));
+    } else {
+      console.log(`Created: ${result.data.name} (${result.data.id})`);
+    }
+  }
+};
+const prompt = async (question) => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+};
+const initCommand = async ({ apiUrl }) => {
+  const configPath = join(process.cwd(), CONFIG_FILENAME);
+  try {
+    await access(configPath);
+    console.error(`${CONFIG_FILENAME} already exists in this directory.`);
+    process.exit(1);
+  } catch (error) {
+    console.debug("[init] Config file not found, creating new:", error instanceof Error ? error.message : error);
+  }
+  console.log("Initializing zakoducthunt.config.json\n");
+  const url = await prompt("Product URL: ");
+  if (!url) {
+    console.error("URL is required.");
+    process.exit(1);
+  }
+  let name = "";
+  let tagline = "";
+  try {
+    console.log("Fetching metadata from URL...");
+    const response = await fetch(`${apiUrl}/api/public/ogp/preview`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url })
+    });
+    const result = await response.json();
+    if (result.success && result.data) {
+      name = result.data.title ?? "";
+      tagline = result.data.description ?? "";
+      if (name) {
+        console.log(`  Found: ${name}`);
+      }
+    }
+  } catch (error) {
+    console.debug("[init] OGP fetch failed:", error instanceof Error ? error.message : error);
+    console.log("  Could not fetch metadata (continuing without it).");
+  }
+  if (!name) {
+    name = await prompt("Product name: ");
+  }
+  if (!tagline) {
+    tagline = await prompt("Tagline: ");
+  }
+  const config = {
+    product: {
+      url,
+      name: name || "My Product",
+      tagline: tagline || "A brief description of my product",
+      categories: ["other"],
+      visibility: "draft"
+    }
+  };
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  console.log(`
+Created ${CONFIG_FILENAME}`);
+  console.log("Edit the file to add categories, platforms, and a description.");
+  console.log("Then run `zako publish` to publish your product.");
+};
+const apiKeyCommand = async (options) => {
+  const auth = await resolveAuth({
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    defaultApiUrl: options.defaultApiUrl
+  });
+  const authBaseUrl = auth.apiBaseUrl;
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": auth.apiKey
+  };
+  switch (options.subcommand) {
+    case "create": {
+      if (!options.name) {
+        console.error("--name is required for api-key create");
+        process.exit(1);
+      }
+      const response = await fetch(`${authBaseUrl}/api/auth/api-key/create-key`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ name: options.name })
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        console.error("Failed to create API key:", result.error?.message ?? "Unknown error");
+        process.exit(1);
+      }
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log("API key created successfully!");
+        console.log(`
+  Key: ${result.key}
+`);
+        console.log("Save this key — it won't be shown again.");
+      }
+      break;
+    }
+    case "list": {
+      const response = await fetch(`${authBaseUrl}/api/auth/api-key/list-keys`, {
+        method: "GET",
+        headers
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        console.error("Failed to list API keys.");
+        process.exit(1);
+      }
+      const keys = result.keys ?? [];
+      if (options.json) {
+        console.log(JSON.stringify(keys, null, 2));
+        return;
+      }
+      if (keys.length === 0) {
+        console.log("No API keys found.");
+        return;
+      }
+      console.log(`${keys.length} API key(s):
+`);
+      for (const key of keys) {
+        const name = key.name ?? "(unnamed)";
+        const prefix = key.start ?? "zk_***";
+        const created = new Date(key.createdAt).toLocaleDateString();
+        const lastUsed = key.lastRequest ? new Date(key.lastRequest).toLocaleDateString() : "never";
+        console.log(`  ${prefix}  ${name}  (created: ${created}, last used: ${lastUsed})  [id: ${key.id}]`);
+      }
+      break;
+    }
+    case "revoke": {
+      if (!options.id) {
+        console.error("--id is required for api-key revoke");
+        process.exit(1);
+      }
+      const response = await fetch(`${authBaseUrl}/api/auth/api-key/delete-key`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ keyId: options.id })
+      });
+      if (!response.ok) {
+        const result = await response.json();
+        console.error("Failed to revoke API key:", result.error?.message ?? "Unknown error");
+        process.exit(1);
+      }
+      console.log(`API key ${options.id} revoked.`);
+      break;
+    }
+    default:
+      console.error(`Unknown api-key subcommand: ${options.subcommand}`);
+      console.error("Available: create, list, revoke");
+      process.exit(1);
+  }
+};
+const formatDate = (dateStr) => {
+  return new Date(dateStr).toLocaleDateString();
+};
+const printProfile = (profile, apiBaseUrl) => {
+  console.log("Logged in\n");
+  console.log(`  User ID:    ${profile.userId}`);
+  if (profile.headline) {
+    console.log(`  Headline:   ${profile.headline}`);
+  }
+  if (profile.bio) {
+    console.log(`  Bio:        ${profile.bio}`);
+  }
+  if (profile.website) {
+    console.log(`  Website:    ${profile.website}`);
+  }
+  if (profile.socialLinks && profile.socialLinks.length > 0) {
+    for (const link of profile.socialLinks) {
+      const display = link.username ? `@${link.username}` : link.url ?? link.provider;
+      console.log(`  ${link.provider}:${" ".repeat(Math.max(1, 10 - link.provider.length))}${display}`);
+    }
+  }
+  console.log(`  Created:    ${formatDate(profile.createdAt)}`);
+  console.log(`  Updated:    ${formatDate(profile.updatedAt)}`);
+  console.log(`
+  API URL:    ${apiBaseUrl}`);
+  console.log(`  Creds:      ${getCredentialsPath()}`);
+};
+const profileCommand = async (options) => {
+  if (options.apiKey) {
+    const client2 = createCliApiClient({
+      baseUrl: options.apiUrl,
+      apiKey: options.apiKey
+    });
+    const result2 = await client2.me();
+    if (!result2.success) {
+      console.error("Failed to fetch profile:", result2.error.message);
+      process.exit(1);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result2.data, null, 2));
+    } else {
+      printProfile(result2.data, options.apiUrl);
+    }
+    return;
+  }
+  const creds = await loadCredentials();
+  if (!creds) {
+    console.log("Not logged in. Run `zako login` first.");
+    process.exit(1);
+  }
+  const apiBaseUrl = options.apiUrl ?? creds.apiBaseUrl;
+  const client = createCliApiClient({
+    baseUrl: apiBaseUrl,
+    apiKey: creds.apiKey
+  });
+  const result = await client.me();
+  if (!result.success) {
+    console.error("Failed to fetch profile:", result.error.message);
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(result.data, null, 2));
+  } else {
+    printProfile(result.data, apiBaseUrl);
+  }
+};
+const DEFAULT_API_URL = "https://zakoducthunt.jp";
+const DEFAULT_WEB_URL = "https://zakoducthunt.jp";
+const VERSION = "0.1.0";
+const HELP_TEXT = `
+zako - zakoducthunt CLI
+Usage:
+  zako <command> [options]
+Commands:
+  login          Log in via browser (OAuth)
+  logout         Clear stored credentials
+  profile        Show current user profile
+  search         Search products
+  publish        Publish product from zakoducthunt.config.json
+  init           Initialize zakoducthunt.config.json
+  api-key        Manage API keys (create, list, revoke)
+Global Options:
+  --api-url <url>   API base URL (default: ${DEFAULT_API_URL})
+  --web-url <url>   Web app URL (default: ${DEFAULT_WEB_URL})
+  --api-key <key>   API key (overrides stored credentials)
+  --json            Output as JSON
+  --help, -h        Show help
+  --version, -v     Show version
+Examples:
+  zako login
+  zako search --query "my app"
+  zako init
+  zako publish
+  zako api-key create --name "CI deploy"
+  zako api-key list
+  zako api-key revoke --id <key-id>
+`.trim();
+const main = async () => {
+  const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    options: {
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false },
+      "api-url": { type: "string" },
+      "web-url": { type: "string" },
+      "api-key": { type: "string" },
+      json: { type: "boolean", default: false },
+      query: { type: "string" },
+      name: { type: "string" },
+      id: { type: "string" }
+    },
+    strict: false
+  });
+  if (values.version) {
+    console.log(`zako ${VERSION}`);
+    return;
+  }
+  if (values.help || positionals.length === 0) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  const command = positionals[0];
+  const apiUrl = values["api-url"] ?? DEFAULT_API_URL;
+  const webUrl = values["web-url"] ?? DEFAULT_WEB_URL;
+  const apiKey = values["api-key"];
+  const json = values.json ?? false;
+  try {
+    switch (command) {
+      case "login":
+        await loginCommand({ apiUrl, webUrl });
+        break;
+      case "logout":
+        await logoutCommand();
+        break;
+      case "profile":
+        await profileCommand({ apiKey, apiUrl, defaultApiUrl: apiUrl, json });
+        break;
+      case "search": {
+        const query = values.query;
+        if (!query) {
+          console.error("--query is required for search");
+          process.exit(1);
+        }
+        await searchCommand({ query, apiUrl, json });
+        break;
+      }
+      case "publish":
+        await publishCommand({ apiKey, apiUrl, defaultApiUrl: apiUrl, json });
+        break;
+      case "init":
+        await initCommand({ apiUrl });
+        break;
+      case "api-key": {
+        const subcommand = positionals[1];
+        if (!subcommand) {
+          console.error("Subcommand required: create, list, revoke");
+          process.exit(1);
+        }
+        await apiKeyCommand({
+          subcommand,
+          name: values.name,
+          id: values.id,
+          apiKey,
+          apiUrl,
+          defaultApiUrl: apiUrl,
+          json
+        });
+        break;
+      }
+      default:
+        console.error(`Unknown command: ${command}`);
+        console.log(HELP_TEXT);
+        process.exit(1);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("An unknown error occurred.");
+    }
+    process.exit(1);
+  }
+};
+main();

package/package.json ADDED Viewed

@@ -0,0 +1,23 @@
+{
+  "name": "zako",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "zako": "./dist/cli.mjs"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "cli": "bun run ./src/cli.ts"
+  },
+  "dependencies": {
+    "zod": "^3.25.36"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "typescript": "^5",
+    "vite": "^6"
+  }
+}