Val Town Code SearchReturn to Val Town

1
2export interface Config {
3    apiToken: string | null
4    apiBase: string
5    cli?: {
6        preferCli: boolean

1import {Config} from "./types.ts"
2
3export async function callValTownApi(
4    config: Config,
5    path: string,
7): Promise<any> {
8    // Path conversion for endpoints that have changed in v2
9    let apiPath = path
10
11    // If any old v1 paths are accidentally used, convert them to v2
12    if (path.startsWith("/v1/projects")) {
13        apiPath = path.replace("/v1/projects", "/v2/vals")
14        console.warn(`Converting deprecated v1 path to v2: ${path} → ${apiPath}`)
15    } else if (path.startsWith("/v1/alias/projects")) {
16        apiPath = path.replace("/v1/alias/projects", "/v2/alias/vals")
17        console.warn(`Converting deprecated v1 path to v2: ${path} → ${apiPath}`)
18    }
19
20    const url = `${config.apiBase}${apiPath}`
21
22    if (!config.apiToken) {
23        throw new Error("API token is required for ValTown API calls");
24    }
25
26    const headers: HeadersInit = {
27        'Authorization': `Bearer ${config.apiToken}`,
28        'Content-Type': 'application/json',
29    }
39    if (!response.ok) {
40        const errorText = await response.text()
41        throw new Error(`API error (${response.status}): ${errorText}`)
42    }
43

1import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"
2import {Config} from "../lib/types.ts"
3import {callValTownApi} from "../lib/api.ts"
4import {getErrorMessage} from "../lib/errorUtils.ts"
5import {getCliAvailability, runVtCommand, parseCliJsonOutput} from "../lib/vtCli.ts"
37          }
38          
39          console.error(`CLI error when getting val, falling back to API: ${result.error}`);
40          // Fall back to API on error
41        } catch (error) {
42          console.error("CLI error, falling back to API:", getErrorMessage(error));
43          // Fall back to API on error
44        }
45      }
46
47      // API implementation (original code)
48      try {
49        const data = await callValTownApi(
50          config,
51          `/v2/alias/vals/${encodeURIComponent(username)}/${encodeURIComponent(valName)}`
75    async ({query, limit, offset}) => {
76      try {
77        const data = await callValTownApi(
78          config,
79          `/v1/search/vals?query=${encodeURIComponent(query)}&limit=${limit}&offset=${offset}`
135          }
136          
137          console.error(`CLI error when creating val, falling back to API: ${result.error}`);
138          // Fall back to API on error
139        } catch (error) {
140          console.error("CLI error, falling back to API:", getErrorMessage(error));
141          // Fall back to API on error
142        }
143      }
144
145      // API implementation (original code)
146      try {
147        const requestBody = {
151        }
152
153        const data = await callValTownApi(
154          config,
155          `/v2/vals`,
192          
193          // Use prepareValWorkspace first (would need to implement special workspace setup)
194          // For now, we'll use the API implementation instead of complex workspace management
195          
196          // This could be implemented with temporary directory setup if needed, 
197          // but for now we'll use the API for deletion as it's simpler
198          console.log("Deletion via CLI requires workspace setup, using API instead");
199        } catch (error) {
200          console.error("CLI error, falling back to API:", getErrorMessage(error));
201          // Fall back to API on error
202        }
203      }
204
205      // API implementation (original code)
206      try {
207        await callValTownApi(
208          config,
209          `/v2/vals/${valId}`,
265          }
266          
267          console.error(`CLI error when listing vals, falling back to API: ${result.error}`);
268          // Fall back to API on error
269        } catch (error) {
270          console.error("CLI error, falling back to API:", getErrorMessage(error));
271          // Fall back to API on error
272        }
273      }
274
275      // API implementation (original code)
276      try {
277        const data = await callValTownApi(
278          config,
279          `/v2/me/vals?limit=${limit}&offset=${offset}`

2import {z} from "zod"
3import {Config} from "../lib/types.ts"
4import {callValTownApi} from "../lib/api.ts"
5import {getErrorMessage} from "../lib/errorUtils.ts"
6
15    async ({statement}: {statement: string}) => {
16      try {
17        const data = await callValTownApi(config, "/v1/sqlite/execute", {
18          method: "POST",
19          body: JSON.stringify({statement}),
46    }) => {
47      try {
48        const data = await callValTownApi(config, "/v1/sqlite/batch", {
49          method: "POST",
50          body: JSON.stringify({statements, mode}),
73    async ({statement}: {statement: string}) => {
74      try {
75        const data = await callValTownApi(config, "/v1/sqlite/query", {
76          method: "POST",
77          body: JSON.stringify({statement}),
104    }) => {
105      try {
106        const data = await callValTownApi(config, "/v1/sqlite/exec", {
107          method: "POST",
108          body: JSON.stringify({statements, mode}),

1import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"
2import {Config} from "../lib/types.ts"
3import {callValTownApi} from "../lib/api.ts"
4import {getErrorMessage} from "../lib/errorUtils.ts"
5import {getCliAvailability, runVtCommand, parseCliJsonOutput, prepareValWorkspace, cleanupTempDirectory} from "../lib/vtCli.ts"
48          }
49          
50          console.error(`CLI error when listing branches, falling back to API: ${workspace.error || "Unknown error"}`);
51          // Fall back to API on error
52        } catch (error) {
53          console.error("CLI error, falling back to API:", getErrorMessage(error));
54          // Fall back to API on error
55        }
56      }
57
58      // API implementation (original code)
59      try {
60        const data = await callValTownApi(
61          config,
62          `/v2/vals/${valId}/branches?limit=${limit}&offset=${offset}`
85    async ({valId, branchId}) => {
86      try {
87        const data = await callValTownApi(
88          config,
89          `/v2/vals/${valId}/branches/${branchId}`
132                console.error(`Failed to checkout source branch: ${checkoutResult.error}`);
133                await cleanupTempDirectory(workspace.workspacePath);
134                // Fall back to API
135                console.error("CLI error when checking out source branch, falling back to API");
136                throw new Error("Failed to checkout source branch");
137              }
155          }
156          
157          console.error(`CLI error when creating branch, falling back to API: ${workspace.error || "Unknown error"}`);
158          // Fall back to API on error
159        } catch (error) {
160          console.error("CLI error, falling back to API:", getErrorMessage(error));
161          // Fall back to API on error
162        }
163      }
164
165      // API implementation (original code)
166      try {
167        const requestBody = {
170        }
171
172        const data = await callValTownApi(
173          config,
174          `/v2/vals/${valId}/branches`,
227          }
228          
229          console.error(`CLI error when deleting branch, falling back to API: ${workspace.error || "Unknown error"}`);
230          // Fall back to API on error
231        } catch (error) {
232          console.error("CLI error, falling back to API:", getErrorMessage(error));
233          // Fall back to API on error
234        }
235      }
236
237      // API implementation (original code)
238      try {
239        await callValTownApi(
240          config,
241          `/v2/vals/${valId}/branches/${branchId}`,

1import {McpServer} from "@modelcontextprotocol/sdk/server/mcp.js"
2import {Config} from "../lib/types.ts"
3import {callValTownApi} from "../lib/api.ts"
4import {getErrorMessage} from "../lib/errorUtils.ts"
5import {getCliAvailability, runVtCommand, parseCliJsonOutput, prepareValWorkspace, cleanupTempDirectory} from "../lib/vtCli.ts"
122                console.error(`Failed to checkout branch: ${checkoutResult.error}`)
123                await cleanupTempDirectory(workspace.workspacePath!)
124                // Fall back to API
125                console.error("CLI error when checking out branch, falling back to API")
126                throw new Error("Failed to checkout branch")
127              }
147          }
148
149          console.error(`CLI error when listing files, falling back to API: ${workspace.error || "Unknown error"}`)
150          // Fall back to API on error
151        } catch (error) {
152          console.error("CLI error, falling back to API:", getErrorMessage(error))
153          // Fall back to API on error
154        }
155      }
156
157      // API implementation (original code)
158      try {
159        let queryParams = `?path=${encodeURIComponent(path)}&recursive=${recursive}&limit=${limit}&offset=${offset}`
162        }
163
164        const data = await callValTownApi(
165          config,
166          `/v2/vals/${valId}/files${queryParams}`
197
198        const response = await fetch(
199          `${config.apiBase}/v2/vals/${valId}/files/content${queryParams}`,
200          {
201            headers: {
202              'Authorization': `Bearer ${config.apiToken}`,
203            },
204          }
207        if (!response.ok) {
208          const errorText = await response.text()
209          throw new Error(`API error (${response.status}): ${errorText}`)
210        }
211
295            }
296          } else {
297            console.error(`CLI error when creating ${type}, falling back to API: ${result.error}`)
298            // Fall back to API
299          }
300        } catch (error) {
301          console.error("CLI error, falling back to API:", getErrorMessage(error))
302          // Fall back to API on error
303        }
304      }
305
306      // API implementation (original code)
307      try {
308        let queryParams = `?path=${encodeURIComponent(filePath)}`
316        }
317
318        const data = await callValTownApi(
319          config,
320          `/v2/vals/${valId}/files${queryParams}`,
384            }
385          } else {
386            console.error(`CLI error when updating file, falling back to API: ${result.error}`)
387            // Fall back to API
388          }
389        } catch (error) {
390          console.error("CLI error, falling back to API:", getErrorMessage(error))
391          // Fall back to API on error
392        }
393      }
394
395      // API implementation (original code)
396      try {
397        let queryParams = `?path=${encodeURIComponent(filePath)}`
400        }
401
402        const data = await callValTownApi(
403          config,
404          `/v2/vals/${valId}/files${queryParams}`,
488            }
489          } else {
490            console.error(`CLI error when deleting path, falling back to API: ${result.error}`)
491            // Fall back to API
492          }
493        } catch (error) {
494          console.error("CLI error, falling back to API:", getErrorMessage(error))
495          // Fall back to API on error
496        }
497      }
498
499      // API implementation (original code)
500      try {
501        let queryParams = `?path=${encodeURIComponent(filePath)}&recursive=${recursive}`
504        }
505
506        await callValTownApi(
507          config,
508          `/v2/vals/${valId}/files${queryParams}`,

2import {z} from "zod"
3import {Config} from "../lib/types.ts"
4import {callValTownApi} from "../lib/api.ts"
5import {getErrorMessage} from "../lib/errorUtils.ts"
6
15    async ({username}: {username: string}) => {
16      try {
17        const data = await callValTownApi(config, `/v1/alias/${encodeURIComponent(username)}`)
18
19        return {
37    async () => {
38      try {
39        const data = await callValTownApi(config, "/v1/me")
40
41        return {

2import {z} from "zod"
3import {Config} from "../lib/types.ts"
4import {callValTownApi} from "../lib/api.ts"
5import {getErrorMessage} from "../lib/errorUtils.ts"
6
16      try {
17        const queryParams = prefix ? `?prefix=${encodeURIComponent(prefix)}` : ""
18        const data = await callValTownApi(config, `/v1/blob${queryParams}`)
19
20        return {
41      try {
42        // For blobs, we need to handle binary data differently
43        const url = `${config.apiBase}/v1/blob/${encodeURIComponent(key)}`
44        const response = await fetch(url, {
45          headers: {
46            "Authorization": `Bearer ${config.apiToken}`,
47          },
48        })
50        if (!response.ok) {
51          const errorText = await response.text()
52          throw new Error(`API request failed: ${response.status} ${response.statusText}\n${errorText}`)
53        }
54
109        }
110
111        const url = `${config.apiBase}/v1/blob/${encodeURIComponent(key)}`
112        const response = await fetch(url, {
113          method: "POST",
114          headers: {
115            "Authorization": `Bearer ${config.apiToken}`,
116            "Content-Type": contentType,
117          },
121        if (!response.ok) {
122          const errorText = await response.text()
123          throw new Error(`API request failed: ${response.status} ${response.statusText}\n${errorText}`)
124        }
125
146    async ({key}: {key: string}) => {
147      try {
148        await callValTownApi(config, `/v1/blob/${encodeURIComponent(key)}`, {
149          method: "DELETE",
150        })

2import {z} from "zod"
3import {Config} from "../lib/types.ts"
4import {callValTownApi} from "../lib/api.ts"
5import {getCliAvailability, runVtCommand} from "../lib/vtCli.ts"
6
16    async ({limit, offset}: {limit: number; offset: number}) => {
17      try {
18        const data = await callValTownApi(
19          config,
20          `/v1/me/projects?limit=${limit}&offset=${offset}`
44    async ({projectId}: {projectId: string}) => {
45      try {
46        const data = await callValTownApi(config, `/v1/projects/${projectId}`)
47
48        return {
84            }
85          }
86          // If CLI fails, fall back to API
87        } catch (error) {
88          console.error("CLI error:", error)
89          // Continue to API fallback
90        }
91      }
92
93      // Fallback to original API implementation
94      try {
95        const data = await callValTownApi(
96          config,
97          `/v1/alias/projects/${encodeURIComponent(username)}/${encodeURIComponent(projectName)}`
162        }
163
164        const data = await callValTownApi(config, "/v1/projects", {
165          method: "POST",
166          body: JSON.stringify(payload),
190    async ({projectId}: {projectId: string}) => {
191      try {
192        await callValTownApi(config, `/v1/projects/${projectId}`, {
193          method: "DELETE",
194        })

1# Val Town API token - get from https://www.val.town/settings
2VAL_TOWN_API_TOKEN=your_api_token_here
3