wind-agent-cli 1.38.2 → 1.39.0

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

@@ -0,0 +1,206 @@
+import { readFile } from 'node:fs/promises';
+
+import { sessionsDb } from '@/modules/database/index.js';
+import { parseFilesInputTag } from '@/shared/image-attachments.js';
+import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import type { IProviderSessions } from '@/shared/interfaces.js';
+import {
+  createNormalizedMessage,
+  generateMessageId,
+  normalizeProviderTimestamp,
+  readObjectRecord,
+  readOptionalString,
+  sliceTailPage,
+} from '@/shared/utils.js';
+
+const textFromContent = (content: unknown, type = 'text'): string => {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.flatMap((part) => {
+    const record = readObjectRecord(part);
+    return record?.type === type ? [readOptionalString(record.text) ?? ''] : [];
+  }).join('');
+};
+
+const formatToolResult = (result: unknown): string => {
+  if (typeof result === 'string') return result;
+  const record = readObjectRecord(result);
+  const content = record?.content;
+  const text = textFromContent(content);
+  if (text) return text;
+  try { return JSON.stringify(content ?? result, null, 2); } catch { return String(result ?? ''); }
+};
+
+const tokenBudgetFromEntries = (entries: AnyRecord[]): AnyRecord | undefined => {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheWrite = 0;
+  for (const entry of entries) {
+    const usage = readObjectRecord(readObjectRecord(entry.message)?.usage) ?? readObjectRecord(entry.usage);
+    if (!usage) continue;
+    input += Number(usage.input ?? 0);
+    output += Number(usage.output ?? 0);
+    cacheRead += Number(usage.cacheRead ?? 0);
+    cacheWrite += Number(usage.cacheWrite ?? 0);
+  }
+  const used = input + output + cacheRead + cacheWrite;
+  return used > 0 ? {
+    used,
+    inputTokens: input + cacheRead,
+    outputTokens: output,
+    breakdown: { input: input + cacheRead, output },
+  } : undefined;
+};
+
+const activeBranch = (entries: AnyRecord[]): AnyRecord[] => {
+  const withIds = entries.filter((entry) => readOptionalString(entry.id));
+  if (withIds.length === 0 || !withIds.some((entry) => readOptionalString(entry.parentId))) return entries;
+  const byId = new Map(withIds.map((entry) => [String(entry.id), entry]));
+  const branch: AnyRecord[] = [];
+  let current: AnyRecord | undefined = withIds[withIds.length - 1];
+  const seen = new Set<string>();
+  while (current) {
+    const id = readOptionalString(current.id);
+    if (!id || seen.has(id)) break;
+    seen.add(id);
+    branch.push(current);
+    const parentId = readOptionalString(current.parentId);
+    current = parentId ? byId.get(parentId) : undefined;
+  }
+  return branch.reverse();
+};
+
+/** Normalizes Pi RPC events and JSONL history into WindCli messages. */
+export class PiSessionsProvider implements IProviderSessions {
+  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
+    const raw = readObjectRecord(rawMessage);
+    if (!raw) return [];
+    const type = readOptionalString(raw.type);
+    const base = { provider: 'pi' as const, sessionId, timestamp: normalizeProviderTimestamp(raw.timestamp) };
+    if (type === 'message_update') {
+      const update = readObjectRecord(raw.assistantMessageEvent) ?? readObjectRecord(raw.event);
+      const delta = readOptionalString(update?.delta);
+      if (!delta) return [];
+      if (update?.type === 'text_delta') return [createNormalizedMessage({ ...base, kind: 'stream_delta', content: delta })];
+      if (update?.type === 'thinking_delta') return [createNormalizedMessage({ ...base, kind: 'thinking', content: delta })];
+    }
+    if (type === 'tool_execution_start') {
+      return [createNormalizedMessage({
+        ...base,
+        kind: 'tool_use',
+        toolId: readOptionalString(raw.toolCallId) ?? generateMessageId('pi-tool'),
+        toolName: readOptionalString(raw.toolName) ?? 'Tool',
+        toolInput: raw.args ?? {},
+      })];
+    }
+    if (type === 'tool_execution_end') {
+      const toolId = readOptionalString(raw.toolCallId) ?? generateMessageId('pi-tool');
+      return [createNormalizedMessage({
+        ...base,
+        kind: 'tool_result',
+        toolId,
+        toolName: readOptionalString(raw.toolName) ?? 'Tool',
+        toolResult: { content: formatToolResult(raw.result), isError: Boolean(raw.isError) },
+      })];
+    }
+    if (type === 'agent_end' && raw.willRetry !== true) {
+      return [createNormalizedMessage({ ...base, kind: 'stream_end' })];
+    }
+    if (type === 'error' || type === 'fault') {
+      return [createNormalizedMessage({
+        ...base,
+        kind: 'error',
+        content: readOptionalString(raw.message) ?? readOptionalString(raw.error) ?? 'Unknown Pi error',
+      })];
+    }
+    return [];
+  }
+
+  async fetchHistory(sessionId: string, options: FetchHistoryOptions = {}): Promise<FetchHistoryResult> {
+    const row = sessionsDb.getSessionById(sessionId);
+    if (!row?.jsonl_path) return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    try {
+      const entries = (await readFile(row.jsonl_path, 'utf8')).split(/\r?\n/).flatMap((line) => {
+        if (!line.trim()) return [];
+        try { return [JSON.parse(line) as AnyRecord]; } catch { return []; }
+      });
+      const branch = activeBranch(entries.filter((entry) => entry.type !== 'session'));
+      const messages = this.normalizeHistory(branch, sessionId);
+      const offset = Math.max(0, options.offset ?? 0);
+      const limit = options.limit === undefined ? null : options.limit === null ? null : Math.max(0, options.limit);
+      const { page, hasMore } = sliceTailPage(messages, limit, offset);
+      return {
+        messages: page,
+        total: messages.length,
+        hasMore,
+        offset,
+        limit,
+        tokenUsage: tokenBudgetFromEntries(branch),
+      };
+    } catch {
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+  }
+
+  private normalizeHistory(entries: AnyRecord[], sessionId: string): NormalizedMessage[] {
+    const messages: NormalizedMessage[] = [];
+    const tools = new Map<string, NormalizedMessage>();
+    for (const entry of entries) {
+      const id = readOptionalString(entry.id) ?? generateMessageId('pi-history');
+      const timestamp = normalizeProviderTimestamp(entry.timestamp);
+      if (entry.type === 'message') {
+        const message = readObjectRecord(entry.message);
+        const role = readOptionalString(message?.role);
+        if (role === 'user') {
+          const parsed = parseFilesInputTag(textFromContent(message?.content));
+          messages.push(createNormalizedMessage({
+            id, provider: 'pi', sessionId, timestamp, kind: 'text', role: 'user',
+            content: parsed.text, ...(parsed.attachments.length ? { files: parsed.attachments } : {}),
+          }));
+        } else if (role === 'assistant') {
+          const content = Array.isArray(message?.content) ? message.content : [];
+          content.forEach((part, index) => {
+            const block = readObjectRecord(part);
+            if (!block) return;
+            const blockId = `${id}:${index}`;
+            if (block.type === 'text' || block.type === 'thinking') {
+              const text = readOptionalString(block.text);
+              if (text) messages.push(createNormalizedMessage({
+                id: blockId, provider: 'pi', sessionId, timestamp,
+                kind: block.type === 'thinking' ? 'thinking' : 'text', role: 'assistant', content: text,
+              }));
+            } else if (block.type === 'toolCall' || block.type === 'tool_use') {
+              const toolId = readOptionalString(block.id) ?? blockId;
+              const normalized = createNormalizedMessage({
+                id: blockId, provider: 'pi', sessionId, timestamp, kind: 'tool_use',
+                toolId, toolName: readOptionalString(block.name) ?? 'Tool', toolInput: block.arguments ?? block.input ?? {},
+              });
+              tools.set(toolId, normalized);
+              messages.push(normalized);
+            }
+          });
+        } else if (role === 'toolResult' || role === 'tool_result') {
+          const toolId = readOptionalString(message?.toolCallId) ?? readOptionalString(message?.tool_use_id);
+          const result = { content: formatToolResult(message), isError: Boolean(message?.isError ?? message?.is_error) };
+          const tool = toolId ? tools.get(toolId) : undefined;
+          if (tool) tool.toolResult = result;
+          else messages.push(createNormalizedMessage({
+            id, provider: 'pi', sessionId, timestamp, kind: 'tool_result', toolId, toolResult: result,
+          }));
+        }
+      } else if (entry.type === 'compaction') {
+        const content = readOptionalString(entry.summary);
+        if (content) messages.push(createNormalizedMessage({
+          id, provider: 'pi', sessionId, timestamp, kind: 'text', role: 'assistant', content, isCompactSummary: true,
+        }));
+      } else if (entry.type === 'custom_message' && entry.display !== false) {
+        const content = textFromContent(entry.content);
+        if (content) messages.push(createNormalizedMessage({
+          id, provider: 'pi', sessionId, timestamp, kind: 'text', role: 'assistant', content,
+        }));
+      }
+    }
+    return messages;
+  }
+}

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

