@mseep/claudian 2.0.25

package/src/providers/pi/runtime/PiCliResolver.ts

@@ -0,0 +1,53 @@
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import { findCliBinaryPath, resolveConfiguredCliPath } from '../../../utils/cliBinaryLocator';
+import { getHostnameKey, parseEnvironmentVariables } from '../../../utils/env';
+import { getPiProviderSettings } from '../settings';
+
+export class PiCliResolver {
+  private readonly cachedHostname = getHostnameKey();
+  private lastCliPath = '';
+  private lastEnvText = '';
+  private lastHostnamePath = '';
+  private resolvedPath: string | null = null;
+
+  resolveFromSettings(settings: Record<string, unknown>): string | null {
+    const piSettings = getPiProviderSettings(settings);
+    const cliPath = piSettings.cliPath.trim();
+    const hostnamePath = (piSettings.cliPathsByHost[this.cachedHostname] ?? '').trim();
+    const envText = getRuntimeEnvironmentText(settings, 'pi');
+
+    if (
+      this.resolvedPath !== null
+      && cliPath === this.lastCliPath
+      && hostnamePath === this.lastHostnamePath
+      && envText === this.lastEnvText
+    ) {
+      return this.resolvedPath;
+    }
+
+    this.lastCliPath = cliPath;
+    this.lastHostnamePath = hostnamePath;
+    this.lastEnvText = envText;
+    this.resolvedPath = this.resolve(piSettings.cliPathsByHost, cliPath, envText);
+    return this.resolvedPath;
+  }
+
+  resolve(
+    hostnamePaths: Record<string, string> | undefined,
+    legacyPath: string,
+    envText = '',
+  ): string | null {
+    const hostnamePath = (hostnamePaths?.[this.cachedHostname] ?? '').trim();
+    const customEnv = parseEnvironmentVariables(envText || '');
+    return resolveConfiguredCliPath(hostnamePath)
+      ?? resolveConfiguredCliPath(legacyPath.trim())
+      ?? findCliBinaryPath('pi', customEnv.PATH);
+  }
+
+  reset(): void {
+    this.lastCliPath = '';
+    this.lastHostnamePath = '';
+    this.lastEnvText = '';
+    this.resolvedPath = null;
+  }
+}

package/src/providers/pi/runtime/PiExtensionUiBridge.ts

