@run0/jiki 0.1.0

package/src/npm/sync-installer.ts

@@ -0,0 +1,217 @@
+import pako from "pako";
+import { MemFS } from "../memfs";
+import * as pathShim from "../polyfills/path";
+import type { AutoInstallProvider } from "../module-resolver";
+import type { LayoutStrategy } from "./index";
+
+const BLOCK = 512;
+const decoder = new TextDecoder();
+
+function decodeField(buf: Uint8Array, start: number, len: number): string {
+  let i = start;
+  const limit = start + len;
+  while (i < limit && buf[i] !== 0) i++;
+  return decoder.decode(buf.subarray(start, i));
+}
+
+function readSize(buf: Uint8Array, offset: number, len: number): number {
+  return parseInt(decodeField(buf, offset, len), 8) || 0;
+}
+
+function isZeroBlock(buf: Uint8Array): boolean {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] !== 0) return false;
+  }
+  return true;
+}
+
+function unpackTarSync(tar: Uint8Array, vfs: MemFS, dest: string): void {
+  vfs.mkdirSync(dest, { recursive: true });
+  let pos = 0;
+
+  while (pos + BLOCK <= tar.length) {
+    const hdr = tar.subarray(pos, pos + BLOCK);
+    pos += BLOCK;
+    if (isZeroBlock(hdr)) break;
+
+    const rawName = decodeField(hdr, 0, 100);
+    if (!rawName) break;
+
+    const size = readSize(hdr, 124, 12);
+    const type = hdr[156];
+    const linkTarget = decodeField(hdr, 157, 100);
+    const prefix = decodeField(hdr, 345, 155);
+    const fullName = prefix ? `${prefix}/${rawName}` : rawName;
+
+    const relative = fullName.split("/").slice(1).join("/");
+    if (!relative || relative === ".") {
+      pos += Math.ceil(size / BLOCK) * BLOCK;
+      continue;
+    }
+
+    const target = pathShim.join(dest, relative);
+    const parentDir = pathShim.dirname(target);
+
+    if (type === 53 || fullName.endsWith("/")) {
+      vfs.mkdirSync(target, { recursive: true });
+    } else if (type === 0 || type === 48) {
+      vfs.mkdirSync(parentDir, { recursive: true });
+      const data =
+        size > 0 && pos + size <= tar.length
+          ? new Uint8Array(tar.subarray(pos, pos + size))
+          : new Uint8Array(0);
+      vfs.writeFileSync(target, data);
+    } else if (type === 50 && linkTarget) {
+      try {
+        vfs.mkdirSync(parentDir, { recursive: true });
+        vfs.symlinkSync(linkTarget, target);
+      } catch {
+        /* skip symlink errors */
+      }
+    }
+
+    pos += Math.ceil(size / BLOCK) * BLOCK;
+  }
+}
+
+function syncFetch(url: string): Uint8Array {
+  if (typeof XMLHttpRequest === "undefined") {
+    throw new Error(
+      "Synchronous auto-install requires XMLHttpRequest (browser environment)",
+    );
+  }
+  const xhr = new XMLHttpRequest();
+  xhr.open("GET", url, false);
+  xhr.responseType = "arraybuffer";
+  xhr.send();
+  if (xhr.status < 200 || xhr.status >= 300) {
+    throw new Error(`Failed to fetch ${url}: ${xhr.status}`);
+  }
+  return new Uint8Array(xhr.response as ArrayBuffer);
+}
+
+interface ManifestVersion {
+  name: string;
+  version: string;
+  dependencies?: Record<string, string>;
+  dist: { tarball: string; shasum: string };
+  bin?: string | Record<string, string>;
+}
+
+interface Manifest {
+  name: string;
+  "dist-tags": Record<string, string>;
+  versions: Record<string, ManifestVersion>;
+}
+
+function normalizeBin(
+  pkgName: string,
+  bin?: Record<string, string> | string,
+): Record<string, string> {
+  if (!bin) return {};
+  if (typeof bin === "string") {
+    const cmdName = pkgName.includes("/") ? pkgName.split("/").pop()! : pkgName;
+    return { [cmdName]: bin };
+  }
+  return bin;
+}
+
+export class SyncAutoInstaller implements AutoInstallProvider {
+  private vfs: MemFS;
+  private registryUrl: string;
+  private cwd: string;
+  private layout: LayoutStrategy;
+  private manifestCache = new Map<string, Manifest>();
+  private installed = new Set<string>();
+
+  constructor(
+    vfs: MemFS,
+    layout: LayoutStrategy,
+    options: { cwd?: string; registry?: string } = {},
+  ) {
+    this.vfs = vfs;
+    this.cwd = options.cwd || "/";
+    this.registryUrl = (
+      options.registry || "https://registry.npmjs.org"
+    ).replace(/\/$/, "");
+    this.layout = layout;
+  }
+
+  installSync(name: string): void {
+    if (this.installed.has(name)) return;
+    const destDir = this.layout.getPackageDir(this.cwd, name, "latest");
+    if (this.vfs.existsSync(destDir)) {
+      this.installed.add(name);
+      return;
+    }
+
+    const manifest = this.fetchManifestSync(name);
+    const latestTag = manifest["dist-tags"]?.latest;
+    if (!latestTag) throw new Error(`No latest version for ${name}`);
+
+    const version = manifest.versions[latestTag];
+    if (!version) throw new Error(`Version ${latestTag} not found for ${name}`);
+
+    this.installPackageSync(version);
+    this.installed.add(name);
+  }
+
+  private installPackageSync(pkg: ManifestVersion): void {
+    const destDir = this.layout.getPackageDir(this.cwd, pkg.name, pkg.version);
+    if (this.vfs.existsSync(destDir)) return;
+
+    const compressed = syncFetch(pkg.dist.tarball);
+    let tar: Uint8Array;
+    try {
+      tar = pako.ungzip(compressed);
+    } catch {
+      tar = compressed;
+    }
+
+    unpackTarSync(tar, this.vfs, destDir);
+    this.layout.createTopLevelLink(this.vfs, this.cwd, pkg.name, pkg.version);
+
+    const binEntries = normalizeBin(pkg.name, pkg.bin);
+    for (const [cmdName, binPath] of Object.entries(binEntries)) {
+      const targetPath = pathShim.join(destDir, binPath);
+      this.layout.createBinStub(this.vfs, this.cwd, cmdName, targetPath);
+    }
+
+    if (pkg.dependencies) {
+      for (const depName of Object.keys(pkg.dependencies)) {
+        try {
+          this.installSync(depName);
+        } catch {
+          /* skip optional failures */
+        }
+      }
+    }
+  }
+
+  private fetchManifestSync(name: string): Manifest {
+    if (this.manifestCache.has(name)) return this.manifestCache.get(name)!;
+
+    const encodedName = name.startsWith("@")
+      ? `@${encodeURIComponent(name.slice(1))}`
+      : encodeURIComponent(name);
+    const url = `${this.registryUrl}/${encodedName}`;
+
+    if (typeof XMLHttpRequest === "undefined") {
+      throw new Error(
+        "Synchronous auto-install requires XMLHttpRequest (browser environment)",
+      );
+    }
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url, false);
+    xhr.setRequestHeader("Accept", "application/json");
+    xhr.send();
+
+    if (xhr.status < 200 || xhr.status >= 300) {
+      throw new Error(`Failed to fetch manifest for ${name}: ${xhr.status}`);
+    }
+
+    const manifest = JSON.parse(xhr.responseText) as Manifest;
+    this.manifestCache.set(name, manifest);
+    return manifest;
+  }
+}

