@hienlh/ppm 0.9.0-beta.8 → 0.9.1

package/packages/vscode-compat/src/index.ts

@@ -0,0 +1,93 @@
+/**
+ * @ppm/vscode-compat — VSCode-compatible API shim for PPM extensions.
+ *
+ * Extension authors replace `import * as vscode from 'vscode'`
+ * with `import * as vscode from '@ppm/vscode-compat'`.
+ *
+ * All API calls serialize over RPC to the main PPM process.
+ */
+
+// Re-export types and classes
+export { Disposable } from "./disposable.ts";
+export { EventEmitter, type Event } from "./event-emitter.ts";
+export { Uri } from "./uri.ts";
+export {
+  TreeItemCollapsibleState, ViewColumn, StatusBarAlignment,
+  ConfigurationTarget, DiagnosticSeverity, ThemeIcon,
+  type TreeItem, type TreeDataProvider, type WebviewPanel,
+  type Webview, type WebviewOptions, type StatusBarItem,
+  type QuickPickItem, type QuickPickOptions, type InputBoxOptions,
+  type OutputChannel, type WorkspaceFolder, type WorkspaceConfiguration,
+  type RpcClient,
+} from "./types.ts";
+export { type ExtensionContext, Memento } from "./context.ts";
+
+// Service imports
+import { CommandService } from "./commands.ts";
+import { WindowService } from "./window.ts";
+import { WorkspaceService } from "./workspace.ts";
+import { createExtensionContext, type ExtensionContext } from "./context.ts";
+import { createEnvNamespace } from "./env.ts";
+import { createNotSupported } from "./not-supported.ts";
+import { Uri } from "./uri.ts";
+import { Disposable } from "./disposable.ts";
+import { EventEmitter } from "./event-emitter.ts";
+import {
+  TreeItemCollapsibleState, ViewColumn, StatusBarAlignment,
+  ConfigurationTarget, DiagnosticSeverity, ThemeIcon,
+} from "./types.ts";
+import type { RpcClient } from "./types.ts";
+
+export interface CreateVscodeCompatOptions {
+  extensionId: string;
+  extensionPath: string;
+  storagePath: string;
+  rpc: RpcClient;
+  appName?: string;
+  machineId?: string;
+  storedState?: { global?: Record<string, string | null>; workspace?: Record<string, string | null> };
+}
+
+/** Create a scoped vscode-compatible API instance for an extension */
+export function createVscodeCompat(options: CreateVscodeCompatOptions) {
+  const { extensionId, extensionPath, storagePath, rpc, storedState } = options;
+
+  const commands = new CommandService(rpc, extensionId);
+  const window = new WindowService(rpc, extensionId);
+  const workspace = new WorkspaceService(rpc, extensionId);
+
+  return {
+    // Active API namespaces
+    commands,
+    window,
+    workspace,
+    env: createEnvNamespace(options.appName ?? "PPM", options.machineId ?? "ppm-local"),
+
+    // Classes & utilities
+    Uri,
+    Disposable,
+    EventEmitter,
+
+    // Enums
+    TreeItemCollapsibleState,
+    ViewColumn,
+    StatusBarAlignment,
+    ConfigurationTarget,
+    DiagnosticSeverity,
+    ThemeIcon,
+
+    // Unsupported namespaces (throw descriptive errors)
+    languages: createNotSupported("languages"),
+    debug: createNotSupported("debug"),
+    tasks: createNotSupported("tasks"),
+    scm: createNotSupported("scm"),
+    notebooks: createNotSupported("notebooks"),
+    authentication: createNotSupported("authentication"),
+    tests: createNotSupported("tests"),
+
+    // Helper: create ExtensionContext for this extension
+    _createContext(): ExtensionContext {
+      return createExtensionContext(rpc, extensionId, extensionPath, storagePath, storedState);
+    },
+  };
+}

package/packages/vscode-compat/src/not-supported.ts