@@ -0,0 +1,161 @@
+import type { StreamChunk } from '../../../core/types';
+import type { PiRpcRecord, PiRpcTransport } from './PiRpcTransport';
+
+export interface PiExtensionUiSelectRequest extends PiRpcRecord {
+  id: string;
+}
+
+export interface PiExtensionUiConfirmRequest extends PiRpcRecord {
+  id: string;
+}
+
+export interface PiExtensionUiInputRequest extends PiRpcRecord {
+  id: string;
+}
+
+export interface PiExtensionUiEditorRequest extends PiRpcRecord {
+  id: string;
+}
+
+export type PiExtensionUiNotifyRequest = PiRpcRecord;
+export type PiExtensionUiSetEditorTextRequest = PiRpcRecord;
+export type PiExtensionUiSetStatusRequest = PiRpcRecord;
+export type PiExtensionUiSetTitleRequest = PiRpcRecord;
+export type PiExtensionUiSetWidgetRequest = PiRpcRecord;
+
+export interface PiExtensionUiRenderer {
+  confirm(request: PiExtensionUiConfirmRequest, signal: AbortSignal): Promise<{ cancelled?: boolean; confirmed?: boolean }>;
+  editor(request: PiExtensionUiEditorRequest, signal: AbortSignal): Promise<{ cancelled?: boolean; value?: string }>;
+  input(request: PiExtensionUiInputRequest, signal: AbortSignal): Promise<{ cancelled?: boolean; value?: string }>;
+  notify(request: PiExtensionUiNotifyRequest): void;
+  select(request: PiExtensionUiSelectRequest, signal: AbortSignal): Promise<{ cancelled?: boolean; value?: string }>;
+  setEditorText(request: PiExtensionUiSetEditorTextRequest): void;
+  setStatus(request: PiExtensionUiSetStatusRequest): void;
+  setTitle(request: PiExtensionUiSetTitleRequest): void;
+  setWidget(request: PiExtensionUiSetWidgetRequest): void;
+}
+
+export class PiExtensionUiBridge {
+  private readonly pending = new Map<string, AbortController>();
+
+  constructor(
+    private readonly transport: PiRpcTransport,
+    private readonly renderer: PiExtensionUiRenderer | null,
+    private readonly emit?: (chunk: StreamChunk) => void,
+  ) {}
+
+  handleRequest(request: PiRpcRecord): boolean {
+    if (request.type !== 'extension_ui_request') {
+      return false;
+    }
+
+    const method = getString(request.method) ?? getString(request.action) ?? getString(request.uiType);
+    switch (method) {
+      case 'select':
+        this.handleDialog(request, (renderer, signal) =>
+          renderer.select(requireDialogRequest(request), signal));
+        return true;
+      case 'confirm':
+        this.handleDialog(request, (renderer, signal) =>
+          renderer.confirm(requireDialogRequest(request), signal));
+        return true;
+      case 'input':
+        this.handleDialog(request, (renderer, signal) =>
+          renderer.input(requireDialogRequest(request), signal));
+        return true;
+      case 'editor':
+        this.handleDialog(request, (renderer, signal) =>
+          renderer.editor(requireDialogRequest(request), signal));
+        return true;
+      case 'notify':
+        this.renderer?.notify(request);
+        this.emit?.({
+          type: 'notice',
+          content: getString(request.message) ?? getString(request.title) ?? 'Pi extension notification.',
+          level: 'info',
+        });
+        return true;
+      case 'setStatus':
+      case 'set_status':
+        this.renderer?.setStatus(request);
+        return true;
+      case 'setWidget':
+      case 'set_widget':
+        this.renderer?.setWidget(request);
+        return true;
+      case 'setTitle':
+      case 'set_title':
+        this.renderer?.setTitle(request);
+        return true;
+      case 'setEditorText':
+      case 'set_editor_text':
+        this.renderer?.setEditorText(request);
+        return true;
+      default:
+        this.sendCancellation(request);
+        return true;
+    }
+  }
+
+  cleanup(): void {
+    for (const [id, controller] of this.pending) {
+      controller.abort();
+      this.sendResponse(id, { cancelled: true });
+    }
+    this.pending.clear();
+  }
+
+  private handleDialog(
+    request: PiRpcRecord,
+    render: (
+      renderer: PiExtensionUiRenderer,
+      signal: AbortSignal,
+    ) => Promise<Record<string, unknown>>,
+  ): void {
+    const id = getString(request.id);
+    if (!id || !this.renderer) {
+      this.sendCancellation(request);
+      return;
+    }
+
+    const controller = new AbortController();
+    this.pending.set(id, controller);
+    render(this.renderer, controller.signal)
+      .then((response) => {
+        if (!controller.signal.aborted) {
+          this.sendResponse(id, response.cancelled ? { cancelled: true } : response);
+        }
+      })
+      .catch(() => {
+        if (!controller.signal.aborted) {
+          this.sendResponse(id, { cancelled: true });
+        }
+      })
+      .finally(() => {
+        this.pending.delete(id);
+      });
+  }
+
+  private sendCancellation(request: PiRpcRecord): void {
+    const id = getString(request.id);
+    if (id) {
+      this.sendResponse(id, { cancelled: true });
+    }
+  }
+
+  private sendResponse(id: string, response: Record<string, unknown>): void {
+    this.transport.send({
+      id,
+      type: 'extension_ui_response',
+      ...response,
+    });
+  }
+}
+
+function requireDialogRequest<T extends PiRpcRecord & { id: string }>(request: PiRpcRecord): T {
+  return request as T;
+}
+
+function getString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}

package/src/providers/pi/runtime/PiJsonl.ts

@@ -0,0 +1,71 @@
+import type { Writable } from 'node:stream';
+
+export type PiJsonlLineHandler = (line: string) => void;
+
+interface JsonlReadableStream {
+  off(eventName: 'data', listener: (chunk: Buffer | string) => void): unknown;
+  off(eventName: 'end' | 'close', listener: () => void): unknown;
+  off(eventName: 'error', listener: (error: unknown) => void): unknown;
+  on(eventName: 'data', listener: (chunk: Buffer | string) => void): unknown;
+  on(eventName: 'end' | 'close', listener: () => void): unknown;
+  on(eventName: 'error', listener: (error: unknown) => void): unknown;
+}
+
+export function subscribePiJsonlLines(
+  input: JsonlReadableStream,
+  onLine: PiJsonlLineHandler,
+  onEnd?: () => void,
+  onError?: (error: Error) => void,
+): () => void {
+  let buffer = '';
+
+  const handleData = (chunk: Buffer | string): void => {
+    buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+
+    while (true) {
+      const newlineIndex = buffer.indexOf('\n');
+      if (newlineIndex < 0) {
+        break;
+      }
+
+      const line = stripTrailingCarriageReturn(buffer.slice(0, newlineIndex));
+      buffer = buffer.slice(newlineIndex + 1);
+      onLine(line);
+    }
+  };
+
+  const handleEnd = (): void => {
+    if (buffer.length > 0) {
+      onLine(stripTrailingCarriageReturn(buffer));
+      buffer = '';
+    }
+    onEnd?.();
+  };
+
+  const handleError = (error: unknown): void => {
+    onError?.(error instanceof Error ? error : new Error(String(error)));
+  };
+
+  input.on('data', handleData);
+  input.on('end', handleEnd);
+  input.on('close', handleEnd);
+  input.on('error', handleError);
+
+  return () => {
+    input.off('data', handleData);
+    input.off('end', handleEnd);
+    input.off('close', handleEnd);
+    input.off('error', handleError);
+  };
+}
+
+export function writePiJsonl(
+  output: Writable | NodeJS.WritableStream,
+  record: unknown,
+): void {
+  output.write(`${JSON.stringify(record)}\n`);
+}
+
+function stripTrailingCarriageReturn(value: string): string {
+  return value.endsWith('\r') ? value.slice(0, -1) : value;
+}

