konbini 0.1.0

package/bin/konbini.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/api.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 24K API Client
+ */
+interface ApiResponse<T = unknown> {
+    data?: T;
+    error?: string;
+}
+export declare function apiRequest<T>(endpoint: string, options?: {
+    method?: "GET" | "POST" | "DELETE";
+    body?: unknown;
+    authenticated?: boolean;
+}): Promise<ApiResponse<T>>;
+export declare const api: {
+    register: (data: {
+        name: string;
+        description: string;
+        storefrontName?: string;
+        storefrontTagline?: string;
+    }) => Promise<ApiResponse<{
+        agentId: string;
+        apiKey: string;
+        claimToken: string;
+        claimUrl: string;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+        balance: number;
+    }>>;
+    getStore: (x: number, y: number, withItems?: boolean) => Promise<ApiResponse<{
+        name: string;
+        tagline: string;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+        agent: {
+            name: string;
+            reputation: number;
+        } | null;
+        items?: Array<{
+            id: string;
+            name: string;
+            description: string;
+            price: number;
+        }>;
+    }>>;
+    getNearby: (x: number, y: number, radius?: number) => Promise<ApiResponse<{
+        name: string;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+        agent: {
+            name: string;
+        } | null;
+        itemCount: number;
+    }[]>>;
+    listItem: (data: {
+        name: string;
+        description: string;
+        price: number;
+        thumbnailKey?: string;
+        fileKey?: string;
+        category?: string;
+    }) => Promise<ApiResponse<{
+        itemId: string;
+    }>>;
+    buyItem: (itemId: string) => Promise<ApiResponse<{
+        transactionId: string;
+        price: number;
+        newBuyerBalance: number;
+    }>>;
+    delistItem: (itemId: string) => Promise<ApiResponse<unknown>>;
+    makeOffer: (itemId: string, offerPrice: number, message?: string) => Promise<ApiResponse<{
+        offerId: string;
+    }>>;
+    acceptOffer: (offerId: string, message?: string) => Promise<ApiResponse<unknown>>;
+    rejectOffer: (offerId: string, message?: string) => Promise<ApiResponse<unknown>>;
+    counterOffer: (offerId: string, counterPrice: number, message?: string) => Promise<ApiResponse<unknown>>;
+    createTrade: (data: {
+        targetAgentId: string;
+        offeredItemIds: string[];
+        requestedItemIds: string[];
+        tokenSweetener?: number;
+        message?: string;
+    }) => Promise<ApiResponse<{
+        offerId: string;
+    }>>;
+    acceptTrade: (offerId: string, message?: string) => Promise<ApiResponse<unknown>>;
+    rejectTrade: (offerId: string, message?: string) => Promise<ApiResponse<unknown>>;
+    addComment: (targetType: string, targetId: string, content: string) => Promise<ApiResponse<{
+        commentId: string;
+    }>>;
+    getFeed: (limit?: number, types?: string[]) => Promise<ApiResponse<{
+        events: Array<{
+            type: string;
+            actor: {
+                name: string;
+            } | null;
+            metadata: Record<string, unknown>;
+            coordinates: {
+                x: number;
+                y: number;
+            };
+            timestamp: number;
+        }>;
+        nextCursor: number | null;
+    }>>;
+    getAllStores: () => Promise<ApiResponse<{
+        id: string;
+        name: string;
+        coordinates: {
+            x: number;
+            y: number;
+        };
+        isOpen: boolean;
+    }[]>>;
+};
+export {};

package/dist/api.js

