reorg: move JS ops implementations to cli/js/ops/, part 3 (#4302)

Following JS ops were moved to separate files in cli/js/ops directory:
- net
- tls
- fs

cli/js/ops/fs/chmod.ts

@@ -0,0 +1,22 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Synchronously changes the permission of a specific file/directory of
+ * specified path.  Ignores the process's umask.
+ *
+ *       Deno.chmodSync("/path/to/file", 0o666);
+ *
+ * Requires `allow-write` permission. */
+export function chmodSync(path: string, mode: number): void {
+  sendSync("op_chmod", { path, mode });
+}
+
+/** Changes the permission of a specific file/directory of specified path.
+ * Ignores the process's umask.
+ *
+ *       await Deno.chmod("/path/to/file", 0o666);
+ *
+ * Requires `allow-write` permission. */
+export async function chmod(path: string, mode: number): Promise<void> {
+  await sendAsync("op_chmod", { path, mode });
+}

cli/js/ops/fs/chown.ts

@@ -0,0 +1,32 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Synchronously change owner of a regular file or directory. Linux/Mac OS
+ * only at the moment.
+ *
+ * Requires `allow-write` permission.
+ *
+ * @param path path to the file
+ * @param uid user id of the new owner
+ * @param gid group id of the new owner
+ */
+export function chownSync(path: string, uid: number, gid: number): void {
+  sendSync("op_chown", { path, uid, gid });
+}
+
+/** Change owner of a regular file or directory. Linux/Mac OS only at the
+ * moment.
+ *
+ * Requires `allow-write` permission.
+ *
+ * @param path path to the file
+ * @param uid user id of the new owner
+ * @param gid group id of the new owner
+ */
+export async function chown(
+  path: string,
+  uid: number,
+  gid: number
+): Promise<void> {
+  await sendAsync("op_chown", { path, uid, gid });
+}

cli/js/ops/fs/copy_file.ts

@@ -0,0 +1,29 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Synchronously copies the contents and permissions of one file to another
+ * specified path, by default creating a new file if needed, else overwriting.
+ * Fails if target path is a directory or is unwritable.
+ *
+ *       Deno.copyFileSync("from.txt", "to.txt");
+ *
+ * Requires `allow-read` permission on fromPath.
+ * Requires `allow-write` permission on toPath. */
+export function copyFileSync(fromPath: string, toPath: string): void {
+  sendSync("op_copy_file", { from: fromPath, to: toPath });
+}
+
+/** Copies the contents and permissions of one file to another specified path,
+ * by default creating a new file if needed, else overwriting. Fails if target
+ * path is a directory or is unwritable.
+ *
+ *       await Deno.copyFile("from.txt", "to.txt");
+ *
+ * Requires `allow-read` permission on fromPath.
+ * Requires `allow-write` permission on toPath. */
+export async function copyFile(
+  fromPath: string,
+  toPath: string
+): Promise<void> {
+  await sendAsync("op_copy_file", { from: fromPath, to: toPath });
+}

cli/js/ops/fs/dir.ts

@@ -0,0 +1,27 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync } from "../dispatch_json.ts";
+
+/**
+ * **UNSTABLE**: maybe needs permissions.
+ *
+ * Return a string representing the current working directory.
+ *
+ * If the current directory can be reached via multiple paths (due to symbolic
+ * links), `cwd()` may return any one of them.
+ *
+ * Throws `Deno.errors.NotFound` if directory not available.
+ */
+export function cwd(): string {
+  return sendSync("op_cwd");
+}
+
+/**
+ * **UNSTABLE**: maybe needs permissions.
+ *
+ * Change the current working directory to the specified path.
+ *
+ * Throws `Deno.errors.NotFound` if directory not available.
+ */
+export function chdir(directory: string): void {
+  sendSync("op_chdir", { directory });
+}

cli/js/ops/fs/link.ts

@@ -0,0 +1,20 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Creates `newname` as a hard link to `oldname`.
+ *
+ *       Deno.linkSync("old/name", "new/name");
+ *
+ * Requires `allow-read` and `allow-write` permissions. */
+export function linkSync(oldname: string, newname: string): void {
+  sendSync("op_link", { oldname, newname });
+}
+
+/** Creates `newname` as a hard link to `oldname`.
+ *
+ *       await Deno.link("old/name", "new/name");
+ *
+ * Requires `allow-read` and `allow-write` permissions. */
+export async function link(oldname: string, newname: string): Promise<void> {
+  await sendAsync("op_link", { oldname, newname });
+}