package/src/providers/pi/runtime/PiLaunchSpec.ts

@@ -0,0 +1,70 @@
+import { decodePiModelId, normalizePiThinkingLevel } from '../models';
+import type { PiProviderSettings } from '../settings';
+import type { PiProviderState } from '../types';
+
+export interface BuildPiLaunchSpecParams {
+  command: string;
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  envText?: string;
+  model?: string | null;
+  noSession?: boolean;
+  noTools?: boolean;
+  providerState?: PiProviderState | null;
+  settings: PiProviderSettings;
+  systemPrompt?: string;
+  thinkingLevel?: string | null;
+}
+
+export interface PiLaunchSpec {
+  args: string[];
+  command: string;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  launchKey: string;
+}
+
+const READONLY_TOOLS = 'read,grep,find,ls';
+
+export function buildPiLaunchSpec(params: BuildPiLaunchSpecParams): PiLaunchSpec {
+  const args = ['--mode', 'rpc'];
+  const systemPrompt = params.systemPrompt?.trim();
+  if (systemPrompt) {
+    args.push('--system-prompt', systemPrompt);
+  }
+
+  if (params.noSession) {
+    args.push('--no-session');
+  } else if (params.providerState?.sessionFile || params.providerState?.sessionId) {
+    args.push('--session', params.providerState.sessionFile ?? params.providerState.sessionId!);
+  }
+
+  if (params.noTools) {
+    args.push('--no-tools');
+  } else if (params.settings.toolMode === 'readonly') {
+    args.push('--tools', READONLY_TOOLS);
+  }
+
+  const decodedModel = typeof params.model === 'string' ? decodePiModelId(params.model) : null;
+  if (decodedModel) {
+    args.push('--provider', decodedModel.provider, '--model', decodedModel.modelId);
+  }
+
+  const thinkingLevel = normalizePiThinkingLevel(params.thinkingLevel);
+  if (thinkingLevel && thinkingLevel !== 'off') {
+    args.push('--thinking', thinkingLevel);
+  }
+
+  return {
+    args,
+    command: params.command,
+    cwd: params.cwd,
+    env: params.env ?? process.env,
+    launchKey: JSON.stringify({
+      args,
+      command: params.command,
+      cwd: params.cwd,
+      envText: params.envText ?? params.settings.environmentVariables,
+    }),
+  };
+}

package/src/providers/pi/runtime/PiModelDiscoveryService.ts

