regpick 0.2.3

package/src/shell/installer.ts

@@ -0,0 +1,70 @@
+import path from "node:path";
+
+import type { OverwritePolicy, RegpickConfig, RegistryItem } from "../types.js";
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import { resolveOutputPathFromPolicy } from "../domain/pathPolicy.js";
+import {
+  getPackageManagerStrategy,
+  type RuntimePackageManager,
+} from "../shell/packageManagers/strategy.js";
+import type { RuntimePorts } from "../shell/runtime/ports.js";
+import { resolvePackageManager } from "../shell/packageManagers/resolver.js";
+
+function unique(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))];
+}
+
+export function collectMissingDependencies(
+  items: RegistryItem[],
+  cwd: string,
+  runtime: RuntimePorts,
+): { missingDependencies: string[]; missingDevDependencies: string[] } {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!runtime.fs.existsSync(packageJsonPath)) {
+    return { missingDependencies: [], missingDevDependencies: [] };
+  }
+
+  const packageJsonResult = runtime.fs.readJsonSync<{
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+  }>(packageJsonPath);
+  const packageJson = packageJsonResult.ok ? packageJsonResult.value : {};
+  const declared = {
+    ...(packageJson.dependencies || {}),
+    ...(packageJson.devDependencies || {}),
+    ...(packageJson.peerDependencies || {}),
+  };
+
+  const allDeps = unique(items.flatMap((item) => item.dependencies || []));
+  const allDevDeps = unique(items.flatMap((item) => item.devDependencies || []));
+
+  const missingDependencies = allDeps.filter((dep) => !declared[dep]);
+  const missingDevDependencies = allDevDeps.filter((dep) => !declared[dep]);
+
+  return { missingDependencies, missingDevDependencies };
+}
+
+export function installDependencies(
+  cwd: string,
+  packageManager: RuntimePackageManager,
+  dependencies: string[],
+  devDependencies: string[],
+  runtime: RuntimePorts,
+): Result<void, AppError> {
+  if (!dependencies.length && !devDependencies.length) {
+    return ok(undefined);
+  }
+
+  const strategy = getPackageManagerStrategy(packageManager);
+  const commands = strategy.buildInstallCommands(dependencies, devDependencies);
+  for (const command of commands) {
+    const result = runtime.process.run(command.command, command.args, cwd);
+    if (result.status !== 0) {
+      return err(appError("InstallError", `Dependency install failed: ${command.command} ${command.args.join(" ")}`));
+    }
+  }
+  return ok(undefined);
+}
+

package/src/shell/lockfile.ts

@@ -0,0 +1,35 @@
+import path from "node:path";
+import crypto from "node:crypto";
+import type { RuntimePorts } from "./runtime/ports.js";
+import type { RegpickLockfile } from "../types.js";
+
+const LOCKFILE_NAME = "regpick-lock.json";
+
+export function getLockfilePath(cwd: string): string {
+  return path.join(cwd, LOCKFILE_NAME);
+}
+
+export async function readLockfile(cwd: string, runtime: RuntimePorts): Promise<RegpickLockfile> {
+  const lockfilePath = getLockfilePath(cwd);
+  const exists = await runtime.fs.pathExists(lockfilePath);
+
+  if (!exists) {
+    return { components: {} };
+  }
+
+  const readRes = runtime.fs.readJsonSync<RegpickLockfile>(lockfilePath);
+  if (!readRes.ok) {
+    return { components: {} };
+  }
+
+  return readRes.value;
+}
+
+export async function writeLockfile(cwd: string, lockfile: RegpickLockfile, runtime: RuntimePorts): Promise<void> {
+  const lockfilePath = getLockfilePath(cwd);
+  await runtime.fs.writeJson(lockfilePath, lockfile, { spaces: 2 });
+}
+
+export function computeHash(content: string): string {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}