@@ -0,0 +1,15 @@
+/** Create a Proxy that throws on any property access for unsupported VSCode APIs */
+export function createNotSupported(namespace: string): unknown {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (prop === Symbol.toPrimitive || prop === "toString" || prop === "valueOf") {
+        return () => `[vscode.${namespace} — not supported in PPM]`;
+      }
+      if (typeof prop === "symbol") return undefined;
+      throw new Error(
+        `vscode.${namespace}.${prop} is not supported in PPM. ` +
+        `See https://github.com/hienlh/ppm/docs/extension-migration.md for alternatives.`,
+      );
+    },
+  });
+}

package/packages/vscode-compat/src/types.ts

@@ -0,0 +1,167 @@
+import type { Uri } from "./uri.ts";
+import type { Event } from "./event-emitter.ts";
+
+// --- Enums ---
+
+export enum TreeItemCollapsibleState {
+  None = 0,
+  Collapsed = 1,
+  Expanded = 2,
+}
+
+export enum ViewColumn {
+  Active = -1,
+  Beside = -2,
+  One = 1,
+  Two = 2,
+  Three = 3,
+}
+
+export enum StatusBarAlignment {
+  Left = 1,
+  Right = 2,
+}
+
+export enum ConfigurationTarget {
+  Global = 1,
+  Workspace = 2,
+  WorkspaceFolder = 3,
+}
+
+export enum DiagnosticSeverity {
+  Error = 0,
+  Warning = 1,
+  Information = 2,
+  Hint = 3,
+}
+
+// --- Tree View ---
+
+export interface TreeItem {
+  label?: string;
+  id?: string;
+  iconPath?: string | Uri | { light: string | Uri; dark: string | Uri };
+  description?: string;
+  tooltip?: string;
+  collapsibleState?: TreeItemCollapsibleState;
+  command?: { command: string; title: string; arguments?: unknown[] };
+  contextValue?: string;
+}
+
+export interface TreeDataProvider<T> {
+  getTreeItem(element: T): TreeItem | Promise<TreeItem>;
+  getChildren(element?: T): T[] | Promise<T[]>;
+  onDidChangeTreeData?: Event<T | undefined | null | void>;
+}
+
+// --- Webview ---
+
+export interface WebviewOptions {
+  enableScripts?: boolean;
+  enableForms?: boolean;
+  localResourceRoots?: Uri[];
+}
+
+export interface Webview {
+  html: string;
+  options: WebviewOptions;
+  onDidReceiveMessage: Event<unknown>;
+  postMessage(message: unknown): Promise<boolean>;
+  asWebviewUri(localResource: Uri): Uri;
+}
+
+export interface WebviewPanel {
+  viewType: string;
+  title: string;
+  webview: Webview;
+  viewColumn?: ViewColumn;
+  active: boolean;
+  visible: boolean;
+  onDidDispose: Event<void>;
+  onDidChangeViewState: Event<{ webviewPanel: WebviewPanel }>;
+  reveal(viewColumn?: ViewColumn, preserveFocus?: boolean): void;
+  dispose(): void;
+}
+
+// --- Status Bar ---
+
+export interface StatusBarItem {
+  alignment: StatusBarAlignment;
+  priority?: number;
+  text: string;
+  tooltip?: string;
+  color?: string;
+  command?: string;
+  show(): void;
+  hide(): void;
+  dispose(): void;
+}
+
+// --- Quick Pick / Input ---
+
+export interface QuickPickItem {
+  label: string;
+  description?: string;
+  detail?: string;
+  picked?: boolean;
+  alwaysShow?: boolean;
+}
+
+export interface QuickPickOptions {
+  title?: string;
+  placeHolder?: string;
+  canPickMany?: boolean;
+  matchOnDescription?: boolean;
+  matchOnDetail?: boolean;
+}
+
+export interface InputBoxOptions {
+  title?: string;
+  value?: string;
+  prompt?: string;
+  placeHolder?: string;
+  password?: boolean;
+  validateInput?(value: string): string | undefined | null | Promise<string | undefined | null>;
+}
+
+// --- Output Channel ---
+
+export interface OutputChannel {
+  name: string;
+  append(value: string): void;
+  appendLine(value: string): void;
+  clear(): void;
+  show(preserveFocus?: boolean): void;
+  hide(): void;
+  dispose(): void;
+}
+
+// --- Workspace ---
+
+export interface WorkspaceFolder {
+  uri: Uri;
+  name: string;
+  index: number;
+}
+
+export interface WorkspaceConfiguration {
+  get<T>(section: string, defaultValue?: T): T | undefined;
+  has(section: string): boolean;
+  update(section: string, value: unknown, target?: ConfigurationTarget): Promise<void>;
+}
+
+// --- Theme ---
+
+export class ThemeIcon {
+  static readonly File = new ThemeIcon("file");
+  static readonly Folder = new ThemeIcon("folder");
+  readonly id: string;
+  constructor(id: string) { this.id = id; }
+}
+
+// --- RPC client interface (injected into Worker) ---
+
+export interface RpcClient {
+  request<T = unknown>(method: string, ...params: unknown[]): Promise<T>;
+  notify(event: string, data: unknown): void;
+}

