@jingyi0605/codingns 0.8.0 → 0.8.5

package/vendor/node-pty-fork/scripts/verify-tarball.cjs

@@ -0,0 +1,80 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const tarballs = fs.readdirSync(packageRoot).filter((fileName) => fileName.endsWith(".tgz")).sort();
+
+if (tarballs.length === 0) {
+  console.error("[codingns-node-pty] tarball 校验失败：当前目录没有 npm pack 产物。");
+  process.exit(1);
+}
+
+const tarballPath = path.join(packageRoot, tarballs[tarballs.length - 1]);
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "codingns-node-pty-pack-"));
+
+const extractResult = spawnSync("tar", ["-xzf", tarballPath, "-C", tempRoot], {
+  cwd: packageRoot,
+  encoding: "utf8",
+  shell: process.platform === "win32"
+});
+
+if (extractResult.status !== 0) {
+  process.stderr.write(`${extractResult.stdout || ""}${extractResult.stderr || ""}`);
+  console.error(`[codingns-node-pty] tarball 校验失败：无法解包 ${tarballPath}`);
+  process.exit(1);
+}
+
+const unpackedRoot = path.join(tempRoot, "package");
+const packageJsonPath = path.join(unpackedRoot, "package.json");
+
+if (!fs.existsSync(packageJsonPath)) {
+  console.error("[codingns-node-pty] tarball 校验失败：解包后缺少 package/package.json。");
+  process.exit(1);
+}
+
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+if (packageJson.name !== "@codingns/node-pty") {
+  console.error(`[codingns-node-pty] tarball 校验失败：包名不对，检测到 ${packageJson.name || "unknown"}。`);
+  process.exit(1);
+}
+
+if (packageJson.version !== "1.0.0-cns.1") {
+  console.error(`[codingns-node-pty] tarball 校验失败：版本不对，检测到 ${packageJson.version || "unknown"}。`);
+  process.exit(1);
+}
+
+if (packageJson.types !== "./typings/node-pty.d.ts") {
+  console.error(`[codingns-node-pty] tarball 校验失败：types 入口不对，检测到 ${packageJson.types || "unknown"}。`);
+  process.exit(1);
+}
+
+const requiredPaths = [
+  path.join(unpackedRoot, "README.md"),
+  path.join(unpackedRoot, "LICENSE"),
+  path.join(unpackedRoot, "lib", "index.js"),
+  path.join(unpackedRoot, "typings", "node-pty.d.ts"),
+  path.join(unpackedRoot, "binding.gyp"),
+  path.join(unpackedRoot, "scripts", "verify-runtime.cjs"),
+  path.join(unpackedRoot, "scripts", "verify-tarball.cjs"),
+  path.join(unpackedRoot, "scripts", "smoke-load.cjs"),
+  path.join(unpackedRoot, "scripts", "install-smoke.cjs"),
+  path.join(unpackedRoot, "build", "Release", "conpty.node"),
+  path.join(unpackedRoot, "build", "Release", "conpty_console_list.node"),
+  path.join(unpackedRoot, "build", "Release", "pty.node"),
+  path.join(unpackedRoot, "build", "Release", "winpty-agent.exe"),
+  path.join(unpackedRoot, "build", "Release", "winpty.dll")
+];
+
+for (const filePath of requiredPaths) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`[codingns-node-pty] tarball 校验失败：缺少关键文件 ${filePath}`);
+    process.exit(1);
+  }
+}
+
+console.log(`[codingns-node-pty] tarball 校验通过：${path.basename(tarballPath)}`);

package/vendor/node-pty-fork/src/conpty_console_list_agent.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ *
+ * This module fetches the console process list for a particular PID. It must be
+ * called from a different process (child_process.fork) as there can only be a
+ * single console attached to a process.
+ */
+
+let getConsoleProcessList: any;
+try {
+  getConsoleProcessList = require('../build/Release/conpty_console_list.node').getConsoleProcessList;
+} catch (err) {
+  getConsoleProcessList = require('../build/Debug/conpty_console_list.node').getConsoleProcessList;
+}
+
+const shellPid = parseInt(process.argv[2], 10);
+const consoleProcessList = getConsoleProcessList(shellPid);
+process.send!({ consoleProcessList });
+process.exit(0);