@@ -0,0 +1,37 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { SkillsProvider } from '@/modules/providers/shared/skills/skills.provider.js';
+import type { ProviderSkillSource } from '@/shared/types.js';
+import { addUniqueProviderSkillSource, findTopmostGitRoot } from '@/shared/utils.js';
+
+/** Discovers Pi-native and cross-agent skills using Pi's `/skill:<name>` syntax. */
+export class PiSkillsProvider extends SkillsProvider {
+  constructor() {
+    super('pi');
+  }
+
+  protected async getSkillSources(workspacePath: string): Promise<ProviderSkillSource[]> {
+    const sources: ProviderSkillSource[] = [];
+    const seen = new Set<string>();
+    const add = (scope: 'user' | 'project', rootDir: string) => addUniqueProviderSkillSource(
+      sources,
+      seen,
+      { scope, rootDir, commandForSkill: (skillName) => `/skill:${skillName}` },
+    );
+    add('user', path.join(os.homedir(), '.pi', 'agent', 'skills'));
+    add('user', path.join(os.homedir(), '.agents', 'skills'));
+    add('project', path.join(workspacePath, '.pi', 'skills'));
+
+    const repoRoot = await findTopmostGitRoot(workspacePath);
+    let current = path.resolve(workspacePath);
+    while (true) {
+      add('project', path.join(current, '.agents', 'skills'));
+      if (!repoRoot || current === path.resolve(repoRoot)) break;
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    return sources;
+  }
+}

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

@@ -0,0 +1,33 @@
+import type {
+  IProviderAuth,
+  IProviderMcp,
+  IProviderModels,
+  IProviderRuntime,
+  IProviderSessionSynchronizer,
+  IProviderSessions,
+  IProviderSkills,
+} from '@/shared/interfaces.js';
+import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
+
+import { PiProviderAuth } from './pi-auth.provider.js';
+import { PiMcpProvider } from './pi-mcp.provider.js';
+import { PiProviderModels } from './pi-models.provider.js';
+import { piRuntime } from './pi-runtime.provider.js';
+import { PiSessionSynchronizer } from './pi-session-synchronizer.provider.js';
+import { PiSessionsProvider } from './pi-sessions.provider.js';
+import { PiSkillsProvider } from './pi-skills.provider.js';
+
+/** Registry wrapper that composes all seven Pi provider facets. */
+export class PiProvider extends AbstractProvider {
+  readonly runtime: IProviderRuntime = piRuntime;
+  readonly models: IProviderModels = new PiProviderModels();
+  readonly mcp: IProviderMcp = new PiMcpProvider();
+  readonly auth: IProviderAuth = new PiProviderAuth();
+  readonly skills: IProviderSkills = new PiSkillsProvider();
+  readonly sessions: IProviderSessions = new PiSessionsProvider();
+  readonly sessionSynchronizer: IProviderSessionSynchronizer = new PiSessionSynchronizer();
+
+  constructor() {
+    super('pi');
+  }
+}

package/server/modules/providers/provider.registry.ts

@@ -2,6 +2,7 @@ import { ClaudeProvider } from '@/modules/providers/list/claude/claude.provider.
 import { CodexProvider } from '@/modules/providers/list/codex/codex.provider.js';
 import { CursorProvider } from '@/modules/providers/list/cursor/cursor.provider.js';
 import { OpenCodeProvider } from '@/modules/providers/list/opencode/opencode.provider.js';
+import { PiProvider } from '@/modules/providers/list/pi/index.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type { LLMProvider } from '@/shared/types.js';
 import { AppError } from '@/shared/utils.js';
@@ -11,6 +12,7 @@ const providers: Record<LLMProvider, IProvider> = {
   codex: new CodexProvider(),
   cursor: new CursorProvider(),
   opencode: new OpenCodeProvider(),
+  pi: new PiProvider(),
 };
 
 /**

package/server/modules/providers/provider.routes.ts

@@ -287,6 +287,7 @@ const parseProvider = (value: unknown): LLMProvider => {
     || normalized === 'codex'
     || normalized === 'cursor'
     || normalized === 'opencode'
+    || normalized === 'pi'
   ) {
     return normalized;
   }

package/server/modules/providers/services/provider-capabilities.service.ts

@@ -25,6 +25,12 @@ type ProviderCapabilities = {
   supportsTokenUsage: boolean;
   /** Whether the provider runtime can accept model-level reasoning effort. */
   supportsEffort: boolean;
+  /** Whether the provider exposes configurable MCP servers. */
+  supportsMcp: boolean;
+  /** Whether the provider exposes discoverable/installable skills. */
+  supportsSkills: boolean;
+  /** Whether the Settings UI has provider permission controls. */
+  supportsPermissionSettings: boolean;
 };
 
 /**
@@ -44,6 +50,9 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: true,
     supportsTokenUsage: true,
     supportsEffort: true,
+    supportsMcp: true,
+    supportsSkills: true,
+    supportsPermissionSettings: true,
   },
   cursor: {
     provider: 'cursor',
@@ -55,6 +64,9 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
     supportsEffort: false,
+    supportsMcp: true,
+    supportsSkills: true,
+    supportsPermissionSettings: true,
   },
   codex: {
     provider: 'codex',
@@ -66,6 +78,9 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
     supportsEffort: true,
+    supportsMcp: true,
+    supportsSkills: true,
+    supportsPermissionSettings: true,
   },
   opencode: {
     provider: 'opencode',
@@ -80,6 +95,23 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
     supportsEffort: true,
+    supportsMcp: true,
+    supportsSkills: false,
+    supportsPermissionSettings: false,
+  },
+  pi: {
+    provider: 'pi',
+    permissionModes: ['default'],
+    defaultPermissionMode: 'default',
+    supportsImages: true,
+    supportsFiles: true,
+    supportsAbort: true,
+    supportsPermissionRequests: false,
+    supportsTokenUsage: true,
+    supportsEffort: true,
+    supportsMcp: false,
+    supportsSkills: true,
+    supportsPermissionSettings: false,
   },
 };
 

package/server/modules/providers/services/session-synchronizer.service.ts

@@ -22,6 +22,7 @@ export const sessionSynchronizerService = {
       codex: 0,
       cursor: 0,
       opencode: 0,
+      pi: 0,
     };
     const failures: string[] = [];
 

package/server/modules/providers/services/sessions-watcher.service.ts

@@ -10,6 +10,7 @@ import { WS_OPEN_STATE, connectedClients } from '@/modules/websocket/index.js';
 import type { LLMProvider } from '@/shared/types.js';
 import { generateDisplayName } from '@/modules/projects/index.js';
 import { SessionWatchScheduler } from '@/modules/providers/services/session-watch-scheduler.js';
+import { getPiSessionDirectory } from '@/modules/providers/list/pi/index.js';
 
 const PROVIDER_WATCH_PATHS: Array<{ provider: LLMProvider; rootPath: string }> = [
   {
@@ -28,6 +29,10 @@ const PROVIDER_WATCH_PATHS: Array<{ provider: LLMProvider; rootPath: string }> =
     provider: 'opencode',
     rootPath: path.join(os.homedir(), '.local', 'share', 'opencode'),
   },
+  {
+    provider: 'pi',
+    rootPath: getPiSessionDirectory(),
+  },
 ];
 
 const WATCHER_IGNORED_DIRECTORY_NAMES = new Set([

package/server/modules/providers/tests/mcp.test.ts

@@ -313,8 +313,10 @@ test('providerMcpService global adder writes to all providers and rejects unsupp
       workspacePath,
     });
 
-    assert.equal(globalResult.length, 4);
-    assert.ok(globalResult.every((entry) => entry.created === true));
+    assert.equal(globalResult.length, 5);
+    assert.ok(globalResult.filter((entry) => entry.provider !== 'pi').every((entry) => entry.created === true));
+    assert.equal(globalResult.find((entry) => entry.provider === 'pi')?.created, false);
+    assert.match(globalResult.find((entry) => entry.provider === 'pi')?.error ?? '', /does not provide native MCP/);
 
     const claudeProject = await readJson(path.join(workspacePath, '.mcp.json'));
     assert.ok((claudeProject.mcpServers as Record<string, unknown>)['global-http']);

package/server/modules/providers/tests/opencode-sessions.test.ts

@@ -6,7 +6,7 @@ import test from 'node:test';
 
 import Database from 'better-sqlite3';
 
-import { closeConnection, initializeDatabase, sessionsDb } from '@/modules/database/index.js';
+import { closeConnection, initializeDatabase, projectsDb, sessionsDb } from '@/modules/database/index.js';
 import { OpenCodeSessionSynchronizer } from '@/modules/providers/list/opencode/opencode-session-synchronizer.provider.js';
 import { OpenCodeSessionsProvider } from '@/modules/providers/list/opencode/opencode-sessions.provider.js';
 import { appendImagesInputTag } from '@/shared/image-attachments.js';
@@ -41,9 +41,15 @@ async function withIsolatedDatabase(runTest: () => void | Promise<void>): Promis
   }
 }
 
-const createOpenCodeDatabase = async (homeDir: string, workspacePath: string): Promise<void> => {
+const createOpenCodeDatabase = async (
+  homeDir: string,
+  workspacePath: string,
+  options: { projectId?: string; worktreePath?: string } = {},
+): Promise<void> => {
   const dataDir = path.join(homeDir, '.local', 'share', 'opencode');
   await mkdir(dataDir, { recursive: true });
+  const projectId = options.projectId ?? 'project-1';
+  const worktreePath = options.worktreePath ?? workspacePath;
 
   const db = new Database(path.join(dataDir, 'opencode.db'));
   try {
@@ -123,8 +129,8 @@ const createOpenCodeDatabase = async (homeDir: string, workspacePath: string): P
     db.prepare(
       'INSERT INTO project (id, worktree, time_created, time_updated, sandboxes) VALUES (?, ?, ?, ?, ?)',
     ).run(
-      'project-1',
-      workspacePath,
+      projectId,
+      worktreePath,
       1_700_000_000_000,
       1_700_000_001_000,
       '[]',
@@ -137,7 +143,7 @@ const createOpenCodeDatabase = async (homeDir: string, workspacePath: string): P
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
       'open-session-1',
-      'project-1',
+      projectId,
       'open-session-1',
       workspacePath,
       'OpenCode indexed title',
@@ -253,7 +259,10 @@ test('OpenCode session synchronizer indexes sqlite sessions without deletable tr
   const restoreHomeDir = patchHomeDir(tempRoot);
 
   try {
-    await createOpenCodeDatabase(tempRoot, workspacePath);
+    await createOpenCodeDatabase(tempRoot, workspacePath, {
+      projectId: 'global',
+      worktreePath: '/',
+    });
     await withIsolatedDatabase(() => {
       const synchronizer = new OpenCodeSessionSynchronizer();
       const processed = synchronizer.synchronize();
@@ -273,6 +282,72 @@ test('OpenCode session synchronizer indexes sqlite sessions without deletable tr
   }
 });
 
+test('OpenCode session synchronizer skips external Multica global workdirs', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'opencode-session-sync-multica-'));
+  const workspacePath = path.join(
+    tempRoot,
+    'multica_workspaces_desktop-api.example.test',
+    'workspace-id',
+    'deadbeef',
+    'workdir',
+  );
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    await createOpenCodeDatabase(tempRoot, workspacePath, {
+      projectId: 'global',
+      worktreePath: '/',
+    });
+    await withIsolatedDatabase(async () => {
+      const count = await new OpenCodeSessionSynchronizer().synchronize();
+
+      assert.equal(count, 0);
+      assert.equal(sessionsDb.getSessionById('open-session-1'), null);
+      assert.equal(projectsDb.getProjectPath(workspacePath), null);
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('OpenCode session synchronizer keeps WindCli sessions in Multica global workdirs', { concurrency: false }, async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'opencode-session-sync-multica-app-'));
+  const workspacePath = path.join(
+    tempRoot,
+    'multica_workspaces_desktop-api.example.test',
+    'workspace-id',
+    'deadbeef',
+    'workdir',
+  );
+  await mkdir(workspacePath, { recursive: true });
+  const restoreHomeDir = patchHomeDir(tempRoot);
+
+  try {
+    await createOpenCodeDatabase(tempRoot, workspacePath, {
+      projectId: 'global',
+      worktreePath: '/',
+    });
+    await withIsolatedDatabase(async () => {
+      sessionsDb.createAppSession('app-session-multica', 'opencode', workspacePath);
+      sessionsDb.assignProviderSessionId('app-session-multica', 'open-session-1');
+
+      const count = await new OpenCodeSessionSynchronizer().synchronize();
+
+      assert.equal(count, 1);
+      assert.equal(sessionsDb.getAllSessions().length, 1);
+      assert.equal(
+        sessionsDb.getSessionById('app-session-multica')?.provider_session_id,
+        'open-session-1',
+      );
+    });
+  } finally {
+    restoreHomeDir();
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
 test('OpenCode session synchronizer returns the app session id once provider mapping exists', { concurrency: false }, async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'opencode-session-sync-mapped-'));
   const workspacePath = path.join(tempRoot, 'workspace');