package/src/npm/tarball.ts

@@ -0,0 +1,136 @@
+import pako from "pako";
+import { MemFS } from "../memfs";
+import * as pathShim from "../polyfills/path";
+import type { PackageCache } from "./cache";
+
+const BLOCK = 512;
+const decoder = new TextDecoder();
+
+function decodeField(buf: Uint8Array, start: number, len: number): string {
+  let i = start;
+  const limit = start + len;
+  while (i < limit && buf[i] !== 0) i++;
+  return decoder.decode(buf.subarray(start, i));
+}
+
+function readSize(buf: Uint8Array, offset: number, len: number): number {
+  return parseInt(decodeField(buf, offset, len), 8) || 0;
+}
+
+function isZeroBlock(buf: Uint8Array): boolean {
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] !== 0) return false;
+  }
+  return true;
+}
+
+function decompress(raw: Uint8Array): Uint8Array {
+  try {
+    return pako.ungzip(raw);
+  } catch {
+    return raw;
+  }
+}
+
+async function fetchArchive(url: string): Promise<Uint8Array> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to download ${url}: ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+
+function* iterateEntries(tar: Uint8Array): Generator<{
+  name: string;
+  size: number;
+  type: number;
+  linkTarget: string;
+  data: Uint8Array | null;
+}> {
+  let pos = 0;
+  while (pos + BLOCK <= tar.length) {
+    const hdr = tar.subarray(pos, pos + BLOCK);
+    pos += BLOCK;
+
+    if (isZeroBlock(hdr)) break;
+
+    const rawName = decodeField(hdr, 0, 100);
+    if (!rawName) break;
+
+    const size = readSize(hdr, 124, 12);
+    const type = hdr[156];
+    const linkTarget = decodeField(hdr, 157, 100);
+    const prefix = decodeField(hdr, 345, 155);
+    const name = prefix ? `${prefix}/${rawName}` : rawName;
+
+    let data: Uint8Array | null = null;
+    if (size > 0 && pos + size <= tar.length) {
+      data = tar.subarray(pos, pos + size);
+    }
+
+    yield { name, size, type, linkTarget, data };
+    pos += Math.ceil(size / BLOCK) * BLOCK;
+  }
+}
+
+function stripPrefix(name: string, depth: number): string {
+  if (depth <= 0) return name;
+  return name.split("/").slice(depth).join("/");
+}
+
+function unpackEntries(
+  tar: Uint8Array,
+  vfs: MemFS,
+  dest: string,
+  stripDepth: number,
+): void {
+  vfs.mkdirSync(dest, { recursive: true });
+
+  for (const entry of iterateEntries(tar)) {
+    const relative = stripPrefix(entry.name, stripDepth);
+    if (!relative || relative === ".") continue;
+
+    const target = pathShim.join(dest, relative);
+    const parentDir = pathShim.dirname(target);
+
+    if (entry.type === 53 || entry.name.endsWith("/")) {
+      vfs.mkdirSync(target, { recursive: true });
+    } else if (entry.type === 0 || entry.type === 48) {
+      vfs.mkdirSync(parentDir, { recursive: true });
+      vfs.writeFileSync(
+        target,
+        entry.data ? new Uint8Array(entry.data) : new Uint8Array(0),
+      );
+    } else if (entry.type === 50 && entry.linkTarget) {
+      try {
+        vfs.mkdirSync(parentDir, { recursive: true });
+        vfs.symlinkSync(entry.linkTarget, target);
+      } catch {}
+    }
+  }
+}
+
+export async function downloadAndExtract(
+  url: string,
+  vfs: MemFS,
+  destDir: string,
+  stripComponents = 1,
+  cache?: PackageCache,
+): Promise<void> {
+  let compressed: Uint8Array;
+  if (cache) {
+    compressed = await cache.getTarball(url, () => fetchArchive(url));
+  } else {
+    compressed = await fetchArchive(url);
+  }
+  const tar = decompress(compressed);
+  unpackEntries(tar, vfs, destDir, stripComponents);
+}
+
+export async function extractTarball(
+  data: Uint8Array,
+  vfs: MemFS,
+  destDir: string,
+  stripComponents = 1,
+): Promise<void> {
+  const tar = decompress(data);
+  unpackEntries(tar, vfs, destDir, stripComponents);
+}

