paseo-plugin-zcode-provider 0.0.0-stage → 0.1.0

package/server/vendor/zcode/packages/model-option-map/src/tokenizer.ts

@@ -0,0 +1,141 @@
+import { RestrictedCelError } from "./types.js";
+
+export type RestrictedCelTokenKind =
+  | "identifier"
+  | "string"
+  | "number"
+  | "operator"
+  | "punctuation"
+  | "eof";
+
+export interface RestrictedCelToken {
+  readonly kind: RestrictedCelTokenKind;
+  readonly value: string;
+  readonly offset: number;
+  readonly end: number;
+}
+
+const DOUBLE_OPERATORS = new Set(["&&", "||", "==", "!=", "<=", ">="]);
+const SINGLE_OPERATORS = new Set(["+", "-", "*", "/", "%", "!", "<", ">"]);
+const PUNCTUATION = new Set(["{", "}", "[", "]", "(", ")", ",", ":", "?", "."]);
+
+export function tokenizeRestrictedCel(source: string): readonly RestrictedCelToken[] {
+  const tokens: RestrictedCelToken[] = [];
+  let offset = 0;
+  while (offset < source.length) {
+    const character = source[offset]!;
+    if (/\s/u.test(character)) {
+      offset += 1;
+      continue;
+    }
+
+    if (character === "'" || character === '"') {
+      const token = readString(source, offset, character);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+
+    if (/[0-9]/u.test(character)) {
+      const token = readNumber(source, offset);
+      tokens.push(token);
+      offset = token.end;
+      continue;
+    }
+
+    if (/[A-Za-z_]/u.test(character)) {
+      const end = readWhile(source, offset + 1, /[A-Za-z0-9_]/u);
+      tokens.push({ kind: "identifier", value: source.slice(offset, end), offset, end });
+      offset = end;
+      continue;
+    }
+
+    const pair = source.slice(offset, offset + 2);
+    if (DOUBLE_OPERATORS.has(pair)) {
+      tokens.push({ kind: "operator", value: pair, offset, end: offset + 2 });
+      offset += 2;
+      continue;
+    }
+    if (SINGLE_OPERATORS.has(character)) {
+      tokens.push({ kind: "operator", value: character, offset, end: offset + 1 });
+      offset += 1;
+      continue;
+    }
+    if (PUNCTUATION.has(character)) {
+      tokens.push({ kind: "punctuation", value: character, offset, end: offset + 1 });
+      offset += 1;
+      continue;
+    }
+    throw new RestrictedCelError(`unsupported token ${JSON.stringify(character)}`, offset);
+  }
+  tokens.push({ kind: "eof", value: "", offset: source.length, end: source.length });
+  return Object.freeze(tokens);
+}
+
+function readNumber(source: string, offset: number): RestrictedCelToken {
+  const match = /^(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(source.slice(offset));
+  if (!match) throw new RestrictedCelError("invalid number literal", offset);
+  const value = match[0];
+  const end = offset + value.length;
+  return { kind: "number", value, offset, end };
+}
+
+function readString(source: string, offset: number, quote: "'" | '"'): RestrictedCelToken {
+  let cursor = offset + 1;
+  let value = "";
+  while (cursor < source.length) {
+    const character = source[cursor]!;
+    if (character === quote) {
+      return { kind: "string", value, offset, end: cursor + 1 };
+    }
+    if (character === "\n" || character === "\r") {
+      throw new RestrictedCelError("unterminated string literal", offset);
+    }
+    if (character !== "\\") {
+      value += character;
+      cursor += 1;
+      continue;
+    }
+
+    const escapeOffset = cursor;
+    cursor += 1;
+    const escaped = source[cursor];
+    if (escaped === undefined) {
+      throw new RestrictedCelError("unterminated string escape", escapeOffset);
+    }
+    const simpleEscape = SIMPLE_ESCAPES[escaped];
+    if (simpleEscape !== undefined) {
+      value += simpleEscape;
+      cursor += 1;
+      continue;
+    }
+    if (escaped === "u") {
+      const digits = source.slice(cursor + 1, cursor + 5);
+      if (!/^[0-9A-Fa-f]{4}$/u.test(digits)) {
+        throw new RestrictedCelError("invalid unicode escape", escapeOffset);
+      }
+      value += String.fromCharCode(Number.parseInt(digits, 16));
+      cursor += 5;
+      continue;
+    }
+    throw new RestrictedCelError(`unsupported string escape \\${escaped}`, escapeOffset);
+  }
+  throw new RestrictedCelError("unterminated string literal", offset);
+}
+
+const SIMPLE_ESCAPES: Readonly<Record<string, string>> = Object.freeze({
+  "'": "'",
+  '"': '"',
+  "\\": "\\",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "\t",
+});
+
+function readWhile(source: string, offset: number, pattern: RegExp): number {
+  let cursor = offset;
+  while (cursor < source.length && pattern.test(source[cursor]!)) cursor += 1;
+  return cursor;
+}

package/server/vendor/zcode/packages/model-option-map/src/types.ts

@@ -0,0 +1,36 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+
+export interface JsonObject {
+  readonly [key: string]: JsonValue;
+}
+
+export type RestrictedCelValue = string | number;
+export type ModelOptionName = "reasoningLevel" | "maxOutputTokens";
+
+export interface RestrictedCelProgram {
+  readonly source: string;
+  evaluate(input: RestrictedCelValue): JsonValue;
+}
+
+export interface ModelOptionMapProgram {
+  readonly source: string;
+  evaluate(input: RestrictedCelValue): JsonObject;
+}
+
+export class RestrictedCelError extends Error {
+  readonly offset: number;
+
+  constructor(message: string, offset: number) {
+    super(`${message} at offset ${offset}`);
+    this.name = "RestrictedCelError";
+    this.offset = offset;
+  }
+}
+
+export class ModelOptionMapError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ModelOptionMapError";
+  }
+}

