Val Town Code Search

valentines_day_card_generator README.md1 match

@charmaine•Updated 2 months ago

3hi sophieee
4
5ok so i only edited `frontend_card`, you can see where im directly grabbing a public url i have in my blob storage aka: https://charmaine-blob_admin.web.val.run/api/public/public%2F1738957543311_Red_Happy_Valentine's_Day_PNG_Clip-Art_Image.png
6
7i would love to be able to make get requests to a url like that instead of hard coding them :p

blob_admin_migrated main.tsx25 matches

@charmaine•Updated 2 months ago

73  const menuRef = useRef(null);
74  const isPublic = blob.key.startsWith("__public/");
75  const publicUrl = isPublic ? `${window.location.origin}/api/public/${encodeURIComponent(blob.key.slice(9))}` : null;
76
77  useEffect(() => {
237    setLoading(true);
238    try {
239      const response = await fetch(`/api/blobs?prefix=${encodeKey(searchPrefix)}&limit=${limit}`);
240      const data = await response.json();
241      setBlobs(data);
264      setBlobContentLoading(true);
265      try {
266        const response = await fetch(`/api/blob?key=${encodeKey(clickedBlob.key)}`);
267        const content = await response.text();
268        setSelectedBlob({ ...clickedBlob, key: decodeKey(clickedBlob.key) });
278  const handleSave = async () => {
279    try {
280      await fetch(`/api/blob?key=${encodeKey(selectedBlob.key)}`, {
281        method: "PUT",
282        body: editContent,
290  const handleDelete = async (key) => {
291    try {
292      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
293      setBlobs(blobs.filter(b => b.key !== key));
294      if (selectedBlob && selectedBlob.key === key) {
307        const key = `${searchPrefix}${file.name}`;
308        formData.append("key", encodeKey(key));
309        await fetch("/api/blob", { method: "POST", body: formData });
310        const newBlob = { key, size: file.size, lastModified: new Date().toISOString() };
311        setBlobs([newBlob, ...blobs]);
329      try {
330        const fullKey = `${searchPrefix}${key}`;
331        await fetch(`/api/blob?key=${encodeKey(fullKey)}`, {
332          method: "PUT",
333          body: "",
344  const handleDownload = async (key) => {
345    try {
346      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
347      const blob = await response.blob();
348      const url = window.URL.createObjectURL(blob);
363    if (newKey && newKey !== oldKey) {
364      try {
365        const response = await fetch(`/api/blob?key=${encodeKey(oldKey)}`);
366        const content = await response.blob();
367        await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
368          method: "PUT",
369          body: content,
370        });
371        await fetch(`/api/blob?key=${encodeKey(oldKey)}`, { method: "DELETE" });
372        setBlobs(blobs.map(b => b.key === oldKey ? { ...b, key: newKey } : b));
373        if (selectedBlob && selectedBlob.key === oldKey) {
383    const newKey = `__public/${key}`;
384    try {
385      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
386      const content = await response.blob();
387      await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
388        method: "PUT",
389        body: content,
390      });
391      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
392      setBlobs(blobs.map(b => b.key === key ? { ...b, key: newKey } : b));
393      if (selectedBlob && selectedBlob.key === key) {
402    const newKey = key.slice(9); // Remove "__public/" prefix
403    try {
404      const response = await fetch(`/api/blob?key=${encodeKey(key)}`);
405      const content = await response.blob();
406      await fetch(`/api/blob?key=${encodeKey(newKey)}`, {
407        method: "PUT",
408        body: content,
409      });
410      await fetch(`/api/blob?key=${encodeKey(key)}`, { method: "DELETE" });
411      setBlobs(blobs.map(b => b.key === key ? { ...b, key: newKey } : b));
412      if (selectedBlob && selectedBlob.key === key) {
557                        onClick={() =>
558                          copyToClipboard(
559                            `${window.location.origin}/api/public/${encodeURIComponent(selectedBlob.key.slice(9))}`,
560                          )}
561                        className="text-blue-400 hover:text-blue-300 text-sm"
580                        >
581                          <img
582                            src={`/api/blob?key=${encodeKey(selectedBlob.key)}`}
583                            alt="Blob content"
584                            className="max-w-full h-auto"
660
661// Public route without authentication
662app.get("/api/public/:id", async (c) => {
663  const key = `__public/${c.req.param("id")}`;
664  const { blob } = await import("https://esm.town/v/std/blob");
766};
767
768app.get("/api/blobs", checkAuth, async (c) => {
769  const prefix = c.req.query("prefix") || "";
770  const limit = parseInt(c.req.query("limit") || "20", 10);
775});
776
777app.get("/api/blob", checkAuth, async (c) => {
778  const key = c.req.query("key");
779  if (!key) return c.text("Missing key parameter", 400);
783});
784
785app.put("/api/blob", checkAuth, async (c) => {
786  const key = c.req.query("key");
787  if (!key) return c.text("Missing key parameter", 400);
792});
793
794app.delete("/api/blob", checkAuth, async (c) => {
795  const key = c.req.query("key");
796  if (!key) return c.text("Missing key parameter", 400);
800});
801
802app.post("/api/blob", checkAuth, async (c) => {
803  const { file, key } = await c.req.parseBody();
804  if (!file || !key) return c.text("Missing file or key", 400);

logmein mw1 match

@maxm•Updated 2 months ago

42          <title>Log Me In</title>
43          <meta name="viewport" content="width=device-width, initial-scale=1" />
44          <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" rel="stylesheet" />
45          <style>{css}</style>
46        </head>

logmein db1 match

@maxm•Updated 2 months ago

25
26  async login(email: string, config: Config | undefined): Promise<string> {
27    const resp = await fetch("https://api.val.town/v1/me", {
28      headers: {
29        "Authorization": `Bearer ${Deno.env.get("valtown")}`,

gptMemoryManager README.md20 matches

@cadence•Updated 2 months ago

1A simple Rest API that allows for you GPT to save and recall snippets of data (memories). You can read my blog post explaining it in detail here: [xkonti.tech](https://xkonti.tech/blog/giving-gpt-memory/)
2
3# Demonstration
7![FirstConversation.png](https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/78c48b8b-8a1b-4caf-ef23-2ad78be3a100/public)
8
9What GPT sent do the API:
10
11```json
24# Setup
25
26There are several steps to set up the API:
27- deploy and configure the API
28- create the API key for your GPT
29- add an action for the API in you GPT
30- add prompt section to your GPT so that it can use it properly
31
32## Deploying the API on Val Town
33
34Deploy your own memory API. You can fork the following Val to do it: https://www.val.town/v/xkonti/memoryApiExample
35
36In the code configure the appropriate values:
37
38- `apiName` the name of your API - used in the Privacy Policy (eg. `Memory API`)
39- `contactEmail` - the email to provide for contact in the Privacy Policy (eg. `some@email.com`)
40- `lastPolicyUpdate` - the date the Privacy Policy was last updated (eg. `2023-11-28`)
41- `blobKeyPrefix` - the prefix for the blob storage keys used by your API - more info below (eg. `gpt:memories:`)
42- `apiKeyPrefix` - the prefix for you API Keys secrets - more info below (eg. `GPTMEMORYAPI_KEY_`)
43
44## Create API keys
45
46The Memory API is designed to serve multiple GPTs at the same time. Each GPT should have it's own unique **name** and **API key**.
47
48The **name** is used for identifying the specific GPT and appended to both:
49- `blobKeyPrefix`- to maintain separate memory storage from other GPTs
50- `apiKeyPrefix` - to maintain separate API key for each GPT
51
521. Please pick a unique alphanumeric name for your GPT. For example `personaltrainer`.
532. Generate some alphanumeric API key for your GPT. For example `Wrangle-Chapped-Monkhood4-Domain-Suspend`
543. Add a new secret to your Val.town secrets storage. The Key should be the picked name prefixed by `apiKeyPrefix`. Using the default it would be `GPTMEMORYAPI_KEY_personaltrainer`. The value of the secret should be the API key itself.
55
56The memories of the GPT will be stored in the blob storage under the key `blobKeyPrefix + name`, for example: `gpt:memories:personaltrainer`.
59
601. Add a new action in your GPT.
612. Get the OpenAPI spefication by calling the `/openapi` endpoint of your API
623. Change all `<APIURL>` instances within the specification to the url of your deployed API. For example `https://xkonti-memoryapiexample.web.val.run`
634. Set the authentication method to basic and provide a [base64 encoded](https://www.base64encode.org/) version of the `<name>:<apiKey>`. For example: `personaltrainer:Wrangle-Chapped-Monkhood4-Domain-Suspend` -> `cGVyc29uYWx0cmFpbmVyOldyYW5nbGUtQ2hhcHBlZC1Nb25raG9vZDQtRG9tYWluLVN1c3BlbmQ=`
645. Add the link to the privacy policy, which is the `/privacy` endpoint of your API. For example: `https://xkonti-memoryapiexample.web.val.run/privacy`
65
66## Adding the prompt section

gptMemoryManager main.tsx24 matches

@cadence•Updated 2 months ago

1import * as uuid from "https://deno.land/std/uuid/mod.ts";
2import { blob } from "https://esm.town/v/std/blob";
3import { getPolicy } from "https://esm.town/v/xkonti/memoryApiPolicy";
4import { Hono } from "npm:hono@3";
5
6export const handleMemoryApiRequest = async (
7  req: Request,
8  apiName: string,
9  contactEmail: string,
10  lastPolicyUpdate: string,
11  blobKeyPrefix: string,
12  apiKeyPrefix: string,
13) => {
14  // ==== HELPERS ====
27
28  const verifyRequest = (c): { memoriesKey: string; error: any } => {
29    // Verify API key coming as a Bearer header
30    const authHeader = c.req.headers.get("Authorization");
31    if (!authHeader || !authHeader.startsWith("Basic ")) {
43      return { memoriesKey: "", error: c.text("Forbidden", 403) };
44    }
45    const expectedKey = Deno.env.get(apiKeyPrefix + key) ?? null;
46    if (token !== expectedKey) {
47      console.error("Invalid API KEY header");
48      return { memoriesKey: "", error: c.text("Forbidden", 403) };
49    }
51  };
52
53  // API
54
55  const app = new Hono();
209  // PRIVACY POLICY
210  app.get("/privacy", async (c) => {
211    const policy = getPolicy(apiName, contactEmail, lastPolicyUpdate);
212    c.header("Content-Type", "text/html");
213    return c.html(policy);
214  });
215
216  app.get("/openapi", async (c) => {
217    const specification = `
218{
219  "openapi": "3.1.0",
220  "info": {
221    "title": "Memories API",
222    "description": "API for managing and storing long-term memories.",
223    "version": "1.0.0"
224  },
225  "servers": [
226    {
227      "url": "<APIURL>"
228    }
229  ],
238          },
239          "401": {
240            "description": "Unauthorized - Missing or invalid API key."
241          },
242          "403": {
243            "description": "Forbidden - Invalid API key."
244          }
245        },
272          },
273          "401": {
274            "description": "Unauthorized - Missing or invalid API key."
275          },
276          "403": {
277            "description": "Forbidden - Invalid API key."
278          }
279        },
328          },
329          "401": {
330            "description": "Unauthorized - Missing or invalid API key."
331          },
332          "403": {
333            "description": "Forbidden - Invalid API key."
334          }
335        },
375          },
376          "401": {
377            "description": "Unauthorized - Missing or invalid API key."
378          },
379          "403": {
380            "description": "Forbidden - Invalid API key."
381          }
382        },
406          },
407          "401": {
408            "description": "Unauthorized - Missing or invalid API key."
409          },
410          "403": {
411            "description": "Forbidden - Invalid API key."
412          }
413        },

gptmemory README.md20 matches

@cadence•Updated 2 months ago

1A simple Rest API that allows for you GPT to save and recall snippets of data (memories). You can read my blog post explaining it in detail here: [xkonti.tech](https://xkonti.tech/blog/giving-gpt-memory/)
2
3# Demonstration
7![FirstConversation.png](https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/78c48b8b-8a1b-4caf-ef23-2ad78be3a100/public)
8
9What GPT sent do the API:
10
11```json
24# Setup
25
26There are several steps to set up the API:
27- deploy and configure the API
28- create the API key for your GPT
29- add an action for the API in you GPT
30- add prompt section to your GPT so that it can use it properly
31
32## Deploying the API on Val Town
33
34Deploy your own memory API. You can fork the following Val to do it: https://www.val.town/v/xkonti/memoryApiExample
35
36In the code configure the appropriate values:
37
38- `apiName` the name of your API - used in the Privacy Policy (eg. `Memory API`)
39- `contactEmail` - the email to provide for contact in the Privacy Policy (eg. `some@email.com`)
40- `lastPolicyUpdate` - the date the Privacy Policy was last updated (eg. `2023-11-28`)
41- `blobKeyPrefix` - the prefix for the blob storage keys used by your API - more info below (eg. `gpt:memories:`)
42- `apiKeyPrefix` - the prefix for you API Keys secrets - more info below (eg. `GPTMEMORYAPI_KEY_`)
43
44## Create API keys
45
46The Memory API is designed to serve multiple GPTs at the same time. Each GPT should have it's own unique **name** and **API key**.
47
48The **name** is used for identifying the specific GPT and appended to both:
49- `blobKeyPrefix`- to maintain separate memory storage from other GPTs
50- `apiKeyPrefix` - to maintain separate API key for each GPT
51
521. Please pick a unique alphanumeric name for your GPT. For example `personaltrainer`.
532. Generate some alphanumeric API key for your GPT. For example `Wrangle-Chapped-Monkhood4-Domain-Suspend`
543. Add a new secret to your Val.town secrets storage. The Key should be the picked name prefixed by `apiKeyPrefix`. Using the default it would be `GPTMEMORYAPI_KEY_personaltrainer`. The value of the secret should be the API key itself.
55
56The memories of the GPT will be stored in the blob storage under the key `blobKeyPrefix + name`, for example: `gpt:memories:personaltrainer`.
59
601. Add a new action in your GPT.
612. Get the OpenAPI spefication by calling the `/openapi` endpoint of your API
623. Change all `<APIURL>` instances within the specification to the url of your deployed API. For example `https://xkonti-memoryapiexample.web.val.run`
634. Set the authentication method to basic and provide a [base64 encoded](https://www.base64encode.org/) version of the `<name>:<apiKey>`. For example: `personaltrainer:Wrangle-Chapped-Monkhood4-Domain-Suspend` -> `cGVyc29uYWx0cmFpbmVyOldyYW5nbGUtQ2hhcHBlZC1Nb25raG9vZDQtRG9tYWluLVN1c3BlbmQ=`
645. Add the link to the privacy policy, which is the `/privacy` endpoint of your API. For example: `https://xkonti-memoryapiexample.web.val.run/privacy`
65
66## Adding the prompt section

gptmemory main.tsx32 matches

@cadence•Updated 2 months ago

1import * as uuid from "https://deno.land/std/uuid/mod.ts";
2import { blob } from "https://esm.town/v/std/blob";
3import { getPolicy } from "https://esm.town/v/xkonti/memoryApiPolicy";
4import { Hono } from "npm:hono@3";
5
6export const handleMemoryApiRequest = async (
7  req: Request,
8  apiName: string,
9  contactEmail: string,
10  lastPolicyUpdate: string,
11  blobKeyPrefix: string,
12  apiKeyPrefix: string,
13) => {
14  // ==== HELPERS ====
51
52  const verifyRequest = (c): { memoriesKey: string; error: any } => {
53    // Verify API key coming as a Bearer header
54    const authHeader = c.req.headers.get("Authorization");
55    if (!authHeader || !authHeader.startsWith("Basic ")) {
67      return { memoriesKey: "", error: c.text("Forbidden", 403) };
68    }
69    const expectedKey = Deno.env.get(apiKeyPrefix + key) ?? null;
70    if (token !== expectedKey) {
71      console.error("Invalid API KEY header");
72      return { memoriesKey: "", error: c.text("Forbidden", 403) };
73    }
75  };
76
77  // API
78
79  const app = new Hono();
405  // PRIVACY POLICY
406  app.get("/privacy", async (c) => {
407    const policy = getPolicy(apiName, contactEmail, lastPolicyUpdate);
408    c.header("Content-Type", "text/html");
409    return c.html(policy);
410  });
411
412  app.get("/openapi", async (c) => {
413    const specification = `
414{
415  "openapi": "3.1.0",
416  "info": {
417    "title": "Memories and Conversations API",
418    "description": "API for managing and storing long-term memories, AI conversations, and file attachments.",
419    "version": "1.2.0"
420  },
421  "servers": [
422    {
423      "url": "<APIURL>"
424    }
425  ],
434          },
435          "401": {
436            "description": "Unauthorized - Missing or invalid API key."
437          },
438          "403": {
439            "description": "Forbidden - Invalid API key."
440          }
441        },
468          },
469          "401": {
470            "description": "Unauthorized - Missing or invalid API key."
471          },
472          "403": {
473            "description": "Forbidden - Invalid API key."
474          }
475        },
524          },
525          "401": {
526            "description": "Unauthorized - Missing or invalid API key."
527          },
528          "403": {
529            "description": "Forbidden - Invalid API key."
530          }
531        },
571          },
572          "401": {
573            "description": "Unauthorized - Missing or invalid API key."
574          },
575          "403": {
576            "description": "Forbidden - Invalid API key."
577          }
578        },
602          },
603          "401": {
604            "description": "Unauthorized - Missing or invalid API key."
605          },
606          "403": {
607            "description": "Forbidden - Invalid API key."
608          },
609          "404": {
641          },
642          "401": {
643            "description": "Unauthorized - Missing or invalid API key."
644          },
645          "403": {
646            "description": "Forbidden - Invalid API key."
647          }
648        },
674          },
675          "401": {
676            "description": "Unauthorized - Missing or invalid API key."
677          },
678          "403": {
679            "description": "Forbidden - Invalid API key."
680          },
681          "404": {
728          },
729          "401": {
730            "description": "Unauthorized - Missing or invalid API key."
731          },
732          "403": {
733            "description": "Forbidden - Invalid API key."
734          },
735          "404": {
781          },
782          "401": {
783            "description": "Unauthorized - Missing or invalid API key."
784          },
785          "403": {
786            "description": "Forbidden - Invalid API key."
787          },
788          "404": {

handleMemoryApiRequest README.md20 matches

@cadence•Updated 2 months ago

1A simple Rest API that allows for you GPT to save and recall snippets of data (memories). You can read my blog post explaining it in detail here: [xkonti.tech](https://xkonti.tech/blog/giving-gpt-memory/)
2
3# Demonstration
7![FirstConversation.png](https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/78c48b8b-8a1b-4caf-ef23-2ad78be3a100/public)
8
9What GPT sent do the API:
10
11```json
24# Setup
25
26There are several steps to set up the API:
27- deploy and configure the API
28- create the API key for your GPT
29- add an action for the API in you GPT
30- add prompt section to your GPT so that it can use it properly
31
32## Deploying the API on Val Town
33
34Deploy your own memory API. You can fork the following Val to do it: https://www.val.town/v/xkonti/memoryApiExample
35
36In the code configure the appropriate values:
37
38- `apiName` the name of your API - used in the Privacy Policy (eg. `Memory API`)
39- `contactEmail` - the email to provide for contact in the Privacy Policy (eg. `some@email.com`)
40- `lastPolicyUpdate` - the date the Privacy Policy was last updated (eg. `2023-11-28`)
41- `blobKeyPrefix` - the prefix for the blob storage keys used by your API - more info below (eg. `gpt:memories:`)
42- `apiKeyPrefix` - the prefix for you API Keys secrets - more info below (eg. `GPTMEMORYAPI_KEY_`)
43
44## Create API keys
45
46The Memory API is designed to serve multiple GPTs at the same time. Each GPT should have it's own unique **name** and **API key**.
47
48The **name** is used for identifying the specific GPT and appended to both:
49- `blobKeyPrefix`- to maintain separate memory storage from other GPTs
50- `apiKeyPrefix` - to maintain separate API key for each GPT
51
521. Please pick a unique alphanumeric name for your GPT. For example `personaltrainer`.
532. Generate some alphanumeric API key for your GPT. For example `Wrangle-Chapped-Monkhood4-Domain-Suspend`
543. Add a new secret to your Val.town secrets storage. The Key should be the picked name prefixed by `apiKeyPrefix`. Using the default it would be `GPTMEMORYAPI_KEY_personaltrainer`. The value of the secret should be the API key itself.
55
56The memories of the GPT will be stored in the blob storage under the key `blobKeyPrefix + name`, for example: `gpt:memories:personaltrainer`.
59
601. Add a new action in your GPT.
612. Get the OpenAPI spefication by calling the `/openapi` endpoint of your API
623. Change all `<APIURL>` instances within the specification to the url of your deployed API. For example `https://xkonti-memoryapiexample.web.val.run`
634. Set the authentication method to basic and provide a [base64 encoded](https://www.base64encode.org/) version of the `<name>:<apiKey>`. For example: `personaltrainer:Wrangle-Chapped-Monkhood4-Domain-Suspend` -> `cGVyc29uYWx0cmFpbmVyOldyYW5nbGUtQ2hhcHBlZC1Nb25raG9vZDQtRG9tYWluLVN1c3BlbmQ=`
645. Add the link to the privacy policy, which is the `/privacy` endpoint of your API. For example: `https://xkonti-memoryapiexample.web.val.run/privacy`
65
66## Adding the prompt section

handleMemoryApiRequest main.tsx24 matches

@cadence•Updated 2 months ago

1import * as uuid from "https://deno.land/std/uuid/mod.ts";
2import { blob } from "https://esm.town/v/std/blob";
3import { getPolicy } from "https://esm.town/v/xkonti/memoryApiPolicy";
4import { Hono } from "npm:hono@3";
5
6export const handleMemoryApiRequest = async (
7  req: Request,
8  apiName: string,
9  contactEmail: string,
10  lastPolicyUpdate: string,
11  blobKeyPrefix: string,
12  apiKeyPrefix: string,
13) => {
14  // ==== HELPERS ====
27
28  const verifyRequest = (c): { memoriesKey: string; error: any } => {
29    // Verify API key coming as a Bearer header
30    const authHeader = c.req.headers.get("Authorization");
31    if (!authHeader || !authHeader.startsWith("Basic ")) {
43      return { memoriesKey: "", error: c.text("Forbidden", 403) };
44    }
45    const expectedKey = Deno.env.get(apiKeyPrefix + key) ?? null;
46    if (token !== expectedKey) {
47      console.error("Invalid API KEY header");
48      return { memoriesKey: "", error: c.text("Forbidden", 403) };
49    }
51  };
52
53  // API
54
55  const app = new Hono();
209  // PRIVACY POLICY
210  app.get("/privacy", async (c) => {
211    const policy = getPolicy(apiName, contactEmail, lastPolicyUpdate);
212    c.header("Content-Type", "text/html");
213    return c.html(policy);
214  });
215
216  app.get("/openapi", async (c) => {
217    const specification = `
218{
219  "openapi": "3.1.0",
220  "info": {
221    "title": "Memories API",
222    "description": "API for managing and storing long-term memories.",
223    "version": "1.0.0"
224  },
225  "servers": [
226    {
227      "url": "<APIURL>"
228    }
229  ],
238          },
239          "401": {
240            "description": "Unauthorized - Missing or invalid API key."
241          },
242          "403": {
243            "description": "Forbidden - Invalid API key."
244          }
245        },
272          },
273          "401": {
274            "description": "Unauthorized - Missing or invalid API key."
275          },
276          "403": {
277            "description": "Forbidden - Invalid API key."
278          }
279        },
328          },
329          "401": {
330            "description": "Unauthorized - Missing or invalid API key."
331          },
332          "403": {
333            "description": "Forbidden - Invalid API key."
334          }
335        },
375          },
376          "401": {
377            "description": "Unauthorized - Missing or invalid API key."
378          },
379          "403": {
380            "description": "Forbidden - Invalid API key."
381          }
382        },
406          },
407          "401": {
408            "description": "Unauthorized - Missing or invalid API key."
409          },
410          "403": {
411            "description": "Forbidden - Invalid API key."
412          }
413        },