feat: Add run subcommand for executing source files in Codize sandbox

Co-Authored-By: Claude <noreply@anthropic.com>

Author: koki-develop

src/commands/run.ts

@@ -0,0 +1,104 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { CodizeApiError, CodizeClient } from "@codize/sdk";
+import type { Command } from "commander";
+import { CliError } from "../error.ts";
+
+const EXTENSION_TO_LANGUAGE: Record<string, string> = {
+  ".ts": "typescript",
+  ".js": "javascript",
+  ".py": "python",
+  ".rb": "ruby",
+  ".go": "go",
+  ".rs": "rust",
+};
+
+function detectLanguage(filePath: string): string | null {
+  const ext = extname(filePath).toLowerCase();
+  return EXTENSION_TO_LANGUAGE[ext] ?? null;
+}
+
+function resolveLanguage(files: string[]): string {
+  const entrypoint = files[0];
+  if (entrypoint == null) {
+    throw new CliError("No files specified.");
+  }
+  const detected = detectLanguage(entrypoint);
+  if (detected == null) {
+    throw new CliError(
+      `Cannot detect language for '${entrypoint}'. Use --language to specify.`,
+    );
+  }
+  return detected;
+}
+
+function readFiles(files: string[]): { name: string; content: string }[] {
+  return files.map((filePath) => {
+    let content: string;
+    try {
+      content = readFileSync(filePath, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new CliError(`Cannot read file '${filePath}': ${message}`);
+    }
+    return { name: basename(filePath), content };
+  });
+}
+
+export function registerRunCommand(program: Command): void {
+  program
+    .command("run")
+    .description("Execute source files in the Codize sandbox")
+    .argument("<files...>", "Source files to execute")
+    .option(
+      "-l, --language <language>",
+      "Language override (auto-detected from extension by default)",
+    )
+    .option(
+      "-k, --api-key <key>",
+      "Codize API key (defaults to CODIZE_API_KEY env var)",
+    )
+    .action(
+      async (
+        files: string[],
+        options: { language?: string; apiKey?: string },
+      ) => {
+        const apiKey = options.apiKey ?? process.env["CODIZE_API_KEY"];
+        if (!apiKey) {
+          throw new CliError(
+            "API key is required. Set CODIZE_API_KEY or use --api-key.",
+          );
+        }
+
+        const language = options.language ?? resolveLanguage(files);
+        const filePayloads = readFiles(files);
+
+        const client = new CodizeClient({ apiKey });
+        let result: Awaited<ReturnType<typeof client.sandbox.execute>>;
+        try {
+          result = await client.sandbox.execute({
+            language,
+            files: filePayloads,
+          });
+        } catch (err) {
+          if (err instanceof CodizeApiError) {
+            throw new CliError(
+              `API error [${err.code}] ${err.message} (HTTP ${err.status})`,
+            );
+          }
+          throw err;
+        }
+
+        if (result.data.compile != null && result.data.compile.output !== "") {
+          process.stderr.write(result.data.compile.output);
+        }
+
+        process.stdout.write(result.data.run.output);
+        if (result.data.compile != null && result.data.compile.exitCode !== 0) {
+          process.exitCode = result.data.compile.exitCode ?? 1;
+        } else {
+          process.exitCode = result.data.run.exitCode ?? 1;
+        }
+      },
+    );
+}

src/error.ts

@@ -0,0 +1,9 @@
+export class CliError extends Error {
+  readonly exitCode: number;
+
+  constructor(message: string, exitCode: number = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}

src/index.ts

@@ -1,13 +1,19 @@
 import { Command } from "commander";
 import packageJson from "../package.json" with { type: "json" };
+import { CliError } from "./error.ts";
+import { registerRunCommand } from "./commands/run.ts";
 
 const program = new Command();
 
-program
-  .name("TODO")
-  .version(packageJson.version)
-  .action(() => {
-    console.log("hello world");
-  });
+program.name("codize").version(packageJson.version);
 
-program.parse(process.argv);
+registerRunCommand(program);
+
+program.parseAsync(process.argv).catch((err: unknown) => {
+  const message =
+    err instanceof CliError
+      ? err.message
+      : `Unexpected error: ${err instanceof Error ? err.message : String(err)}`;
+  process.stderr.write(`error: ${message}\n`);
+  process.exit(err instanceof CliError ? err.exitCode : 1);
+});