package/server/vendor/zcode/packages/rpc/src/buffer.ts

@@ -0,0 +1,88 @@
+/**
+ * Layer 0.5: 跨平台 Buffer 抽象
+ *
+ * VS Code 需要在 Node.js (Buffer) 和浏览器 (Uint8Array) 之间统一二进制操作。
+ * VSBuffer 是对 Uint8Array 的薄封装，提供统一的读写接口。
+ *
+ * 这是序列化层和传输层的基础。
+ */
+
+export class VSBuffer {
+  readonly buffer: Uint8Array;
+  readonly byteLength: number;
+
+  private constructor(buffer: Uint8Array) {
+    this.buffer = buffer;
+    this.byteLength = buffer.byteLength;
+  }
+
+  /** 分配指定大小的空 buffer */
+  static alloc(byteLength: number): VSBuffer {
+    return new VSBuffer(new Uint8Array(byteLength));
+  }
+
+  /** 包装已有的 Uint8Array */
+  static wrap(buffer: Uint8Array): VSBuffer {
+    return new VSBuffer(buffer);
+  }
+
+  /** 从字符串创建 buffer (UTF-8) */
+  static fromString(str: string): VSBuffer {
+    const encoder = new TextEncoder();
+    return new VSBuffer(encoder.encode(str));
+  }
+
+  /** 拼接多个 buffer */
+  static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer {
+    const len = totalLength ?? buffers.reduce((sum, b) => sum + b.byteLength, 0);
+    const result = VSBuffer.alloc(len);
+    let offset = 0;
+    for (const buf of buffers) {
+      result.set(buf, offset);
+      offset += buf.byteLength;
+    }
+    return result;
+  }
+
+  /** 转为 UTF-8 字符串 */
+  toString(): string {
+    const decoder = new TextDecoder();
+    return decoder.decode(this.buffer);
+  }
+
+  /** 切片 */
+  slice(start: number, end?: number): VSBuffer {
+    return new VSBuffer(this.buffer.slice(start, end));
+  }
+
+  /** 拷贝数据到 this buffer 的指定位置 */
+  set(source: VSBuffer | Uint8Array, offset = 0): void {
+    const raw = source instanceof VSBuffer ? source.buffer : source;
+    this.buffer.set(raw, offset);
+  }
+
+  readUInt8(offset: number): number {
+    return this.buffer[offset];
+  }
+
+  writeUInt8(value: number, offset: number): void {
+    this.buffer[offset] = value;
+  }
+
+  readUInt32BE(offset: number): number {
+    return (
+      ((this.buffer[offset] << 24) |
+        (this.buffer[offset + 1] << 16) |
+        (this.buffer[offset + 2] << 8) |
+        this.buffer[offset + 3]) >>>
+      0
+    );
+  }
+
+  writeUInt32BE(value: number, offset: number): void {
+    this.buffer[offset] = (value >>> 24) & 0xff;
+    this.buffer[offset + 1] = (value >>> 16) & 0xff;
+    this.buffer[offset + 2] = (value >>> 8) & 0xff;
+    this.buffer[offset + 3] = value & 0xff;
+  }
+}