package/vendor/node-pty-fork/src/eventEmitter2.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+import * as assert from 'assert';
+import { EventEmitter2 } from './eventEmitter2';
+
+describe('EventEmitter2', () => {
+  it('should fire listeners multiple times', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    emitter.event(data => order.push(data + 'b'));
+    emitter.fire(1);
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '2a', '2b' ]);
+  });
+
+  it('should not fire listeners once disposed', () => {
+    const order: string[] = [];
+    const emitter = new EventEmitter2<number>();
+    emitter.event(data => order.push(data + 'a'));
+    const disposeB = emitter.event(data => order.push(data + 'b'));
+    emitter.event(data => order.push(data + 'c'));
+    emitter.fire(1);
+    disposeB.dispose();
+    emitter.fire(2);
+    assert.deepEqual(order, [ '1a', '1b', '1c', '2a', '2c' ]);
+  });
+});

package/vendor/node-pty-fork/src/eventEmitter2.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+import { IDisposable } from './types';
+
+interface IListener<T> {
+  (e: T): void;
+}
+
+export interface IEvent<T> {
+  (listener: (e: T) => any): IDisposable;
+}
+
+export class EventEmitter2<T> {
+  private _listeners: IListener<T>[] = [];
+  private _event?: IEvent<T>;
+
+  public get event(): IEvent<T> {
+    if (!this._event) {
+      this._event = (listener: (e: T) => any) => {
+        this._listeners.push(listener);
+        const disposable = {
+          dispose: () => {
+            for (let i = 0; i < this._listeners.length; i++) {
+              if (this._listeners[i] === listener) {
+                this._listeners.splice(i, 1);
+                return;
+              }
+            }
+          }
+        };
+        return disposable;
+      };
+    }
+    return this._event;
+  }
+
+  public fire(data: T): void {
+    const queue: IListener<T>[] = [];
+    for (let i = 0; i < this._listeners.length; i++) {
+      queue.push(this._listeners[i]);
+    }
+    for (let i = 0; i < queue.length; i++) {
+      queue[i].call(undefined, data);
+    }
+  }
+}