cli/js/ops/fs/make_temp.ts

@@ -0,0 +1,90 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+export interface MakeTempOptions {
+  /** Directory where the temporary directory should be created (defaults to
+   * the env variable TMPDIR, or the system's default, usually /tmp). */
+  dir?: string;
+  /** String that should precede the random portion of the temporary
+   * directory's name. */
+  prefix?: string;
+  /** String that should follow the random portion of the temporary
+   * directory's name. */
+  suffix?: string;
+}
+
+/** Synchronously creates a new temporary directory in the directory `dir`,
+ * its name beginning with `prefix` and ending with `suffix`.
+ *
+ * It returns the full path to the newly created directory.
+ *
+ * If `dir` is unspecified, uses the default directory for temporary files.
+ * Multiple programs calling this function simultaneously will create different
+ * directories. It is the caller's responsibility to remove the directory when
+ * no longer needed.
+ *
+ *       const tempDirName0 = Deno.makeTempDirSync();
+ *       const tempDirName1 = Deno.makeTempDirSync({ prefix: 'my_temp' });
+ *
+ * Requires `allow-write` permission. */
+export function makeTempDirSync(options: MakeTempOptions = {}): string {
+  return sendSync("op_make_temp_dir", options);
+}
+
+/** Creates a new temporary directory in the directory `dir`, its name
+ * beginning with `prefix` and ending with `suffix`.
+ *
+ * It resolves to the full path to the newly created directory.
+ *
+ * If `dir` is unspecified, uses the default directory for temporary files.
+ * Multiple programs calling this function simultaneously will create different
+ * directories. It is the caller's responsibility to remove the directory when
+ * no longer needed.
+ *
+ *       const tempDirName0 = await Deno.makeTempDir();
+ *       const tempDirName1 = await Deno.makeTempDir({ prefix: 'my_temp' });
+ *
+ * Requires `allow-write` permission. */
+export async function makeTempDir(
+  options: MakeTempOptions = {}
+): Promise<string> {
+  return await sendAsync("op_make_temp_dir", options);
+}
+
+/** Synchronously creates a new temporary file in the directory `dir`, its name
+ * beginning with `prefix` and ending with `suffix`.
+ *
+ * It returns the full path to the newly created file.
+ *
+ * If `dir` is unspecified, uses the default directory for temporary files.
+ * Multiple programs calling this function simultaneously will create different
+ * files. It is the caller's responsibility to remove the file when
+ * no longer needed.
+ *
+ *       const tempFileName0 = Deno.makeTempFileSync();
+ *       const tempFileName1 = Deno.makeTempFileSync({ prefix: 'my_temp' });
+ *
+ * Requires `allow-write` permission. */
+export function makeTempFileSync(options: MakeTempOptions = {}): string {
+  return sendSync("op_make_temp_file", options);
+}
+
+/** Creates a new temporary file in the directory `dir`, its name
+ * beginning with `prefix` and ending with `suffix`.
+ *
+ * It resolves to the full path to the newly created file.
+ *
+ * If `dir` is unspecified, uses the default directory for temporary files.
+ * Multiple programs calling this function simultaneously will create different
+ * files. It is the caller's responsibility to remove the file when
+ * no longer needed.
+ *
+ *       const tempFileName0 = await Deno.makeTempFile();
+ *       const tempFileName1 = await Deno.makeTempFile({ prefix: 'my_temp' });
+ *
+ * Requires `allow-write` permission. */
+export async function makeTempFile(
+  options: MakeTempOptions = {}
+): Promise<string> {
+  return await sendAsync("op_make_temp_file", options);
+}

cli/js/ops/fs/mkdir.ts