package/server/vendor/zcode/packages/rpc/src/channelClient.ts

@@ -0,0 +1,275 @@
+import { VSBuffer } from "./buffer.js";
+import { CancellationToken, Event, Emitter, type IDisposable } from "./foundation.js";
+import { BufferReader, BufferWriter, deserialize, serialize } from "./serialization.js";
+import type { IMessagePassingProtocol } from "./protocol.js";
+import {
+  type IChannel,
+  type IChannelClient,
+  type IHandler,
+  type IRawResponse,
+  RequestType,
+  ResponseType,
+} from "./channels.shared.js";
+
+enum State {
+  Uninitialized,
+  Idle,
+}
+
+export class ChannelClient implements IChannelClient, IDisposable {
+  private state = State.Uninitialized;
+  private isDisposed = false;
+  private activeRequests = new Set<IDisposable>();
+  private handlers = new Map<number, IHandler>();
+  // Promise 请求和事件监听共用 handlers，但只有前者需要在连接终结时 reject。
+  // 单独维护 reject map，避免 dispose 把事件订阅误当成挂起的 RPC 请求。
+  private pendingRejections = new Map<number, (error: Error) => void>();
+  private lastRequestId = 0;
+  private protocolListener: IDisposable | null;
+
+  private readonly _onDidInitialize = new Emitter<void>();
+  readonly onDidInitialize = this._onDidInitialize.event;
+
+  constructor(private protocol: IMessagePassingProtocol) {
+    this.protocolListener = this.protocol.onMessage((msg) => this.onBuffer(msg));
+  }
+
+  getChannel<T extends IChannel>(channelName: string): T {
+    return {
+      call: (command: string, arg?: any, cancellationToken?: CancellationToken) => {
+        if (this.isDisposed) {
+          return Promise.reject(new Error("ChannelClient is disposed"));
+        }
+        return this.requestPromise(channelName, command, arg, cancellationToken);
+      },
+      listen: (event: string, arg?: any) => {
+        if (this.isDisposed) {
+          return Event.None;
+        }
+        return this.requestEvent(channelName, event, arg);
+      },
+    } as T;
+  }
+
+  private requestPromise(
+    channelName: string,
+    name: string,
+    arg?: any,
+    cancellationToken = CancellationToken.None,
+  ): Promise<any> {
+    const id = this.lastRequestId++;
+
+    if (cancellationToken.isCancellationRequested) {
+      return Promise.reject(new Error("Cancelled"));
+    }
+
+    let disposable: IDisposable | undefined;
+    const result = new Promise<any>((resolve, reject) => {
+      this.pendingRejections.set(id, reject);
+      const doRequest = () => {
+        // dispose/cancel 可能发生在 Initialize 之前；此时不能再把已经 rejected
+        // 的请求发送到新连接或已终结的传输上。
+        if (this.isDisposed || !this.pendingRejections.has(id)) {
+          return;
+        }
+
+        const handler: IHandler = (response) => {
+          switch (response.type) {
+            case ResponseType.PromiseSuccess:
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              resolve(response.data);
+              return;
+            case ResponseType.PromiseError: {
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              const error = new Error(response.data.message) as Error & Record<string, unknown>;
+              error.name = response.data.name;
+              if (response.data.stack) {
+                error.stack = response.data.stack.join("\n");
+              }
+              const passthroughKeys = [
+                "code",
+                "kind",
+                "status",
+                "retryAfterMs",
+                "data",
+                "detail",
+                "details",
+                "taskId",
+                "traceId",
+              ] as const;
+              for (const key of passthroughKeys) {
+                const value = response.data[key];
+                if (value !== undefined) {
+                  error[key] = value;
+                }
+              }
+              reject(error);
+              return;
+            }
+            case ResponseType.PromiseErrorObj:
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              reject(response.data);
+              return;
+          }
+        };
+
+        this.handlers.set(id, handler);
+        this.sendRequest(RequestType.Promise, id, channelName, name, arg);
+      };
+
+      if (this.state === State.Idle) {
+        doRequest();
+      } else {
+        this.whenInitialized().then(doRequest);
+      }
+
+      disposable = cancellationToken.onCancellationRequested(() => {
+        if (!this.pendingRejections.has(id)) {
+          return;
+        }
+        this.sendCancelOrDispose(RequestType.PromiseCancel, id);
+        this.handlers.delete(id);
+        this.pendingRejections.delete(id);
+        reject(new Error("Cancelled"));
+      });
+      this.activeRequests.add(disposable);
+    });
+
+    return result.finally(() => {
+      disposable?.dispose();
+      if (disposable) {
+        this.activeRequests.delete(disposable);
+      }
+    });
+  }
+
+  private requestEvent(channelName: string, name: string, arg?: any): Event<any> {
+    const id = this.lastRequestId++;
+    const emitter = new Emitter<any>({
+      onWillAddFirstListener: () => {
+        const doRequest = () => {
+          this.activeRequests.add(emitter);
+          this.sendRequest(RequestType.EventListen, id, channelName, name, arg);
+        };
+
+        if (this.state === State.Idle) {
+          doRequest();
+        } else {
+          this.whenInitialized().then(doRequest);
+        }
+      },
+      onDidRemoveLastListener: () => {
+        this.activeRequests.delete(emitter);
+        this.sendCancelOrDispose(RequestType.EventDispose, id);
+        this.handlers.delete(id);
+      },
+    });
+
+    this.handlers.set(id, (response) => {
+      emitter.fire((response as { data: any }).data);
+    });
+
+    return emitter.event;
+  }
+
+  private sendRequest(
+    type: RequestType,
+    id: number,
+    channelName: string,
+    name: string,
+    arg?: any,
+  ): void {
+    const writer = new BufferWriter();
+    serialize(writer, [type, id, channelName, name]);
+    serialize(writer, arg);
+    try {
+      this.protocol.send(writer.buffer);
+    } catch {
+      /* noop */
+    }
+  }
+
+  private sendCancelOrDispose(
+    type: RequestType.PromiseCancel | RequestType.EventDispose,
+    id: number,
+  ): void {
+    const writer = new BufferWriter();
+    serialize(writer, [type, id]);
+    serialize(writer, undefined);
+    try {
+      this.protocol.send(writer.buffer);
+    } catch {
+      /* noop */
+    }
+  }
+
+  private onBuffer(message: VSBuffer): void {
+    const reader = new BufferReader(message);
+    const header = deserialize(reader);
+    const body = deserialize(reader);
+    const type = header[0] as ResponseType;
+
+    switch (type) {
+      case ResponseType.Initialize:
+        this.onResponse({ type: ResponseType.Initialize });
+        return;
+      case ResponseType.PromiseSuccess:
+      case ResponseType.PromiseError:
+      case ResponseType.EventFire:
+      case ResponseType.PromiseErrorObj:
+        this.onResponse({
+          type,
+          id: header[1],
+          data: body,
+        } as IRawResponse);
+        return;
+    }
+  }
+
+  private onResponse(response: IRawResponse): void {
+    if (response.type === ResponseType.Initialize) {
+      this.state = State.Idle;
+      this._onDidInitialize.fire();
+      return;
+    }
+
+    this.handlers.get(response.id)?.(response);
+  }
+
+  private whenInitialized(): Promise<void> {
+    if (this.state === State.Idle) {
+      return Promise.resolve();
+    }
+    return Event.toPromise(this.onDidInitialize);
+  }
+
+  dispose(reason?: Error): void {
+    if (this.isDisposed) {
+      return;
+    }
+    this.isDisposed = true;
+    this.protocolListener?.dispose();
+    this.protocolListener = null;
+
+    const rejection = reason ?? new Error("ChannelClient disposed");
+    if (!reason) {
+      rejection.name = "ConnectionClosed";
+    }
+    // 传输已终结时，所有已发出以及排队等待 Initialize 的 Promise 请求都必须
+    // fail-closed。否则上层的 in-flight 去重 Promise 会永久占用 workspace key。
+    for (const [id, reject] of this.pendingRejections) {
+      this.pendingRejections.delete(id);
+      this.handlers.delete(id);
+      reject(rejection);
+    }
+    for (const disposable of this.activeRequests) {
+      disposable.dispose();
+    }
+    this.activeRequests.clear();
+    this.pendingRejections.clear();
+    this._onDidInitialize.dispose();
+  }
+}