Val Town Code SearchReturn to Val Town

92
93/**
94 * Format chat history for Anthropic API
95 */
96function formatChatHistoryForAI(history) {
321bot.on("message", async (ctx) => {
322  try {
323    // Get Anthropic API key from environment
324    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
325    if (!apiKey) {
326      console.error("Anthropic API key is not configured.");
327      ctx.reply(
328        "I apologize, but I'm not properly configured at the moment. Please inform the household administrator."
332
333    // Initialize Anthropic client
334    const anthropic = new Anthropic({ apiKey });
335
336    // Get message text and user info
502  // Set webhook if it is not set yet
503  if (!isEndpointSet) {
504    await bot.api.setWebhook(req.url, {
505      secret_token: SECRET_TOKEN,
506    });

27async function generateConciseWeatherSummary(weatherDay) {
28  try {
29    // Get API key from environment
30    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
31    if (!apiKey) {
32      console.error("Anthropic API key is not configured.");
33      return null;
34    }
35
36    // Initialize Anthropic client
37    const anthropic = new Anthropic({ apiKey });
38
39    const response = await anthropic.messages.create({

77async function generateFunFacts(previousFacts) {
78  try {
79    // Get API key from environment
80    const apiKey = Deno.env.get("ANTHROPIC_API_KEY");
81    if (!apiKey) {
82      console.error("Anthropic API key is not configured.");
83      return null;
84    }
85
86    // Initialize Anthropic client
87    const anthropic = new Anthropic({ apiKey });
88
89    // Format previous facts for the prompt

20### 2. HTTP Vals
21
22- Create web APIs and endpoints
23- Handle HTTP requests and responses
24- Example structure:
66- Generate code in TypeScript
67- Add appropriate TypeScript types and interfaces for all data structures
68- Prefer official SDKs or libraries than writing API calls directly
69- Ask the user to supply API or library documentation if you are at all unsure about it
70- **Never bake in secrets into the code** - always use environment variables
71- Include comments explaining complex logic (avoid commenting obvious operations)
190- For AI-generated images, use: `https://maxm-imggenurl.web.val.run/the-description-of-your-image`
191- **Storage:** DO NOT use the Deno KV module for storage
192- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods
193- **Weather Data:** Use open-meteo for weather data (doesn't require API keys) unless otherwise specified
194- **View Source:** Add a view source link with `import.meta.url.replace("esm.town", "val.town")` and include `target="_top"` attribute
195- **Error Debugging:** Add `<script src="https://esm.town/v/std/catch"></script>` to HTML to capture client-side errors
196- **Error Handling:** Only use try...catch when there's a clear local resolution; avoid catches that merely log or return 500s - let errors bubble up with full context
197- **Environment Variables:** Use `Deno.env.get('keyname')` and minimize their use - prefer APIs without keys
198- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure compatibility on server and browser
199- **Storage Strategy:** Only use backend storage if explicitly required; prefer simple static client-side sites
230
231### Backend (Hono) Best Practices
232- Hono is the recommended API framework (similar to Express, Flask, or Sinatra)
233- Main entry point should be `backend/index.ts`
234- **Static asset serving:** Use the utility functions to read and serve project files:
251  });
252  ```
253- Create RESTful API routes for CRUD operations
254- Be careful with error handling as Hono tends to swallow errors
255- Always include this snippet at the top-level Hono app to re-throwing errors to see full stack traces:
268- Use React 18.2.0 consistently in all imports and the `@jsxImportSource` pragma
269- Follow the React component pattern from the example project
270- Handle API calls properly with proper error catching
271
272### Database Patterns
299   - For files in the project, use `readFile` helpers
300
3015. **API Design:**
302   - `fetch` handler is the entry point for HTTP vals
303   - Run the Hono app with `export default app.fetch // This is the entry point for HTTP vals`

10import { NotebookView } from "./NotebookView.tsx";
11
12const API_BASE = "/api/memories";
13const MEMORIES_PER_PAGE = 20; // Increased from 7 to 20 memories per page
14
90
91    // Fetch avatar image
92    fetch("/api/images/stevens.jpg")
93      .then((response) => {
94        if (response.ok) return response.blob();
104
105    // Fetch wood background
106    fetch("/api/images/wood.jpg")
107      .then((response) => {
108        if (response.ok) return response.blob();
133    setError(null);
134    try {
135      const response = await fetch(API_BASE);
136      if (!response.ok) {
137        throw new Error(`HTTP error! status: ${response.status}`);
176
177    try {
178      const response = await fetch(API_BASE, {
179        method: "POST",
180        headers: { "Content-Type": "application/json" },
199
200    try {
201      const response = await fetch(`${API_BASE}/${id}`, {
202        method: "DELETE",
203      });
231
232    try {
233      const response = await fetch(`${API_BASE}/${editingMemory.id}`, {
234        method: "PUT",
235        headers: { "Content-Type": "application/json" },
606    <div className="font-pixel text-[#f8f1e0]">
607      <style jsx>{`
608        @import url("https://fonts.googleapis.com/css2?family=Pixelify+Sans&display=swap");
609
610        @tailwind base;

75### 📊 Other Export Formats
76- **CSV**: Structured data with headers for spreadsheet applications
77- **JSON**: Machine-readable format for API integration
78- **Text**: Human-readable format with detailed card information
79
133│   └── utils.ts            # Luhn algorithm, validation, bulk parsing
134└── backend/
135    └── index.ts            # Static file server with API endpoints
136```
137
203   - **LIST**: Clean format `CCNUMBER|MM|YY|CVV` (perfect for direct use)
204   - **CSV**: Structured data with headers for spreadsheets
205   - **JSON**: Machine-readable format for API integration
206   - **TEXT**: Human-readable format with detailed information
2072. Use "Copy All" to copy to clipboard or "Export" to download as file
228- **Placeholders**: `xxx`, `xx`, `xxxx` for random
229
230## API Endpoints
231
232- `POST /api/generate` - Generate card (simple/custom/bulk)
233- `POST /api/validate` - Validate card number using Luhn
234- `POST /api/validate-bin` - Validate BIN format
235- `POST /api/validate-bulk` - Validate bulk format string
236- `GET /api/health` - Health check endpoint
237- `GET /api/marketplace/products` - Get all marketplace products
238- `GET /api/marketplace/products/:id` - Get specific product details
239- `POST /api/marketplace/contact` - Contact seller about a product
240
241## Note

51      "Custom Dashboard Builder",
52      "Advanced Reporting",
53      "API Integration"
54    ],
55    inStock: true,

33});
34
35// API endpoint to validate card numbers (for educational purposes)
36app.post("/api/validate", async c => {
37  try {
38    const { cardNumber } = await c.req.json();
55});
56
57// API endpoint to generate card data
58app.post("/api/generate", async c => {
59  try {
60    const { type, customBin, bulkFormat, quantity } = await c.req.json();
158});
159
160// API endpoint to validate bulk format
161app.post("/api/validate-bulk", async c => {
162  try {
163    const { bulkFormat } = await c.req.json();
182});
183
184// API endpoint to validate BIN
185app.post("/api/validate-bin", async c => {
186  try {
187    const { bin, cardType } = await c.req.json();
208
209// BIN lookup endpoint
210app.post("/api/bin-lookup", async c => {
211  try {
212    const { bin } = await c.req.json();
222    }
223    
224    // Use BinList.net free API (no API key required)
225    const response = await fetch(`https://lookup.binlist.net/${cleanBin}`);
226    
265
266// Health check endpoint
267app.get("/api/health", c => {
268  return c.json({ 
269    status: "healthy", 
273});
274
275// Marketplace API endpoints
276app.get("/api/marketplace/products", async c => {
277  try {
278    // In a real application, this would fetch from a database
311          "Custom Dashboard Builder",
312          "Advanced Reporting",
313          "API Integration"
314        ],
315        inStock: true,
351});
352
353app.get("/api/marketplace/products/:id", async c => {
354  try {
355    const id = c.req.param("id");
404});
405
406app.post("/api/marketplace/contact", async c => {
407  try {
408    const { productId, message, contactInfo } = await c.req.json();

7    <script src="https://cdn.twind.style" crossorigin></script>
8    <script src="https://esm.town/v/std/catch"></script>
9    <link rel="preconnect" href="https://fonts.googleapis.com">
10    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
11    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
12    <style>
13        * {

42    
43    try {
44      const response = await fetch(`/api/bin-lookup`, {
45        method: "POST",
46        headers: {
193              <div className="input-icy rounded-lg p-4">
194                <div className="text-sm text-blue-200 mb-1">Brand</div>
195                <div className="font-semibold capitalize">{binInfo.brand}</div>
196              </div>
197              
198              <div className="input-icy rounded-lg p-4">
199                <div className="text-sm text-blue-200 mb-1">Type</div>
200                <div className="capitalize">{binInfo.type}</div>
201              </div>
202              
203              <div className="input-icy rounded-lg p-4">
204                <div className="text-sm text-blue-200 mb-1">Category</div>
205                <div className="capitalize">{binInfo.category}</div>
206              </div>
207