wind-agent-cli 1.38.3 → 1.39.0

package/server/modules/providers/list/pi/pi-models.provider.ts

@@ -0,0 +1,114 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import spawn from 'cross-spawn';
+
+import type { IProviderModels } from '@/shared/interfaces.js';
+import type { ProviderCurrentActiveModel, ProviderModelOption, ProviderModelsDefinition } from '@/shared/types.js';
+import { readObjectRecord, readOptionalString } from '@/shared/utils.js';
+
+const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+type PiCommandResult = { status: number | null; stdout: string; stderr: string; error?: Error };
+
+/** Used by Pi auth and model facets so both execute the CLI without a shell. */
+export function runPiCommand(args: string[]): PiCommandResult {
+  const result = spawn.sync('pi', args, {
+    encoding: 'utf8',
+    timeout: 10_000,
+    windowsHide: true,
+  });
+  return {
+    status: result.status,
+    stdout: String(result.stdout ?? ''),
+    stderr: String(result.stderr ?? ''),
+    error: result.error,
+  };
+}
+
+const normalizeHeader = (value: string): string => value.toLowerCase().replace(/[^a-z]/g, '');
+
+/** Parses Pi's fixed-column `--list-models` table; exported for focused provider tests. */
+export function parsePiModelsTable(output: string): ProviderModelOption[] {
+  const lines = output.split(/\r?\n/).filter((line) => line.trim());
+  const headerIndex = lines.findIndex((line) => /provider/i.test(line) && /model/i.test(line));
+  if (headerIndex < 0) return [];
+
+  const header = lines[headerIndex];
+  const matches = [...header.matchAll(/\S+/g)];
+  const columns = matches.map((match, index) => ({
+    name: normalizeHeader(match[0]),
+    start: match.index ?? 0,
+    end: matches[index + 1]?.index ?? Number.POSITIVE_INFINITY,
+  }));
+  const providerColumn = columns.find((column) => column.name === 'provider');
+  const modelColumn = columns.find((column) => column.name === 'model' || column.name === 'modelid');
+  const thinkingColumn = columns.find((column) => column.name === 'thinking');
+  const imageColumn = columns.find((column) => column.name === 'images' || column.name === 'image');
+  if (!providerColumn || !modelColumn) return [];
+
+  const readColumn = (line: string, column: typeof columns[number]): string => (
+    line.slice(column.start, Number.isFinite(column.end) ? column.end : undefined).trim()
+  );
+
+  return lines.slice(headerIndex + 1).flatMap((line) => {
+    if (/^-+$/.test(line.replace(/\s/g, ''))) return [];
+    const provider = readColumn(line, providerColumn);
+    const model = readColumn(line, modelColumn);
+    if (!provider || !model) return [];
+    const value = `${provider}/${model}`;
+    const supportsThinking = thinkingColumn
+      ? /^(yes|true|supported)$/i.test(readColumn(line, thinkingColumn))
+      : false;
+    const supportsImages = imageColumn
+      ? /^(yes|true|supported)$/i.test(readColumn(line, imageColumn))
+      : false;
+    return [{
+      value,
+      label: model,
+      description: `${provider}${supportsImages ? ' · Images' : ''}`,
+      ...(supportsThinking ? {
+        effort: {
+          default: 'medium',
+          values: THINKING_LEVELS.map((level) => ({ value: level })),
+        },
+      } : {}),
+    }];
+  });
+}
+
+async function readPiDefaultModel(): Promise<string | null> {
+  try {
+    const settings = readObjectRecord(JSON.parse(await readFile(
+      path.join(os.homedir(), '.pi', 'agent', 'settings.json'),
+      'utf8',
+    )));
+    const provider = readOptionalString(settings?.defaultProvider);
+    const model = readOptionalString(settings?.defaultModel);
+    return provider && model ? `${provider}/${model}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Dynamic Pi catalog adapter. Discovery is intentionally uncached because auth changes alter the list. */
+export class PiProviderModels implements IProviderModels {
+  async getSupportedModels(): Promise<ProviderModelsDefinition> {
+    const result = runPiCommand(['--list-models']);
+    const options = result.status === 0 && !result.error ? parsePiModelsTable(result.stdout) : [];
+    const configuredDefault = await readPiDefaultModel();
+    const fallback = options[0]?.value ?? configuredDefault ?? '';
+    return {
+      OPTIONS: options,
+      DEFAULT: configuredDefault && options.some((option) => option.value === configuredDefault)
+        ? configuredDefault
+        : fallback,
+    };
+  }
+
+  async getCurrentActiveModel(): Promise<ProviderCurrentActiveModel> {
+    const models = await this.getSupportedModels();
+    return { model: models.DEFAULT };
+  }
+}

package/server/modules/providers/list/pi/pi-runtime.provider.ts

@@ -0,0 +1,271 @@
+import { existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import spawn from 'cross-spawn';
+
+import {
+  appendFilesInputTag,
+  isAllowedImageSourcePath,
+  normalizeImageDescriptors,
+  resolveImageAbsolutePath,
+  resolveImageMediaType,
+} from '@/shared/image-attachments.js';
+import type { AnyRecord, ProviderRuntimeContext, ProviderRuntimeWriter } from '@/shared/types.js';
+import { createCompleteMessage, createNormalizedMessage, findTopmostGitRoot } from '@/shared/utils.js';
+
+type PiChild = ReturnType<typeof spawn> & { aborted?: boolean };
+
+const activePiProcesses = new Map<string, PiChild>();
+const ABORT_GRACE_MS = 500;
+
+const formatError = (value: unknown): string => value instanceof Error ? value.message : String(value);
+
+async function buildPiImages(images: unknown, cwd: string): Promise<Array<{
+  type: 'image';
+  data: string;
+  mimeType: string;
+}>> {
+  const result: Array<{ type: 'image'; data: string; mimeType: string }> = [];
+  for (const descriptor of normalizeImageDescriptors(images)) {
+    const mimeType = resolveImageMediaType(descriptor);
+    const resolvedPath = resolveImageAbsolutePath(cwd, descriptor.path);
+    if (!mimeType?.startsWith('image/') || !isAllowedImageSourcePath(resolvedPath, cwd)) continue;
+    try {
+      const canonicalPath = await fs.realpath(resolvedPath);
+      if (!isAllowedImageSourcePath(canonicalPath, cwd)) continue;
+      result.push({
+        type: 'image',
+        data: (await fs.readFile(canonicalPath)).toString('base64'),
+        mimeType,
+      });
+    } catch (error) {
+      console.warn(`[Pi] Unable to attach image ${descriptor.path}: ${formatError(error)}`);
+    }
+  }
+  return result;
+}
+
+async function collectProjectSkillArgs(cwd: string): Promise<string[]> {
+  const skillDirs = [path.join(cwd, '.pi', 'skills')];
+  const repoRoot = await findTopmostGitRoot(cwd);
+  let current = path.resolve(cwd);
+  while (true) {
+    skillDirs.push(path.join(current, '.agents', 'skills'));
+    if (!repoRoot || current === path.resolve(repoRoot)) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return skillDirs.filter(existsSync).flatMap((directory) => ['--skill', directory]);
+}
+
+const readTokenBudget = (event: AnyRecord): AnyRecord | null => {
+  const messages = Array.isArray(event.messages) ? event.messages : [];
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  for (const message of messages) {
+    if (!message || typeof message !== 'object') continue;
+    const usage = (message as AnyRecord).usage;
+    if (!usage || typeof usage !== 'object') continue;
+    const record = usage as AnyRecord;
+    input += Number(record.input ?? 0);
+    output += Number(record.output ?? 0);
+    cacheRead += Number(record.cacheRead ?? 0);
+    cacheWrite += Number(record.cacheWrite ?? 0);
+  }
+  const used = input + output + cacheRead + cacheWrite;
+  return used > 0 ? {
+    used,
+    inputTokens: input + cacheRead,
+    outputTokens: output,
+    breakdown: { input: input + cacheRead, output },
+  } : null;
+};
+
+/** Starts one isolated Pi RPC process for a single chat.send operation. */
+export async function runPi(
+  command: string,
+  options: AnyRecord,
+  writer: ProviderRuntimeWriter,
+  context: ProviderRuntimeContext,
+): Promise<void> {
+  const sessionId = typeof options.sessionId === 'string' && options.sessionId.trim()
+    ? options.sessionId.trim()
+    : crypto.randomUUID();
+  const workingDir = typeof options.cwd === 'string' && options.cwd.trim()
+    ? options.cwd
+    : typeof options.projectPath === 'string' && options.projectPath.trim()
+      ? options.projectPath
+      : process.cwd();
+  const providerSessionId = context.resolveProviderSessionId(sessionId);
+  const resolvedModel = await context.resolveResumeModel(
+    sessionId,
+    typeof options.model === 'string' ? options.model : undefined,
+  );
+  const args = ['--mode', 'rpc', '--no-approve'];
+  if (providerSessionId) args.push('--session', providerSessionId);
+  else args.push('--session-id', sessionId);
+  if (resolvedModel) {
+    const slash = resolvedModel.indexOf('/');
+    if (slash > 0) args.push('--provider', resolvedModel.slice(0, slash));
+    args.push('--model', resolvedModel);
+  }
+  if (typeof options.effort === 'string' && options.effort !== 'default') {
+    args.push('--thinking', options.effort);
+  }
+  args.push(...await collectProjectSkillArgs(workingDir));
+
+  const images = await buildPiImages(options.images, workingDir);
+  const prompt = appendFilesInputTag(command?.trim() ?? '', options.files);
+
+  await new Promise<void>((resolve, reject) => {
+    let child: PiChild;
+    let stdoutBuffer = '';
+    let stderr = '';
+    let terminalSent = false;
+    let settled = false;
+    let agentEnded = false;
+    let protocolError: Error | null = null;
+
+    const cleanup = () => {
+      if (activePiProcesses.get(sessionId) === child) activePiProcesses.delete(sessionId);
+    };
+    const settle = (exitCode: number, error?: Error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (!terminalSent && !child.aborted) {
+        terminalSent = true;
+        writer.send(createCompleteMessage({ provider: 'pi', sessionId, exitCode }));
+      }
+      if (error) reject(error);
+      else resolve();
+    };
+    const emitError = (message: string) => writer.send(createNormalizedMessage({
+      kind: 'error', provider: 'pi', sessionId, content: message,
+    }));
+    const processLine = (line: string) => {
+      if (!line.trim()) return;
+      let event: AnyRecord;
+      try {
+        event = JSON.parse(line) as AnyRecord;
+      } catch {
+        protocolError = new Error('Pi RPC returned invalid JSONL output.');
+        emitError(protocolError.message);
+        child.stdin?.end();
+        setTimeout(() => { if (child.exitCode === null) child.kill(); }, ABORT_GRACE_MS).unref();
+        return;
+      }
+      if (event.type === 'response' && event.success === false) {
+        protocolError = new Error(
+          typeof event.error === 'string' ? event.error : 'Pi rejected the RPC request.',
+        );
+        emitError(protocolError.message);
+        child.stdin?.end();
+        setTimeout(() => { if (child.exitCode === null) child.kill(); }, ABORT_GRACE_MS).unref();
+        return;
+      }
+      for (const message of context.normalizeMessage(event, sessionId)) writer.send(message);
+      if (event.type === 'agent_end' && event.willRetry !== true) {
+        agentEnded = true;
+        const tokenBudget = readTokenBudget(event);
+        if (tokenBudget) writer.send(createNormalizedMessage({
+          kind: 'status', provider: 'pi', sessionId, text: 'token_budget', tokenBudget,
+        }));
+        if (!terminalSent) {
+          terminalSent = true;
+          writer.send(createCompleteMessage({ provider: 'pi', sessionId, exitCode: 0 }));
+        }
+        child.stdin?.end();
+        setTimeout(() => {
+          if (child.exitCode === null) child.kill();
+        }, ABORT_GRACE_MS).unref();
+      }
+    };
+
+    try {
+      child = spawn('pi', args, {
+        cwd: workingDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: process.env,
+        windowsHide: true,
+      }) as PiChild;
+    } catch (error) {
+      const wrapped = new Error(`Unable to start Pi CLI: ${formatError(error)}`);
+      emitError(wrapped.message);
+      reject(wrapped);
+      return;
+    }
+
+    activePiProcesses.set(sessionId, child);
+    writer.setSessionId?.(sessionId);
+    child.stdout?.on('data', (chunk: Buffer) => {
+      stdoutBuffer += chunk.toString('utf8');
+      const lines = stdoutBuffer.split(/\r?\n/);
+      stdoutBuffer = lines.pop() ?? '';
+      for (const line of lines) processLine(line);
+    });
+    child.stderr?.on('data', (chunk: Buffer) => { stderr += chunk.toString('utf8'); });
+    child.on('error', (error) => {
+      const wrapped = new Error(`Pi CLI failed: ${error.message}`);
+      emitError(wrapped.message);
+      settle(1, wrapped);
+    });
+    child.on('close', (code) => {
+      if (stdoutBuffer.trim()) processLine(stdoutBuffer);
+      if (settled) {
+        cleanup();
+        return;
+      }
+      if (child.aborted) {
+        settle(0);
+        return;
+      }
+      if (agentEnded) {
+        settle(0);
+        return;
+      }
+      if (protocolError) {
+        settle(1, protocolError);
+        return;
+      }
+      const exitCode = code ?? 1;
+      if (exitCode !== 0) {
+        const message = stderr.trim() || `Pi CLI exited with code ${exitCode}.`;
+        emitError(message);
+        settle(exitCode, new Error(message));
+      } else {
+        const error = new Error('Pi RPC exited before emitting agent_end.');
+        emitError(error.message);
+        settle(1, error);
+      }
+    });
+    child.stdin?.write(`${JSON.stringify({
+      id: `prompt-${sessionId}`,
+      type: 'prompt',
+      message: prompt,
+      ...(images.length > 0 ? { images } : {}),
+    })}\n`);
+  });
+}
+
+/** Sends Pi's RPC abort command, then force-terminates an unresponsive child. */
+export function abortPiSession(sessionId: string): boolean {
+  const child = activePiProcesses.get(sessionId);
+  if (!child) return false;
+  child.aborted = true;
+  try {
+    child.stdin?.write(`${JSON.stringify({ id: `abort-${sessionId}`, type: 'abort' })}\n`);
+  } catch {
+    child.kill();
+  }
+  setTimeout(() => {
+    if (child.exitCode === null) child.kill();
+  }, ABORT_GRACE_MS).unref();
+  activePiProcesses.delete(sessionId);
+  return true;
+}
+
+export const piRuntime = { run: runPi, abort: abortPiSession };

package/server/modules/providers/list/pi/pi-session-synchronizer.provider.ts

@@ -0,0 +1,134 @@
+import fsSync from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { sessionsDb } from '@/modules/database/index.js';
+import type { IProviderSessionSynchronizer } from '@/shared/interfaces.js';
+import type { AnyRecord } from '@/shared/types.js';
+import {
+  normalizeProviderTimestamp,
+  normalizeSessionName,
+  readObjectRecord,
+  readOptionalString,
+} from '@/shared/utils.js';
+
+const PI_SETTINGS_PATH = path.join(os.homedir(), '.pi', 'agent', 'settings.json');
+const DEFAULT_PI_SESSION_DIR = path.join(os.homedir(), '.pi', 'agent', 'sessions');
+
+const expandHome = (value: string): string => {
+  if (value === '~') return os.homedir();
+  if (value.startsWith(`~${path.sep}`) || value.startsWith('~/') || value.startsWith('~\\')) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return path.isAbsolute(value) ? value : path.resolve(os.homedir(), value);
+};
+
+/** Resolves Pi's transcript root for the synchronizer and filesystem watcher. */
+export function getPiSessionDirectory(): string {
+  const environmentDirectory = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
+  if (environmentDirectory) return expandHome(environmentDirectory);
+  try {
+    const settings = readObjectRecord(JSON.parse(fsSync.readFileSync(PI_SETTINGS_PATH, 'utf8')));
+    const configured = readOptionalString(settings?.sessionDir);
+    if (configured) return expandHome(configured);
+  } catch {
+    // Missing or partially-written settings use Pi's standard session root.
+  }
+  return DEFAULT_PI_SESSION_DIR;
+}
+
+const listJsonlFiles = async (root: string): Promise<string[]> => {
+  const files: string[] = [];
+  const visit = async (directory: string): Promise<void> => {
+    let entries;
+    try { entries = await readdir(directory, { withFileTypes: true }); } catch { return; }
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(entryPath);
+      else if (entry.isFile() && entry.name.endsWith('.jsonl')) files.push(entryPath);
+    }));
+  };
+  await visit(root);
+  return files;
+};
+
+const firstUserText = (entries: AnyRecord[]): string | undefined => {
+  for (const entry of entries) {
+    if (entry.type !== 'message') continue;
+    const message = readObjectRecord(entry.message);
+    if (message?.role !== 'user') continue;
+    if (typeof message.content === 'string' && message.content.trim()) return message.content.trim();
+    if (Array.isArray(message.content)) {
+      const text = message.content.flatMap((part) => {
+        const block = readObjectRecord(part);
+        return block?.type === 'text' ? [readOptionalString(block.text) ?? ''] : [];
+      }).join('').trim();
+      if (text) return text;
+    }
+  }
+  return undefined;
+};
+
+/** Indexes Pi's JSONL transcript tree into WindCli's stable sessions table. */
+export class PiSessionSynchronizer implements IProviderSessionSynchronizer {
+  async synchronize(since?: Date): Promise<number> {
+    const files = await listJsonlFiles(getPiSessionDirectory());
+    let processed = 0;
+    for (const filePath of files) {
+      if (since) {
+        try {
+          if ((await stat(filePath)).mtime < since) continue;
+        } catch {
+          continue;
+        }
+      }
+      if (await this.synchronizeFile(filePath)) processed += 1;
+    }
+    return processed;
+  }
+
+  async synchronizeFile(filePath: string): Promise<string | null> {
+    if (!filePath.endsWith('.jsonl')) return null;
+    try {
+      const entries = (await readFile(filePath, 'utf8')).split(/\r?\n/).flatMap((line) => {
+        if (!line.trim()) return [];
+        try { return [JSON.parse(line) as AnyRecord]; } catch { return []; }
+      });
+      const header = entries.find((entry) => entry.type === 'session');
+      const sessionId = readOptionalString(header?.id);
+      const projectPath = readOptionalString(header?.cwd);
+      if (!sessionId || !projectPath) return null;
+
+      const sessionInfo = [...entries].reverse().find((entry) => entry.type === 'session_info');
+      const title = readOptionalString(sessionInfo?.name)
+        ?? readOptionalString(sessionInfo?.title)
+        ?? firstUserText(entries);
+      const fileStats = await stat(filePath);
+      const createdAt = normalizeProviderTimestamp(header?.timestamp ?? fileStats.birthtime);
+      const updatedAt = normalizeProviderTimestamp(
+        [...entries].reverse().find((entry) => readOptionalString(entry.timestamp))?.timestamp ?? fileStats.mtime,
+      );
+      const pending = sessionsDb.getSessionByProviderSessionId(sessionId)
+        ?? sessionsDb.getSessionById(sessionId)
+        ?? sessionsDb.findLatestPendingAppSession('pi', projectPath);
+      if (pending && !pending.provider_session_id) {
+        sessionsDb.assignProviderSessionId(pending.session_id, sessionId);
+      }
+      const existing = sessionsDb.getSessionByProviderSessionId(sessionId) ?? sessionsDb.getSessionById(sessionId);
+      const fallback = 'Untitled Pi Session';
+      return sessionsDb.createSession(
+        sessionId,
+        'pi',
+        projectPath,
+        normalizeSessionName(existing?.custom_name || title, fallback),
+        createdAt,
+        updatedAt,
+        filePath,
+      );
+    } catch (error) {
+      console.warn(`[PiProvider] Failed to synchronize ${filePath}:`, error instanceof Error ? error.message : String(error));
+      return null;
+    }
+  }
+}