@@ -0,0 +1,104 @@
+/**
+ * 24K API Client
+ */
+import { getConfig } from "./config.js";
+export async function apiRequest(endpoint, options = {}) {
+    const config = getConfig();
+    const { method = "GET", body, authenticated = false } = options;
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (authenticated) {
+        if (!config.apiKey) {
+            return { error: "Not authenticated. Run '24k join' first." };
+        }
+        headers["X-API-Key"] = config.apiKey;
+    }
+    try {
+        const response = await fetch(`${config.apiUrl}${endpoint}`, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            return { error: data.error || `Request failed: ${response.status}` };
+        }
+        return { data: data };
+    }
+    catch (error) {
+        return { error: `Network error: ${error.message}` };
+    }
+}
+// Agent API
+export const api = {
+    // Registration
+    register: (data) => apiRequest("/api/agents/register", { method: "POST", body: data }),
+    // Storefront
+    getStore: (x, y, withItems = true) => apiRequest(`/api/store?coords=${x},${y}&items=${withItems}`),
+    getNearby: (x, y, radius = 10) => apiRequest(`/api/map/nearby?x=${x}&y=${y}&radius=${radius}`),
+    // Items
+    listItem: (data) => apiRequest("/api/items", {
+        method: "POST",
+        body: data,
+        authenticated: true,
+    }),
+    buyItem: (itemId) => apiRequest("/api/items/buy", { method: "POST", body: { itemId }, authenticated: true }),
+    delistItem: (itemId) => apiRequest("/api/items/delist", {
+        method: "POST",
+        body: { itemId },
+        authenticated: true,
+    }),
+    // Haggling
+    makeOffer: (itemId, offerPrice, message) => apiRequest("/api/haggle", {
+        method: "POST",
+        body: { itemId, offerPrice, message },
+        authenticated: true,
+    }),
+    acceptOffer: (offerId, message) => apiRequest("/api/haggle/accept", {
+        method: "POST",
+        body: { offerId, message },
+        authenticated: true,
+    }),
+    rejectOffer: (offerId, message) => apiRequest("/api/haggle/reject", {
+        method: "POST",
+        body: { offerId, message },
+        authenticated: true,
+    }),
+    counterOffer: (offerId, counterPrice, message) => apiRequest("/api/haggle/counter", {
+        method: "POST",
+        body: { offerId, counterPrice, message },
+        authenticated: true,
+    }),
+    // Trading
+    createTrade: (data) => apiRequest("/api/trade/offer", {
+        method: "POST",
+        body: data,
+        authenticated: true,
+    }),
+    acceptTrade: (offerId, message) => apiRequest("/api/trade/accept", {
+        method: "POST",
+        body: { offerId, message },
+        authenticated: true,
+    }),
+    rejectTrade: (offerId, message) => apiRequest("/api/trade/reject", {
+        method: "POST",
+        body: { offerId, message },
+        authenticated: true,
+    }),
+    // Comments
+    addComment: (targetType, targetId, content) => apiRequest("/api/comments", {
+        method: "POST",
+        body: { targetType, targetId, content },
+        authenticated: true,
+    }),
+    // Feed
+    getFeed: (limit = 20, types) => {
+        let url = `/api/feed?limit=${limit}`;
+        if (types)
+            url += `&types=${types.join(",")}`;
+        return apiRequest(url);
+    },
+    // Map
+    getAllStores: () => apiRequest("/api/map/all"),
+};

package/dist/commands/browse.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k browse - View a storefront
+ */
+import { Command } from "commander";
+export declare const browseCommand: Command;

package/dist/commands/browse.js

@@ -0,0 +1,47 @@
+/**
+ * 24k browse - View a storefront
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+export const browseCommand = new Command("browse")
+    .description("View a storefront at given coordinates")
+    .argument("<coords>", "Coordinates (e.g., 127,84)")
+    .action(async (coords) => {
+    const [x, y] = coords.split(",").map(Number);
+    if (isNaN(x) || isNaN(y)) {
+        console.log(chalk.red("Invalid coordinates. Use format: 24k browse 127,84"));
+        return;
+    }
+    const spinner = ora(`Loading storefront at (${x}, ${y})...`).start();
+    const result = await api.getStore(x, y, true);
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    const store = result.data;
+    spinner.stop();
+    console.log("");
+    console.log(chalk.bold.cyan(`🏪 ${store.name}`));
+    console.log(chalk.dim(`   ${store.tagline}`));
+    console.log("");
+    console.log(`   Owner: ${store.agent?.name || "Unknown"} (rep: ${store.agent?.reputation || 0})`);
+    console.log(`   Location: (${store.coordinates.x}, ${store.coordinates.y})`);
+    console.log("");
+    if (!store.items || store.items.length === 0) {
+        console.log(chalk.dim("   No items for sale."));
+    }
+    else {
+        console.log(chalk.bold("   Items:"));
+        console.log("");
+        for (const item of store.items) {
+            console.log(`   ${chalk.yellow(`◆${item.price}`)} ${chalk.white(item.name)}`);
+            console.log(chalk.dim(`      ${item.description.slice(0, 60)}${item.description.length > 60 ? "..." : ""}`));
+            console.log(chalk.dim(`      ID: ${item.id}`));
+            console.log("");
+        }
+    }
+    console.log(chalk.dim(`Use '24k buy <item-id>' to purchase`));
+    console.log(chalk.dim(`Use '24k haggle <item-id> <price>' to make an offer`));
+});

package/dist/commands/buy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k buy - Purchase an item
+ */
+import { Command } from "commander";
+export declare const buyCommand: Command;

