feat(cli): implement kirie-cli v0 (#29)

Author: LemonNekoGH

packages/cli/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@gd-kirie/cli",
+  "version": "0.1.1",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/moeru-ai/godot-kirie.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "kirie": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "test:run": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "citty": "^0.2.2",
+    "execa": "9.6.1",
+    "vite": "^8.0.16"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.2",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js"
+      }
+    }
+  }
+}

packages/cli/src/cli.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+
+import packageJson from "../package.json" with { type: "json" };
+import { runDev } from "./dev";
+
+const main = defineCommand({
+  meta: {
+    description: "Kirie development tools.",
+    name: "kirie",
+    version: packageJson.version,
+  },
+  subCommands: {
+    dev: defineCommand({
+      meta: {
+        description: "Start Vite and launch Godot for desktop development.",
+        name: "dev",
+      },
+      run: () => runDev(),
+    }),
+  },
+});
+
+await runMain(main);

packages/cli/src/config.ts

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { loadConfigFromFile, type UserConfig } from "vite";
+
+export interface KirieConfig extends Record<string, unknown> {
+  godot?: {
+    args?: string[];
+    command?: string;
+    project?: string;
+  };
+  web?: {
+    root?: string;
+    vite?: UserConfig;
+  };
+}
+
+export interface ResolvedKirieConfig {
+  configFile: string;
+  cwd: string;
+  godot: {
+    args: string[];
+    command: string;
+    project: string;
+  };
+  web: {
+    root: string;
+    vite: UserConfig;
+  };
+}
+
+export function defineKirieConfig(config: KirieConfig): KirieConfig {
+  return config;
+}
+
+export async function loadKirieConfig(cwd: string = process.cwd()): Promise<ResolvedKirieConfig> {
+  const configFile = path.join(cwd, "kirie.config.ts");
+  const result = await loadConfigFromFile(
+    {
+      command: "serve",
+      isPreview: false,
+      mode: "development",
+    },
+    configFile,
+    cwd,
+  );
+
+  if (!result) {
+    throw new Error("Missing kirie.config.ts.");
+  }
+
+  return resolveKirieConfig(result.config as KirieConfig, {
+    configFile: result.path,
+    cwd,
+  });
+}
+
+export function resolveKirieConfig(
+  input: KirieConfig | undefined,
+  context: { configFile: string; cwd: string },
+): ResolvedKirieConfig {
+  const config = input ?? {};
+  const godot = config.godot ?? {};
+  const web = config.web ?? {};
+  const project = path.resolve(context.cwd, godot.project ?? ".");
+  const webRoot = path.resolve(project, web.root ?? "src-web");
+
+  return {
+    configFile: context.configFile,
+    cwd: context.cwd,
+    godot: {
+      args: godot.args ?? [],
+      command: godot.command ?? "godot",
+      project,
+    },
+    web: {
+      root: webRoot,
+      vite: web.vite ?? {},
+    },
+  };
+}

packages/cli/src/dev.test.ts