package/vendor/node-pty-fork/src/index.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2012-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import { ITerminal, IPtyOpenOptions, IPtyForkOptions, IWindowsPtyForkOptions } from './interfaces';
+import { ArgvOrCommandLine } from './types';
+
+let terminalCtor: any;
+if (process.platform === 'win32') {
+  terminalCtor = require('./windowsTerminal').WindowsTerminal;
+} else {
+  terminalCtor = require('./unixTerminal').UnixTerminal;
+}
+
+/**
+ * Forks a process as a pseudoterminal.
+ * @param file The file to launch.
+ * @param args The file's arguments as argv (string[]) or in a pre-escaped
+ * CommandLine format (string). Note that the CommandLine option is only
+ * available on Windows and is expected to be escaped properly.
+ * @param options The options of the terminal.
+ * @throws When the file passed to spawn with does not exists.
+ * @see CommandLineToArgvW https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx
+ * @see Parsing C++ Comamnd-Line Arguments https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+ * @see GetCommandLine https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156.aspx
+ */
+export function spawn(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+/** @deprecated */
+export function fork(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+/** @deprecated */
+export function createTerminal(file?: string, args?: ArgvOrCommandLine, opt?: IPtyForkOptions | IWindowsPtyForkOptions): ITerminal {
+  return new terminalCtor(file, args, opt);
+}
+
+export function open(options: IPtyOpenOptions): ITerminal {
+  return terminalCtor.open(options);
+}
+
+/**
+ * Expose the native API when not Windows, note that this is not public API and
+ * could be removed at any time.
+ */
+export const native = (process.platform !== 'win32' ? require('../build/Release/pty.node') : null);

package/vendor/node-pty-fork/src/interfaces.ts

@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+export interface IProcessEnv {
+  [key: string]: string | undefined;
+}
+
+export interface ITerminal {
+  /**
+   * Gets the name of the process.
+   */
+  process: string;
+
+  /**
+   * Gets the process ID.
+   */
+  pid: number;
+
+  /**
+   * Writes data to the socket.
+   * @param data The data to write.
+   */
+  write(data: string): void;
+
+  /**
+   * Resize the pty.
+   * @param cols The number of columns.
+   * @param rows The number of rows.
+   */
+  resize(cols: number, rows: number): void;
+
+  /**
+   * Clears the pty's internal representation of its buffer. This is a no-op
+   * unless on Windows/ConPTY.
+   */
+  clear(): void;
+
+  /**
+   * Close, kill and destroy the socket.
+   */
+  destroy(): void;
+
+  /**
+   * Kill the pty.
+   * @param signal The signal to send, by default this is SIGHUP. This is not
+   * supported on Windows.
+   */
+  kill(signal?: string): void;
+
+  /**
+   * Set the pty socket encoding.
+   */
+  setEncoding(encoding: string | null): void;
+
+  /**
+   * Resume the pty socket.
+   */
+  resume(): void;
+
+  /**
+   * Pause the pty socket.
+   */
+  pause(): void;
+
+  /**
+   * Alias for ITerminal.on(eventName, listener).
+   */
+  addListener(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Adds the listener function to the end of the listeners array for the event
+   * named eventName.
+   * @param eventName The event name.
+   * @param listener The callback function
+   */
+  on(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Returns a copy of the array of listeners for the event named eventName.
+   */
+  listeners(eventName: string): Function[];
+
+  /**
+   * Removes the specified listener from the listener array for the event named
+   * eventName.
+   */
+  removeListener(eventName: string, listener: (...args: any[]) => any): void;
+
+  /**
+   * Removes all listeners, or those of the specified eventName.
+   */
+  removeAllListeners(eventName: string): void;
+
+  /**
+   * Adds a one time listener function for the event named eventName. The next
+   * time eventName is triggered, this listener is removed and then invoked.
+   */
+  once(eventName: string, listener: (...args: any[]) => any): void;
+}
+
+interface IBasePtyForkOptions {
+  name?: string;
+  cols?: number;
+  rows?: number;
+  cwd?: string;
+  env?: IProcessEnv;
+  encoding?: string | null;
+  handleFlowControl?: boolean;
+  flowControlPause?: string;
+  flowControlResume?: string;
+}
+
+export interface IPtyForkOptions extends IBasePtyForkOptions {
+  uid?: number;
+  gid?: number;
+}
+
+export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
+  useConpty?: boolean;
+  conptyInheritCursor?: boolean;
+}
+
+export interface IPtyOpenOptions {
+  cols?: number;
+  rows?: number;
+  encoding?: string | null;
+}

package/vendor/node-pty-fork/src/native.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+interface IConptyNative {
+  startProcess(file: string, cols: number, rows: number, debug: boolean, pipeName: string, conptyInheritCursor: boolean): IConptyProcess;
+  connect(ptyId: number, commandLine: string, cwd: string, env: string[], onExitCallback: (exitCode: number) => void): { pid: number };
+  resize(ptyId: number, cols: number, rows: number): void;
+  clear(ptyId: number): void;
+  kill(ptyId: number): void;
+}
+
+interface IWinptyNative {
+  startProcess(file: string, commandLine: string, env: string[], cwd: string, cols: number, rows: number, debug: boolean): IWinptyProcess;
+  resize(processHandle: number, cols: number, rows: number): void;
+  kill(pid: number, innerPidHandle: number): void;
+  getProcessList(pid: number): number[];
+  getExitCode(innerPidHandle: number): number;
+}
+
+interface IUnixNative {
+  fork(file: string, args: string[], parsedEnv: string[], cwd: string, cols: number, rows: number, uid: number, gid: number, useUtf8: boolean, helperPath: string, onExitCallback: (code: number, signal: number) => void): IUnixProcess;
+  open(cols: number, rows: number): IUnixOpenProcess;
+  process(fd: number, pty: string): string;
+  process(pid: number): string;
+  resize(fd: number, cols: number, rows: number): void;
+}
+
+interface IConptyProcess {
+  pty: number;
+  fd: number;
+  conin: string;
+  conout: string;
+}
+
+interface IWinptyProcess {
+  pty: number;
+  fd: number;
+  conin: string;
+  conout: string;
+  pid: number;
+  innerPid: number;
+  innerPidHandle: number;
+}
+
+interface IUnixProcess {
+  fd: number;
+  pid: number;
+  pty: string;
+}
+
+interface IUnixOpenProcess {
+  master: number;
+  slave: number;
+  pty: string;
+}

package/vendor/node-pty-fork/src/shared/conout.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+export interface IWorkerData {
+  conoutPipeName: string;
+}
+
+export const enum ConoutWorkerMessage {
+  READY = 1
+}
+
+export function getWorkerPipeName(conoutPipeName: string): string {
+  return `${conoutPipeName}-worker`;
+}

package/vendor/node-pty-fork/src/terminal.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import * as assert from 'assert';
+import { WindowsTerminal } from './windowsTerminal';
+import { UnixTerminal } from './unixTerminal';
+import { Terminal } from './terminal';
+import { Socket } from 'net';
+
+const terminalConstructor = (process.platform === 'win32') ? WindowsTerminal : UnixTerminal;
+const SHELL = (process.platform === 'win32') ? 'cmd.exe' : '/bin/bash';
+
+let terminalCtor: WindowsTerminal | UnixTerminal;
+if (process.platform === 'win32') {
+  terminalCtor = require('./windowsTerminal');
+} else {
+  terminalCtor = require('./unixTerminal');
+}
+
+class TestTerminal extends Terminal {
+  public checkType<T>(name: string, value: T, type: string, allowArray: boolean = false): void {
+    this._checkType(name, value, type, allowArray);
+  }
+  protected _write(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public resize(cols: number, rows: number): void {
+    throw new Error('Method not implemented.');
+  }
+  public clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  public destroy(): void {
+    throw new Error('Method not implemented.');
+  }
+  public kill(signal?: string): void {
+    throw new Error('Method not implemented.');
+  }
+  public get process(): string {
+    throw new Error('Method not implemented.');
+  }
+  public get master(): Socket {
+    throw new Error('Method not implemented.');
+  }
+  public get slave(): Socket {
+    throw new Error('Method not implemented.');
+  }
+}
+
+describe('Terminal', () => {
+  describe('constructor', () => {
+    it('should do basic type checks', () => {
+      assert.throws(
+        () => new (<any>terminalCtor)('a', 'b', { 'name': {} }),
+        'name must be a string (not a object)'
+      );
+    });
+  });
+
+  describe('checkType', () => {
+    it('should throw for the wrong type', () => {
+      const t = new TestTerminal();
+      assert.doesNotThrow(() => t.checkType('foo', 'test', 'string'));
+      assert.doesNotThrow(() => t.checkType('foo', 1, 'number'));
+      assert.doesNotThrow(() => t.checkType('foo', {}, 'object'));
+
+      assert.throws(() => t.checkType('foo', 'test', 'number'));
+      assert.throws(() => t.checkType('foo', 1, 'object'));
+      assert.throws(() => t.checkType('foo', {}, 'string'));
+    });
+    it('should throw for wrong types within arrays', () => {
+      const t = new TestTerminal();
+      assert.doesNotThrow(() => t.checkType('foo', ['test'], 'string', true));
+      assert.doesNotThrow(() => t.checkType('foo', [1], 'number', true));
+      assert.doesNotThrow(() => t.checkType('foo', [{}], 'object', true));
+
+      assert.throws(() => t.checkType('foo', ['test'], 'number', true));
+      assert.throws(() => t.checkType('foo', [1], 'object', true));
+      assert.throws(() => t.checkType('foo', [{}], 'string', true));
+    });
+  });
+
+  describe('automatic flow control', () => {
+    it('should respect ctor flow control options', () => {
+      const pty = new terminalConstructor(SHELL, [], {handleFlowControl: true, flowControlPause: 'abc', flowControlResume: '123'});
+      assert.equal(pty.handleFlowControl, true);
+      assert.equal((pty as any)._flowControlPause, 'abc');
+      assert.equal((pty as any)._flowControlResume, '123');
+    });
+    // TODO: I don't think this test ever worked due to pollUntil being used incorrectly
+    // it('should do flow control automatically', async function(): Promise<void> {
+    //   // Flow control doesn't work on Windows
+    //   if (process.platform === 'win32') {
+    //     return;
+    //   }
+
+    //   this.timeout(10000);
+    //   const pty = new terminalConstructor(SHELL, [], {handleFlowControl: true, flowControlPause: 'PAUSE', flowControlResume: 'RESUME'});
+    //   let read: string = '';
+    //   pty.on('data', data => read += data);
+    //   pty.on('pause', () => read += 'paused');
+    //   pty.on('resume', () => read += 'resumed');
+    //   pty.write('1');
+    //   pty.write('PAUSE');
+    //   pty.write('2');
+    //   pty.write('RESUME');
+    //   pty.write('3');
+    //   await pollUntil(() => {
+    //     return stripEscapeSequences(read).endsWith('1pausedresumed23');
+    //   }, 100, 10);
+    // });
+  });
+});
+
+function stripEscapeSequences(data: string): string {
+  return data.replace(/\u001b\[0K/, '');
+}