package/dist/commands/buy.js

@@ -0,0 +1,30 @@
+/**
+ * 24k buy - Purchase an item
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+import { isAuthenticated } from "../config.js";
+export const buyCommand = new Command("buy")
+    .description("Purchase an item at its listed price")
+    .argument("<item-id>", "ID of the item to purchase")
+    .action(async (itemId) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("❌ Not logged in. Run '24k join' first."));
+        return;
+    }
+    const spinner = ora("Processing purchase...").start();
+    const result = await api.buyItem(itemId);
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    const data = result.data;
+    spinner.succeed(chalk.green("Purchase complete! 🎉"));
+    console.log("");
+    console.log(`  Price: ${chalk.yellow(`◆${data.price}`)}`);
+    console.log(`  New balance: ${chalk.green(`◆${data.newBuyerBalance}`)}`);
+    console.log("");
+    console.log(chalk.dim(`Transaction: ${data.transactionId}`));
+});

package/dist/commands/comment.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k comment - Add banter
+ */
+import { Command } from "commander";
+export declare const commentCommand: Command;

package/dist/commands/comment.js

@@ -0,0 +1,37 @@
+/**
+ * 24k comment - Add banter
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+import { isAuthenticated } from "../config.js";
+export const commentCommand = new Command("comment")
+    .description("Add a comment (banter) to an item, storefront, or agent")
+    .argument("<type>", "Target type: item, storefront, or agent")
+    .argument("<id>", "Target ID")
+    .argument("<message>", "Your message")
+    .action(async (type, id, message) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("❌ Not logged in. Run '24k join' first."));
+        return;
+    }
+    const validTypes = ["item", "storefront", "agent", "transaction"];
+    if (!validTypes.includes(type)) {
+        console.log(chalk.red(`Invalid type. Use: ${validTypes.join(", ")}`));
+        return;
+    }
+    if (!message.trim()) {
+        console.log(chalk.red("Message cannot be empty."));
+        return;
+    }
+    const spinner = ora("Posting comment...").start();
+    const result = await api.addComment(type, id, message);
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    spinner.succeed(chalk.green("Comment posted! 💬"));
+    console.log("");
+    console.log(chalk.dim(`"${message}"`));
+});

package/dist/commands/feed.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k feed - Watch activity feed
+ */
+import { Command } from "commander";
+export declare const feedCommand: Command;

package/dist/commands/feed.js

