pi-cursor-agent 0.1.0

package/src/pi/executors/read.ts

@@ -0,0 +1,73 @@
+import { createReadTool } from "@mariozechner/pi-coding-agent";
+import type { ToolResultMessage } from "@mariozechner/pi-ai";
+import type { Executor } from "../../vendor/agent-exec";
+import type {
+  ReadArgs,
+  ReadResult,
+} from "../../__generated__/agent/v1/read_exec_pb";
+import {
+  ReadError,
+  ReadRejected,
+  ReadResult as ReadResultClass,
+  ReadSuccess,
+} from "../../__generated__/agent/v1/read_exec_pb";
+import { toolResultToText, toolResultWasTruncated } from "../utils/tool-result";
+import { type PiToolContext, decodeToolCallId, executePiTool } from "../local-resource-provider/types";
+
+function buildReadResultFromToolResult(
+  path: string,
+  result: ToolResultMessage,
+): ReadResult {
+  const text = toolResultToText(result);
+  if (result.isError) {
+    return new ReadResultClass({
+      result: { case: "error", value: new ReadError({ path, error: text || "Read failed" }) },
+    });
+  }
+  const totalLines = text ? text.split("\n").length : 0;
+  return new ReadResultClass({
+    result: {
+      case: "success",
+      value: new ReadSuccess({
+        path,
+        totalLines,
+        fileSize: BigInt(Buffer.byteLength(text, "utf-8")),
+        truncated: toolResultWasTruncated(result),
+        output: { case: "content", value: text },
+      }),
+    },
+  });
+}
+
+function buildReadRejectedResult(path: string, reason: string): ReadResult {
+  return new ReadResultClass({
+    result: { case: "rejected", value: new ReadRejected({ path, reason }) },
+  });
+}
+
+export class LocalReadExecutor implements Executor<ReadArgs, ReadResult> {
+  private readonly readTool;
+  private readonly ctx: PiToolContext;
+
+  constructor(ctx: PiToolContext) {
+    this.ctx = ctx;
+    this.readTool = createReadTool(ctx.cwd);
+  }
+
+  async execute(_ctx: unknown, args: ReadArgs): Promise<ReadResult> {
+    const toolCallId = decodeToolCallId(args.toolCallId);
+
+    if (!this.ctx.getActiveTools().has("read")) {
+      return buildReadRejectedResult(args.path, "Tool not available");
+    }
+
+    const toolResult = await executePiTool(
+      this.ctx,
+      this.readTool,
+      "read",
+      toolCallId,
+      { path: args.path },
+    );
+    return buildReadResultFromToolResult(args.path, toolResult);
+  }
+}

package/src/pi/executors/request-context.ts