@@ -0,0 +1,67 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+// TODO(ry) The complexity in argument parsing is to support deprecated forms of
+// mkdir and mkdirSync.
+function mkdirArgs(
+  path: string,
+  optionsOrRecursive?: MkdirOptions | boolean,
+  mode?: number
+): { path: string; recursive: boolean; mode: number } {
+  const args = { path, recursive: false, mode: 0o777 };
+  if (typeof optionsOrRecursive == "boolean") {
+    args.recursive = optionsOrRecursive;
+    if (mode) {
+      args.mode = mode;
+    }
+  } else if (optionsOrRecursive) {
+    if (typeof optionsOrRecursive.recursive == "boolean") {
+      args.recursive = optionsOrRecursive.recursive;
+    }
+    if (optionsOrRecursive.mode) {
+      args.mode = optionsOrRecursive.mode;
+    }
+  }
+  return args;
+}
+
+export interface MkdirOptions {
+  /** Defaults to `false`. If set to `true`, means that any intermediate
+   * directories will also be created (as with the shell command `mkdir -p`).
+   * Intermediate directories are created with the same permissions.
+   * When recursive is set to `true`, succeeds silently (without changing any
+   * permissions) if a directory already exists at the path. */
+  recursive?: boolean;
+  /** Permissions to use when creating the directory (defaults to `0o777`,
+   * before the process's umask).
+   * Does nothing/raises on Windows. */
+  mode?: number;
+}
+
+/** Synchronously creates a new directory with the specified path.
+ *
+ *       Deno.mkdirSync("new_dir");
+ *       Deno.mkdirSync("nested/directories", { recursive: true });
+ *
+ * Requires `allow-write` permission. */
+export function mkdirSync(
+  path: string,
+  optionsOrRecursive?: MkdirOptions | boolean,
+  mode?: number
+): void {
+  sendSync("op_mkdir", mkdirArgs(path, optionsOrRecursive, mode));
+}
+
+/** Creates a new directory with the specified path.
+ *
+ *       await Deno.mkdir("new_dir");
+ *       await Deno.mkdir("nested/directories", { recursive: true });
+ *
+ * Requires `allow-write` permission. */
+export async function mkdir(
+  path: string,
+  optionsOrRecursive?: MkdirOptions | boolean,
+  mode?: number
+): Promise<void> {
+  await sendAsync("op_mkdir", mkdirArgs(path, optionsOrRecursive, mode));
+}

cli/js/ops/fs/open.ts

@@ -0,0 +1,67 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+export interface OpenOptions {
+  /** Sets the option for read access. This option, when `true`, means that the
+   * file should be read-able if opened. */
+  read?: boolean;
+  /** Sets the option for write access. This option, when `true`, means that
+   * the file should be write-able if opened. If the file already exists,
+   * any write calls on it will overwrite its contents, by default without
+   * truncating it. */
+  write?: boolean;
+  /**Sets the option for the append mode. This option, when `true`, means that
+   * writes will append to a file instead of overwriting previous contents.
+   * Note that setting `{ write: true, append: true }` has the same effect as
+   * setting only `{ append: true }`. */
+  append?: boolean;
+  /** Sets the option for truncating a previous file. If a file is
+   * successfully opened with this option set it will truncate the file to `0`
+   * length if it already exists. The file must be opened with write access
+   * for truncate to work. */
+  truncate?: boolean;
+  /** Sets the option to allow creating a new file, if one doesn't already
+   * exist at the specified path. Requires write or append access to be
+   * used. */
+  create?: boolean;
+  /** Defaults to `false`. If set to `true`, no file, directory, or symlink is
+   * allowed to exist at the target location. Requires write or append
+   * access to be used. When createNew is set to `true`, create and truncate
+   * are ignored. */
+  createNew?: boolean;
+}
+
+/** A set of string literals which specify the open mode of a file.
+ *
+ * |Value |Description                                                                                       |
+ * |------|--------------------------------------------------------------------------------------------------|
+ * |`"r"` |Read-only. Default. Starts at beginning of file.                                                  |
+ * |`"r+"`|Read-write. Start at beginning of file.                                                           |
+ * |`"w"` |Write-only. Opens and truncates existing file or creates new one for writing only.                |
+ * |`"w+"`|Read-write. Opens and truncates existing file or creates new one for writing and reading.         |
+ * |`"a"` |Write-only. Opens existing file or creates new one. Each write appends content to the end of file.|
+ * |`"a+"`|Read-write. Behaves like `"a"` and allows to read from file.                                      |
+ * |`"x"` |Write-only. Exclusive create - creates new file only if one doesn't exist already.                |
+ * |`"x+"`|Read-write. Behaves like `x` and allows reading from file.                                        |
+ */
+export type OpenMode = "r" | "r+" | "w" | "w+" | "a" | "a+" | "x" | "x+";
+
+export function openSync(
+  path: string,
+  mode: OpenMode | undefined,
+  options: OpenOptions | undefined
+): number {
+  return sendSync("op_open", { path, options, mode });
+}
+
+export async function open(
+  path: string,
+  mode: OpenMode | undefined,
+  options: OpenOptions | undefined
+): Promise<number> {
+  return await sendAsync("op_open", {
+    path,
+    options,
+    mode
+  });
+}

