shyim-hosting-test-cli 0.0.1

package/.app-hosting/kv/local-cache/blobs/31b6e14132d4fc13bdcea6c476f84d6ae21cccfa838c0e604b09ebe4e2a157810000019d25d8210e

@@ -0,0 +1 @@
+world

package/dist/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { defineCommand as defineCommand7, runMain } from "citty";
+
+// src/commands/login.ts
+import { defineCommand } from "citty";
+import consola from "consola";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFile, writeFile, mkdir } from "fs/promises";
+var CONFIG_DIR = join(homedir(), ".config", "app-hosting");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+async function loadConfig() {
+  try {
+    const data = await readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return {};
+  }
+}
+async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function getApiUrl(config) {
+  return "https://sw-test-app-hosting.click";
+}
+
+// src/commands/login.ts
+var loginCommand = defineCommand({
+  meta: {
+    name: "login",
+    description: "Store a deploy token for authentication"
+  },
+  args: {
+    token: {
+      type: "string",
+      description: "Deploy token from the web UI",
+      required: false
+    },
+    "api-url": {
+      type: "string",
+      description: "API base URL",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const config = await loadConfig();
+    let token = args.token;
+    if (!token) {
+      token = await consola.prompt("Enter your deploy token:", {
+        type: "text"
+      });
+      if (!token || typeof token !== "string") {
+        consola.error("No token provided.");
+        process.exit(1);
+      }
+    }
+    config.token = token;
+    if (args["api-url"]) {
+      config.apiUrl = args["api-url"];
+    }
+    await saveConfig(config);
+    consola.success("Token saved. You can now use `deploy` and other commands.");
+  }
+});
+
+// src/commands/logout.ts
+import { defineCommand as defineCommand2 } from "citty";
+import consola2 from "consola";
+var logoutCommand = defineCommand2({
+  meta: {
+    name: "logout",
+    description: "Remove stored credentials"
+  },
+  async run() {
+    const config = await loadConfig();
+    delete config.token;
+    await saveConfig(config);
+    consola2.success("Logged out.");
+  }
+});
+
+// src/commands/init.ts
+import { defineCommand as defineCommand3 } from "citty";
+import consola3 from "consola";
+
+// src/project.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var PROJECT_FILE = "app-hosting.json";
+async function loadProjectConfig(cwd) {
+  try {
+    const data = await readFile2(join2(cwd, PROJECT_FILE), "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+async function saveProjectConfig(cwd, config) {
+  await writeFile2(join2(cwd, PROJECT_FILE), JSON.stringify(config, null, 2) + "\n");
+}
+
+// src/trpc.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+async function createClient() {
+  const config = await loadConfig();
+  if (!config.token) {
+    throw new Error("Not logged in. Run `app-hosting login` first.");
+  }
+  const apiUrl = getApiUrl(config);
+  const client = createTRPCClient({
+    links: [
+      httpBatchLink({
+        url: `${apiUrl}/api`,
+        headers: {
+          Authorization: `Bearer ${config.token}`
+        }
+      })
+    ]
+  });
+  return client;
+}
+
+// src/commands/init.ts
+var initCommand = defineCommand3({
+  meta: {
+    name: "init",
+    description: "Link current directory to a project"
+  },
+  args: {
+    "project-id": {
+      type: "string",
+      description: "Project ID to link",
+      required: false
+    }
+  },
+  async run({ args }) {
+    const client = await createClient();
+    let projectId = args["project-id"];
+    let projectName;
+    if (projectId) {
+      const project = await client.projects.get.query({ id: projectId });
+      projectName = project.name;
+    } else {
+      const projects = await client.projects.list.query();
+      if (projects.length === 0) {
+        consola3.error("No projects found. Create one in the web UI first.");
+        process.exit(1);
+      }
+      const selected = await consola3.prompt("Select a project:", {
+        type: "select",
+        options: projects.map((p) => ({ label: p.name, value: p.id }))
+      });
+      if (!selected || typeof selected !== "string") {
+        consola3.error("No project selected.");
+        process.exit(1);
+      }
+      projectId = selected;
+      projectName = projects.find((p) => p.id === selected).name;
+    }
+    await saveProjectConfig(process.cwd(), {
+      project_id: projectId,
+      project_name: projectName
+    });
+    consola3.success(`Linked to project "${projectName}" (${projectId})`);
+    consola3.info("Created app-hosting.json");
+  }
+});
+
+// src/commands/deploy.ts
+import { defineCommand as defineCommand4 } from "citty";
+import consola4 from "consola";
+import { resolve } from "path";
+import { build } from "esbuild";
+var deployCommand = defineCommand4({
+  meta: {
+    name: "deploy",
+    description: "Deploy worker code to your project"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to the worker entry point",
+      required: true,
+      default: "index.js"
+    },
+    "no-bundle": {
+      type: "boolean",
+      description: "Skip bundling and upload the file as-is",
+      default: false
+    }
+  },
+  async run({ args }) {
+    const client = await createClient();
+    const projectConfig = await loadProjectConfig(process.cwd());
+    if (!projectConfig) {
+      consola4.error("No app-hosting.json found. Run `app-hosting init` first.");
+      process.exit(1);
+    }
+    const filePath = resolve(args.file);
+    let scriptContent;
+    if (args["no-bundle"]) {
+      const { readFile: readFile3 } = await import("fs/promises");
+      try {
+        scriptContent = await readFile3(filePath, "utf-8");
+      } catch {
+        consola4.error(`Could not read file: ${filePath}`);
+        process.exit(1);
+      }
+    } else {
+      consola4.start("Bundling with esbuild...");
+      try {
+        const result = await build({
+          entryPoints: [filePath],
+          bundle: true,
+          write: false,
+          format: "esm",
+          target: "esnext",
+          platform: "browser",
+          conditions: ["workerd", "worker", "browser"],
+          minify: true,
+          sourcemap: false
+        });
+        scriptContent = result.outputFiles[0].text;
+      } catch (e) {
+        consola4.error(`Bundle failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+        process.exit(1);
+      }
+      consola4.success("Bundle complete.");
+    }
+    const sizeKb = (Buffer.byteLength(scriptContent) / 1024).toFixed(1);
+    consola4.start(`Deploying (${sizeKb} KB) to "${projectConfig.project_name}"...`);
+    try {
+      const result = await client.deployments.deploy.mutate({
+        projectId: projectConfig.project_id,
+        script: scriptContent
+      });
+      consola4.success(`Deployed! Deployment ID: ${result.deploymentId}`);
+    } catch (e) {
+      consola4.error(`Deployment failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  }
+});
+
+// src/commands/dev.ts
+import { defineCommand as defineCommand5 } from "citty";
+import consola5 from "consola";
+import { resolve as resolve2, dirname, join as join3 } from "path";
+import { watch } from "fs";
+import { build as build2 } from "esbuild";
+import { Miniflare } from "miniflare";
+async function bundleWorker(entryPoint) {
+  const result = await build2({
+    entryPoints: [entryPoint],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "esnext",
+    platform: "browser",
+    conditions: ["workerd", "worker", "browser"],
+    minify: false,
+    sourcemap: false
+  });
+  return result.outputFiles[0].text;
+}
+function getMiniflareOptions(script, port, persistDir) {
+  return {
+    modules: true,
+    script,
+    port,
+    compatibilityDate: "2025-03-25",
+    kvNamespaces: { cache: "local-cache" },
+    d1Databases: { db: "local-db" },
+    kvPersist: join3(persistDir, "kv"),
+    d1Persist: join3(persistDir, "d1")
+  };
+}
+var devCommand = defineCommand5({
+  meta: {
+    name: "dev",
+    description: "Start a local dev server with workerd"
+  },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to the worker entry point",
+      required: true
+    },
+    port: {
+      type: "string",
+      description: "Port to listen on",
+      default: "8787"
+    },
+    persist: {
+      type: "string",
+      description: "Directory for persisting KV and D1 data",
+      default: ".app-hosting"
+    }
+  },
+  async run({ args }) {
+    const filePath = resolve2(args.file);
+    const port = parseInt(args.port, 10);
+    const persistDir = resolve2(args.persist);
+    consola5.start("Bundling...");
+    let script;
+    try {
+      script = await bundleWorker(filePath);
+    } catch (e) {
+      consola5.error(`Bundle failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+      process.exit(1);
+    }
+    const mf = new Miniflare(getMiniflareOptions(script, port, persistDir));
+    const url = await mf.ready;
+    consola5.success(`Listening on ${url}`);
+    consola5.info("Bindings available: env.cache (KV), env.db (D1)");
+    const watchDir = dirname(filePath);
+    let debounce = null;
+    consola5.info(`Watching ${watchDir} for changes...`);
+    watch(watchDir, { recursive: true }, (_event, filename) => {
+      if (!filename) return;
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(async () => {
+        consola5.start("Rebuilding...");
+        try {
+          const newScript = await bundleWorker(filePath);
+          await mf.setOptions(getMiniflareOptions(newScript, port, persistDir));
+          consola5.success("Reloaded.");
+        } catch (e) {
+          consola5.error(`Rebuild failed: ${e instanceof Error ? e.message : e}`);
+        }
+      }, 100);
+    });
+    process.on("SIGINT", async () => {
+      consola5.info("Shutting down...");
+      await mf.dispose();
+      process.exit(0);
+    });
+  }
+});
+
+// src/commands/projects.ts
+import { defineCommand as defineCommand6 } from "citty";
+import consola6 from "consola";
+var projectsCommand = defineCommand6({
+  meta: {
+    name: "projects",
+    description: "Manage projects"
+  },
+  subCommands: {
+    list: defineCommand6({
+      meta: {
+        name: "list",
+        description: "List your projects"
+      },
+      async run() {
+        const client = await createClient();
+        const projects = await client.projects.list.query();
+        if (projects.length === 0) {
+          consola6.info("No projects yet.");
+          return;
+        }
+        consola6.log("");
+        for (const p of projects) {
+          consola6.log(`  ${p.name}`);
+          consola6.log(`    ID:        ${p.id}`);
+          consola6.log(`    Subdomain: ${p.subdomain}`);
+          if (p.description) {
+            consola6.log(`    Desc:      ${p.description}`);
+          }
+          consola6.log("");
+        }
+      }
+    })
+  }
+});
+
+// src/index.ts
+var main = defineCommand7({
+  meta: {
+    name: "app-hosting",
+    version: "0.0.1",
+    description: "CLI for App Hosting platform"
+  },
+  subCommands: {
+    login: loginCommand,
+    logout: logoutCommand,
+    init: initCommand,
+    deploy: deployCommand,
+    dev: devCommand,
+    projects: projectsCommand
+  }
+});
+runMain(main);

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "shyim-hosting-test-cli",
+	"version": "0.0.1",
+	"type": "module",
+	"bin": {
+		"app-hosting": "./dist/index.mjs"
+	},
+	"scripts": {
+		"build": "tsup src/index.ts --format esm --out-dir dist --clean",
+		"dev": "tsx src/index.ts"
+	},
+	"dependencies": {
+		"@trpc/client": "^11.15.0",
+		"@trpc/server": "^11.15.0",
+		"citty": "^0.1.6",
+		"consola": "^3.4.2",
+		"esbuild": "^0.27.4",
+		"miniflare": "^4.20260317.2"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "^4.20260317.1",
+		"@types/node": "^25.5.0",
+		"tsup": "^8.5.0",
+		"tsx": "^4.20.0",
+		"typescript": "^5.5.2"
+	}
+}

package/src/commands/deploy.ts

@@ -0,0 +1,85 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { resolve } from "node:path";
+import { build } from "esbuild";
+import { loadProjectConfig } from "../project";
+import { createClient } from "../trpc";
+
+export const deployCommand = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Deploy worker code to your project",
+	},
+	args: {
+		file: {
+			type: "positional",
+			description: "Path to the worker entry point",
+			required: true,
+			default: 'index.js',
+		},
+		"no-bundle": {
+			type: "boolean",
+			description: "Skip bundling and upload the file as-is",
+			default: false,
+		},
+	},
+	async run({ args }) {
+		const client = await createClient();
+
+		const projectConfig = await loadProjectConfig(process.cwd());
+		if (!projectConfig) {
+			consola.error("No app-hosting.json found. Run `app-hosting init` first.");
+			process.exit(1);
+		}
+
+		const filePath = resolve(args.file);
+		let scriptContent: string;
+
+		if (args["no-bundle"]) {
+			const { readFile } = await import("node:fs/promises");
+			try {
+				scriptContent = await readFile(filePath, "utf-8");
+			} catch {
+				consola.error(`Could not read file: ${filePath}`);
+				process.exit(1);
+			}
+		} else {
+			consola.start("Bundling with esbuild...");
+
+			try {
+				const result = await build({
+					entryPoints: [filePath],
+					bundle: true,
+					write: false,
+					format: "esm",
+					target: "esnext",
+					platform: "browser",
+					conditions: ["workerd", "worker", "browser"],
+					minify: true,
+					sourcemap: false,
+				});
+
+				scriptContent = result.outputFiles[0]!.text;
+			} catch (e: unknown) {
+				consola.error(`Bundle failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+				process.exit(1);
+			}
+
+			consola.success("Bundle complete.");
+		}
+
+		const sizeKb = (Buffer.byteLength(scriptContent) / 1024).toFixed(1);
+		consola.start(`Deploying (${sizeKb} KB) to "${projectConfig.project_name}"...`);
+
+		try {
+			const result = await client.deployments.deploy.mutate({
+				projectId: projectConfig.project_id,
+				script: scriptContent,
+			});
+			consola.success(`Deployed! Deployment ID: ${result.deploymentId}`);
+		} catch (e: unknown) {
+			consola.error(`Deployment failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+			process.exit(1);
+		}
+	},
+});

package/src/commands/dev.ts

@@ -0,0 +1,109 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { resolve, dirname, join } from "node:path";
+import { watch } from "node:fs";
+import { build, type BuildResult } from "esbuild";
+import { Miniflare } from "miniflare";
+
+async function bundleWorker(entryPoint: string): Promise<string> {
+	const result: BuildResult = await build({
+		entryPoints: [entryPoint],
+		bundle: true,
+		write: false,
+		format: "esm",
+		target: "esnext",
+		platform: "browser",
+		conditions: ["workerd", "worker", "browser"],
+		minify: false,
+		sourcemap: false,
+	});
+
+	return result.outputFiles![0]!.text;
+}
+
+function getMiniflareOptions(script: string, port: number, persistDir: string) {
+	return {
+		modules: true,
+		script,
+		port,
+		compatibilityDate: "2025-03-25",
+		kvNamespaces: { cache: "local-cache" },
+		d1Databases: { db: "local-db" },
+		kvPersist: join(persistDir, "kv"),
+		d1Persist: join(persistDir, "d1"),
+	};
+}
+
+export const devCommand = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start a local dev server with workerd",
+	},
+	args: {
+		file: {
+			type: "positional",
+			description: "Path to the worker entry point",
+			required: true,
+		},
+		port: {
+			type: "string",
+			description: "Port to listen on",
+			default: "8787",
+		},
+		persist: {
+			type: "string",
+			description: "Directory for persisting KV and D1 data",
+			default: ".app-hosting",
+		},
+	},
+	async run({ args }) {
+		const filePath = resolve(args.file);
+		const port = parseInt(args.port, 10);
+		const persistDir = resolve(args.persist);
+
+		consola.start("Bundling...");
+
+		let script: string;
+		try {
+			script = await bundleWorker(filePath);
+		} catch (e: unknown) {
+			consola.error(`Bundle failed: ${e instanceof Error ? e.message : "Unknown error"}`);
+			process.exit(1);
+		}
+
+		const mf = new Miniflare(getMiniflareOptions(script, port, persistDir));
+
+		const url = await mf.ready;
+		consola.success(`Listening on ${url}`);
+		consola.info("Bindings available: env.cache (KV), env.db (D1)");
+
+		// Watch the entry point directory for changes
+		const watchDir = dirname(filePath);
+		let debounce: ReturnType<typeof setTimeout> | null = null;
+
+		consola.info(`Watching ${watchDir} for changes...`);
+
+		watch(watchDir, { recursive: true }, (_event, filename) => {
+			if (!filename) return;
+
+			if (debounce) clearTimeout(debounce);
+			debounce = setTimeout(async () => {
+				consola.start("Rebuilding...");
+				try {
+					const newScript = await bundleWorker(filePath);
+					await mf.setOptions(getMiniflareOptions(newScript, port, persistDir));
+					consola.success("Reloaded.");
+				} catch (e: unknown) {
+					consola.error(`Rebuild failed: ${e instanceof Error ? e.message : e}`);
+				}
+			}, 100);
+		});
+
+		// Keep process alive, handle shutdown
+		process.on("SIGINT", async () => {
+			consola.info("Shutting down...");
+			await mf.dispose();
+			process.exit(0);
+		});
+	},
+});

package/src/commands/init.ts

@@ -0,0 +1,57 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { saveProjectConfig } from "../project";
+import { createClient } from "../trpc";
+
+export const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Link current directory to a project",
+	},
+	args: {
+		"project-id": {
+			type: "string",
+			description: "Project ID to link",
+			required: false,
+		},
+	},
+	async run({ args }) {
+		const client = await createClient();
+
+		let projectId = args["project-id"];
+		let projectName: string;
+
+		if (projectId) {
+			const project = await client.projects.get.query({ id: projectId });
+			projectName = project.name;
+		} else {
+			const projects = await client.projects.list.query();
+
+			if (projects.length === 0) {
+				consola.error("No projects found. Create one in the web UI first.");
+				process.exit(1);
+			}
+
+			const selected = await consola.prompt("Select a project:", {
+				type: "select",
+				options: projects.map((p) => ({ label: p.name, value: p.id })),
+			});
+
+			if (!selected || typeof selected !== "string") {
+				consola.error("No project selected.");
+				process.exit(1);
+			}
+
+			projectId = selected;
+			projectName = projects.find((p) => p.id === selected)!.name;
+		}
+
+		await saveProjectConfig(process.cwd(), {
+			project_id: projectId,
+			project_name: projectName,
+		});
+
+		consola.success(`Linked to project "${projectName}" (${projectId})`);
+		consola.info("Created app-hosting.json");
+	},
+});

package/src/commands/login.ts

@@ -0,0 +1,44 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { loadConfig, saveConfig } from "../config";
+
+export const loginCommand = defineCommand({
+	meta: {
+		name: "login",
+		description: "Store a deploy token for authentication",
+	},
+	args: {
+		token: {
+			type: "string",
+			description: "Deploy token from the web UI",
+			required: false,
+		},
+		"api-url": {
+			type: "string",
+			description: "API base URL",
+			required: false,
+		},
+	},
+	async run({ args }) {
+		const config = await loadConfig();
+
+		let token = args.token;
+		if (!token) {
+			token = await consola.prompt("Enter your deploy token:", {
+				type: "text",
+			});
+			if (!token || typeof token !== "string") {
+				consola.error("No token provided.");
+				process.exit(1);
+			}
+		}
+
+		config.token = token;
+		if (args["api-url"]) {
+			config.apiUrl = args["api-url"];
+		}
+
+		await saveConfig(config);
+		consola.success("Token saved. You can now use `deploy` and other commands.");
+	},
+});

package/src/commands/logout.ts

@@ -0,0 +1,16 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { loadConfig, saveConfig } from "../config";
+
+export const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Remove stored credentials",
+	},
+	async run() {
+		const config = await loadConfig();
+		delete config.token;
+		await saveConfig(config);
+		consola.success("Logged out.");
+	},
+});

package/src/commands/projects.ts

@@ -0,0 +1,38 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { createClient } from "../trpc";
+
+export const projectsCommand = defineCommand({
+	meta: {
+		name: "projects",
+		description: "Manage projects",
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List your projects",
+			},
+			async run() {
+				const client = await createClient();
+				const projects = await client.projects.list.query();
+
+				if (projects.length === 0) {
+					consola.info("No projects yet.");
+					return;
+				}
+
+				consola.log("");
+				for (const p of projects) {
+					consola.log(`  ${p.name}`);
+					consola.log(`    ID:        ${p.id}`);
+					consola.log(`    Subdomain: ${p.subdomain}`);
+					if (p.description) {
+						consola.log(`    Desc:      ${p.description}`);
+					}
+					consola.log("");
+				}
+			},
+		}),
+	},
+});

package/src/config.ts

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
+interface Config {
+	token?: string;
+	apiUrl?: string;
+}
+
+const CONFIG_DIR = join(homedir(), ".config", "app-hosting");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+export async function loadConfig(): Promise<Config> {
+	try {
+		const data = await readFile(CONFIG_FILE, "utf-8");
+		return JSON.parse(data) as Config;
+	} catch {
+		return {};
+	}
+}
+
+export async function saveConfig(config: Config): Promise<void> {
+	await mkdir(CONFIG_DIR, { recursive: true });
+	await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+export function getApiUrl(config: Config): string {
+	return "https://sw-test-app-hosting.click";
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+import { loginCommand } from "./commands/login";
+import { logoutCommand } from "./commands/logout";
+import { initCommand } from "./commands/init";
+import { deployCommand } from "./commands/deploy";
+import { devCommand } from "./commands/dev";
+import { projectsCommand } from "./commands/projects";
+
+const main = defineCommand({
+	meta: {
+		name: "app-hosting",
+		version: "0.0.1",
+		description: "CLI for App Hosting platform",
+	},
+	subCommands: {
+		login: loginCommand,
+		logout: logoutCommand,
+		init: initCommand,
+		deploy: deployCommand,
+		dev: devCommand,
+		projects: projectsCommand,
+	},
+});
+
+runMain(main);

package/src/project.ts

@@ -0,0 +1,22 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+interface ProjectConfig {
+	project_id: string;
+	project_name: string;
+}
+
+const PROJECT_FILE = "app-hosting.json";
+
+export async function loadProjectConfig(cwd: string): Promise<ProjectConfig | null> {
+	try {
+		const data = await readFile(join(cwd, PROJECT_FILE), "utf-8");
+		return JSON.parse(data) as ProjectConfig;
+	} catch {
+		return null;
+	}
+}
+
+export async function saveProjectConfig(cwd: string, config: ProjectConfig): Promise<void> {
+	await writeFile(join(cwd, PROJECT_FILE), JSON.stringify(config, null, 2) + "\n");
+}

package/src/trpc.ts

@@ -0,0 +1,25 @@
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import type { AppRouter } from "../../src/routers";
+import { loadConfig, getApiUrl } from "./config";
+
+export async function createClient() {
+	const config = await loadConfig();
+	if (!config.token) {
+		throw new Error("Not logged in. Run `app-hosting login` first.");
+	}
+
+	const apiUrl = getApiUrl(config);
+
+	const client = createTRPCClient<AppRouter>({
+		links: [
+			httpBatchLink({
+				url: `${apiUrl}/api`,
+				headers: {
+					Authorization: `Bearer ${config.token}`,
+				},
+			}),
+		],
+	});
+
+	return client;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"compilerOptions": {
+		"target": "es2022",
+		"module": "es2022",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"types": ["node", "@cloudflare/workers-types"],
+		"noEmit": true
+	},
+	"include": ["src", "../worker-configuration.d.ts"]
+}