package/packages/vscode-compat/src/uri.ts

@@ -0,0 +1,65 @@
+/** VSCode-compatible Uri implementation */
+export class Uri {
+  readonly scheme: string;
+  readonly authority: string;
+  readonly path: string;
+  readonly query: string;
+  readonly fragment: string;
+
+  private constructor(scheme: string, authority: string, path: string, query: string, fragment: string) {
+    this.scheme = scheme;
+    this.authority = authority;
+    this.path = path;
+    this.query = query;
+    this.fragment = fragment;
+  }
+
+  /** File system path (decoded, platform-specific) */
+  get fsPath(): string {
+    return this.path;
+  }
+
+  static file(path: string): Uri {
+    return new Uri("file", "", path, "", "");
+  }
+
+  static parse(value: string): Uri {
+    try {
+      const url = new URL(value);
+      return new Uri(
+        url.protocol.replace(":", ""),
+        url.host,
+        decodeURIComponent(url.pathname),
+        url.search.replace("?", ""),
+        url.hash.replace("#", ""),
+      );
+    } catch {
+      // Treat as file path if not a valid URL
+      return Uri.file(value);
+    }
+  }
+
+  with(change: { scheme?: string; authority?: string; path?: string; query?: string; fragment?: string }): Uri {
+    return new Uri(
+      change.scheme ?? this.scheme,
+      change.authority ?? this.authority,
+      change.path ?? this.path,
+      change.query ?? this.query,
+      change.fragment ?? this.fragment,
+    );
+  }
+
+  toString(): string {
+    if (this.scheme === "file") return `file://${this.path}`;
+    let result = `${this.scheme}://`;
+    if (this.authority) result += this.authority;
+    result += this.path;
+    if (this.query) result += `?${this.query}`;
+    if (this.fragment) result += `#${this.fragment}`;
+    return result;
+  }
+
+  toJSON(): { scheme: string; authority: string; path: string; query: string; fragment: string } {
+    return { scheme: this.scheme, authority: this.authority, path: this.path, query: this.query, fragment: this.fragment };
+  }
+}

package/packages/vscode-compat/src/window.ts