@@ -0,0 +1,120 @@
+import * as os from "node:os";
+import type { Executor } from "../../vendor/agent-exec";
+import {
+  LocalGitExecutor,
+  getGitRepoPath,
+  getGitStatus,
+  getGitBranch,
+  getGitRemoteUrl,
+} from "../../vendor/local-exec";
+import type { McpToolDefinition } from "../../__generated__/agent/v1/mcp_pb";
+import { GitRepoInfo } from "../../__generated__/agent/v1/repo_pb";
+import type { RequestContextArgs } from "../../__generated__/agent/v1/request_context_exec_pb";
+import {
+  RequestContext,
+  RequestContextEnv,
+  RequestContextError,
+  RequestContextResult,
+  RequestContextSuccess,
+} from "../../__generated__/agent/v1/request_context_exec_pb";
+
+export class LocalRequestContextExecutor
+  implements Executor<RequestContextArgs, RequestContextResult>
+{
+  private readonly tools: McpToolDefinition[];
+  private readonly workspacePaths: string[];
+  private readonly gitExecutor: LocalGitExecutor;
+
+  constructor(tools: McpToolDefinition[], workspacePaths: string[]) {
+    this.tools = tools;
+    this.workspacePaths = workspacePaths;
+    this.gitExecutor = new LocalGitExecutor();
+  }
+
+  async execute(
+    _ctx: unknown,
+    _args: RequestContextArgs,
+  ): Promise<RequestContextResult> {
+    try {
+      const [gitRepos, env] = await Promise.all([
+        this.collectGitRepos(),
+        this.computeEnv(),
+      ]);
+
+      const requestContext = new RequestContext({
+        rules: [],
+        env,
+        repositoryInfo: [],
+        tools: this.tools,
+        gitRepos,
+        projectLayouts: [],
+        mcpInstructions: [],
+        fileContents: {},
+        customSubagents: [],
+      });
+
+      return new RequestContextResult({
+        result: {
+          case: "success",
+          value: new RequestContextSuccess({ requestContext }),
+        },
+      });
+    } catch (error) {
+      return new RequestContextResult({
+        result: {
+          case: "error",
+          value: new RequestContextError({
+            error: error instanceof Error ? error.message : String(error),
+          }),
+        },
+      });
+    }
+  }
+
+  private async collectGitRepos(): Promise<GitRepoInfo[]> {
+    const seen = new Set<string>();
+    const repos: GitRepoInfo[] = [];
+
+    for (const workspacePath of this.workspacePaths) {
+      const repoPath = await getGitRepoPath(this.gitExecutor, workspacePath);
+      if (!repoPath || seen.has(repoPath)) continue;
+      seen.add(repoPath);
+
+      const [status, branchName, remoteUrl] = await Promise.all([
+        getGitStatus(this.gitExecutor, repoPath),
+        getGitBranch(this.gitExecutor, repoPath),
+        getGitRemoteUrl(this.gitExecutor, repoPath),
+      ]);
+
+      const info: ConstructorParameters<typeof GitRepoInfo>[0] = {
+        path: repoPath,
+        status: status ?? "",
+        branchName: branchName ?? "",
+      };
+      if (remoteUrl) info.remoteUrl = remoteUrl;
+      repos.push(new GitRepoInfo(info));
+    }
+
+    return repos;
+  }
+
+  private async computeEnv(): Promise<RequestContextEnv> {
+    const osVersion = `${os.platform()} ${os.release()}`;
+    const shell = process.env["SHELL"] || "";
+
+    let timeZone: string | undefined;
+    try {
+      timeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      timeZone = undefined;
+    }
+
+    return new RequestContextEnv({
+      osVersion,
+      workspacePaths: this.workspacePaths,
+      shell,
+      sandboxEnabled: false,
+      timeZone: timeZone ?? "",
+    });
+  }
+}

package/src/pi/executors/shell-stream.ts

