playcademy 0.15.6 → 0.16.1

package/dist/index.js

@@ -3976,7 +3976,7 @@ import { join as join12 } from "path";
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "playcademy",
-  version: "0.15.5",
+  version: "0.16.0",
   type: "module",
   exports: {
     ".": {
@@ -10625,7 +10625,7 @@ var getStatusCommand = new Command13("status").description("Check your developer
 });
 
 // package.json
-var version2 = "0.15.5";
+var version2 = "0.16.0";
 
 // src/commands/dev/server.ts
 function setupCleanupHandlers(workspace, getServer) {
@@ -11577,96 +11577,155 @@ import { Command as Command20 } from "commander";
 import { join as join38 } from "path";
 import { confirm as confirm11 } from "@inquirer/prompts";
 import { Miniflare as Miniflare4 } from "miniflare";
-async function runKVClear(options = {}) {
-  try {
+async function runKVClearRemote(options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const keys = await client.dev.games.kv.list(game.slug);
+  const keyCount = keys.length;
+  if (keyCount === 0) {
+    if (options.json) {
+      logger.json({
+        success: true,
+        deleted: 0,
+        message: "No keys to clear",
+        environment
+      });
+    } else if (options.raw) {
+      logger.raw("0");
+    } else {
+      logger.remark(`No keys found in ${environment} KV namespace`);
+      logger.newLine();
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    return;
+  }
+  if (!options.force && !options.raw && !options.json) {
+    logger.warn(
+      `This will delete ${keyCount} ${pluralize(keyCount, "key")} from ${environment}`
+    );
+    logger.newLine();
+    const confirmed = await confirm11({
+      message: "Are you sure you want to clear all keys?",
+      default: false
+    });
+    if (!confirmed) {
+      logger.remark("Cancelled");
+      logger.newLine();
+      return;
     }
-    const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare4({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+    logger.newLine();
+  }
+  const deleted = await client.dev.games.kv.clear(game.slug);
+  if (options.json) {
+    logger.json({
+      success: true,
+      deleted,
+      environment
     });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const listResult = await kv.list();
-      const keyCount = listResult.keys?.length || 0;
-      if (keyCount === 0) {
-        if (options.json) {
-          logger.json({
-            success: true,
-            deleted: 0,
-            message: "No keys to clear"
-          });
-        } else if (options.raw) {
-          logger.raw("0");
-        } else {
-          logger.newLine();
-          logger.remark("No keys found in KV namespace");
-          logger.newLine();
-        }
-        return;
-      }
-      if (!options.force && !options.raw && !options.json) {
-        logger.warn(`This will delete ${keyCount} ${pluralize(keyCount, "key")}`);
-        logger.newLine();
-        const confirmed = await confirm11({
-          message: "Are you sure you want to clear all keys?",
-          default: false
-        });
-        if (!confirmed) {
-          logger.remark("Cancelled");
-          logger.newLine();
-          return;
-        }
-        logger.newLine();
-      }
-      const keys = listResult.keys || [];
-      for (const key of keys) {
-        await kv.delete(key.name);
-      }
+  } else if (options.raw) {
+    logger.raw(deleted.toString());
+  } else {
+    logger.success(`Deleted ${deleted} ${pluralize(deleted, "key")} from ${environment}`);
+    logger.newLine();
+  }
+}
+async function runKVClearLocal(options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join38(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare4({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const listResult = await kv.list();
+    const keyCount = listResult.keys?.length || 0;
+    if (keyCount === 0) {
       if (options.json) {
         logger.json({
           success: true,
-          deleted: keyCount
+          deleted: 0,
+          message: "No keys to clear"
         });
       } else if (options.raw) {
-        logger.raw(keyCount.toString());
+        logger.raw("0");
       } else {
-        logger.success(`Deleted ${keyCount} ${pluralize(keyCount, "key")}`);
         logger.newLine();
+        logger.remark("No keys found in KV namespace");
+        logger.newLine();
+      }
+      return;
+    }
+    if (!options.force && !options.raw && !options.json) {
+      logger.warn(`This will delete ${keyCount} ${pluralize(keyCount, "key")}`);
+      logger.newLine();
+      const confirmed = await confirm11({
+        message: "Are you sure you want to clear all keys?",
+        default: false
+      });
+      if (!confirmed) {
+        logger.remark("Cancelled");
+        logger.newLine();
+        return;
       }
-    } finally {
-      await mf.dispose();
+      logger.newLine();
+    }
+    const keys = listResult.keys || [];
+    for (const key of keys) {
+      await kv.delete(key.name);
+    }
+    if (options.json) {
+      logger.json({
+        success: true,
+        deleted: keyCount
+      });
+    } else if (options.raw) {
+      logger.raw(keyCount.toString());
+    } else {
+      logger.success(`Deleted ${keyCount} ${pluralize(keyCount, "key")}`);
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVClear(options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
+    if (options.remote) {
+      await runKVClearRemote(options);
+    } else {
+      await runKVClearLocal(options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -11681,24 +11740,107 @@ async function runKVClear(options = {}) {
 
 // src/commands/kv/delete.ts
 import { join as join39 } from "path";
+import { confirm as confirm12 } from "@inquirer/prompts";
 import { Miniflare as Miniflare5 } from "miniflare";
-async function runKVDelete(key, options = {}) {
-  try {
+async function runKVDeleteRemote(key, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  if (!options.force && !options.raw && !options.json) {
+    const confirmed = await confirm12({
+      message: `Delete key "${key}" from ${environment}?`,
+      default: false
+    });
+    if (!confirmed) {
+      logger.remark("Cancelled");
+      logger.newLine();
+      return;
+    }
+    logger.newLine();
+  }
+  await client.dev.games.kv.delete(game.slug, key);
+  if (options.json) {
+    logger.json({
+      key,
+      success: true,
+      environment
+    });
+  } else if (options.raw) {
+    logger.raw("ok");
+  } else {
+    logger.success(`Deleted key: ${key} from ${environment}`);
+    logger.newLine();
+  }
+}
+async function runKVDeleteLocal(key, options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join39(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare5({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    if (!options.force && !options.raw && !options.json) {
+      const confirmed = await confirm12({
+        message: `Delete key "${key}"?`,
+        default: false
+      });
+      if (!confirmed) {
+        logger.remark("Cancelled");
         logger.newLine();
+        return;
       }
-      process.exit(1);
+      logger.newLine();
+    }
+    await kv.delete(key);
+    if (options.json) {
+      logger.json({
+        key,
+        success: true
+      });
+    } else if (options.raw) {
+      logger.raw("ok");
+    } else {
+      logger.success(`Deleted key: ${key}`);
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVDelete(key, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
     }
     if (!key) {
       if (!options.raw && !options.json) {
@@ -11709,43 +11851,10 @@ async function runKVDelete(key, options = {}) {
       }
       process.exit(1);
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    const kvDir = join39(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare5({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      await kv.delete(key);
-      if (options.json) {
-        logger.json({
-          key,
-          success: true
-        });
-      } else if (options.raw) {
-        logger.raw("ok");
-      } else {
-        logger.success(`Deleted key: ${key}`);
-        logger.newLine();
-      }
-    } finally {
-      await mf.dispose();
+    if (options.remote) {
+      await runKVDeleteRemote(key, options);
+    } else {
+      await runKVDeleteLocal(key, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -11761,98 +11870,154 @@ async function runKVDelete(key, options = {}) {
 // src/commands/kv/get.ts
 import { join as join40 } from "path";
 import { Miniflare as Miniflare6 } from "miniflare";
-async function runKVGet(key, options = {}) {
-  try {
+async function runKVGetRemote(key, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    if (!key) {
-      if (!options.raw && !options.json) {
-        logger.error("Key is required");
-        logger.newLine();
-        logger.admonition("tip", "Usage", ["`playcademy kv get <key>`"]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const value = await client.dev.games.kv.get(game.slug, key);
+  if (value === null) {
+    if (!options.raw && !options.json) {
+      logger.warn(`Key '${key}' not found in ${environment}`);
+      logger.newLine();
+      logger.admonition("tip", "Hint", [
+        "Use `playcademy kv list --remote` to see all available keys"
+      ]);
+      logger.newLine();
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
+    process.exit(1);
+  }
+  let parsedValue;
+  let isJson = false;
+  try {
+    parsedValue = JSON.parse(value);
+    isJson = true;
+  } catch {
+    parsedValue = value;
+  }
+  if (options.json) {
+    if (isJson) {
+      logger.json(parsedValue);
+    } else {
+      logger.json(value);
+    }
+    return;
+  }
+  if (options.raw) {
+    logger.raw(value);
+    return;
+  }
+  logger.data("Key", key, 1);
+  if (isJson) {
+    logger.newLine();
+    logger.data("Value", "", 1);
+    logger.newLine();
+    logger.json(parsedValue, 2);
+  } else {
+    logger.data("Value", value, 1);
+  }
+  logger.newLine();
+}
+async function runKVGetLocal(key, options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join40(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare6({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const value = await kv.get(key, "text");
+    if (value === null) {
       if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
+        logger.warn(`Key '${key}' not found`);
         logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+        logger.admonition("tip", "Hint", [
+          "Use `playcademy kv list` to see all available keys"
         ]);
         logger.newLine();
       }
       process.exit(1);
     }
-    const kvDir = join40(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare6({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
+    let parsedValue;
+    let isJson = false;
     try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const value = await kv.get(key, "text");
-      if (value === null) {
-        if (!options.raw && !options.json) {
-          logger.warn(`Key '${key}' not found`);
-          logger.newLine();
-          logger.admonition("tip", "Hint", [
-            "Use `playcademy kv list` to see all available keys"
-          ]);
-          logger.newLine();
-        }
-        process.exit(1);
-      }
-      let parsedValue;
-      let isJson = false;
-      try {
-        parsedValue = JSON.parse(value);
-        isJson = true;
-      } catch {
-        parsedValue = value;
-      }
-      if (options.json) {
-        if (isJson) {
-          logger.json(parsedValue);
-        } else {
-          logger.json(value);
-        }
-        return;
-      }
-      if (options.raw) {
-        logger.raw(value);
-        return;
-      }
-      logger.success(`Key: ${key}`);
-      logger.newLine();
+      parsedValue = JSON.parse(value);
+      isJson = true;
+    } catch {
+      parsedValue = value;
+    }
+    if (options.json) {
       if (isJson) {
-        logger.json(parsedValue, 1);
+        logger.json(parsedValue);
       } else {
-        logger.data("Value", value, 1);
+        logger.json(value);
       }
+      return;
+    }
+    if (options.raw) {
+      logger.raw(value);
+      return;
+    }
+    logger.data("Key", key, 1);
+    if (isJson) {
       logger.newLine();
-    } finally {
-      await mf.dispose();
+      logger.data("Value", "", 1);
+      logger.newLine();
+      logger.json(parsedValue, 2);
+    } else {
+      logger.data("Value", value, 1);
+    }
+    logger.newLine();
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVGet(key, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
+    if (!key) {
+      if (!options.raw && !options.json) {
+        logger.error("Key is required");
+        logger.newLine();
+        logger.admonition("tip", "Usage", ["`playcademy kv get <key>`"]);
+        logger.newLine();
+      }
+      process.exit(1);
+    }
+    if (options.remote) {
+      await runKVGetRemote(key, options);
+    } else {
+      await runKVGetLocal(key, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -11935,24 +12100,192 @@ async function runKVInit() {
 // src/commands/kv/inspect.ts
 import { join as join41 } from "path";
 import { Miniflare as Miniflare7 } from "miniflare";
-async function runKVInspect(key, options = {}) {
+async function runKVInspectRemote(key, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
+    if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const [value, metadata] = await Promise.all([
+    client.dev.games.kv.get(game.slug, key),
+    client.dev.games.kv.inspect(game.slug, key)
+  ]);
+  if (value === null) {
+    const result2 = {
+      key,
+      exists: false
+    };
+    if (options.json) {
+      logger.json(result2);
+    } else if (!options.raw) {
+      logger.warn(`Key '${key}' not found in ${environment}`);
+      logger.newLine();
+      logger.admonition("tip", "Hint", [
+        "Use `playcademy kv list --remote` to see all available keys"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const size = new Blob([value]).size;
+  let parsedValue;
+  let valueType = "string";
   try {
+    parsedValue = JSON.parse(value);
+    valueType = "json";
+  } catch {
+    parsedValue = value;
+  }
+  const result = {
+    key,
+    exists: true,
+    size,
+    value: parsedValue,
+    valueType,
+    customMetadata: metadata?.metadata
+  };
+  if (options.json) {
+    logger.json(result);
+  } else if (options.raw) {
+    logger.raw(size.toString());
+  } else {
+    logger.data("Key", key, 1);
+    const sizeKB = (size / 1024).toFixed(2);
+    const sizeDisplay = size >= 1024 ? `${sizeKB} KB` : `${size} bytes`;
+    logger.data("Size", sizeDisplay, 1);
+    logger.data("Type", valueType === "json" ? "JSON" : "String", 1);
+    logger.newLine();
+    logger.data("Environment", environment, 1);
+    if (result.customMetadata && Object.keys(result.customMetadata).length > 0) {
+      logger.newLine();
+      logger.data("Custom Metadata:", "", 1);
+      logger.json(result.customMetadata, 2);
+    }
+    logger.newLine();
+    logger.data("Value", "", 1);
+    logger.newLine();
+    if (valueType === "json") {
+      logger.json(parsedValue, 2);
+    } else {
+      const lines = value.split("\n");
+      const maxLines = 5;
+      const preview = lines.slice(0, maxLines);
+      for (const line of preview) {
+        logger.raw(line, 2);
+      }
+      if (lines.length > maxLines) {
+        logger.raw(`... (${lines.length - maxLines} more lines)`, 2);
+      }
+    }
+    logger.newLine();
+  }
+}
+async function runKVInspectLocal(key, options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
     if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
+    process.exit(1);
+  }
+  const kvDir = join41(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare7({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const value = await kv.get(key, "text");
+    if (value === null) {
+      const metadata2 = {
+        key,
+        exists: false
+      };
+      if (options.json) {
+        logger.json(metadata2);
+      } else if (!options.raw) {
+        logger.warn(`Key '${key}' not found`);
         logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
+        logger.admonition("tip", "Hint", [
+          "Use `playcademy kv list` to see all available keys"
         ]);
         logger.newLine();
       }
       process.exit(1);
     }
+    const size = new Blob([value]).size;
+    let parsedValue;
+    let valueType = "string";
+    try {
+      parsedValue = JSON.parse(value);
+      valueType = "json";
+    } catch {
+      parsedValue = value;
+    }
+    const metadata = {
+      key,
+      exists: true,
+      size,
+      value: parsedValue,
+      valueType
+    };
+    if (options.json) {
+      logger.json(metadata);
+    } else if (options.raw) {
+      logger.raw(size.toString());
+    } else {
+      logger.data("Key", key, 1);
+      const sizeKB = (size / 1024).toFixed(2);
+      const sizeDisplay = size >= 1024 ? `${sizeKB} KB` : `${size} bytes`;
+      logger.data("Size", sizeDisplay, 1);
+      logger.data("Type", valueType === "json" ? "JSON" : "String", 1);
+      logger.newLine();
+      logger.data("Value", "", 1);
+      logger.newLine();
+      if (valueType === "json") {
+        logger.json(parsedValue, 2);
+      } else {
+        const lines = value.split("\n");
+        const maxLines = 5;
+        const preview = lines.slice(0, maxLines);
+        for (const line of preview) {
+          logger.raw(line, 2);
+        }
+        if (lines.length > maxLines) {
+          logger.raw(`... (${lines.length - maxLines} more lines)`, 2);
+        }
+      }
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVInspect(key, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
     if (!key) {
       if (!options.raw && !options.json) {
         logger.error("Key is required");
@@ -11962,93 +12295,10 @@ async function runKVInspect(key, options = {}) {
       }
       process.exit(1);
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    const kvDir = join41(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare7({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const value = await kv.get(key, "text");
-      if (value === null) {
-        const metadata2 = {
-          key,
-          exists: false
-        };
-        if (options.json) {
-          logger.json(metadata2);
-        } else if (!options.raw) {
-          logger.warn(`Key '${key}' not found`);
-          logger.newLine();
-          logger.admonition("tip", "Hint", [
-            "Use `playcademy kv list` to see all available keys"
-          ]);
-          logger.newLine();
-        }
-        process.exit(1);
-      }
-      const size = new Blob([value]).size;
-      let parsedValue;
-      let valueType = "string";
-      try {
-        parsedValue = JSON.parse(value);
-        valueType = "json";
-      } catch {
-        parsedValue = value;
-      }
-      const metadata = {
-        key,
-        exists: true,
-        size,
-        value: parsedValue,
-        valueType
-      };
-      if (options.json) {
-        logger.json(metadata);
-      } else if (options.raw) {
-        logger.raw(size.toString());
-      } else {
-        logger.success(`Key: ${key}`);
-        logger.newLine();
-        const sizeKB = (size / 1024).toFixed(2);
-        const sizeDisplay = size >= 1024 ? `${sizeKB} KB` : `${size} bytes`;
-        logger.data("Size", sizeDisplay, 1);
-        logger.data("Type", valueType === "json" ? "JSON" : "String", 1);
-        logger.newLine();
-        logger.data("Value", "", 1);
-        if (valueType === "json") {
-          logger.json(parsedValue, 2);
-        } else {
-          const lines = value.split("\n");
-          const maxLines = 5;
-          const preview = lines.slice(0, maxLines);
-          for (const line of preview) {
-            logger.dim(line, 2);
-          }
-          if (lines.length > maxLines) {
-            logger.dim(`... (${lines.length - maxLines} more lines)`, 2);
-          }
-        }
-        logger.newLine();
-      }
-    } finally {
-      await mf.dispose();
+    if (options.remote) {
+      await runKVInspectRemote(key, options);
+    } else {
+      await runKVInspectLocal(key, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -12064,71 +12314,112 @@ async function runKVInspect(key, options = {}) {
 // src/commands/kv/list.ts
 import { join as join42 } from "path";
 import { Miniflare as Miniflare8 } from "miniflare";
-async function runKVList(options = {}) {
-  try {
+async function runKVListRemote(options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const keys = await client.dev.games.kv.list(game.slug, options.prefix);
+  if (options.json) {
+    logger.json(keys);
+    return;
+  }
+  if (options.raw) {
+    for (const key of keys) {
+      logger.raw(key.name);
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    return;
+  }
+  if (keys.length === 0) {
+    logger.remark("No keys found");
+    if (options.prefix) {
+      logger.newLine();
+      logger.data("Prefix", options.prefix, 1);
     }
-    const kvDir = join42(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare8({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const listResult = await kv.list();
-      const keyNames = listResult.keys?.map((k) => k.name) || [];
-      if (options.json) {
-        logger.json(keyNames);
-        return;
-      }
-      if (options.raw) {
-        for (const keyName of keyNames) {
-          logger.raw(keyName);
-        }
-        return;
+    logger.newLine();
+    return;
+  }
+  logger.success(`Found ${keys.length} ${pluralize(keys.length, "key")} in ${environment}`);
+  if (options.prefix) {
+    logger.data("Prefix", options.prefix, 1);
+  }
+  logger.newLine();
+  for (const key of keys) {
+    logger.bold(key.name, 1);
+  }
+  logger.newLine();
+}
+async function runKVListLocal(options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join42(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare8({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const listResult = await kv.list({ prefix: options.prefix });
+    const keyNames = listResult.keys?.map((k) => k.name) || [];
+    if (options.json) {
+      logger.json(keyNames);
+      return;
+    }
+    if (options.raw) {
+      for (const keyName of keyNames) {
+        logger.raw(keyName);
       }
-      if (keyNames.length === 0) {
-        logger.remark("No keys found in KV namespace");
-      } else {
-        logger.success(`Found ${keyNames.length} ${pluralize(keyNames.length, "key")}`);
-        logger.newLine();
-        for (const keyName of keyNames) {
-          logger.bold(keyName, 1);
-        }
+      return;
+    }
+    if (keyNames.length === 0) {
+      logger.remark("No keys found in KV namespace");
+    } else {
+      logger.success(`Found ${keyNames.length} ${pluralize(keyNames.length, "key")}`);
+      logger.newLine();
+      for (const keyName of keyNames) {
+        logger.bold(keyName, 1);
       }
+    }
+    logger.newLine();
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVList(options = {}) {
+  try {
+    if (!options.raw && !options.json) {
       logger.newLine();
-    } finally {
-      await mf.dispose();
+    }
+    if (options.remote) {
+      await runKVListRemote(options);
+    } else {
+      await runKVListLocal(options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -12144,25 +12435,196 @@ async function runKVList(options = {}) {
 // src/commands/kv/seed.ts
 init_file_loader();
 import { join as join43 } from "path";
-import { confirm as confirm12 } from "@inquirer/prompts";
+import { confirm as confirm13 } from "@inquirer/prompts";
+import { underline as underline5 } from "colorette";
 import { Miniflare as Miniflare9 } from "miniflare";
-async function runKVSeed(seedFile, options = {}) {
-  try {
+async function runKVSeedRemote(seedFile, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
+    process.exit(1);
+  }
+  const seedData = await loadFile(seedFile, {
+    cwd: workspace,
+    parseJson: true
+  });
+  if (!seedData) {
+    if (!options.raw && !options.json) {
+      logger.error(`Seed file not found: ${seedFile}`);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  if (typeof seedData !== "object" || seedData === null || Array.isArray(seedData)) {
+    if (!options.raw && !options.json) {
+      logger.error("Seed file must contain a JSON object");
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const keysToSeed = Object.keys(seedData);
+  if (!options.force && !options.raw && !options.json) {
+    logger.bold(
+      `Found ${underline5(keysToSeed.length.toString())} ${underline5(pluralize(keysToSeed.length, "key"))} to seed to ${environment}`
+    );
+    if (options.replace) {
+      logger.warn("All existing keys will be cleared first");
+    }
+    logger.newLine();
+    const confirmed = await confirm13({
+      message: "Continue seeding?",
+      default: false
+    });
+    if (!confirmed) {
+      logger.remark("Cancelled");
+      logger.newLine();
+      return;
+    }
+    logger.newLine();
+  }
+  if (options.replace) {
+    await client.dev.games.kv.clear(game.slug);
+  }
+  const entries = keysToSeed.map((key) => {
+    const value = seedData[key];
+    const valueString = typeof value === "string" ? value : JSON.stringify(value);
+    return { key, value: valueString };
+  });
+  const seededCount = await client.dev.games.kv.seed(game.slug, entries);
+  if (options.json) {
+    logger.json({
+      success: true,
+      seeded: seededCount,
+      environment,
+      ...options.replace && { cleared: true }
+    });
+  } else if (options.raw) {
+    logger.raw(seededCount.toString());
+  } else {
+    if (options.replace) {
+      logger.success("Cleared existing keys");
+    }
+    logger.success(`Seeded ${seededCount} ${pluralize(seededCount, "key")} to ${environment}`);
+    logger.newLine();
+  }
+}
+async function runKVSeedLocal(seedFile, options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const workspace = getWorkspace();
+  const seedData = await loadFile(seedFile, {
+    cwd: workspace,
+    parseJson: true
+  });
+  if (!seedData) {
+    if (!options.raw && !options.json) {
+      logger.error(`Seed file not found: ${seedFile}`);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  if (typeof seedData !== "object" || seedData === null || Array.isArray(seedData)) {
+    if (!options.raw && !options.json) {
+      logger.error("Seed file must contain a JSON object");
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join43(workspace, CLI_DIRECTORIES.KV);
+  const mf = new Miniflare9({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const keysToSeed = Object.keys(seedData);
+    if (!options.force && !options.replace && !options.raw && !options.json) {
+      const existingKeys = [];
+      for (const key of keysToSeed) {
+        const existingValue = await kv.get(key);
+        if (existingValue !== null) {
+          existingKeys.push(key);
+        }
+      }
+      if (existingKeys.length > 0) {
+        logger.warn(
+          `${existingKeys.length} ${pluralize(existingKeys.length, "key")} will be overwritten`
+        );
         logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
+        const confirmed = await confirm13({
+          message: "Continue seeding?",
+          default: false
+        });
+        if (!confirmed) {
+          logger.remark("Cancelled");
+          logger.newLine();
+          return;
+        }
         logger.newLine();
       }
-      process.exit(1);
+    }
+    if (options.replace) {
+      const listResult = await kv.list();
+      const existingKeys = listResult.keys || [];
+      for (const key of existingKeys) {
+        await kv.delete(key.name);
+      }
+    }
+    let seededCount = 0;
+    for (const key of keysToSeed) {
+      const value = seedData[key];
+      const valueString = typeof value === "string" ? value : JSON.stringify(value);
+      await kv.put(key, valueString);
+      seededCount++;
+    }
+    if (options.json) {
+      logger.json({
+        success: true,
+        seeded: seededCount,
+        ...options.replace && { cleared: true }
+      });
+    } else if (options.raw) {
+      logger.raw(seededCount.toString());
+    } else {
+      if (options.replace) {
+        logger.success("Cleared existing keys");
+      }
+      logger.success(`Seeded ${seededCount} ${pluralize(seededCount, "key")}`);
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVSeed(seedFile, options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
     }
     if (!seedFile) {
       if (!options.raw && !options.json) {
@@ -12178,105 +12640,10 @@ async function runKVSeed(seedFile, options = {}) {
       }
       process.exit(1);
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    const workspace = getWorkspace();
-    const seedData = await loadFile(seedFile, {
-      cwd: workspace,
-      parseJson: true
-    });
-    if (!seedData) {
-      if (!options.raw && !options.json) {
-        logger.error(`Seed file not found: ${seedFile}`);
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    if (typeof seedData !== "object" || seedData === null || Array.isArray(seedData)) {
-      if (!options.raw && !options.json) {
-        logger.error("Seed file must contain a JSON object");
-        logger.newLine();
-      }
-      process.exit(1);
-    }
-    const kvDir = join43(workspace, CLI_DIRECTORIES.KV);
-    const mf = new Miniflare9({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const keysToSeed = Object.keys(seedData);
-      if (!options.force && !options.replace && !options.raw && !options.json) {
-        const existingKeys = [];
-        for (const key of keysToSeed) {
-          const existingValue = await kv.get(key);
-          if (existingValue !== null) {
-            existingKeys.push(key);
-          }
-        }
-        if (existingKeys.length > 0) {
-          logger.warn(
-            `${existingKeys.length} ${pluralize(existingKeys.length, "key")} will be overwritten`
-          );
-          logger.newLine();
-          const confirmed = await confirm12({
-            message: "Continue seeding?",
-            default: false
-          });
-          if (!confirmed) {
-            logger.remark("Cancelled");
-            logger.newLine();
-            return;
-          }
-          logger.newLine();
-        }
-      }
-      if (options.replace) {
-        const listResult = await kv.list();
-        const existingKeys = listResult.keys || [];
-        for (const key of existingKeys) {
-          await kv.delete(key.name);
-        }
-      }
-      let seededCount = 0;
-      for (const key of keysToSeed) {
-        const value = seedData[key];
-        const valueString = typeof value === "string" ? value : JSON.stringify(value);
-        await kv.put(key, valueString);
-        seededCount++;
-      }
-      if (options.json) {
-        logger.json({
-          success: true,
-          seeded: seededCount,
-          ...options.replace && { cleared: true }
-        });
-      } else if (options.raw) {
-        logger.raw(seededCount.toString());
-      } else {
-        if (options.replace) {
-          logger.success("Cleared existing keys");
-        }
-        logger.success(`Seeded ${seededCount} ${pluralize(seededCount, "key")}`);
-        logger.newLine();
-      }
-    } finally {
-      await mf.dispose();
+    if (options.remote) {
+      await runKVSeedRemote(seedFile, options);
+    } else {
+      await runKVSeedLocal(seedFile, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -12293,67 +12660,133 @@ async function runKVSeed(seedFile, options = {}) {
 init_file_loader();
 import { join as join44 } from "path";
 import { Miniflare as Miniflare10 } from "miniflare";
-async function runKVSet(key, value, options = {}) {
-  try {
+async function runKVSetRemote(key, value, options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
+    process.exit(1);
+  }
+  let valueToSet;
+  if (options.file) {
+    const fileContent = await loadFile(options.file, { cwd: workspace });
+    if (!fileContent) {
       if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
+        logger.error(`File not found: ${options.file}`);
         logger.newLine();
       }
       process.exit(1);
     }
-    if (!key) {
-      if (!options.raw && !options.json) {
-        logger.error("Key is required");
-        logger.newLine();
-        logger.admonition("tip", "Usage", [
-          "`playcademy kv set <key> <value>`",
-          "`playcademy kv set <key> --file <path>`"
-        ]);
-        logger.newLine();
-      }
-      process.exit(1);
+    valueToSet = fileContent;
+  } else if (value !== void 0) {
+    valueToSet = value;
+  } else {
+    if (!options.raw && !options.json) {
+      logger.error("Value is required (either as argument or via --file)");
+      logger.newLine();
+      logger.admonition("tip", "Usage", [
+        "`playcademy kv set <key> <value> --remote`",
+        "`playcademy kv set <key> --file <path> --remote`"
+      ]);
+      logger.newLine();
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  await client.dev.games.kv.set(game.slug, key, valueToSet);
+  if (options.json) {
+    logger.json({
+      key,
+      success: true,
+      environment
+    });
+  } else if (options.raw) {
+    logger.raw("ok");
+  } else {
+    logger.success(`Set key: ${key} in ${environment}`);
+    logger.newLine();
+  }
+}
+async function runKVSetLocal(key, value, options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  let valueToSet;
+  if (options.file) {
+    const workspace = getWorkspace();
+    const fileContent = await loadFile(options.file, { cwd: workspace });
+    if (!fileContent) {
       if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
+        logger.error(`File not found: ${options.file}`);
         logger.newLine();
       }
       process.exit(1);
     }
-    let valueToSet;
-    if (options.file) {
-      const workspace = getWorkspace();
-      const fileContent = await loadFile(options.file, { cwd: workspace });
-      if (!fileContent) {
-        if (!options.raw && !options.json) {
-          logger.error(`File not found: ${options.file}`);
-          logger.newLine();
-        }
-        process.exit(1);
-      }
-      valueToSet = fileContent;
-    } else if (value !== void 0) {
-      valueToSet = value;
+    valueToSet = fileContent;
+  } else if (value !== void 0) {
+    valueToSet = value;
+  } else {
+    if (!options.raw && !options.json) {
+      logger.error("Value is required (either as argument or via --file)");
+      logger.newLine();
+      logger.admonition("tip", "Usage", [
+        "`playcademy kv set <key> <value>`",
+        "`playcademy kv set <key> --file <path>`"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join44(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare10({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    await kv.put(key, valueToSet);
+    if (options.json) {
+      logger.json({
+        key,
+        success: true
+      });
+    } else if (options.raw) {
+      logger.raw("ok");
     } else {
+      logger.success(`Set key: ${key}`);
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVSet(key, value, options = {}) {
+  try {
+    if (!key) {
       if (!options.raw && !options.json) {
-        logger.error("Value is required (either as argument or via --file)");
+        logger.error("Key is required");
         logger.newLine();
         logger.admonition("tip", "Usage", [
           "`playcademy kv set <key> <value>`",
@@ -12363,29 +12796,10 @@ async function runKVSet(key, value, options = {}) {
       }
       process.exit(1);
     }
-    const kvDir = join44(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare10({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      await kv.put(key, valueToSet);
-      if (options.json) {
-        logger.json({
-          key,
-          success: true
-        });
-      } else if (options.raw) {
-        logger.raw("ok");
-      } else {
-        logger.success(`Set key: ${key}`);
-        logger.newLine();
-      }
-    } finally {
-      await mf.dispose();
+    if (options.remote) {
+      await runKVSetRemote(key, value, options);
+    } else {
+      await runKVSetLocal(key, value, options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -12401,100 +12815,135 @@ async function runKVSet(key, value, options = {}) {
 // src/commands/kv/stats.ts
 import { join as join45 } from "path";
 import { Miniflare as Miniflare11 } from "miniflare";
-async function runKVStats(options = {}) {
-  try {
+async function runKVStatsRemote(options) {
+  const environment = ensureEnvironment(options.env);
+  const client = await requireAuthenticatedClient();
+  const workspace = getWorkspace();
+  const deployedGame = await getDeployedGame(workspace);
+  if (!deployedGame) {
     if (!options.raw && !options.json) {
+      logger.admonition("warning", "Deploy First", [
+        "Deploy your project before accessing remote KV: `playcademy deploy`"
+      ]);
       logger.newLine();
     }
-    if (options.remote) {
-      if (!options.raw && !options.json) {
-        logger.newLine();
-        logger.warn("Remote KV operations are not yet implemented");
-        logger.newLine();
-        logger.admonition("info", "Coming Soon", [
-          "Remote KV support is on the roadmap and will be available soon.",
-          "For now, KV commands only work with local development storage."
-        ]);
-        logger.newLine();
+    process.exit(1);
+  }
+  const game = await getGameById(client, deployedGame.gameId, {
+    silent: options.raw || options.json
+  });
+  const stats = await client.dev.games.kv.stats(game.slug);
+  if (options.json) {
+    logger.json(stats);
+  } else if (options.raw) {
+    logger.raw(stats.totalKeys.toString());
+  } else {
+    if (stats.totalKeys === 0) {
+      logger.remark(`No keys found in ${environment} KV namespace`);
+      logger.newLine();
+      return;
+    }
+    logger.data("Total Keys", stats.totalKeys.toString(), 1);
+    logger.data("Environment", environment, 1);
+    const sortedPrefixes = Object.entries(stats.prefixes).sort((a, b) => b[1] - a[1]);
+    if (sortedPrefixes.length > 0) {
+      logger.newLine();
+      logger.data("Keys by Prefix:", "", 1);
+      for (const [prefix, count] of sortedPrefixes) {
+        logger.dim(`${prefix.padEnd(20)} ${count} ${pluralize(count, "key")}`, 2);
       }
-      process.exit(1);
     }
-    const config = await loadConfig();
-    if (!hasKVSetup(config)) {
-      if (!options.raw && !options.json) {
-        logger.error("KV storage is not configured");
-        logger.newLine();
-        logger.admonition("tip", "Getting Started", [
-          "Run `playcademy kv init` to enable KV storage",
-          "",
-          "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
-        ]);
+    logger.newLine();
+  }
+}
+async function runKVStatsLocal(options) {
+  const config = await loadConfig();
+  if (!hasKVSetup(config)) {
+    if (!options.raw && !options.json) {
+      logger.error("KV storage is not configured");
+      logger.newLine();
+      logger.admonition("tip", "Getting Started", [
+        "Run `playcademy kv init` to enable KV storage",
+        "",
+        "Learn more: <<https://docs.playcademy.net/platform/integrations/kv>>"
+      ]);
+      logger.newLine();
+    }
+    process.exit(1);
+  }
+  const kvDir = join45(getWorkspace(), CLI_DIRECTORIES.KV);
+  const mf = new Miniflare11({
+    modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
+    kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
+    kvPersist: kvDir,
+    compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
+  });
+  try {
+    const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
+    const listResult = await kv.list();
+    const keys = listResult.keys || [];
+    let totalSize = 0;
+    let largestKey;
+    const prefixes = {};
+    for (const key of keys) {
+      const value = await kv.get(key.name, "arrayBuffer");
+      const size = value ? value.byteLength : 0;
+      totalSize += size;
+      if (!largestKey || size > largestKey.size) {
+        largestKey = { name: key.name, size };
+      }
+      const prefixMatch = key.name.match(/^([^:]+):/);
+      const prefix = prefixMatch ? `${prefixMatch[1]}:*` : "(no prefix)";
+      prefixes[prefix] = (prefixes[prefix] || 0) + 1;
+    }
+    const stats = {
+      totalKeys: keys.length,
+      totalSize,
+      largestKey,
+      prefixes
+    };
+    if (options.json) {
+      logger.json(stats);
+    } else if (options.raw) {
+      logger.raw(stats.totalKeys.toString());
+    } else {
+      if (stats.totalKeys === 0) {
+        logger.remark("No keys found in KV namespace");
         logger.newLine();
+        return;
       }
-      process.exit(1);
-    }
-    const kvDir = join45(getWorkspace(), CLI_DIRECTORIES.KV);
-    const mf = new Miniflare11({
-      modules: [{ type: "ESModule", path: "index.mjs", contents: "" }],
-      kvNamespaces: [CLOUDFLARE_BINDINGS.KV],
-      kvPersist: kvDir,
-      compatibilityDate: CLOUDFLARE_COMPATIBILITY_DATE
-    });
-    try {
-      const kv = await mf.getKVNamespace(CLOUDFLARE_BINDINGS.KV);
-      const listResult = await kv.list();
-      const keys = listResult.keys || [];
-      let totalSize = 0;
-      let largestKey;
-      const prefixes = {};
-      for (const key of keys) {
-        const value = await kv.get(key.name, "arrayBuffer");
-        const size = value ? value.byteLength : 0;
-        totalSize += size;
-        if (!largestKey || size > largestKey.size) {
-          largestKey = { name: key.name, size };
-        }
-        const prefixMatch = key.name.match(/^([^:]+):/);
-        const prefix = prefixMatch ? `${prefixMatch[1]}:*` : "(no prefix)";
-        prefixes[prefix] = (prefixes[prefix] || 0) + 1;
-      }
-      const stats = {
-        totalKeys: keys.length,
-        totalSize,
-        largestKey,
-        prefixes
-      };
-      if (options.json) {
-        logger.json(stats);
-      } else if (options.raw) {
-        logger.raw(stats.totalKeys.toString());
-      } else {
-        if (stats.totalKeys === 0) {
-          logger.remark("No keys found in KV namespace");
-          logger.newLine();
-          return;
-        }
-        logger.data("Total Keys", stats.totalKeys.toString(), 1);
-        const sizeKB = (stats.totalSize / 1024).toFixed(2);
-        const sizeMB = (stats.totalSize / 1024 / 1024).toFixed(2);
-        const sizeDisplay = stats.totalSize >= 1024 * 1024 ? `${sizeMB} MB` : `${sizeKB} KB`;
-        logger.data("Total Size", sizeDisplay, 1);
-        if (stats.largestKey) {
-          const largestKB = (stats.largestKey.size / 1024).toFixed(2);
-          logger.data("Largest Key", `${stats.largestKey.name} (${largestKB} KB)`, 1);
-        }
-        const sortedPrefixes = Object.entries(stats.prefixes).sort((a, b) => b[1] - a[1]);
-        if (sortedPrefixes.length > 0) {
-          logger.newLine();
-          logger.data("Keys by Prefix:", "", 1);
-          for (const [prefix, count] of sortedPrefixes) {
-            logger.dim(`${prefix.padEnd(20)} ${count} ${pluralize(count, "key")}`, 2);
-          }
-        }
+      logger.data("Total Keys", stats.totalKeys.toString(), 1);
+      const sizeKB = (stats.totalSize / 1024).toFixed(2);
+      const sizeMB = (stats.totalSize / 1024 / 1024).toFixed(2);
+      const sizeDisplay = stats.totalSize >= 1024 * 1024 ? `${sizeMB} MB` : `${sizeKB} KB`;
+      logger.data("Total Size", sizeDisplay, 1);
+      if (stats.largestKey) {
+        const largestKB = (stats.largestKey.size / 1024).toFixed(2);
+        logger.data("Largest Key", `${stats.largestKey.name} (${largestKB} KB)`, 1);
+      }
+      const sortedPrefixes = Object.entries(stats.prefixes).sort((a, b) => b[1] - a[1]);
+      if (sortedPrefixes.length > 0) {
         logger.newLine();
+        logger.data("Keys by Prefix:", "", 1);
+        for (const [prefix, count] of sortedPrefixes) {
+          logger.dim(`${prefix.padEnd(20)} ${count} ${pluralize(count, "key")}`, 2);
+        }
       }
-    } finally {
-      await mf.dispose();
+      logger.newLine();
+    }
+  } finally {
+    await mf.dispose();
+  }
+}
+async function runKVStats(options = {}) {
+  try {
+    if (!options.raw && !options.json) {
+      logger.newLine();
+    }
+    if (options.remote) {
+      await runKVStatsRemote(options);
+    } else {
+      await runKVStatsLocal(options);
     }
   } catch (error) {
     if (!options.raw && !options.json) {
@@ -12512,35 +12961,35 @@ var kvCommand = new Command20("kv").description("Manage KV storage integration")
   kvCommand.help();
 });
 kvCommand.command("init").description("Add KV storage integration to your project").action(runKVInit);
-kvCommand.command("list").alias("ls").description("List keys in local KV namespace (dev mode)").option("--raw", "Output key names one per line, no formatting").option("--json", "Output as JSON array").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("list").alias("ls").description("List keys in KV namespace").option("--raw", "Output key names one per line, no formatting").option("--json", "Output as JSON array").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
-).action(runKVList);
-kvCommand.command("stats").description("Show statistics about local KV namespace (dev mode)").option("--raw", "Output total key count only").option("--json", "Output statistics as JSON").option("--remote", "Use remote KV storage (not yet implemented)").option(
+).option("--prefix <prefix>", "Filter keys by prefix").action(runKVList);
+kvCommand.command("stats").description("Show statistics about KV namespace").option("--raw", "Output total key count only").option("--json", "Output statistics as JSON").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVStats);
-kvCommand.command("get <key>").description("Get value for a specific key in local KV namespace (dev mode)").option("--raw", "Output raw value without formatting").option("--json", "Force JSON pretty-printing (default for valid JSON)").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("get <key>").description("Get value for a specific key in KV namespace").option("--raw", "Output raw value without formatting").option("--json", "Force JSON pretty-printing (default for valid JSON)").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVGet);
-kvCommand.command("inspect <key>").description("Inspect metadata and value for a specific key in local KV namespace (dev mode)").option("--raw", "Output size in bytes only").option("--json", "Output metadata as JSON").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("inspect <key>").description("Inspect metadata and value for a specific key in KV namespace").option("--raw", "Output size in bytes only").option("--json", "Output metadata as JSON").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVInspect);
-kvCommand.command("set <key> [value]").description("Set a key-value pair in local KV namespace (dev mode)").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--file <path>", "Read value from file").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("set <key> [value]").description("Set a key-value pair in KV namespace").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--file <path>", "Read value from file").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVSet);
-kvCommand.command("delete <key>").alias("del").alias("rm").description("Delete a specific key from local KV namespace (dev mode)").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("delete <key>").alias("del").alias("rm").description("Delete a specific key from KV namespace").option("--raw", "Output minimal confirmation").option("--json", "Output result as JSON").option("-f, --force", "Skip confirmation prompt").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVDelete);
-kvCommand.command("clear").description("Clear all keys from local KV namespace (dev mode)").option("--raw", "Output count of deleted keys").option("--json", "Output result as JSON").option("-f, --force", "Skip confirmation prompt").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("clear").description("Clear all keys from KV namespace").option("--raw", "Output count of deleted keys").option("--json", "Output result as JSON").option("-f, --force", "Skip confirmation prompt").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVClear);
-kvCommand.command("seed <file>").description("Seed KV namespace with key-value pairs from JSON file (dev mode)").option("--raw", "Output count of seeded keys").option("--json", "Output result as JSON").option("--replace", "Clear existing keys before seeding").option("-f, --force", "Skip confirmation prompt").option("--remote", "Use remote KV storage (not yet implemented)").option(
+kvCommand.command("seed <file>").description("Seed KV namespace with key-value pairs from JSON file").option("--raw", "Output count of seeded keys").option("--json", "Output result as JSON").option("--replace", "Clear existing keys before seeding").option("-f, --force", "Skip confirmation prompt").option("--remote", "Use remote KV storage instead of local").option(
   "--env <environment>",
   "Environment to use with --remote: staging (default) or production"
 ).action(runKVSeed);
@@ -13405,7 +13854,7 @@ bucketCommand.command("bulk <directory>").description(
 import { Command as Command22 } from "commander";
 
 // src/commands/domain/add.ts
-import { underline as underline5 } from "colorette";
+import { underline as underline6 } from "colorette";
 async function runDomainAdd(hostname, options) {
   try {
     logger.newLine();
@@ -13431,7 +13880,7 @@ async function runDomainAdd(hostname, options) {
       async () => {
         return client.dev.games.domains.add(slug, normalizedHostname);
       },
-      (domain2) => `Custom domain added: ${underline5(`<https://${domain2.hostname}>`)}`
+      (domain2) => `Custom domain added: ${underline6(`<https://${domain2.hostname}>`)}`
     );
     logger.newLine();
     displayDomainValidationRecords(domain, normalizedHostname);
@@ -13456,7 +13905,7 @@ async function runDomainAdd(hostname, options) {
 }
 
 // src/commands/domain/delete.ts
-import { confirm as confirm13 } from "@inquirer/prompts";
+import { confirm as confirm14 } from "@inquirer/prompts";
 async function runDomainDelete(hostname, options) {
   try {
     logger.newLine();
@@ -13465,7 +13914,7 @@ async function runDomainDelete(hostname, options) {
     const config = await loadConfig();
     const slug = getSlugFromConfig(config);
     if (!options.force) {
-      const shouldDelete = await confirm13({
+      const shouldDelete = await confirm14({
         message: `Delete custom domain ${hostname}?`,
         default: false
       });
@@ -13548,7 +13997,7 @@ async function runDomainList(options) {
 }
 
 // src/commands/domain/verify.ts
-import { underline as underline6 } from "colorette";
+import { underline as underline7 } from "colorette";
 async function runDomainVerify(hostname, options) {
   try {
     if (!options.json) {
@@ -13575,7 +14024,7 @@ async function runDomainVerify(hostname, options) {
     displayDomainStatus(hostname, domain);
     if (domain.status === "active" && domain.sslStatus === "active") {
       logger.admonition("info", "Domain Active", [
-        `Your app is now accessible at: ${underline6(`<https://${hostname}>`)}`
+        `Your app is now accessible at: ${underline7(`<https://${hostname}>`)}`
       ]);
       logger.newLine();
     } else if (domain.status === "pending" || domain.status === "pending_validation" || domain.sslStatus === "pending_validation") {
@@ -13608,7 +14057,7 @@ domainCommand.command("delete <hostname>").description("Remove a custom domain")
 import { Command as Command26 } from "commander";
 
 // src/commands/secret/delete.ts
-import { confirm as confirm14 } from "@inquirer/prompts";
+import { confirm as confirm15 } from "@inquirer/prompts";
 import { Command as Command23 } from "commander";
 var deleteCommand2 = new Command23("delete").description("Delete a project secret").argument("<key>", "Secret key to delete").option("--env <environment>", "Environment (staging or production)").option("-f, --force", "Skip confirmation").action(async (key, options) => {
   const { env } = options;
@@ -13637,7 +14086,7 @@ var deleteCommand2 = new Command23("delete").description("Delete a project secre
       process.exit(1);
     }
     if (!options.force) {
-      const confirmed = await confirm14({
+      const confirmed = await confirm15({
         message: `Delete secret "${key}" from "${game.slug}" in ${environment}?`,
         default: false
       });
@@ -13840,7 +14289,7 @@ var removeCommand = new Command29("remove").alias("rm").description('Remove an a
 });
 
 // src/commands/profiles/reset.ts
-import { confirm as confirm15 } from "@inquirer/prompts";
+import { confirm as confirm16 } from "@inquirer/prompts";
 import { Command as Command30 } from "commander";
 var resetCommand = new Command30("reset").description(
   "Remove all authentication profiles across all environments (requires confirmation)"
@@ -13878,7 +14327,7 @@ var resetCommand = new Command30("reset").description(
         logger.newLine();
       }
     }
-    const confirmed = await confirm15({
+    const confirmed = await confirm16({
       message: "Are you sure you want to remove all profiles?",
       default: false
     });
@@ -13927,7 +14376,7 @@ profilesCommand.addCommand(resetCommand);
 import { Command as Command37 } from "commander";
 
 // src/commands/timeback/cleanup.ts
-import { confirm as confirm16 } from "@inquirer/prompts";
+import { confirm as confirm17 } from "@inquirer/prompts";
 import { Command as Command32 } from "commander";
 var cleanupCommand = new Command32("cleanup").description("Remove TimeBack integration from your project").option(
   "--env <environment>",
@@ -13951,7 +14400,7 @@ var cleanupCommand = new Command32("cleanup").description("Remove TimeBack integ
       return;
     }
     displayCleanupWarning(integrations, game.displayName, logger);
-    const confirmed = await confirm16({
+    const confirmed = await confirm17({
       message: "Are you sure you want to remove TimeBack integration?",
       default: false
     });
@@ -14313,7 +14762,7 @@ import { Command as Command40 } from "commander";
 
 // src/commands/vite/config.ts
 import path3 from "node:path";
-import { confirm as confirm17 } from "@inquirer/prompts";
+import { confirm as confirm18 } from "@inquirer/prompts";
 import { dim as dim12 } from "colorette";
 async function runViteConfig() {
   try {
@@ -14323,7 +14772,7 @@ async function runViteConfig() {
     if (!existingViteConfig) {
       logger.warn("No vite config file found in your project");
       logger.newLine();
-      const shouldCreate = await confirm17({
+      const shouldCreate = await confirm18({
         message: "Would you like to create a new vite.config.ts?",
         default: true
       });