@@ -0,0 +1,229 @@
+import { Disposable } from "./disposable.ts";
+import { EventEmitter } from "./event-emitter.ts";
+import type {
+  RpcClient, StatusBarItem, StatusBarAlignment, QuickPickItem,
+  QuickPickOptions, InputBoxOptions, OutputChannel, ViewColumn,
+} from "./types.ts";
+import { StatusBarAlignment as SBAlign } from "./types.ts";
+
+/** VSCode-compatible window namespace — all UI ops go through RPC to main→browser */
+export class WindowService {
+  private rpc: RpcClient;
+  private extId: string;
+  /** @internal Monotonic counter for unique panel/statusbar IDs */
+  private _idCounter = 0;
+  /** @internal Panel emitters keyed by panelId — for webview message delivery */
+  private _panelEmitters = new Map<string, EventEmitter<unknown>>();
+  /** @internal Tree providers keyed by viewId — for tree expand/refresh */
+  private _treeProviders = new Map<string, { provider: any }>();
+  /** @internal Cache original tree elements by ID so getChildren receives the real object */
+  private _treeElementCache = new Map<string, Map<string, unknown>>();
+
+  constructor(rpc: RpcClient, extId: string) {
+    this.rpc = rpc;
+    this.extId = extId;
+  }
+
+  /** @internal Deliver a message from the WS bridge to a webview panel's onDidReceiveMessage */
+  _deliverWebviewMessage(panelId: string, message: unknown): boolean {
+    const emitter = this._panelEmitters.get(panelId);
+    if (emitter) { emitter.fire(message); return true; }
+    return false;
+  }
+
+  /** @internal Get tree children for a viewId (used by Worker for tree:expand) */
+  async _getTreeChildren(viewId: string, parentId?: string): Promise<unknown[]> {
+    const entry = this._treeProviders.get(viewId);
+    if (!entry) return [];
+    const provider = entry.provider;
+    // Resolve parentId → original cached element (or undefined for root)
+    let parentElement: unknown = undefined;
+    if (parentId) {
+      const cache = this._treeElementCache.get(viewId);
+      parentElement = cache?.get(parentId) ?? parentId;
+    }
+    const children = await Promise.resolve(provider.getChildren(parentElement));
+    if (!children || !Array.isArray(children)) return [];
+    return this._serializeTreeItems(provider, children, viewId);
+  }
+
+  /** @internal Serialize tree elements into TreeItemMsg-compatible objects */
+  private async _serializeTreeItems(provider: any, elements: unknown[], viewId?: string): Promise<unknown[]> {
+    const results: unknown[] = [];
+    // Ensure element cache exists for this view
+    if (viewId && !this._treeElementCache.has(viewId)) {
+      this._treeElementCache.set(viewId, new Map());
+    }
+    const cache = viewId ? this._treeElementCache.get(viewId)! : null;
+
+    for (const el of elements) {
+      const treeItem = provider.getTreeItem ? await Promise.resolve(provider.getTreeItem(el)) : el;
+      const id = treeItem.id ?? String(el);
+      // Cache the original element so getChildren receives the real object on expand
+      if (cache) cache.set(id, el);
+      results.push({
+        id,
+        label: treeItem.label ?? String(el),
+        description: treeItem.description,
+        tooltip: treeItem.tooltip,
+        icon: treeItem.iconPath?.id ?? treeItem.iconPath ?? undefined,
+        collapsibleState: treeItem.collapsibleState === 0 ? "none" : treeItem.collapsibleState === 2 ? "expanded" : treeItem.collapsibleState === 1 ? "collapsed" : (treeItem.collapsibleState ?? "none"),
+        command: typeof treeItem.command === "string" ? treeItem.command : treeItem.command?.command,
+        commandArgs: treeItem.commandArgs ?? (typeof treeItem.command === "object" ? treeItem.command?.arguments : undefined),
+        color: treeItem.color,
+        badge: treeItem.badge,
+        actions: treeItem.actions,
+        contextValue: treeItem.contextValue,
+      });
+    }
+    return results;
+  }
+
+  // --- Messages ---
+
+  async showInformationMessage(message: string, ...items: string[]): Promise<string | undefined> {
+    return this.rpc.request<string | undefined>("window:showMessage", "info", message, items);
+  }
+
+  async showWarningMessage(message: string, ...items: string[]): Promise<string | undefined> {
+    return this.rpc.request<string | undefined>("window:showMessage", "warn", message, items);
+  }
+
+  async showErrorMessage(message: string, ...items: string[]): Promise<string | undefined> {
+    return this.rpc.request<string | undefined>("window:showMessage", "error", message, items);
+  }
+
+  // --- Quick Pick / Input ---
+
+  async showQuickPick(
+    items: string[] | QuickPickItem[],
+    options?: QuickPickOptions,
+  ): Promise<string | QuickPickItem | undefined> {
+    return this.rpc.request("window:showQuickPick", items, options ?? {});
+  }
+
+  async showInputBox(options?: InputBoxOptions): Promise<string | undefined> {
+    // Remove non-serializable validateInput before sending over RPC
+    const { validateInput, ...serializableOpts } = options ?? {};
+    return this.rpc.request<string | undefined>("window:showInputBox", serializableOpts);
+  }
+
+  // --- Status Bar ---
+
+  createStatusBarItem(alignment?: StatusBarAlignment, priority?: number): StatusBarItem {
+    const id = `${this.extId}-sb-${++this._idCounter}`;
+    const rpc = this.rpc;
+    const extId = this.extId;
+    const item: StatusBarItem = {
+      alignment: (alignment as StatusBarAlignment) ?? SBAlign.Left,
+      priority,
+      text: "",
+      tooltip: undefined,
+      color: undefined,
+      command: undefined,
+      show() {
+        rpc.request("window:statusbar:update", {
+          id, text: item.text, tooltip: item.tooltip, command: item.command as string | undefined,
+          alignment: item.alignment === SBAlign.Left ? "left" : "right",
+          priority: item.priority ?? 0, extensionId: extId,
+        });
+      },
+      hide() { rpc.request("window:statusbar:remove", id); },
+      dispose() { rpc.request("window:statusbar:remove", id); },
+    };
+    return item;
+  }
+
+  // --- Output Channel ---
+
+  createOutputChannel(name: string): OutputChannel {
+    const rpc = this.rpc;
+    const extId = this.extId;
+    let buffer = "";
+    return {
+      name,
+      append(value: string) { buffer += value; },
+      appendLine(value: string) {
+        buffer += value + "\n";
+        rpc.notify("window:output:append", { extId, name, text: buffer });
+        buffer = "";
+      },
+      clear() { rpc.notify("window:output:clear", { extId, name }); },
+      show() { rpc.notify("window:output:show", { extId, name }); },
+      hide() { rpc.notify("window:output:hide", { extId, name }); },
+      dispose() { rpc.notify("window:output:dispose", { extId, name }); },
+    };
+  }
+
+  // --- Tree View ---
+
+  createTreeView(viewId: string, options: { treeDataProvider: unknown }): Disposable {
+    const rpc = this.rpc;
+    const provider = options.treeDataProvider as any;
+    this._treeProviders.set(viewId, { provider });
+    // Initial tree data push — serialize via getTreeItem
+    if (provider.getChildren) {
+      this._getTreeChildren(viewId).then((items) => {
+        rpc.request("window:tree:update", viewId, items);
+      }).catch((e) => console.error(`[vscode-compat] tree init error (${viewId}):`, e));
+    }
+    // Subscribe to onDidChangeTreeData — re-push entire tree on change
+    let changeUnsub: (() => void) | undefined;
+    if (provider.onDidChangeTreeData) {
+      changeUnsub = provider.onDidChangeTreeData(() => {
+        this._getTreeChildren(viewId).then((items) => {
+          rpc.request("window:tree:update", viewId, items);
+        }).catch((e) => console.error(`[vscode-compat] tree refresh error (${viewId}):`, e));
+      });
+    }
+    return new Disposable(() => {
+      if (changeUnsub) changeUnsub();
+      this._treeProviders.delete(viewId);
+      this._treeElementCache.delete(viewId);
+      rpc.request("window:tree:refresh", viewId);
+    });
+  }
+
+  // --- Webview Panel ---
+
+  createWebviewPanel(viewType: string, title: string, showOptions: ViewColumn): unknown {
+    const panelId = `${this.extId}-wv-${++this._idCounter}`;
+    const rpc = this.rpc;
+    const extId = this.extId;
+    rpc.request("window:webview:create", panelId, extId, viewType, title);
+
+    const onDidDispose = new EventEmitter<void>();
+    const onDidReceiveMessage = new EventEmitter<unknown>();
+    this._panelEmitters.set(panelId, onDidReceiveMessage);
+
+    let currentHtml = "";
+    const webview = {
+      get html() { return currentHtml; },
+      set html(value: string) {
+        currentHtml = value;
+        rpc.request("window:webview:html", panelId, value);
+      },
+      options: {},
+      async postMessage(message: unknown): Promise<boolean> {
+        await rpc.request("window:webview:postMessage", panelId, message);
+        return true;
+      },
+      onDidReceiveMessage: onDidReceiveMessage.event,
+      asWebviewUri: (uri: unknown) => uri,
+    };
+
+    return {
+      viewType, title, webview,
+      onDidDispose: onDidDispose.event,
+      onDidChangeViewState: new EventEmitter().event,
+      reveal() {},
+      dispose: () => {
+        this._panelEmitters.delete(panelId);
+        rpc.request("window:webview:dispose", panelId);
+        onDidDispose.fire();
+        onDidDispose.dispose();
+        onDidReceiveMessage.dispose();
+      },
+    };
+  }
+}