package/src/shell/packageManagers/__tests__/resolver.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+
+import type { RuntimePorts } from "../../runtime/ports.js";
+import { resolvePackageManager } from "../resolver.js";
+import { ok, err } from "../../../core/result.js";
+import { appError } from "../../../core/errors.js";
+
+function runtimeWithLockfiles(lockfiles: string[]): RuntimePorts {
+  return {
+    fs: {
+      existsSync: (filePath: string) => lockfiles.some((lock) => filePath.endsWith(lock)),
+      pathExists: async () => false,
+      ensureDir: async () => ok(undefined),
+      writeFile: async () => ok(undefined),
+      readFile: async () => ok(""),
+      readJsonSync: <T>() => ok({} as T),
+      writeJson: async () => ok(undefined),
+      stat: async () => err(appError("RuntimeError", "not implemented")),
+      readdir: async () => ok([]),
+    },
+    http: {
+      getJson: async <T>() => ok({} as T),
+      getText: async () => ok(""),
+    },
+    prompt: {
+      intro: () => undefined,
+      outro: () => undefined,
+      cancel: () => undefined,
+      isCancel: () => false,
+      info: () => undefined,
+      warn: () => undefined,
+      error: () => undefined,
+      success: () => undefined,
+      text: async () => "",
+      confirm: async () => true,
+      select: async () => "overwrite",
+      multiselect: async () => [],
+      autocompleteMultiselect: async () => [],
+    },
+    process: {
+      run: () => ({ status: 0 }),
+    },
+  };
+}
+
+describe("package manager resolver", () => {
+  it("prefers configured manager over lockfiles", () => {
+    const runtime = runtimeWithLockfiles(["pnpm-lock.yaml"]);
+    expect(resolvePackageManager("/tmp/project", "yarn", runtime)).toBe("yarn");
+  });
+
+  it("resolves lockfile-based manager", () => {
+    expect(resolvePackageManager("/tmp/project", "auto", runtimeWithLockfiles(["pnpm-lock.yaml"]))).toBe("pnpm");
+    expect(resolvePackageManager("/tmp/project", "auto", runtimeWithLockfiles(["yarn.lock"]))).toBe("yarn");
+    expect(resolvePackageManager("/tmp/project", "auto", runtimeWithLockfiles(["package-lock.json"]))).toBe("npm");
+  });
+
+  it("falls back to npm when no lockfile exists", () => {
+    expect(resolvePackageManager("/tmp/project", "auto", runtimeWithLockfiles([]))).toBe("npm");
+  });
+});

package/src/shell/packageManagers/__tests__/strategy.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { getPackageManagerStrategy } from "../strategy.js";
+
+describe("package manager strategy", () => {
+  it("builds npm commands for deps and devDeps", () => {
+    const strategy = getPackageManagerStrategy("npm");
+    const commands = strategy.buildInstallCommands(["react"], ["@types/react"]);
+    expect(commands).toEqual([
+      { command: "npm", args: ["install", "react"] },
+      { command: "npm", args: ["install", "-D", "@types/react"] },
+    ]);
+  });
+
+  it("builds yarn commands", () => {
+    const strategy = getPackageManagerStrategy("yarn");
+    const commands = strategy.buildInstallCommands(["react"], ["@types/react"]);
+    expect(commands).toEqual([
+      { command: "yarn", args: ["add", "react"] },
+      { command: "yarn", args: ["add", "-D", "@types/react"] },
+    ]);
+  });
+
+  it("builds pnpm commands", () => {
+    const strategy = getPackageManagerStrategy("pnpm");
+    const commands = strategy.buildInstallCommands(["react"], ["@types/react"]);
+    expect(commands).toEqual([
+      { command: "pnpm", args: ["add", "react"] },
+      { command: "pnpm", args: ["add", "-D", "@types/react"] },
+    ]);
+  });
+
+  it("omits empty command groups", () => {
+    const strategy = getPackageManagerStrategy("npm");
+    expect(strategy.buildInstallCommands([], [])).toEqual([]);
+    expect(strategy.buildInstallCommands(["react"], [])).toEqual([
+      { command: "npm", args: ["install", "react"] },
+    ]);
+  });
+});

package/src/shell/packageManagers/resolver.ts