package/src/npm/workspaces.ts

@@ -0,0 +1,255 @@
+/**
+ * Monorepo workspace support.
+ *
+ * Parses `workspaces` field from package.json or `pnpm-workspace.yaml`
+ * and resolves `workspace:*` version specifiers to local packages.
+ *
+ * @example
+ * ```ts
+ * const workspaces = discoverWorkspaces(vfs, '/');
+ * // [{ name: '@myapp/utils', path: '/packages/utils', version: '1.0.0' }]
+ * ```
+ */
+
+import type { MemFS } from "../memfs";
+import * as pathShim from "../polyfills/path";
+
+export interface WorkspacePackage {
+  /** Package name from its package.json. */
+  name: string;
+  /** Absolute path to the workspace package directory. */
+  path: string;
+  /** Version from its package.json. */
+  version: string;
+}
+
+/**
+ * Discover all workspace packages in a monorepo.
+ *
+ * Checks for:
+ * 1. `workspaces` field in root package.json (npm/yarn format)
+ * 2. `pnpm-workspace.yaml` (pnpm format)
+ *
+ * Returns an array of discovered workspace packages with their names,
+ * paths, and versions.
+ */
+export function discoverWorkspaces(
+  vfs: MemFS,
+  cwd: string,
+): WorkspacePackage[] {
+  const patterns = getWorkspacePatterns(vfs, cwd);
+  if (patterns.length === 0) return [];
+
+  const packages: WorkspacePackage[] = [];
+
+  for (const pattern of patterns) {
+    // Expand glob-like patterns (e.g. "packages/*")
+    const dirs = expandWorkspacePattern(vfs, cwd, pattern);
+    for (const dir of dirs) {
+      const pkgJsonPath = pathShim.join(dir, "package.json");
+      try {
+        if (!vfs.existsSync(pkgJsonPath)) continue;
+        const pkg = JSON.parse(vfs.readFileSync(pkgJsonPath, "utf8"));
+        if (pkg.name) {
+          packages.push({
+            name: pkg.name,
+            path: dir,
+            version: pkg.version || "0.0.0",
+          });
+        }
+      } catch {
+        // Skip invalid package.json
+      }
+    }
+  }
+
+  return packages;
+}
+
+/**
+ * Read workspace patterns from package.json or pnpm-workspace.yaml.
+ */
+function getWorkspacePatterns(vfs: MemFS, cwd: string): string[] {
+  // Check package.json workspaces field
+  const pkgJsonPath = pathShim.join(cwd, "package.json");
+  try {
+    if (vfs.existsSync(pkgJsonPath)) {
+      const pkg = JSON.parse(vfs.readFileSync(pkgJsonPath, "utf8"));
+      if (Array.isArray(pkg.workspaces)) {
+        return pkg.workspaces;
+      }
+      if (pkg.workspaces?.packages && Array.isArray(pkg.workspaces.packages)) {
+        return pkg.workspaces.packages;
+      }
+    }
+  } catch {
+    /* skip */
+  }
+
+  // Check pnpm-workspace.yaml
+  const pnpmWsPath = pathShim.join(cwd, "pnpm-workspace.yaml");
+  try {
+    if (vfs.existsSync(pnpmWsPath)) {
+      const content = vfs.readFileSync(pnpmWsPath, "utf8");
+      return parsePnpmWorkspaceYaml(content);
+    }
+  } catch {
+    /* skip */
+  }
+
+  return [];
+}
+
+/**
+ * Parse a simple pnpm-workspace.yaml to extract package patterns.
+ * Handles the common format:
+ * ```yaml
+ * packages:
+ *   - 'packages/*'
+ *   - 'apps/*'
+ * ```
+ */
+function parsePnpmWorkspaceYaml(content: string): string[] {
+  const patterns: string[] = [];
+  let inPackages = false;
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "packages:" || trimmed === "packages :") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (trimmed.startsWith("- ")) {
+        // Strip quotes and the leading "- "
+        const pattern = trimmed
+          .slice(2)
+          .replace(/^['"]|['"]$/g, "")
+          .trim();
+        if (pattern) patterns.push(pattern);
+      } else if (trimmed && !trimmed.startsWith("#")) {
+        // Non-list item means we've left the packages section
+        break;
+      }
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Expand a workspace pattern like "packages/*" into actual directory paths.
+ */
+function expandWorkspacePattern(
+  vfs: MemFS,
+  cwd: string,
+  pattern: string,
+): string[] {
+  // Remove trailing /
+  pattern = pattern.replace(/\/+$/, "");
+
+  if (pattern.endsWith("/*")) {
+    // Glob: list children of the directory
+    const parentDir = pathShim.join(cwd, pattern.slice(0, -2));
+    try {
+      if (!vfs.existsSync(parentDir)) return [];
+      return vfs
+        .readdirSync(parentDir)
+        .filter(name => {
+          const full = pathShim.join(parentDir, name);
+          try {
+            return vfs.statSync(full).isDirectory();
+          } catch {
+            return false;
+          }
+        })
+        .map(name => pathShim.join(parentDir, name));
+    } catch {
+      return [];
+    }
+  }
+
+  if (pattern.endsWith("/**")) {
+    // Recursive glob: find all directories containing package.json
+    const parentDir = pathShim.join(cwd, pattern.slice(0, -3));
+    const results: string[] = [];
+    findPackageDirs(vfs, parentDir, results);
+    return results;
+  }
+
+  // Exact path
+  const dir = pathShim.join(cwd, pattern);
+  return vfs.existsSync(dir) ? [dir] : [];
+}
+
+function findPackageDirs(vfs: MemFS, dir: string, results: string[]): void {
+  try {
+    const pkgJson = pathShim.join(dir, "package.json");
+    if (vfs.existsSync(pkgJson)) results.push(dir);
+
+    for (const name of vfs.readdirSync(dir)) {
+      if (name === "node_modules" || name.startsWith(".")) continue;
+      const full = pathShim.join(dir, name);
+      try {
+        if (vfs.statSync(full).isDirectory()) {
+          findPackageDirs(vfs, full, results);
+        }
+      } catch {
+        /* skip */
+      }
+    }
+  } catch {
+    /* skip */
+  }
+}
+
+/**
+ * Resolve a `workspace:*` version specifier to the local package path.
+ * Returns the workspace package if found, or `null` if not a workspace dep.
+ */
+export function resolveWorkspaceDep(
+  specifier: string,
+  workspaces: WorkspacePackage[],
+): WorkspacePackage | null {
+  for (const ws of workspaces) {
+    if (ws.name === specifier) return ws;
+  }
+  return null;
+}
+
+/**
+ * Check if a version string is a workspace protocol specifier.
+ */
+export function isWorkspaceProtocol(version: string): boolean {
+  return version.startsWith("workspace:");
+}
+
+/**
+ * Create symlinks in node_modules for workspace packages, similar to
+ * how pnpm/yarn link local packages.
+ */
+export function linkWorkspaces(
+  vfs: MemFS,
+  cwd: string,
+  workspaces: WorkspacePackage[],
+): void {
+  const nmDir = pathShim.join(cwd, "node_modules");
+  vfs.mkdirSync(nmDir, { recursive: true });
+
+  for (const ws of workspaces) {
+    const linkPath = pathShim.join(nmDir, ws.name);
+    // Create parent for scoped packages
+    if (ws.name.includes("/")) {
+      const scope = pathShim.dirname(linkPath);
+      vfs.mkdirSync(scope, { recursive: true });
+    }
+    // Only create if not already present
+    if (!vfs.existsSync(linkPath)) {
+      try {
+        vfs.symlinkSync(ws.path, linkPath);
+      } catch {
+        // Symlink may already exist
+      }
+    }
+  }
+}