rooms.sh 0.0.1

package/dist/chunk-4BUZNJPJ.js

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+
+// src/lib.ts
+import { spawn } from "child_process";
+import { promises as fs, readFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+import { build } from "esbuild";
+var DEFAULT_ORIGIN = "http://localhost:3000";
+var ALLOWED_BARE_IMPORTS = /* @__PURE__ */ new Set(["@rooms.sh/sdk"]);
+var RUNTIME_SDK_SPECIFIER = "__rooms_sdk__";
+var TARGET_ENV_KEY = "ROOMS_TARGET";
+var CLI_PACKAGE_NAME = "rooms.sh";
+var SDK_PACKAGE_NAME = "@rooms.sh/sdk";
+var TYPESCRIPT_VERSION = "^5.9.3";
+var DEFAULT_ROOM_ENTRY_FILE = "room.ts";
+var DEFAULT_TSCONFIG_FILE = "tsconfig.json";
+function getPackageVersion() {
+  const packageJsonPath = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "../package.json"
+  );
+  const packageJson = JSON.parse(
+    readFileSync(packageJsonPath, "utf8")
+  );
+  return packageJson.version ?? "0.0.1";
+}
+var CLI_PACKAGE_VERSION = getPackageVersion();
+var SDK_PACKAGE_VERSION = CLI_PACKAGE_VERSION;
+function parseAgentTarget(target, options = {}) {
+  if (target.startsWith("http://") || target.startsWith("https://")) {
+    const url = new URL(target);
+    const token = url.searchParams.get("token");
+    const match = url.pathname.match(/^\/api\/agent\/rooms\/([^/]+)$/);
+    if (!token || !match?.[1]) {
+      throw new Error(
+        "Agent URL must look like /api/agent/rooms/:roomId?token=..."
+      );
+    }
+    return buildAgentTarget(url.origin, match[1], token);
+  }
+  if (!options.roomId) {
+    throw new Error("A room id is required when providing a raw token.");
+  }
+  return buildAgentTarget(options.origin ?? DEFAULT_ORIGIN, options.roomId, target);
+}
+function buildAgentTarget(origin, roomId, token) {
+  const base = new URL(`/api/agent/rooms/${roomId}`, origin);
+  base.searchParams.set("token", token);
+  const source = new URL(`/api/agent/rooms/${roomId}/source`, origin);
+  source.searchParams.set("token", token);
+  const build2 = new URL(`/api/agent/rooms/${roomId}/build`, origin);
+  build2.searchParams.set("token", token);
+  const normalizedOrigin = origin.endsWith("/") ? origin.slice(0, -1) : origin;
+  return {
+    origin,
+    roomId,
+    token,
+    contextUrl: base.toString(),
+    sourceUrl: source.toString(),
+    buildUrl: build2.toString(),
+    buildStatusUrlTemplate: `${normalizedOrigin}/api/agent/rooms/${roomId}/builds/{buildJobId}?token=${encodeURIComponent(token)}`
+  };
+}
+async function runProcess(command, args, options = {}) {
+  await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: "inherit",
+      env: process.env
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(" ")} exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+function resolveNodeCommand() {
+  const pathEntries = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
+  for (const entry of pathEntries) {
+    const candidate = path.join(entry, "node");
+    try {
+      readFileSync(candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return "node";
+}
+var NODE_COMMAND = resolveNodeCommand();
+function createNodeRequire(fromDirectory) {
+  return createRequire(path.join(fromDirectory, "__rooms_cli__.js"));
+}
+function resolveProjectBinary(specifier, fromDirectory) {
+  const require2 = createNodeRequire(fromDirectory);
+  return require2.resolve(specifier, {
+    paths: [fromDirectory]
+  });
+}
+async function typecheckRoomEntry(entryFile, options = {}) {
+  const resolvedEntry = path.resolve(entryFile);
+  const projectRoot = options.project ? path.dirname(path.resolve(options.project)) : path.dirname(resolvedEntry);
+  const tscBin = resolveProjectBinary("typescript/bin/tsc", projectRoot);
+  if (options.project) {
+    const resolvedProject = path.resolve(options.project);
+    await runProcess(NODE_COMMAND, [tscBin, "--noEmit", "--project", resolvedProject], {
+      cwd: path.dirname(resolvedProject)
+    });
+    return;
+  }
+  await runProcess(
+    NODE_COMMAND,
+    [
+      tscBin,
+      "--noEmit",
+      "--module",
+      "ESNext",
+      "--moduleResolution",
+      "bundler",
+      "--target",
+      "ES2022",
+      "--allowSyntheticDefaultImports",
+      "--skipLibCheck",
+      resolvedEntry
+    ],
+    {
+      cwd: projectRoot
+    }
+  );
+}
+function allowlistedImportsPlugin() {
+  return {
+    name: "rooms-allowlisted-imports",
+    setup(buildApi) {
+      buildApi.onResolve({ filter: /^[^./].*/ }, (args) => {
+        if (args.path === "@rooms.sh/sdk") {
+          return {
+            path: RUNTIME_SDK_SPECIFIER,
+            external: true
+          };
+        }
+        if (ALLOWED_BARE_IMPORTS.has(args.path)) {
+          return null;
+        }
+        return {
+          errors: [
+            {
+              text: `Unsupported bare import "${args.path}". Only @rooms.sh/sdk and relative imports are allowed.`
+            }
+          ]
+        };
+      });
+    }
+  };
+}
+async function bundleRoomEntry(entryFile) {
+  const resolvedEntry = path.resolve(entryFile);
+  await fs.access(resolvedEntry);
+  const result = await build({
+    entryPoints: [resolvedEntry],
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    write: false,
+    sourcemap: false,
+    legalComments: "none",
+    logLevel: "silent",
+    plugins: [allowlistedImportsPlugin()]
+  });
+  const output = result.outputFiles?.[0];
+  if (!output) {
+    throw new Error("esbuild did not emit a bundle.");
+  }
+  return {
+    bundleCode: output.text,
+    entryPoint: path.relative(process.cwd(), resolvedEntry),
+    bundleSize: output.text.length
+  };
+}
+async function fetchJson(url, init) {
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  const text = await response.text();
+  const parsed = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    throw new Error(
+      typeof parsed.error === "string" ? parsed.error : `Request failed with status ${response.status}`
+    );
+  }
+  return parsed;
+}
+async function readProjectPackageManifest(projectDir) {
+  const packageJsonPath = path.join(projectDir, "package.json");
+  try {
+    const packageJson = await fs.readFile(packageJsonPath, "utf8");
+    return JSON.parse(packageJson);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function uploadBundle(target, bundle, options = {}) {
+  return await fetchJson(target.sourceUrl, {
+    method: "PUT",
+    body: JSON.stringify({
+      bundleCode: bundle.bundleCode,
+      entryPoint: bundle.entryPoint,
+      roomName: options.roomName
+    })
+  });
+}
+async function createBuild(target) {
+  return await fetchJson(target.buildUrl, {
+    method: "POST",
+    body: JSON.stringify({})
+  });
+}
+async function waitForBuild(target, buildJobId, options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+  const statusUrl = target.buildStatusUrlTemplate.replace("{buildJobId}", buildJobId);
+  for (; ; ) {
+    const build2 = await fetchJson(statusUrl);
+    if (!build2) {
+      throw new Error("Build job disappeared.");
+    }
+    if (build2.status === "succeeded") {
+      return build2;
+    }
+    if (build2.status === "failed") {
+      throw new Error(build2.error ?? build2.log ?? "Build failed.");
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+}
+function slugifyRoomName(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("pnpm/")) {
+    return "pnpm";
+  }
+  if (userAgent.startsWith("yarn/")) {
+    return "yarn";
+  }
+  if (userAgent.startsWith("bun/")) {
+    return "bun";
+  }
+  return "npm";
+}
+async function ensureDirectoryIsWritable(projectDir) {
+  try {
+    const existingEntries = await fs.readdir(projectDir);
+    if (existingEntries.length > 0) {
+      throw new Error(`Directory ${projectDir} already exists and is not empty.`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await fs.mkdir(projectDir, { recursive: true });
+      return;
+    }
+    throw error;
+  }
+}
+function createRoomProjectPackageJson(projectName) {
+  return {
+    name: projectName,
+    private: true,
+    type: "module",
+    scripts: {
+      typecheck: "tsc --noEmit",
+      "publish:room": `${CLI_PACKAGE_NAME} publish`
+    },
+    dependencies: {
+      [SDK_PACKAGE_NAME]: `^${SDK_PACKAGE_VERSION}`
+    },
+    devDependencies: {
+      [CLI_PACKAGE_NAME]: `^${CLI_PACKAGE_VERSION}`,
+      typescript: TYPESCRIPT_VERSION
+    }
+  };
+}
+function createRoomProjectTsconfig() {
+  return {
+    compilerOptions: {
+      target: "ES2022",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      noEmit: true,
+      allowSyntheticDefaultImports: true,
+      skipLibCheck: true
+    },
+    include: ["./room.ts"]
+  };
+}
+function createRoomEntrySource(roomName, roomId) {
+  return `import {
+  ambientLight,
+  defineItem,
+  defineRoom,
+  directionalLight,
+  geometry,
+  material,
+  mesh,
+  placeFloor,
+} from "@rooms.sh/sdk"
+
+const cream = material.standard({ color: 0xf3ecdf, roughness: 0.95 })
+const blush = material.standard({ color: 0xd8afba, roughness: 0.9 })
+const plum = material.standard({ color: 0x5b425f, roughness: 0.88 })
+const walnut = material.standard({ color: 0x57392b, roughness: 0.82 })
+
+const items = {
+  platform: defineItem({
+    id: "platform",
+    nodes: [
+      mesh(
+        geometry.box({ width: 1.8, height: 0.32, depth: 1.2 }),
+        walnut,
+        {
+        position: [0, 0.16, 0],
+        },
+      ),
+      mesh(
+        geometry.roundedBox({
+          width: 1.86,
+          height: 0.18,
+          depth: 1.26,
+          radius: 0.08,
+        }),
+        blush,
+        {
+        position: [0, 0.41, 0],
+        },
+      ),
+    ],
+  }),
+  orbLamp: defineItem({
+    id: "orbLamp",
+    nodes: [
+      mesh(
+        geometry.cylinder({ radiusTop: 0.05, radiusBottom: 0.08, height: 1.2 }),
+        plum,
+        {
+        position: [0, 0.6, 0],
+        },
+      ),
+      mesh(
+        geometry.sphere({ radius: 0.24 }),
+        material.glass({ color: 0xfff4ef, transmission: 0.9, opacity: 0.7 }),
+        {
+        position: [0, 1.28, 0],
+        },
+      ),
+    ],
+  }),
+}
+
+export default defineRoom({
+  id: ${JSON.stringify(roomId)},
+  shell: {
+    width: 7,
+    depth: 7,
+    height: 3.4,
+    floorMaterial: cream,
+    wallMaterial: material.standard({ color: 0xf8f3fb, roughness: 0.98 }),
+    ceilingMaterial: material.standard({ color: 0xfffcff, roughness: 1 }),
+  },
+  atmosphere: {
+    background: "#f1d8f4",
+    fogColor: "#f1d8f4",
+    fogDensity: 0.028,
+  },
+  items,
+  instances: [
+    placeFloor("platform", "platform", 0, 0),
+    placeFloor("lamp", "orbLamp", -2.1, -1.9),
+  ],
+  lights: [
+    ambientLight("#fff6fb", 0.9),
+    directionalLight("#ffd7ee", 1.2, [3, 4.8, 2], [0, 0.8, 0]),
+  ],
+  cameras: {
+    wide: {
+      position: [0, 2.2, 6.2],
+      target: [0, 0.9, 0],
+      fov: 52,
+    },
+    top: {
+      position: [0, 7.4, 0.01],
+      target: [0, 0.4, 0],
+      fov: 38,
+    },
+  },
+  defaultCamera: "wide",
+})
+`;
+}
+async function writeProjectFile(projectDir, relativePath, contents) {
+  const filePath = path.join(projectDir, relativePath);
+  await fs.writeFile(filePath, contents, "utf8");
+}
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function findNearestProjectDirectory(startPath) {
+  let currentDir = path.resolve(startPath);
+  for (; ; ) {
+    if (await fileExists(path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+async function installProjectDependencies(projectDir, packageManager) {
+  await runProcess(packageManager, ["install"], { cwd: projectDir });
+}
+function readEnvFileValue(contents, key) {
+  for (const rawLine of contents.split(/\r?\n/u)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = line.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const envKey = line.slice(0, separatorIndex).trim();
+    if (envKey !== key) {
+      continue;
+    }
+    let value = line.slice(separatorIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    return value;
+  }
+  return null;
+}
+async function readTargetFromEnv(projectDir) {
+  const envPath = path.join(projectDir, ".env");
+  try {
+    const envContents = await fs.readFile(envPath, "utf8");
+    return readEnvFileValue(envContents, TARGET_ENV_KEY);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+async function initRoomProject(options) {
+  const roomSlug = slugifyRoomName(options.name);
+  if (!roomSlug) {
+    throw new Error("Room name must include at least one letter or number.");
+  }
+  const projectDir = path.resolve(options.directory ?? roomSlug);
+  const packageManager = options.packageManager ?? detectPackageManager();
+  await ensureDirectoryIsWritable(projectDir);
+  await writeProjectFile(
+    projectDir,
+    "package.json",
+    `${JSON.stringify(createRoomProjectPackageJson(roomSlug), null, 2)}
+`
+  );
+  await writeProjectFile(
+    projectDir,
+    DEFAULT_TSCONFIG_FILE,
+    `${JSON.stringify(createRoomProjectTsconfig(), null, 2)}
+`
+  );
+  await writeProjectFile(projectDir, ".env", `${TARGET_ENV_KEY}=${options.target}
+`);
+  await writeProjectFile(projectDir, ".gitignore", "node_modules\n.env\n");
+  await writeProjectFile(projectDir, DEFAULT_ROOM_ENTRY_FILE, createRoomEntrySource(options.name, roomSlug));
+  if (!options.skipInstall) {
+    await installProjectDependencies(projectDir, packageManager);
+  }
+  return {
+    projectDir,
+    packageManager
+  };
+}
+async function publishRoomProject(projectDir, options = {}) {
+  const resolvedBaseDir = path.resolve(projectDir);
+  const entryFile = path.resolve(
+    resolvedBaseDir,
+    options.entryFile ?? DEFAULT_ROOM_ENTRY_FILE
+  );
+  const resolvedProjectDir = await findNearestProjectDirectory(path.dirname(entryFile)) ?? resolvedBaseDir;
+  const targetInput = options.target ?? await readTargetFromEnv(resolvedProjectDir);
+  if (!targetInput) {
+    throw new Error(
+      `Missing agent target. Pass --target or set ${TARGET_ENV_KEY} in ${path.join(resolvedProjectDir, ".env")}.`
+    );
+  }
+  const target = parseAgentTarget(targetInput);
+  const defaultProject = path.join(resolvedProjectDir, DEFAULT_TSCONFIG_FILE);
+  const project = options.project ? path.resolve(resolvedProjectDir, options.project) : await fileExists(defaultProject) ? defaultProject : void 0;
+  await typecheckRoomEntry(entryFile, {
+    project
+  });
+  const bundle = await bundleRoomEntry(entryFile);
+  const packageManifest = await readProjectPackageManifest(resolvedProjectDir);
+  const roomName = typeof packageManifest?.name === "string" && packageManifest.name.trim().length > 0 ? packageManifest.name.trim() : void 0;
+  await uploadBundle(target, bundle, { roomName });
+  const build2 = await createBuild(target);
+  const finalBuild = await waitForBuild(target, build2.buildJobId);
+  return {
+    target,
+    bundle,
+    build: build2,
+    finalBuild
+  };
+}
+
+export {
+  parseAgentTarget,
+  buildAgentTarget,
+  typecheckRoomEntry,
+  bundleRoomEntry,
+  readProjectPackageManifest,
+  uploadBundle,
+  createBuild,
+  waitForBuild,
+  readTargetFromEnv,
+  initRoomProject,
+  publishRoomProject
+};

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import {
+  initRoomProject,
+  publishRoomProject
+} from "./chunk-4BUZNJPJ.js";
+
+// src/cli.ts
+import path from "path";
+import process from "process";
+function printUsage() {
+  console.log(`rooms.sh init --name <room-name> --target <agent-room-url> [--directory <path>] [--skip-install]
+rooms.sh publish [entry-file] [--target <agent-room-url>] [--project <tsconfig>]
+
+Examples:
+  npx rooms.sh@latest init --name "Pink Loft" --target "http://localhost:3000/api/agent/rooms/ROOM_ID?token=rt_..."
+  npm run publish:room
+  rooms.sh publish ./room.ts --target "http://localhost:3000/api/agent/rooms/ROOM_ID?token=rt_..."
+`);
+}
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const parsed = { command };
+  const positional = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const part = rest[index];
+    if (!part.startsWith("--")) {
+      positional.push(part);
+      continue;
+    }
+    switch (part) {
+      case "--skip-install":
+        parsed.skipInstall = true;
+        break;
+      case "--target":
+      case "--name":
+      case "--project":
+      case "--directory": {
+        const value = rest[index + 1];
+        if (!value) {
+          throw new Error(`Missing value for ${part}`);
+        }
+        if (part === "--target") {
+          parsed.target = value;
+        }
+        if (part === "--name") {
+          parsed.name = value;
+        }
+        if (part === "--project") {
+          parsed.project = value;
+        }
+        if (part === "--directory") {
+          parsed.directory = value;
+        }
+        index += 1;
+        break;
+      }
+      default:
+        throw new Error(`Unknown argument ${part}`);
+    }
+  }
+  if ((command === "publish" || command === "push") && positional[0]) {
+    parsed.entryFile = positional[0];
+  }
+  return parsed;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === "init") {
+    if (!args.name || !args.target) {
+      printUsage();
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Scaffolding ${args.name}`);
+    const result = await initRoomProject({
+      name: args.name,
+      target: args.target,
+      directory: args.directory,
+      skipInstall: args.skipInstall
+    });
+    console.log(`Created project at ${result.projectDir}`);
+    if (!args.skipInstall) {
+      console.log(`Installed dependencies with ${result.packageManager}`);
+    }
+    const relativeProjectDir = path.relative(process.cwd(), result.projectDir);
+    const displayProjectDir = relativeProjectDir && relativeProjectDir !== "." && !relativeProjectDir.startsWith("..") ? relativeProjectDir : result.projectDir;
+    console.log(`Next steps:
+  cd ${displayProjectDir}
+  npm run publish:room`);
+    return;
+  }
+  if (args.command === "publish" || args.command === "push") {
+    const projectDir = process.cwd();
+    if (args.entryFile) {
+      console.log(`Publishing ${path.resolve(projectDir, args.entryFile)}`);
+    } else {
+      console.log(`Publishing ${path.resolve(projectDir, "room.ts")}`);
+    }
+    const result = await publishRoomProject(projectDir, {
+      entryFile: args.entryFile,
+      target: args.target,
+      project: args.project
+    });
+    console.log(`Bundle size: ${result.bundle.bundleSize} bytes`);
+    console.log(`Uploaded bundle to room ${result.target.roomId}`);
+    console.log(`Build job: ${result.build.buildJobId}`);
+    console.log(
+      `Build succeeded: ${String(
+        result.finalBuild.producedVersionId ?? result.build.buildJobId
+      )}`
+    );
+    if (typeof result.finalBuild.log === "string" && result.finalBuild.log.length > 0) {
+      console.log(result.finalBuild.log);
+    }
+    return;
+  }
+  printUsage();
+  process.exitCode = 1;
+}
+void main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/dist/lib.d.ts

@@ -0,0 +1,92 @@
+interface AgentTarget {
+    origin: string;
+    roomId: string;
+    token: string;
+    contextUrl: string;
+    sourceUrl: string;
+    buildUrl: string;
+    buildStatusUrlTemplate: string;
+}
+interface BundleResult {
+    bundleCode: string;
+    entryPoint: string;
+    bundleSize: number;
+}
+interface ProjectPackageManifest {
+    name?: string;
+}
+interface InitRoomProjectResult {
+    projectDir: string;
+    packageManager: PackageManagerName;
+}
+interface PublishRoomProjectResult {
+    target: AgentTarget;
+    bundle: BundleResult;
+    build: {
+        buildJobId: string;
+        queuedAt: number;
+    };
+    finalBuild: {
+        status?: string;
+        error?: string;
+        log?: string;
+        producedVersionId?: string;
+    };
+}
+type PackageManagerName = "npm" | "pnpm" | "yarn" | "bun";
+declare function parseAgentTarget(target: string, options?: {
+    roomId?: string;
+    origin?: string;
+}): AgentTarget;
+declare function buildAgentTarget(origin: string, roomId: string, token: string): AgentTarget;
+declare function typecheckRoomEntry(entryFile: string, options?: {
+    project?: string;
+}): Promise<void>;
+declare function bundleRoomEntry(entryFile: string): Promise<BundleResult>;
+declare function readProjectPackageManifest(projectDir: string): Promise<ProjectPackageManifest | null>;
+declare function uploadBundle(target: AgentTarget, bundle: BundleResult, options?: {
+    roomName?: string;
+}): Promise<Record<string, unknown>>;
+declare function createBuild(target: AgentTarget): Promise<{
+    buildJobId: string;
+    queuedAt: number;
+}>;
+declare function waitForBuild(target: AgentTarget, buildJobId: string, options?: {
+    pollIntervalMs?: number;
+}): Promise<{
+    status?: string;
+    error?: string;
+    log?: string;
+    producedVersionId?: string;
+}>;
+declare function readTargetFromEnv(projectDir: string): Promise<string | null>;
+declare function initRoomProject(options: {
+    name: string;
+    target: string;
+    directory?: string;
+    packageManager?: PackageManagerName;
+    skipInstall?: boolean;
+}): Promise<{
+    projectDir: string;
+    packageManager: PackageManagerName;
+}>;
+declare function publishRoomProject(projectDir: string, options?: {
+    entryFile?: string;
+    target?: string;
+    project?: string;
+}): Promise<{
+    target: AgentTarget;
+    bundle: BundleResult;
+    build: {
+        buildJobId: string;
+        queuedAt: number;
+    };
+    finalBuild: {
+        status?: string;
+        error?: string;
+        log?: string;
+        producedVersionId?: string;
+    };
+}>;
+
+export { type AgentTarget, type BundleResult, type InitRoomProjectResult, type ProjectPackageManifest, type PublishRoomProjectResult, buildAgentTarget, bundleRoomEntry, createBuild, initRoomProject, parseAgentTarget, publishRoomProject, readProjectPackageManifest, readTargetFromEnv, typecheckRoomEntry, uploadBundle, waitForBuild };

package/dist/lib.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  buildAgentTarget,
+  bundleRoomEntry,
+  createBuild,
+  initRoomProject,
+  parseAgentTarget,
+  publishRoomProject,
+  readProjectPackageManifest,
+  readTargetFromEnv,
+  typecheckRoomEntry,
+  uploadBundle,
+  waitForBuild
+} from "./chunk-4BUZNJPJ.js";
+export {
+  buildAgentTarget,
+  bundleRoomEntry,
+  createBuild,
+  initRoomProject,
+  parseAgentTarget,
+  publishRoomProject,
+  readProjectPackageManifest,
+  readTargetFromEnv,
+  typecheckRoomEntry,
+  uploadBundle,
+  waitForBuild
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "rooms.sh",
+  "version": "0.0.1",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "rooms.sh": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "esbuild": "^0.25.11"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}