cli/js/ops/fs/read_dir.ts

@@ -0,0 +1,37 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+import { FileInfo, FileInfoImpl } from "../../file_info.ts";
+import { StatResponse } from "./stat.ts";
+
+interface ReadDirResponse {
+  entries: StatResponse[];
+}
+
+function res(response: ReadDirResponse): FileInfo[] {
+  return response.entries.map(
+    (statRes: StatResponse): FileInfo => {
+      return new FileInfoImpl(statRes);
+    }
+  );
+}
+
+/** Synchronously reads the directory given by `path` and returns an array of
+ * `Deno.FileInfo`.
+ *
+ *       const files = Deno.readdirSync("/");
+ *
+ * Requires `allow-read` permission. */
+export function readdirSync(path: string): FileInfo[] {
+  return res(sendSync("op_read_dir", { path }));
+}
+
+/** UNSTABLE: Maybe need to return an `AsyncIterable`.
+ *
+ * Reads the directory given by `path` and resolves to an array of `Deno.FileInfo`.
+ *
+ *       const files = await Deno.readdir("/");
+ *
+ * Requires `allow-read` permission. */
+export async function readdir(path: string): Promise<FileInfo[]> {
+  return res(await sendAsync("op_read_dir", { path }));
+}

cli/js/ops/fs/read_link.ts

@@ -0,0 +1,20 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Returns the destination of the named symbolic link.
+ *
+ *       const targetPath = Deno.readlinkSync("symlink/path");
+ *
+ * Requires `allow-read` permission. */
+export function readlinkSync(path: string): string {
+  return sendSync("op_read_link", { path });
+}
+
+/** Resolves to the destination of the named symbolic link.
+ *
+ *       const targetPath = await Deno.readlink("symlink/path");
+ *
+ * Requires `allow-read` permission. */
+export async function readlink(path: string): Promise<string> {
+  return await sendAsync("op_read_link", { path });
+}

cli/js/ops/fs/realpath.ts

@@ -0,0 +1,18 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Returns absolute normalized path with symbolic links resolved synchronously.
+ *
+ *       const realPath = Deno.realpathSync("./some/path");
+ */
+export function realpathSync(path: string): string {
+  return sendSync("op_realpath", { path });
+}
+
+/** Returns absolute normalized path with symbolic links resolved.
+ *
+ *       const realPath = await Deno.realpath("./some/path");
+ */
+export async function realpath(path: string): Promise<string> {
+  return await sendAsync("op_realpath", { path });
+}

cli/js/ops/fs/remove.ts

@@ -0,0 +1,33 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+export interface RemoveOptions {
+  /** Defaults to `false`. If set to `true`, path will be removed even if
+   * it's a non-empty directory. */
+  recursive?: boolean;
+}
+
+/** Synchronously removes the named file or directory. Throws error if
+ * permission denied, path not found, or path is a non-empty directory and
+ * the `recursive` option isn't set to `true`.
+ *
+ *       Deno.removeSync("/path/to/dir/or/file", { recursive: false });
+ *
+ * Requires `allow-write` permission. */
+export function removeSync(path: string, options: RemoveOptions = {}): void {
+  sendSync("op_remove", { path, recursive: !!options.recursive });
+}
+
+/** Removes the named file or directory. Throws error if permission denied,
+ * path not found, or path is a non-empty directory and the `recursive`
+ * option isn't set to `true`.
+ *
+ *       await Deno.remove("/path/to/dir/or/file", { recursive: false });
+ *
+ * Requires `allow-write` permission. */
+export async function remove(
+  path: string,
+  options: RemoveOptions = {}
+): Promise<void> {
+  await sendAsync("op_remove", { path, recursive: !!options.recursive });
+}