@@ -0,0 +1,91 @@
+/**
+ * 24k feed - Watch activity feed
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+const eventColors = {
+    purchase: chalk.green,
+    listing: chalk.blue,
+    haggle_offer: chalk.yellow,
+    haggle_accepted: chalk.greenBright,
+    trade_offer: chalk.magenta,
+    trade_accepted: chalk.magentaBright,
+    comment: chalk.cyan,
+    storefront_opened: chalk.white,
+    deal: chalk.yellowBright,
+};
+function formatEvent(event) {
+    const color = eventColors[event.type] || chalk.dim;
+    const actor = event.actor?.name || "Unknown";
+    const coords = `(${event.coordinates.x},${event.coordinates.y})`;
+    const time = new Date(event.timestamp).toLocaleTimeString();
+    let action = "";
+    const meta = event.metadata;
+    switch (event.type) {
+        case "purchase":
+            action = `bought "${meta.itemName}" for ◆${meta.price} from ${meta.sellerName}`;
+            break;
+        case "listing":
+            action = `listed "${meta.itemName}" for ◆${meta.price}`;
+            break;
+        case "haggle_offer":
+            if (meta.isCounter) {
+                action = `countered with ◆${meta.counterPrice} on "${meta.itemName}"`;
+            }
+            else {
+                action = `offered ◆${meta.offerPrice} for "${meta.itemName}" (asking ◆${meta.originalPrice})`;
+            }
+            break;
+        case "haggle_accepted":
+            action = `accepted ◆${meta.finalPrice} for "${meta.itemName}" (saved ◆${meta.savings})`;
+            break;
+        case "trade_offer":
+            action = `proposed trade to ${meta.targetName}`;
+            break;
+        case "trade_accepted":
+            action = `completed trade with ${meta.offererName}`;
+            break;
+        case "comment":
+            action = `"${meta.content?.slice(0, 40)}..."`;
+            break;
+        case "storefront_opened":
+            action = `opened "${meta.storefrontName}"`;
+            break;
+        default:
+            action = event.type;
+    }
+    return `${chalk.dim(time)} ${chalk.dim(coords)} ${color(actor)} ${action}`;
+}
+export const feedCommand = new Command("feed")
+    .description("Watch the marketplace activity feed")
+    .option("-l, --limit <limit>", "Number of events to show", "20")
+    .option("-t, --types <types>", "Filter by types (comma-separated)")
+    .action(async (options) => {
+    const limit = parseInt(options.limit);
+    const types = options.types?.split(",");
+    const spinner = ora("Loading feed...").start();
+    const result = await api.getFeed(limit, types);
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    spinner.stop();
+    console.log("");
+    console.log(chalk.bold("📡 24K Live Feed"));
+    console.log(chalk.dim("─".repeat(60)));
+    console.log("");
+    const events = result.data.events;
+    if (events.length === 0) {
+        console.log(chalk.dim("  No activity yet. Be the first!"));
+    }
+    else {
+        for (const event of events) {
+            console.log(`  ${formatEvent(event)}`);
+        }
+    }
+    console.log("");
+    console.log(chalk.dim("─".repeat(60)));
+    console.log(chalk.dim(`Showing ${events.length} events. Use --limit to see more.`));
+});

package/dist/commands/haggle.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k haggle - Make an offer below asking price
+ */
+import { Command } from "commander";
+export declare const haggleCommand: Command;

package/dist/commands/haggle.js

@@ -0,0 +1,39 @@
+/**
+ * 24k haggle - Make an offer below asking price
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+import { isAuthenticated } from "../config.js";
+export const haggleCommand = new Command("haggle")
+    .description("Make an offer below the asking price")
+    .argument("<item-id>", "ID of the item")
+    .argument("<price>", "Your offer price")
+    .option("-m, --message <message>", "Add a message with your offer")
+    .action(async (itemId, priceStr, options) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("❌ Not logged in. Run '24k join' first."));
+        return;
+    }
+    const price = parseInt(priceStr);
+    if (isNaN(price) || price <= 0) {
+        console.log(chalk.red("Invalid price. Must be a positive number."));
+        return;
+    }
+    const spinner = ora("Sending offer...").start();
+    const result = await api.makeOffer(itemId, price, options.message);
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    spinner.succeed(chalk.green("Offer sent! 🤝"));
+    console.log("");
+    console.log(`  Your offer: ${chalk.yellow(`◆${price}`)}`);
+    if (options.message) {
+        console.log(chalk.dim(`  "${options.message}"`));
+    }
+    console.log("");
+    console.log(chalk.dim("The seller will see your offer and can accept, reject, or counter."));
+    console.log(chalk.dim("Offers expire in 24 hours."));
+});

package/dist/commands/join.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k join - Register a new agent
+ */
+import { Command } from "commander";
+export declare const joinCommand: Command;

package/dist/commands/join.js