package/packages/vscode-compat/src/workspace.ts

@@ -0,0 +1,76 @@
+import { EventEmitter } from "./event-emitter.ts";
+import { Uri } from "./uri.ts";
+import type { RpcClient, WorkspaceFolder, WorkspaceConfiguration, ConfigurationTarget } from "./types.ts";
+
+/** VSCode-compatible workspace namespace — config, fs, folders via RPC */
+export class WorkspaceService {
+  private rpc: RpcClient;
+  private extId: string;
+  private _onDidChangeConfiguration = new EventEmitter<{ affectsConfiguration(section: string): boolean }>();
+  readonly onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+
+  constructor(rpc: RpcClient, extId: string) {
+    this.rpc = rpc;
+    this.extId = extId;
+  }
+
+  getConfiguration(section?: string): WorkspaceConfiguration {
+    const rpc = this.rpc;
+    // Config reads go through RPC — returns a snapshot object
+    return {
+      async get<T>(key: string, defaultValue?: T): Promise<T | undefined> {
+        const fullKey = section ? `${section}.${key}` : key;
+        const val = await rpc.request<T | null>("workspace:config:get", fullKey);
+        return val ?? defaultValue;
+      },
+      has(key: string): boolean {
+        // Synchronous check not possible over RPC — always returns true
+        return true;
+      },
+      async update(key: string, value: unknown, target?: ConfigurationTarget): Promise<void> {
+        const fullKey = section ? `${section}.${key}` : key;
+        await rpc.request("workspace:config:update", fullKey, value, target);
+      },
+    } as WorkspaceConfiguration;
+  }
+
+  get workspaceFolders(): WorkspaceFolder[] | undefined {
+    // This is sync in VSCode but we return a cached value; updated via RPC event
+    return this._cachedFolders;
+  }
+
+  private _cachedFolders: WorkspaceFolder[] | undefined;
+
+  /** Called during init to hydrate workspace folders */
+  _setFolders(folders: Array<{ uri: string; name: string; index: number }>): void {
+    this._cachedFolders = folders.map((f) => ({
+      uri: Uri.file(f.uri),
+      name: f.name,
+      index: f.index,
+    }));
+  }
+
+  // --- File system operations ---
+
+  readonly fs = {
+    readFile: async (uri: Uri): Promise<Uint8Array> => {
+      const base64 = await this.rpc.request<string>("workspace:fs:readFile", uri.fsPath);
+      return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+    },
+    writeFile: async (uri: Uri, content: Uint8Array): Promise<void> => {
+      const base64 = btoa(String.fromCharCode(...content));
+      await this.rpc.request("workspace:fs:writeFile", uri.fsPath, base64);
+    },
+    stat: async (uri: Uri): Promise<{ type: number; size: number; mtime: number }> => {
+      return this.rpc.request("workspace:fs:stat", uri.fsPath);
+    },
+    readDirectory: async (uri: Uri): Promise<Array<[string, number]>> => {
+      return this.rpc.request("workspace:fs:readDirectory", uri.fsPath);
+    },
+  };
+
+  async findFiles(pattern: string, maxResults?: number): Promise<Uri[]> {
+    const paths = await this.rpc.request<string[]>("workspace:findFiles", pattern, maxResults ?? 100);
+    return paths.map((p) => Uri.file(p));
+  }
+}

package/packages/vscode-compat/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "declaration": true,
+    "noEmit": false
+  },
+  "include": ["src/**/*.ts"]
+}