cli/js/ops/fs/rename.ts

@@ -0,0 +1,25 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+/** Synchronously renames (moves) `oldpath` to `newpath`. If `newpath` already
+ * exists and is not a directory, `renameSync()` replaces it. OS-specific
+ * restrictions may apply when `oldpath` and `newpath` are in different
+ * directories.
+ *
+ *       Deno.renameSync("old/path", "new/path");
+ *
+ * Requires `allow-read` and `allow-write` permissions. */
+export function renameSync(oldpath: string, newpath: string): void {
+  sendSync("op_rename", { oldpath, newpath });
+}
+
+/** Renames (moves) `oldpath` to `newpath`. If `newpath` already exists and is
+ * not a directory, `rename()` replaces it. OS-specific restrictions may apply
+ * when `oldpath` and `newpath` are in different directories.
+ *
+ *       await Deno.rename("old/path", "new/path");
+ *
+ * Requires `allow-read` and `allow-write`. */
+export async function rename(oldpath: string, newpath: string): Promise<void> {
+  await sendAsync("op_rename", { oldpath, newpath });
+}

cli/js/ops/fs/seek.ts

@@ -0,0 +1,33 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+import { SeekMode } from "../../io.ts";
+
+/** Synchronously seek a file ID to the given offset under mode given by `whence`.
+ *
+ * Returns the number of cursor position.
+ *
+ *       const file = Deno.openSync("/foo/bar.txt");
+ *       const position = Deno.seekSync(file.rid, 0, 0);
+ */
+export function seekSync(
+  rid: number,
+  offset: number,
+  whence: SeekMode
+): number {
+  return sendSync("op_seek", { rid, offset, whence });
+}
+
+/** Seek a file ID to the given offset under mode given by `whence`.
+ *
+ * Resolves with the number of cursor position.
+ *
+ *      const file = await Deno.open("/foo/bar.txt");
+ *      const position = await Deno.seek(file.rid, 0, 0);
+ */
+export async function seek(
+  rid: number,
+  offset: number,
+  whence: SeekMode
+): Promise<number> {
+  return await sendAsync("op_seek", { rid, offset, whence });
+}

cli/js/ops/fs/stat.ts

@@ -0,0 +1,84 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+import { FileInfo, FileInfoImpl } from "../../file_info.ts";
+
+/** @internal */
+export interface StatResponse {
+  isFile: boolean;
+  isSymlink: boolean;
+  len: number;
+  modified: number;
+  accessed: number;
+  created: number;
+  name: string | null;
+  // Unix only members
+  dev: number;
+  ino: number;
+  mode: number;
+  nlink: number;
+  uid: number;
+  gid: number;
+  rdev: number;
+  blksize: number;
+  blocks: number;
+}
+
+/** Resolves to a `Deno.FileInfo` for the specified `path`. If `path` is a
+ * symlink, information for the symlink will be returned.
+ *
+ *       const fileInfo = await Deno.lstat("hello.txt");
+ *       assert(fileInfo.isFile());
+ *
+ * Requires `allow-read` permission. */
+export async function lstat(path: string): Promise<FileInfo> {
+  const res = (await sendAsync("op_stat", {
+    path,
+    lstat: true
+  })) as StatResponse;
+  return new FileInfoImpl(res);
+}
+
+/** Synchronously returns a `Deno.FileInfo` for the specified `path`. If
+ * `path` is a symlink, information for the symlink will be returned.
+ *
+ *       const fileInfo = Deno.lstatSync("hello.txt");
+ *       assert(fileInfo.isFile());
+ *
+ * Requires `allow-read` permission. */
+export function lstatSync(path: string): FileInfo {
+  const res = sendSync("op_stat", {
+    path,
+    lstat: true
+  }) as StatResponse;
+  return new FileInfoImpl(res);
+}
+
+/** Resolves to a `Deno.FileInfo` for the specified `path`. Will always
+ * follow symlinks.
+ *
+ *       const fileInfo = await Deno.stat("hello.txt");
+ *       assert(fileInfo.isFile());
+ *
+ * Requires `allow-read` permission. */
+export async function stat(path: string): Promise<FileInfo> {
+  const res = (await sendAsync("op_stat", {
+    path,
+    lstat: false
+  })) as StatResponse;
+  return new FileInfoImpl(res);
+}
+
+/** Synchronously returns a `Deno.FileInfo` for the specified `path`. Will
+ * always follow symlinks.
+ *
+ *       const fileInfo = Deno.statSync("hello.txt");
+ *       assert(fileInfo.isFile());
+ *
+ * Requires `allow-read` permission. */
+export function statSync(path: string): FileInfo {
+  const res = sendSync("op_stat", {
+    path,
+    lstat: false
+  }) as StatResponse;
+  return new FileInfoImpl(res);
+}