@@ -0,0 +1,92 @@
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import type ClaudianPlugin from '../../../main';
+import { parseEnvironmentVariables } from '../../../utils/env';
+import { getVaultPath } from '../../../utils/path';
+import {
+  normalizePiDiscoveredModels,
+  type PiDiscoveredModel,
+} from '../models';
+import { getPiProviderSettings } from '../settings';
+import { buildPiLaunchSpec } from './PiLaunchSpec';
+import { PiRpcTransport } from './PiRpcTransport';
+import { PiSubprocess } from './PiSubprocess';
+
+export interface PiModelDiscoveryResult {
+  diagnostics?: string;
+  models: PiDiscoveredModel[];
+}
+
+export class PiModelDiscoveryService {
+  constructor(private readonly plugin: ClaudianPlugin) {}
+
+  async discoverModels(): Promise<PiModelDiscoveryResult> {
+    const settings = getPiProviderSettings(this.plugin.settings as unknown as Record<string, unknown>);
+    const cwd = getVaultPath(this.plugin.app) ?? process.cwd();
+    const command = this.plugin.getResolvedProviderCliPath('pi') ?? 'pi';
+    const envText = getRuntimeEnvironmentText(this.plugin.settings as unknown as Record<string, unknown>, 'pi');
+    const env = {
+      ...process.env,
+      ...parseEnvironmentVariables(envText),
+    };
+    const launchSpec = buildPiLaunchSpec({
+      command,
+      cwd,
+      env,
+      envText,
+      noSession: true,
+      settings,
+    });
+    const subprocess = new PiSubprocess(launchSpec);
+    let transport: PiRpcTransport | null = null;
+    let removeEventListener: (() => void) | null = null;
+
+    try {
+      subprocess.start();
+      transport = new PiRpcTransport({
+        input: subprocess.stdout,
+        onClose: (listener) => subprocess.onClose(listener),
+        output: subprocess.stdin,
+      });
+      transport.start();
+      removeEventListener = transport.onEvent((event) => {
+        if (event.type !== 'extension_ui_request') {
+          return;
+        }
+
+        const id = typeof event.id === 'string' && event.id.trim() ? event.id.trim() : '';
+        if (id) {
+          transport?.send({
+            cancelled: true,
+            id,
+            type: 'extension_ui_response',
+          });
+        }
+      });
+      const response = await transport.request('get_available_models', {}, 20_000);
+      const models = normalizePiDiscoveredModels(extractModels(response));
+      return { models };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Pi model discovery failed';
+      const stderr = subprocess.getStderrSnapshot();
+      return {
+        diagnostics: stderr ? `${message}\n\n${stderr}` : message,
+        models: [],
+      };
+    } finally {
+      removeEventListener?.();
+      transport?.dispose();
+      await subprocess.shutdown().catch(() => {});
+    }
+  }
+}
+
+function extractModels(response: unknown): unknown {
+  if (Array.isArray(response)) {
+    return response;
+  }
+  if (response && typeof response === 'object' && !Array.isArray(response)) {
+    const record = response as Record<string, unknown>;
+    return record.models ?? record.availableModels ?? record.available_models ?? [];
+  }
+  return [];
+}

package/src/providers/pi/runtime/PiRpcPayloads.ts

@@ -0,0 +1,18 @@
+import { decodePiModelId } from '../models';
+
+export interface PiSetModelPayload extends Record<string, unknown> {
+  modelId: string;
+  provider: string;
+}
+
+export function buildPiSetModelPayload(model: string): PiSetModelPayload | null {
+  const decoded = decodePiModelId(model);
+  if (!decoded) {
+    return null;
+  }
+
+  return {
+    modelId: decoded.modelId,
+    provider: decoded.provider,
+  };
+}

package/src/providers/pi/runtime/PiRpcTransport.ts