@@ -0,0 +1,136 @@
+import type { TextContent } from "@mariozechner/pi-ai";
+import type { StreamExecutor } from "../../vendor/agent-exec";
+import type {
+  ShellArgs,
+  ShellStream,
+} from "../../__generated__/agent/v1/shell_exec_pb";
+import {
+  ShellStream as ShellStreamClass,
+  ShellRejected,
+  ShellStreamExit,
+  ShellStreamStart,
+  ShellStreamStderr,
+  ShellStreamStdout,
+} from "../../__generated__/agent/v1/shell_exec_pb";
+import { type PiToolContext, decodeToolCallId, executePiTool } from "../local-resource-provider/types";
+import { type LocalShellExecutor, confirmIfDangerous } from "./shell";
+
+export class LocalShellStreamExecutor implements StreamExecutor<
+  ShellArgs,
+  ShellStream
+> {
+  private readonly ctx: PiToolContext;
+  private readonly shellExecutor: LocalShellExecutor;
+
+  constructor(ctx: PiToolContext, shellExecutor: LocalShellExecutor) {
+    this.ctx = ctx;
+    this.shellExecutor = shellExecutor;
+  }
+
+  execute(_ctx: unknown, args: ShellArgs): AsyncIterable<ShellStream> {
+    return this.run(args);
+  }
+
+  private async *run(args: ShellArgs): AsyncIterable<ShellStream> {
+    const toolCallId = decodeToolCallId(args.toolCallId);
+    const cwd = args.workingDirectory || this.ctx.cwd;
+
+    if (!this.ctx.getActiveTools().has("bash")) {
+      yield new ShellStreamClass({
+        event: {
+          case: "rejected",
+          value: new ShellRejected({
+            command: args.command,
+            workingDirectory: args.workingDirectory,
+            reason: "Tool not available",
+            isReadonly: false,
+          }),
+        },
+      });
+      yield new ShellStreamClass({
+        event: {
+          case: "exit",
+          value: new ShellStreamExit({ code: 1, cwd, aborted: false }),
+        },
+      });
+      return;
+    }
+
+    const approved = await confirmIfDangerous(this.ctx.getCtx, args.command);
+    if (!approved) {
+      yield new ShellStreamClass({
+        event: {
+          case: "rejected",
+          value: new ShellRejected({
+            command: args.command,
+            workingDirectory: args.workingDirectory,
+            reason: "Command rejected",
+            isReadonly: false,
+          }),
+        },
+      });
+      yield new ShellStreamClass({
+        event: {
+          case: "exit",
+          value: new ShellStreamExit({ code: 1, cwd, aborted: false }),
+        },
+      });
+      return;
+    }
+
+    yield new ShellStreamClass({
+      event: { case: "start", value: new ShellStreamStart({}) },
+    });
+
+    const timeoutSeconds =
+      args.timeout && args.timeout > 0 ? args.timeout : undefined;
+    const bashTool = this.shellExecutor.getBashTool(
+      args.workingDirectory || undefined,
+    );
+
+    const toolResult = await executePiTool(
+      this.ctx,
+      bashTool,
+      "bash",
+      toolCallId,
+      { command: args.command, timeout: timeoutSeconds },
+    );
+
+    const text = toolResult.content
+      .filter((c): c is TextContent => c.type === "text")
+      .map((c) => c.text)
+      .join("\n");
+
+    if (toolResult.isError) {
+      yield new ShellStreamClass({
+        event: {
+          case: "stderr",
+          value: new ShellStreamStderr({ data: text || "Shell failed" }),
+        },
+      });
+      yield new ShellStreamClass({
+        event: {
+          case: "exit",
+          value: new ShellStreamExit({ code: 1, cwd, aborted: false }),
+        },
+      });
+      return;
+    }
+
+    if (text) {
+      yield new ShellStreamClass({
+        event: {
+          case: "stdout",
+          value: new ShellStreamStdout({ data: text }),
+        },
+      });
+    }
+
+    yield new ShellStreamClass({
+      event: {
+        case: "exit",
+        value: new ShellStreamExit({ code: 0, cwd, aborted: false }),
+      },
+    });
+  }
+}

package/src/pi/executors/shell.ts