cli/js/ops/fs/symlink.ts

@@ -0,0 +1,44 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+import * as util from "../../util.ts";
+import { build } from "../../build.ts";
+
+/** **UNSTABLE**: `type` argument type may be changed to `"dir" | "file"`.
+ *
+ * Creates `newname` as a symbolic link to `oldname`. The type argument can be
+ * set to `dir` or `file`. Is only available on Windows and ignored on other
+ * platforms.
+ *
+ *       Deno.symlinkSync("old/name", "new/name");
+ *
+ * Requires `allow-read` and `allow-write` permissions. */
+export function symlinkSync(
+  oldname: string,
+  newname: string,
+  type?: string
+): void {
+  if (build.os === "win" && type) {
+    return util.notImplemented();
+  }
+  sendSync("op_symlink", { oldname, newname });
+}
+
+/** **UNSTABLE**: `type` argument may be changed to "dir" | "file"
+ *
+ * Creates `newname` as a symbolic link to `oldname`. The type argument can be
+ * set to `dir` or `file`. Is only available on Windows and ignored on other
+ * platforms.
+ *
+ *       await Deno.symlink("old/name", "new/name");
+ *
+ * Requires `allow-read` and `allow-write` permissions. */
+export async function symlink(
+  oldname: string,
+  newname: string,
+  type?: string
+): Promise<void> {
+  if (build.os === "win" && type) {
+    return util.notImplemented();
+  }
+  await sendAsync("op_symlink", { oldname, newname });
+}

cli/js/ops/fs/truncate.ts

@@ -0,0 +1,33 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+function coerceLen(len?: number): number {
+  if (!len) {
+    return 0;
+  }
+
+  if (len < 0) {
+    return 0;
+  }
+
+  return len;
+}
+
+/** Synchronously truncates or extends the specified file, to reach the
+ * specified `len`.
+ *
+ *       Deno.truncateSync("hello.txt", 10);
+ *
+ * Requires `allow-write` permission. */
+export function truncateSync(path: string, len?: number): void {
+  sendSync("op_truncate", { path, len: coerceLen(len) });
+}
+
+/** Truncates or extends the specified file, to reach the specified `len`.
+ *
+ *       await Deno.truncate("hello.txt", 10);
+ *
+ * Requires `allow-write` permission. */
+export async function truncate(path: string, len?: number): Promise<void> {
+  await sendAsync("op_truncate", { path, len: coerceLen(len) });
+}

cli/js/ops/fs/utime.ts

@@ -0,0 +1,50 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "../dispatch_json.ts";
+
+function toSecondsFromEpoch(v: number | Date): number {
+  return v instanceof Date ? v.valueOf() / 1000 : v;
+}
+
+/** **UNSTABLE**: needs investigation into high precision time.
+ *
+ * Synchronously changes the access and modification times of a file system
+ * object referenced by `path`. Given times are either in seconds (UNIX epoch
+ * time) or as `Date` objects.
+ *
+ *       Deno.utimeSync("myfile.txt", 1556495550, new Date());
+ *
+ * Requires `allow-write` permission. */
+export function utimeSync(
+  path: string,
+  atime: number | Date,
+  mtime: number | Date
+): void {
+  sendSync("op_utime", {
+    path,
+    // TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
+    atime: toSecondsFromEpoch(atime),
+    mtime: toSecondsFromEpoch(mtime)
+  });
+}
+
+/** **UNSTABLE**: needs investigation into high precision time.
+ *
+ * Changes the access and modification times of a file system object
+ * referenced by `path`. Given times are either in seconds (UNIX epoch time)
+ * or as `Date` objects.
+ *
+ *       await Deno.utime("myfile.txt", 1556495550, new Date());
+ *
+ * Requires `allow-write` permission. */
+export async function utime(
+  path: string,
+  atime: number | Date,
+  mtime: number | Date
+): Promise<void> {
+  await sendAsync("op_utime", {
+    path,
+    // TODO(ry) split atime, mtime into [seconds, nanoseconds] tuple
+    atime: toSecondsFromEpoch(atime),
+    mtime: toSecondsFromEpoch(mtime)
+  });
+}