@@ -0,0 +1,243 @@
+import type { Readable, Writable } from 'node:stream';
+
+import { subscribePiJsonlLines, writePiJsonl } from './PiJsonl';
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+
+export type PiRpcRecord = Record<string, unknown>;
+export type PiRpcEventHandler = (event: PiRpcRecord) => void;
+
+export interface PiRpcStreams {
+  input: Readable | NodeJS.ReadableStream;
+  onClose?: (listener: (error?: Error) => void) => () => void;
+  output: Writable | NodeJS.WritableStream;
+}
+
+interface PendingRequest {
+  cleanup: () => void;
+  reject: (error: Error) => void;
+  resolve: (response: unknown) => void;
+  type: string;
+}
+
+export class PiRpcTransportClosedError extends Error {
+  constructor(message = 'Pi RPC transport closed') {
+    super(message);
+    this.name = 'PiRpcTransportClosedError';
+  }
+}
+
+export class PiRpcResponseError extends Error {
+  constructor(
+    readonly commandType: string,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'PiRpcResponseError';
+  }
+}
+
+export class PiRpcTransport {
+  private readonly closeListeners = new Set<(error?: Error) => void>();
+  private disposed = false;
+  private readonly eventHandlers = new Set<PiRpcEventHandler>();
+  private nextId = 1;
+  private readonly pending = new Map<string, PendingRequest>();
+  private unregisterClose?: () => void;
+  private unsubscribeLines?: () => void;
+
+  constructor(
+    private readonly streams: PiRpcStreams,
+    private readonly defaultTimeoutMs = DEFAULT_TIMEOUT_MS,
+  ) {}
+
+  get isClosed(): boolean {
+    return this.disposed;
+  }
+
+  start(): void {
+    if (this.unsubscribeLines || this.disposed) {
+      return;
+    }
+
+    this.unsubscribeLines = subscribePiJsonlLines(
+      this.streams.input,
+      (line) => this.handleLine(line),
+      () => {
+        if (!this.disposed) {
+          this.dispose(new PiRpcTransportClosedError('Pi RPC input closed'));
+        }
+      },
+      (error) => {
+        if (!this.disposed) {
+          this.dispose(error);
+        }
+      },
+    );
+
+    this.unregisterClose = this.streams.onClose?.((error) => {
+      if (!this.disposed) {
+        this.dispose(error ?? new PiRpcTransportClosedError());
+      }
+    });
+  }
+
+  onEvent(handler: PiRpcEventHandler): () => void {
+    this.eventHandlers.add(handler);
+    return () => {
+      this.eventHandlers.delete(handler);
+    };
+  }
+
+  onClose(listener: (error?: Error) => void): () => void {
+    this.closeListeners.add(listener);
+    return () => {
+      this.closeListeners.delete(listener);
+    };
+  }
+
+  request<T = unknown>(
+    commandType: string,
+    payload: Record<string, unknown> = {},
+    timeoutMs = this.defaultTimeoutMs,
+  ): Promise<T> {
+    this.start();
+    if (this.disposed) {
+      return Promise.reject(new PiRpcTransportClosedError());
+    }
+
+    const id = `req_${this.nextId++}`;
+    return new Promise<T>((resolve, reject) => {
+      let timer: number | undefined;
+      const cleanup = (): void => {
+        if (timer !== undefined) {
+          window.clearTimeout(timer);
+        }
+      };
+
+      if (timeoutMs > 0) {
+        timer = window.setTimeout(() => {
+          this.pending.delete(id);
+          cleanup();
+          reject(new Error(`Request timeout: ${commandType} (${timeoutMs}ms)`));
+        }, timeoutMs);
+      }
+
+      this.pending.set(id, {
+        cleanup,
+        reject,
+        resolve: (response: unknown) => resolve(response as T),
+        type: commandType,
+      });
+
+      try {
+        this.sendRaw({ id, type: commandType, ...payload });
+      } catch (error) {
+        this.pending.delete(id);
+        cleanup();
+        const transportError = error instanceof Error ? error : new Error(String(error));
+        this.dispose(transportError);
+        reject(transportError);
+      }
+    });
+  }
+
+  send(record: PiRpcRecord): void {
+    this.start();
+    if (this.disposed) {
+      return;
+    }
+    this.sendRaw(record);
+  }
+
+  dispose(error: Error = new PiRpcTransportClosedError('Pi RPC transport disposed')): void {
+    if (this.disposed) {
+      return;
+    }
+
+    this.disposed = true;
+    this.unsubscribeLines?.();
+    this.unsubscribeLines = undefined;
+    this.unregisterClose?.();
+    this.unregisterClose = undefined;
+    this.rejectAllPending(error);
+    for (const listener of this.closeListeners) {
+      try {
+        listener(error);
+      } catch {
+        // Best-effort close notification.
+      }
+    }
+    this.closeListeners.clear();
+    this.eventHandlers.clear();
+  }
+
+  private sendRaw(record: PiRpcRecord): void {
+    writePiJsonl(this.streams.output, record);
+  }
+
+  private handleLine(line: string): void {
+    if (!line.trim()) {
+      return;
+    }
+
+    let record: PiRpcRecord;
+    try {
+      const parsed = JSON.parse(line) as unknown;
+      if (!isPlainObject(parsed)) {
+        return;
+      }
+      record = parsed;
+    } catch {
+      return;
+    }
+
+    if (record.type === 'response' && typeof record.id === 'string') {
+      this.handleResponse(record.id, record);
+      return;
+    }
+
+    for (const handler of this.eventHandlers) {
+      handler(record);
+    }
+  }
+
+  private handleResponse(id: string, record: PiRpcRecord): void {
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+
+    this.pending.delete(id);
+    pending.cleanup();
+    if (record.success === false) {
+      const errorText = typeof record.error === 'string'
+        ? record.error
+        : `Pi RPC command failed: ${pending.type}`;
+      pending.reject(new PiRpcResponseError(pending.type, errorText));
+      return;
+    }
+
+    if ('result' in record) {
+      pending.resolve(record.result);
+      return;
+    }
+    if ('data' in record) {
+      pending.resolve(record.data);
+      return;
+    }
+    pending.resolve(record);
+  }
+
+  private rejectAllPending(error: Error): void {
+    for (const pending of this.pending.values()) {
+      pending.cleanup();
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+}
+
+function isPlainObject(value: unknown): value is PiRpcRecord {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}