@@ -0,0 +1,157 @@
+import { createBashTool } from "@mariozechner/pi-coding-agent";
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ToolResultMessage } from "@mariozechner/pi-ai";
+import type { Executor } from "../../vendor/agent-exec";
+import { resolvePath } from "../../vendor/local-exec";
+import type {
+  ShellArgs,
+  ShellResult,
+} from "../../__generated__/agent/v1/shell_exec_pb";
+import {
+  ShellFailure,
+  ShellRejected,
+  ShellResult as ShellResultClass,
+  ShellSuccess,
+} from "../../__generated__/agent/v1/shell_exec_pb";
+import { toolResultToText } from "../utils/tool-result";
+import { type PiToolContext, decodeToolCallId, executePiTool } from "../local-resource-provider/types";
+
+function buildShellResultFromToolResult(
+  args: { command: string; workingDirectory: string },
+  result: ToolResultMessage,
+): ShellResult {
+  const output = toolResultToText(result);
+  if (result.isError) {
+    return new ShellResultClass({
+      result: {
+        case: "failure",
+        value: new ShellFailure({
+          command: args.command,
+          workingDirectory: args.workingDirectory,
+          exitCode: 1,
+          signal: "",
+          stdout: "",
+          stderr: output || "Shell failed",
+          executionTime: 0,
+          aborted: false,
+        }),
+      },
+    });
+  }
+  return new ShellResultClass({
+    result: {
+      case: "success",
+      value: new ShellSuccess({
+        command: args.command,
+        workingDirectory: args.workingDirectory,
+        exitCode: 0,
+        signal: "",
+        stdout: output,
+        stderr: "",
+        executionTime: 0,
+      }),
+    },
+  });
+}
+
+function buildShellRejectedResult(
+  command: string,
+  workingDirectory: string,
+  reason: string,
+): ShellResult {
+  return new ShellResultClass({
+    result: {
+      case: "rejected",
+      value: new ShellRejected({
+        command,
+        workingDirectory,
+        reason,
+        isReadonly: false,
+      }),
+    },
+  });
+}
+
+function isDangerousShellCommand(command: string): boolean {
+  const c = command.toLowerCase();
+  if (/(^|\s)sudo\b/.test(c)) return true;
+  if (/\brm\b.*\s-rf\b/.test(c)) return true;
+  if (/\bmkfs\b|\bdd\b|\bshutdown\b|\breboot\b/.test(c)) return true;
+  if (/\bcurl\b.*\|\s*(sh|bash)\b/.test(c)) return true;
+  if (/\bwget\b.*\|\s*(sh|bash)\b/.test(c)) return true;
+  return false;
+}
+
+export async function confirmIfDangerous(
+  getCtx: () => ExtensionContext | null,
+  command: string,
+): Promise<boolean> {
+  if (!isDangerousShellCommand(command)) return true;
+  const ctx = getCtx();
+  if (!ctx?.hasUI) return false;
+  return ctx.ui.confirm("Cursor command approval", command);
+}
+
+export class LocalShellExecutor implements Executor<ShellArgs, ShellResult> {
+  private readonly ctx: PiToolContext;
+  private readonly bashByCwd = new Map<string, AgentTool<any>>();
+
+  constructor(ctx: PiToolContext) {
+    this.ctx = ctx;
+    this.bashByCwd.set(ctx.cwd, createBashTool(ctx.cwd));
+  }
+
+  getBashTool(workingDirectory?: string): AgentTool<any> {
+    const resolved = resolvePath(
+      workingDirectory || this.ctx.cwd,
+      this.ctx.cwd,
+    );
+    const cached = this.bashByCwd.get(resolved);
+    if (cached) return cached;
+    const tool = createBashTool(resolved);
+    this.bashByCwd.set(resolved, tool);
+    return tool;
+  }
+
+  async execute(_ctx: unknown, args: ShellArgs): Promise<ShellResult> {
+    const toolCallId = decodeToolCallId(args.toolCallId);
+
+    if (!this.ctx.getActiveTools().has("bash")) {
+      return buildShellRejectedResult(
+        args.command,
+        args.workingDirectory,
+        "Tool not available",
+      );
+    }
+
+    const approved = await confirmIfDangerous(this.ctx.getCtx, args.command);
+    if (!approved) {
+      return buildShellRejectedResult(
+        args.command,
+        args.workingDirectory,
+        "Command rejected",
+      );
+    }
+
+    const timeoutSeconds =
+      args.timeout && args.timeout > 0 ? args.timeout : undefined;
+    const bashTool = this.getBashTool(args.workingDirectory || undefined);
+
+    const toolResult = await executePiTool(
+      this.ctx,
+      bashTool,
+      "bash",
+      toolCallId,
+      { command: args.command, timeout: timeoutSeconds },
+    );
+
+    return buildShellResultFromToolResult(
+      {
+        command: args.command,
+        workingDirectory: args.workingDirectory || this.ctx.cwd,
+      },
+      toolResult,
+    );
+  }
+}

package/src/pi/executors/stubs.ts