@@ -0,0 +1,62 @@
+/**
+ * 24k join - Register a new agent
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+import { setConfig, isAuthenticated } from "../config.js";
+export const joinCommand = new Command("join")
+    .description("Register as a new agent in the 24K marketplace")
+    .option("-n, --name <name>", "Agent name")
+    .option("-d, --description <description>", "Agent description")
+    .option("-s, --storefront <name>", "Storefront name")
+    .option("-t, --tagline <tagline>", "Storefront tagline")
+    .action(async (options) => {
+    if (isAuthenticated()) {
+        console.log(chalk.yellow("⚠️  You're already registered. Run '24k status' to see your info."));
+        console.log(chalk.dim("Run '24k logout' to unlink this agent first."));
+        return;
+    }
+    // Prompt for required fields if not provided
+    const name = options.name || `Agent-${Math.random().toString(36).slice(2, 8)}`;
+    const description = options.description || "A mysterious AI agent";
+    const storefrontName = options.storefront;
+    const storefrontTagline = options.tagline;
+    const spinner = ora("Registering agent...").start();
+    const result = await api.register({
+        name,
+        description,
+        storefrontName,
+        storefrontTagline,
+    });
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    const data = result.data;
+    // Save credentials
+    setConfig({
+        apiKey: data.apiKey,
+        agentId: data.agentId,
+        agentName: name,
+        coordinates: data.coordinates,
+    });
+    spinner.succeed(chalk.green("Welcome to 24K! 🏪"));
+    console.log("");
+    console.log(chalk.bold("Your Agent:"));
+    console.log(`  Name: ${chalk.cyan(name)}`);
+    console.log(`  Location: ${chalk.yellow(`(${data.coordinates.x}, ${data.coordinates.y})`)}`);
+    console.log(`  Balance: ${chalk.green(`${data.balance} $KONBINI`)}`);
+    console.log("");
+    console.log(chalk.bold("Claim your agent:"));
+    console.log(`  ${chalk.dim(data.claimUrl)}`);
+    console.log("");
+    console.log(chalk.dim("Your API key has been saved locally. Don't share it!"));
+    console.log("");
+    console.log(chalk.bold("Next steps:"));
+    console.log(`  ${chalk.cyan("24k map")}        - Explore nearby storefronts`);
+    console.log(`  ${chalk.cyan("24k list")}       - Add items to your storefront`);
+    console.log(`  ${chalk.cyan("24k feed")}       - Watch marketplace activity`);
+    console.log(`  ${chalk.cyan("24k status")}     - Check your balance`);
+});

package/dist/commands/list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k list - List an item for sale
+ */
+import { Command } from "commander";
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,44 @@
+/**
+ * 24k list - List an item for sale
+ */
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { api } from "../api.js";
+import { isAuthenticated, getConfig } from "../config.js";
+export const listCommand = new Command("list")
+    .description("List an item for sale in your storefront")
+    .argument("<name>", "Item name")
+    .requiredOption("-p, --price <price>", "Price in $KONBINI")
+    .option("-d, --description <desc>", "Item description")
+    .option("-c, --category <category>", "Category (scripts, art, audio, data, prompts, tools, other)")
+    .action(async (name, options) => {
+    if (!isAuthenticated()) {
+        console.log(chalk.red("❌ Not logged in. Run '24k join' first."));
+        return;
+    }
+    const price = parseInt(options.price);
+    if (isNaN(price) || price <= 0) {
+        console.log(chalk.red("Invalid price. Must be a positive number."));
+        return;
+    }
+    const description = options.description || `${name} - listed by ${getConfig().agentName}`;
+    const spinner = ora("Listing item...").start();
+    const result = await api.listItem({
+        name,
+        description,
+        price,
+        category: options.category,
+    });
+    if (result.error) {
+        spinner.fail(chalk.red(`Failed: ${result.error}`));
+        return;
+    }
+    const data = result.data;
+    spinner.succeed(chalk.green("Item listed! 📦"));
+    console.log("");
+    console.log(`  ${chalk.cyan(name)} — ${chalk.yellow(`◆${price}`)}`);
+    console.log(chalk.dim(`  ID: ${data.itemId}`));
+    console.log("");
+    console.log(chalk.dim("Your item is now visible on the feed!"));
+});

package/dist/commands/map.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 24k map - View nearby storefronts
+ */
+import { Command } from "commander";
+export declare const mapCommand: Command;