@@ -0,0 +1,27 @@
+import path from "node:path";
+
+import type { PackageManager } from "../../types.js";
+import type { RuntimePorts } from "../runtime/ports.js";
+import type { RuntimePackageManager } from "./strategy.js";
+
+export function resolvePackageManager(
+  cwd: string,
+  configured: PackageManager,
+  runtime: RuntimePorts,
+): RuntimePackageManager {
+  if (configured && configured !== "auto") {
+    return configured;
+  }
+
+  if (runtime.fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (runtime.fs.existsSync(path.join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (runtime.fs.existsSync(path.join(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+
+  return "npm";
+}

package/src/shell/packageManagers/strategy.ts

@@ -0,0 +1,65 @@
+import type { PackageManager } from "../../types.js";
+
+export type RuntimePackageManager = Exclude<PackageManager, "auto">;
+
+type InstallCommand = {
+  command: string;
+  args: string[];
+};
+
+type PackageManagerStrategy = {
+  manager: RuntimePackageManager;
+  buildInstallCommands: (dependencies: string[], devDependencies: string[]) => InstallCommand[];
+};
+
+function buildNpmCommands(dependencies: string[], devDependencies: string[]): InstallCommand[] {
+  const commands: InstallCommand[] = [];
+  if (dependencies.length) {
+    commands.push({ command: "npm", args: ["install", ...dependencies] });
+  }
+  if (devDependencies.length) {
+    commands.push({ command: "npm", args: ["install", "-D", ...devDependencies] });
+  }
+  return commands;
+}
+
+function buildYarnCommands(dependencies: string[], devDependencies: string[]): InstallCommand[] {
+  const commands: InstallCommand[] = [];
+  if (dependencies.length) {
+    commands.push({ command: "yarn", args: ["add", ...dependencies] });
+  }
+  if (devDependencies.length) {
+    commands.push({ command: "yarn", args: ["add", "-D", ...devDependencies] });
+  }
+  return commands;
+}
+
+function buildPnpmCommands(dependencies: string[], devDependencies: string[]): InstallCommand[] {
+  const commands: InstallCommand[] = [];
+  if (dependencies.length) {
+    commands.push({ command: "pnpm", args: ["add", ...dependencies] });
+  }
+  if (devDependencies.length) {
+    commands.push({ command: "pnpm", args: ["add", "-D", ...devDependencies] });
+  }
+  return commands;
+}
+
+const strategyMap: Record<RuntimePackageManager, PackageManagerStrategy> = {
+  npm: {
+    manager: "npm",
+    buildInstallCommands: buildNpmCommands,
+  },
+  yarn: {
+    manager: "yarn",
+    buildInstallCommands: buildYarnCommands,
+  },
+  pnpm: {
+    manager: "pnpm",
+    buildInstallCommands: buildPnpmCommands,
+  },
+};
+
+export function getPackageManagerStrategy(manager: RuntimePackageManager): PackageManagerStrategy {
+  return strategyMap[manager];
+}

package/src/shell/registry.ts

@@ -0,0 +1,182 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import type { RegistryFile, RegistryItem, RegistrySourceMeta } from "../types.js";
+import { appError, type AppError } from "../core/errors.js";
+import { err, ok, type Result } from "../core/result.js";
+import { extractItemReferences, normalizeItem, normalizeManifestInline } from "../domain/registryModel.js";
+import type { RuntimePorts } from "../shell/runtime/ports.js";
+
+function isHttpUrl(value: string): boolean {
+  return /^https?:\/\//i.test(value);
+}
+
+function isFileUrl(value: string): boolean {
+  return /^file:\/\//i.test(value);
+}
+
+function joinUrl(baseUrl: string, relativePath: string): string {
+  return new URL(relativePath, baseUrl).toString();
+}
+
+async function normalizeManifest(
+  data: unknown,
+  sourceMeta: RegistrySourceMeta,
+  runtime: RuntimePorts,
+): Promise<Result<RegistryItem[], AppError>> {
+  const inlineItemsRes = normalizeManifestInline(data, sourceMeta);
+
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return inlineItemsRes;
+  }
+
+  const references = extractItemReferences(data as Record<string, unknown>);
+  if (!references.length) {
+    return inlineItemsRes;
+  }
+  
+  const inlineItems = inlineItemsRes.ok ? inlineItemsRes.value : [];
+
+  const resolvedItems: RegistryItem[] = [];
+  for (const itemRef of references) {
+    let itemData: unknown;
+    if (isHttpUrl(itemRef)) {
+      const res = await runtime.http.getJson(itemRef);
+      if (!res.ok) return err(res.error);
+      itemData = res.value;
+    } else if (sourceMeta.type === "http" && sourceMeta.baseUrl) {
+      const res = await runtime.http.getJson(joinUrl(sourceMeta.baseUrl, itemRef));
+      if (!res.ok) return err(res.error);
+      itemData = res.value;
+    } else if ((sourceMeta.type === "file" || sourceMeta.type === "directory") && sourceMeta.baseDir) {
+      const res = await runtime.fs.readFile(path.resolve(sourceMeta.baseDir, itemRef), "utf8");
+      if (!res.ok) return err(res.error);
+      try { itemData = JSON.parse(res.value); } catch { return err(appError("RegistryError", `Invalid JSON: ${itemRef}`)); }
+    } else {
+      const res = await runtime.fs.readFile(path.resolve(itemRef), "utf8");
+      if (!res.ok) return err(res.error);
+      try { itemData = JSON.parse(res.value); } catch { return err(appError("RegistryError", `Invalid JSON: ${itemRef}`)); }
+    }
+
+    if (itemData && typeof itemData === "object") {
+      resolvedItems.push(normalizeItem(itemData as Record<string, unknown>, sourceMeta));
+    }
+  }
+
+  return ok([...inlineItems, ...resolvedItems]);
+}
+
+async function loadDirectoryRegistry(directoryPath: string, runtime: RuntimePorts): Promise<Result<RegistryItem[], AppError>> {
+  const absoluteDir = path.resolve(directoryPath);
+  const dirRes = await runtime.fs.readdir(absoluteDir);
+  if (!dirRes.ok) return err(dirRes.error);
+  
+  const files = dirRes.value;
+  const jsonFiles = files.filter((file) => file.endsWith(".json"));
+
+  const items: RegistryItem[] = [];
+  for (const fileName of jsonFiles) {
+    const fullPath = path.join(absoluteDir, fileName);
+    const readRes = await runtime.fs.readFile(fullPath, "utf8");
+    if (!readRes.ok) return err(readRes.error);
+    
+    let parsed: unknown;
+    try { parsed = JSON.parse(readRes.value); } catch { continue; }
+    
+    if (!parsed || typeof parsed !== "object" || !Array.isArray((parsed as Record<string, unknown>).files)) {
+      continue;
+    }
+    items.push(normalizeItem(parsed as Record<string, unknown>, { type: "directory", baseDir: absoluteDir }));
+  }
+
+  return ok(items);
+}
+
+export async function loadRegistry(
+  source: string,
+  cwd: string,
+  runtime: RuntimePorts,
+): Promise<Result<{ items: RegistryItem[]; source: string }, AppError>> {
+  if (!source) {
+    return err(appError("ValidationError", "Registry source is required."));
+  }
+
+  const resolved = isHttpUrl(source) || isFileUrl(source) ? source : path.resolve(cwd, source);
+
+  if (isHttpUrl(resolved)) {
+    const dataRes = await runtime.http.getJson(resolved);
+    if (!dataRes.ok) return err(dataRes.error);
+    const baseUrl = resolved.endsWith("/") ? resolved : resolved.replace(/[^/]*$/, "");
+    const itemsRes = await normalizeManifest(dataRes.value, { type: "http", baseUrl }, runtime);
+    if (!itemsRes.ok) return err(itemsRes.error);
+    return ok({ items: itemsRes.value, source: resolved });
+  }
+
+  const fileSystemPath = isFileUrl(resolved) ? fileURLToPath(new URL(resolved)) : path.resolve(resolved);
+  const statsRes = await runtime.fs.stat(fileSystemPath);
+  if (!statsRes.ok) {
+    return err(appError("RegistryError", `Registry source not found: ${source}`));
+  }
+  const stats = statsRes.value;
+
+  if (stats.isDirectory()) {
+    const itemsRes = await loadDirectoryRegistry(fileSystemPath, runtime);
+    if (!itemsRes.ok) return err(itemsRes.error);
+    return ok({ items: itemsRes.value, source: fileSystemPath });
+  }
+
+  const readRes = await runtime.fs.readFile(fileSystemPath, "utf8");
+  if (!readRes.ok) return err(readRes.error);
+  
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readRes.value);
+  } catch (cause) {
+    return err(appError("RegistryError", "Failed to parse registry JSON.", cause));
+  }
+
+  const itemsRes = await normalizeManifest(
+    parsed,
+    {
+      type: "file",
+      baseDir: path.dirname(fileSystemPath),
+    },
+    runtime,
+  );
+  
+  if (!itemsRes.ok) return err(itemsRes.error);
+  return ok({ items: itemsRes.value, source: fileSystemPath });
+}
+
+export async function resolveFileContent(
+  file: RegistryFile,
+  item: RegistryItem,
+  cwd: string,
+  runtime: RuntimePorts,
+): Promise<Result<string, AppError>> {
+  if (typeof file.content === "string") {
+    return ok(file.content);
+  }
+
+  const targetPathOrUrl = file.url || file.path;
+
+  if (!targetPathOrUrl) {
+    return err(appError("ValidationError", `File entry in "${item.name}" is missing both content and path/url.`));
+  }
+
+  if (isHttpUrl(targetPathOrUrl)) {
+    return await runtime.http.getText(targetPathOrUrl);
+  }
+
+  if (item.sourceMeta.type === "http" && item.sourceMeta.baseUrl) {
+    const remoteUrl = joinUrl(item.sourceMeta.baseUrl, targetPathOrUrl);
+    return await runtime.http.getText(remoteUrl);
+  }
+
+  const localPath =
+    item.sourceMeta.baseDir && !path.isAbsolute(targetPathOrUrl)
+      ? path.resolve(item.sourceMeta.baseDir, targetPathOrUrl)
+      : path.resolve(cwd, targetPathOrUrl);
+
+  return await runtime.fs.readFile(localPath, "utf8");
+}

package/src/shell/runtime/ports.ts

@@ -0,0 +1,200 @@
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import {
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  log,
+  multiselect,
+  autocompleteMultiselect,
+  outro,
+  select,
+  text,
+} from "@clack/prompts";
+import { spawnSync } from "node:child_process";
+import { type Result, ok, err } from "../../core/result.js";
+import { appError, type AppError } from "../../core/errors.js";
+
+export type FileSystemPort = {
+  existsSync(path: string): boolean;
+  pathExists(path: string): Promise<boolean>;
+  ensureDir(path: string): Promise<Result<void, AppError>>;
+  writeFile(path: string, content: string, encoding: BufferEncoding): Promise<Result<void, AppError>>;
+  readFile(path: string, encoding: BufferEncoding): Promise<Result<string, AppError>>;
+  readJsonSync<T = unknown>(path: string): Result<T, AppError>;
+  writeJson(path: string, value: unknown, options?: { spaces?: number }): Promise<Result<void, AppError>>;
+  stat(path: string): Promise<Result<import("fs").Stats, AppError>>;
+  readdir(path: string): Promise<Result<string[], AppError>>;
+};
+
+export type HttpPort = {
+  getJson<T = unknown>(url: string, timeoutMs?: number): Promise<Result<T, AppError>>;
+  getText(url: string, timeoutMs?: number): Promise<Result<string, AppError>>;
+};
+
+export type PromptPort = {
+  intro(message: string): void;
+  outro(message: string): void;
+  cancel(message: string): void;
+  isCancel(value: unknown): boolean;
+  info(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+  success(message: string): void;
+  text(options: { message: string; placeholder?: string; defaultValue?: string }): Promise<string | symbol>;
+  confirm(options: { message: string; initialValue?: boolean }): Promise<boolean | symbol>;
+  select(options: {
+    message: string;
+    options: Array<{ value: string; label: string; hint?: string }>;
+  }): Promise<string | symbol>;
+  multiselect(options: {
+    message: string;
+    options: Array<{ value: string; label: string; hint?: string }>;
+    maxItems?: number;
+    required?: boolean;
+  }): Promise<Array<string> | symbol>;
+  autocompleteMultiselect(options: {
+    message: string;
+    options: Array<{ value: string; label: string; hint?: string }>;
+    maxItems?: number;
+    required?: boolean;
+  }): Promise<Array<string> | symbol>;
+};
+
+export type ProcessPort = {
+  run(command: string, args: string[], cwd: string): { status: number | null };
+};
+
+export type RuntimePorts = {
+  fs: FileSystemPort;
+  http: HttpPort;
+  prompt: PromptPort;
+  process: ProcessPort;
+};
+
+export const createRuntimePorts = (options?: { signal?: AbortSignal }): RuntimePorts => ({
+  fs: {
+    existsSync: (path) => fs.existsSync(path),
+    pathExists: async (path) => {
+      try {
+        await fsPromises.access(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    ensureDir: async (path) => {
+      try {
+        await fsPromises.mkdir(path, { recursive: true });
+        return ok(undefined);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to ensure directory: ${path}`, cause));
+      }
+    },
+    writeFile: async (path, content, encoding) => {
+      try {
+        await fsPromises.writeFile(path, content, encoding);
+        return ok(undefined);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to write file: ${path}`, cause));
+      }
+    },
+    readFile: async (path, encoding) => {
+      try {
+        const content = await fsPromises.readFile(path, encoding);
+        return ok(content);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to read file: ${path}`, cause));
+      }
+    },
+    readJsonSync: <T = unknown>(path: string) => {
+      try {
+        const content = fs.readFileSync(path, "utf8");
+        return ok(JSON.parse(content) as T);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to read JSON: ${path}`, cause));
+      }
+    },
+    writeJson: async (path, value, opts) => {
+      try {
+        const content = JSON.stringify(value, null, opts?.spaces ?? 2);
+        await fsPromises.writeFile(path, content, "utf8");
+        return ok(undefined);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to write JSON: ${path}`, cause));
+      }
+    },
+    stat: async (path) => {
+      try {
+        const stats = await fsPromises.stat(path);
+        return ok(stats);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to stat path: ${path}`, cause));
+      }
+    },
+    readdir: async (path) => {
+      try {
+        const files = await fsPromises.readdir(path);
+        return ok(files);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to read directory: ${path}`, cause));
+      }
+    },
+  },
+  http: {
+    getJson: async <T>(url: string, timeoutMs = 15000): Promise<Result<T, AppError>> => {
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        
+        if (!response.ok) {
+          return err(appError("RuntimeError", `HTTP error! status: ${response.status} when fetching JSON from: ${url}`));
+        }
+        
+        const data = await response.json();
+        return ok(data as T);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to fetch JSON from: ${url}`, cause));
+      }
+    },
+    getText: async (url: string, timeoutMs = 15000): Promise<Result<string, AppError>> => {
+      try {
+        const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+        
+        if (!response.ok) {
+          return err(appError("RuntimeError", `HTTP error! status: ${response.status} when fetching text from: ${url}`));
+        }
+        
+        const data = await response.text();
+        return ok(data);
+      } catch (cause) {
+        return err(appError("RuntimeError", `Failed to fetch text from: ${url}`, cause));
+      }
+    },
+  },
+  prompt: {
+    intro: (message) => intro(message),
+    outro: (message) => outro(message),
+    cancel: (message) => cancel(message),
+    isCancel: (value) => isCancel(value),
+    info: (message) => log.info(message),
+    warn: (message) => log.warn(message),
+    error: (message) => log.error(message),
+    success: (message) => log.success(message),
+    text: (opts) => text({ signal: options?.signal, ...opts }),
+    confirm: (opts) => confirm({ signal: options?.signal, ...opts }),
+    select: (opts) => select({ signal: options?.signal, ...opts } as any),
+    multiselect: (opts) => multiselect({ signal: options?.signal, ...opts } as any),
+    autocompleteMultiselect: (opts) => autocompleteMultiselect({ signal: options?.signal, ...opts } as any),
+  },
+  process: {
+    run: (command, args, cwd) =>
+      spawnSync(command, args, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+      }),
+  },
+});
+
+export const defaultRuntimePorts: RuntimePorts = createRuntimePorts();