@@ -0,0 +1,173 @@
+import type { Executor } from "../../vendor/agent-exec";
+
+import type { BackgroundShellSpawnArgs } from "../../__generated__/agent/v1/background_shell_exec_pb";
+import { BackgroundShellSpawnResult } from "../../__generated__/agent/v1/background_shell_exec_pb";
+import type { WriteShellStdinArgs } from "../../__generated__/agent/v1/write_shell_stdin_tool_pb";
+import {
+  WriteShellStdinError,
+  WriteShellStdinResult,
+} from "../../__generated__/agent/v1/write_shell_stdin_tool_pb";
+import type { FetchArgs } from "../../__generated__/agent/v1/fetch_tool_pb";
+import {
+  FetchError,
+  FetchResult,
+} from "../../__generated__/agent/v1/fetch_tool_pb";
+import type { DiagnosticsArgs } from "../../__generated__/agent/v1/diagnostics_exec_pb";
+import {
+  DiagnosticsResult,
+  DiagnosticsSuccess,
+} from "../../__generated__/agent/v1/diagnostics_exec_pb";
+import type { McpArgs } from "../../__generated__/agent/v1/mcp_tool_pb";
+import { McpError, McpResult } from "../../__generated__/agent/v1/mcp_tool_pb";
+import type {
+  ListMcpResourcesExecArgs,
+  ReadMcpResourceExecArgs,
+} from "../../__generated__/agent/v1/mcp_resource_tool_pb";
+import {
+  ListMcpResourcesExecResult,
+  ListMcpResourcesRejected,
+  ReadMcpResourceExecResult,
+  ReadMcpResourceRejected,
+} from "../../__generated__/agent/v1/mcp_resource_tool_pb";
+import type { RecordScreenArgs } from "../../__generated__/agent/v1/record_screen_tool_pb";
+import {
+  RecordScreenFailure,
+  RecordScreenResult,
+} from "../../__generated__/agent/v1/record_screen_tool_pb";
+import type { ComputerUseArgs } from "../../__generated__/agent/v1/computer_use_tool_pb";
+import {
+  ComputerUseError,
+  ComputerUseResult,
+} from "../../__generated__/agent/v1/computer_use_tool_pb";
+import { ShellRejected } from "../../__generated__/agent/v1/shell_exec_pb";
+
+export class StubBackgroundShellExecutor implements Executor<
+  BackgroundShellSpawnArgs,
+  BackgroundShellSpawnResult
+> {
+  async execute(_ctx: unknown, args: BackgroundShellSpawnArgs) {
+    return new BackgroundShellSpawnResult({
+      result: {
+        case: "rejected",
+        value: new ShellRejected({
+          command: args.command,
+          workingDirectory: args.workingDirectory,
+          reason: "Not implemented",
+          isReadonly: false,
+        }),
+      },
+    });
+  }
+}
+
+export class StubWriteShellStdinExecutor implements Executor<
+  WriteShellStdinArgs,
+  WriteShellStdinResult
+> {
+  async execute() {
+    return new WriteShellStdinResult({
+      result: {
+        case: "error",
+        value: new WriteShellStdinError({ error: "Not implemented" }),
+      },
+    });
+  }
+}
+
+export class StubFetchExecutor implements Executor<FetchArgs, FetchResult> {
+  async execute(_ctx: unknown, args: FetchArgs) {
+    return new FetchResult({
+      result: {
+        case: "error",
+        value: new FetchError({ url: args.url, error: "Not implemented" }),
+      },
+    });
+  }
+}
+
+export class StubDiagnosticsExecutor implements Executor<
+  DiagnosticsArgs,
+  DiagnosticsResult
+> {
+  async execute() {
+    return new DiagnosticsResult({
+      result: {
+        case: "success",
+        value: new DiagnosticsSuccess({
+          diagnostics: [],
+          totalDiagnostics: 0,
+        }),
+      },
+    });
+  }
+}
+
+export class StubMcpExecutor implements Executor<McpArgs, McpResult> {
+  async execute() {
+    return new McpResult({
+      result: {
+        case: "error",
+        value: new McpError({ error: "MCP not supported" }),
+      },
+    });
+  }
+}
+
+export class StubListMcpResourcesExecutor implements Executor<
+  ListMcpResourcesExecArgs,
+  ListMcpResourcesExecResult
+> {
+  async execute() {
+    return new ListMcpResourcesExecResult({
+      result: {
+        case: "rejected",
+        value: new ListMcpResourcesRejected({ reason: "MCP not supported" }),
+      },
+    });
+  }
+}
+
+export class StubReadMcpResourceExecutor implements Executor<
+  ReadMcpResourceExecArgs,
+  ReadMcpResourceExecResult
+> {
+  async execute(_ctx: unknown, args: ReadMcpResourceExecArgs) {
+    return new ReadMcpResourceExecResult({
+      result: {
+        case: "rejected",
+        value: new ReadMcpResourceRejected({
+          uri: args.uri,
+          reason: "MCP not supported",
+        }),
+      },
+    });
+  }
+}
+
+export class StubRecordScreenExecutor implements Executor<
+  RecordScreenArgs,
+  RecordScreenResult
+> {
+  async execute() {
+    return new RecordScreenResult({
+      result: {
+        case: "failure",
+        value: new RecordScreenFailure({ error: "Not implemented" }),
+      },
+    });
+  }
+}
+
+export class StubComputerUseExecutor implements Executor<
+  ComputerUseArgs,
+  ComputerUseResult
+> {
+  async execute() {
+    return new ComputerUseResult({
+      result: {
+        case: "error",
+        value: new ComputerUseError({ error: "Not implemented" }),
+      },
+    });
+  }
+}