cli/js/ops/net.ts

@@ -0,0 +1,117 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendSync, sendAsync } from "./dispatch_json.ts";
+
+export type Transport = "tcp" | "udp";
+// TODO support other types:
+// export type Transport = "tcp" | "tcp4" | "tcp6" | "unix" | "unixpacket";
+
+export enum ShutdownMode {
+  // See http://man7.org/linux/man-pages/man2/shutdown.2.html
+  // Corresponding to SHUT_RD, SHUT_WR, SHUT_RDWR
+  Read = 0,
+  Write,
+  ReadWrite // unused
+}
+
+/** Shut down socket send and receive operations.
+ *
+ * Matches behavior of POSIX shutdown(3).
+ *
+ *       const listener = Deno.listen({ port: 80 });
+ *       const conn = await listener.accept();
+ *       Deno.shutdown(conn.rid, Deno.ShutdownMode.Write);
+ */
+export function shutdown(rid: number, how: ShutdownMode): void {
+  sendSync("op_shutdown", { rid, how });
+}
+
+interface AcceptResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+  remoteAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export async function accept(rid: number): Promise<AcceptResponse> {
+  return await sendAsync("op_accept", { rid });
+}
+
+export interface ListenRequest {
+  transport: Transport;
+  hostname: string;
+  port: number;
+}
+
+interface ListenResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export function listen(args: ListenRequest): ListenResponse {
+  return sendSync("op_listen", args);
+}
+
+interface ConnectResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+  remoteAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export interface ConnectRequest {
+  transport: Transport;
+  hostname: string;
+  port: number;
+}
+
+export async function connect(args: ConnectRequest): Promise<ConnectResponse> {
+  return await sendAsync("op_connect", args);
+}
+
+interface ReceiveResponse {
+  size: number;
+  remoteAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export async function receive(
+  rid: number,
+  zeroCopy: Uint8Array
+): Promise<ReceiveResponse> {
+  return await sendAsync("op_receive", { rid }, zeroCopy);
+}
+
+export interface SendRequest {
+  rid: number;
+  hostname: string;
+  port: number;
+  transport: Transport;
+}
+
+export async function send(
+  args: SendRequest,
+  zeroCopy: Uint8Array
+): Promise<void> {
+  await sendAsync("op_send", args, zeroCopy);
+}

cli/js/ops/timers.ts

@@ -8,3 +8,12 @@ export function stopGlobalTimer(): void {
 export async function startGlobalTimer(timeout: number): Promise<void> {
   await sendAsync("op_global_timer", { timeout });
 }
+
+interface NowResponse {
+  seconds: number;
+  subsecNanos: number;
+}
+
+export function now(): NowResponse {
+  return sendSync("op_now");
+}

cli/js/ops/tls.ts

@@ -0,0 +1,69 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { sendAsync, sendSync } from "./dispatch_json.ts";
+import { Transport } from "./net.ts";
+
+export interface ConnectTLSRequest {
+  transport: Transport;
+  hostname: string;
+  port: number;
+  cert_file?: string;
+}
+
+interface ConnectTLSResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+  remoteAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export async function connectTLS(
+  args: ConnectTLSRequest
+): Promise<ConnectTLSResponse> {
+  return await sendAsync("op_connect_tls", args);
+}
+
+interface AcceptTLSResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+  remoteAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export async function acceptTLS(rid: number): Promise<AcceptTLSResponse> {
+  return await sendAsync("op_accept_tls", { rid });
+}
+
+export interface ListenTLSRequest {
+  port: number;
+  hostname: string;
+  transport: Transport;
+  certFile: string;
+  keyFile: string;
+}
+
+interface ListenTLSResponse {
+  rid: number;
+  localAddr: {
+    hostname: string;
+    port: number;
+    transport: Transport;
+  };
+}
+
+export function listenTLS(args: ListenTLSRequest): ListenTLSResponse {
+  return sendSync("op_listen_tls", args);
+}