@@ -0,0 +1,134 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { runDev } from "./dev";
+
+const testProjects: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    testProjects.splice(0).map((project) => fs.rm(project, { force: true, recursive: true })),
+  );
+});
+
+describe("runDev", () => {
+  it("starts Vite and launches Godot with the resolved dev URL", async () => {
+    const project = await createProject();
+    const captureFile = path.join(project, "godot-capture.json");
+
+    await fs.writeFile(
+      path.join(project, "fake-godot.mjs"),
+      `import { writeFileSync } from "node:fs";
+
+writeFileSync("godot-capture.json", JSON.stringify({
+  argv: process.argv.slice(2),
+  cwd: process.cwd(),
+  env: {
+    KIRIE_DEV: process.env.KIRIE_DEV,
+    KIRIE_WEB_URL: process.env.KIRIE_WEB_URL,
+  },
+}));
+`,
+    );
+    await writeConfig(
+      project,
+      `{
+  godot: {
+    command: process.execPath,
+    args: ["fake-godot.mjs"],
+  },
+  web: {
+    vite: {
+      logLevel: "silent",
+    },
+  },
+}
+`,
+    );
+
+    await runDev({
+      cwd: project,
+    });
+
+    const realProject = await fs.realpath(project);
+    const capture = JSON.parse(await fs.readFile(captureFile, "utf8")) as {
+      argv: string[];
+      cwd: string;
+      env: {
+        KIRIE_DEV?: string;
+        KIRIE_WEB_URL?: string;
+      };
+    };
+
+    expect(capture.argv).toEqual(["--path", project]);
+    expect(capture.cwd).toBe(realProject);
+    expect(capture.env.KIRIE_DEV).toBe("1");
+    expect(capture.env.KIRIE_WEB_URL).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/$/);
+  });
+
+  it("rejects Kirie-owned Vite options", async () => {
+    const project = await createProject();
+    await writeConfig(
+      project,
+      `{
+  web: {
+    vite: {
+      server: {
+        port: 4321,
+      },
+    },
+  },
+}
+`,
+    );
+
+    await expect(
+      runDev({
+        cwd: project,
+      }),
+    ).rejects.toThrow("web.vite.server.port is owned by Kirie");
+  });
+
+  it("fails clearly when src-web/index.html is missing", async () => {
+    const project = await createProject({ index: false });
+    await writeConfig(
+      project,
+      `{
+  web: {
+    vite: {
+      logLevel: "silent",
+    },
+  },
+}
+`,
+    );
+
+    await expect(
+      runDev({
+        cwd: project,
+      }),
+    ).rejects.toThrow(/Kirie dev requires .*index\.html/);
+  });
+});
+
+async function createProject(options: { index?: boolean } = {}): Promise<string> {
+  const project = await fs.mkdtemp(path.join(os.tmpdir(), "kirie-cli-"));
+  testProjects.push(project);
+  await fs.mkdir(path.join(project, "src-web"), { recursive: true });
+  await fs.writeFile(path.join(project, "project.godot"), "");
+
+  if (options.index ?? true) {
+    await fs.writeFile(
+      path.join(project, "src-web", "index.html"),
+      '<main id="app">Kirie dev test</main>',
+    );
+  }
+
+  return project;
+}
+
+async function writeConfig(project: string, content: string): Promise<void> {
+  await fs.writeFile(path.join(project, "kirie.config.ts"), `export default ${content};\n`);
+}

packages/cli/src/dev.ts

@@ -0,0 +1,22 @@
+import { loadKirieConfig } from "./config";
+import { launchGodot } from "./godot";
+import { startViteDevServer } from "./vite";
+
+export interface DevOptions {
+  cwd?: string;
+}
+
+export async function runDev(options: DevOptions = {}): Promise<void> {
+  const config = await loadKirieConfig(options.cwd);
+  const vite = await startViteDevServer(config);
+  let godot: ReturnType<typeof launchGodot> | undefined;
+
+  try {
+    console.log(`Kirie dev server: ${vite.url}`);
+    godot = launchGodot(config, vite.url);
+    await godot;
+  } finally {
+    godot?.kill("SIGTERM");
+    await vite.server.close();
+  }
+}

packages/cli/src/godot.ts

@@ -0,0 +1,15 @@
+import { execa } from "execa";
+
+import type { ResolvedKirieConfig } from "./config";
+
+export function launchGodot(config: ResolvedKirieConfig, webUrl: string): ReturnType<typeof execa> {
+  return execa(config.godot.command, [...config.godot.args, "--path", config.godot.project], {
+    cwd: config.godot.project,
+    env: {
+      KIRIE_DEV: "1",
+      KIRIE_WEB_URL: webUrl,
+    },
+    forceKillAfterDelay: 5_000,
+    stdio: "inherit",
+  });
+}

packages/cli/src/index.ts

@@ -0,0 +1,7 @@
+export type {
+  KirieConfig,
+  ResolvedKirieConfig,
+} from "./config";
+export { defineKirieConfig, loadKirieConfig, resolveKirieConfig } from "./config";
+export type { DevOptions } from "./dev";
+export { runDev } from "./dev";