@elizaos/app-core 2.0.0-beta.2 → 2.0.11-beta.5

package/platforms/electrobun/remotes/git/src/bun/errors.ts

@@ -0,0 +1,69 @@
+import type { GitError, GitErrorCode } from "./protocol.ts";
+
+export class GitException extends Error {
+  readonly code: GitErrorCode;
+  readonly cwd?: string;
+  readonly command?: string[];
+  readonly status?: number;
+  readonly stderr?: string;
+  readonly details?: unknown;
+
+  constructor(input: GitError) {
+    super(input.message);
+    this.name = "GitException";
+    this.code = input.code;
+    this.cwd = input.cwd;
+    this.command = input.command;
+    this.status = input.status;
+    this.stderr = input.stderr;
+    this.details = input.details;
+  }
+}
+
+export function createGitError(input: GitError): GitError {
+  return {
+    code: input.code,
+    message: input.message,
+    ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
+    ...(input.command === undefined ? {} : { command: input.command }),
+    ...(input.status === undefined ? {} : { status: input.status }),
+    ...(input.stderr === undefined ? {} : { stderr: input.stderr }),
+    ...(input.details === undefined ? {} : { details: input.details }),
+  };
+}
+
+export function throwGitError(input: GitError): never {
+  throw new GitException(createGitError(input));
+}
+
+export function isGitError(value: unknown): value is GitError {
+  if (value === null || typeof value !== "object") return false;
+  const record = value as Record<string, unknown>;
+  return typeof record.code === "string" && typeof record.message === "string";
+}
+
+export function serializeGitError(error: unknown): GitError {
+  if (error instanceof GitException) {
+    return createGitError({
+      code: error.code,
+      message: error.message,
+      cwd: error.cwd,
+      command: error.command,
+      status: error.status,
+      stderr: error.stderr,
+      details: error.details,
+    });
+  }
+  if (isGitError(error)) return createGitError(error);
+  if (error instanceof Error) {
+    return createGitError({
+      code: "GIT_REQUEST_FAILED",
+      message: error.message.length > 0 ? error.message : error.name,
+    });
+  }
+  return createGitError({
+    code: "GIT_UNKNOWN",
+    message: "Unknown Git Remote failure",
+    details: typeof error === "string" ? error : undefined,
+  });
+}

package/platforms/electrobun/remotes/git/src/bun/git-command.ts

@@ -0,0 +1,156 @@
+import { throwGitError } from "./errors.ts";
+import { GitOperationHistory } from "./operation-history.ts";
+import type { GitOperation } from "./protocol.ts";
+
+export type GitRunInput = {
+  name: string;
+  args: string[];
+  cwd?: string;
+  timeoutMs?: number;
+};
+
+export type GitRunOutput = {
+  operation: GitOperation;
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  signal: string | null;
+};
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+
+export class GitCommandRunner {
+  readonly history: GitOperationHistory;
+  private readonly timeoutMs: number;
+
+  constructor(
+    options: { env?: NodeJS.ProcessEnv; history?: GitOperationHistory } = {},
+  ) {
+    const env = options.env ?? process.env;
+    this.history = options.history ?? new GitOperationHistory({ env });
+    this.timeoutMs = parsePositiveInt(
+      env.ELIZA_GIT_COMMAND_TIMEOUT_MS,
+      DEFAULT_TIMEOUT_MS,
+    );
+  }
+
+  async run(input: GitRunInput): Promise<GitRunOutput> {
+    const cwd = input.cwd?.trim() || defaultCwd();
+    const command = ["git", ...input.args];
+    const operation = this.history.start(input.name, cwd, command);
+    let process: Bun.Subprocess<"ignore", "pipe", "pipe">;
+    try {
+      process = Bun.spawn(command, {
+        cwd,
+        env: processEnv(),
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+    } catch (error) {
+      const message = errorMessage(error);
+      const failed = this.history.fail(operation.id, message);
+      throwGitError({
+        code:
+          input.args[0] === "--version"
+            ? "GIT_NOT_AVAILABLE"
+            : "GIT_COMMAND_FAILED",
+        message,
+        cwd,
+        command,
+        details: { operation: failed },
+      });
+    }
+
+    const timeoutMs = normalizeTimeout(input.timeoutMs, this.timeoutMs);
+    const timeout = setTimeout(() => process.kill("SIGKILL"), timeoutMs);
+    const [stdout, stderr, exitCode] = await Promise.all([
+      streamToString(process.stdout),
+      streamToString(process.stderr),
+      process.exited,
+    ]).finally(() => clearTimeout(timeout));
+
+    if (exitCode !== 0) {
+      const message =
+        stderr.trim() || stdout.trim() || `git exited with ${exitCode}`;
+      const failed = this.history.fail(
+        operation.id,
+        message,
+        stdout,
+        stderr,
+        exitCode,
+        null,
+      );
+      throwGitError({
+        code:
+          input.args[0] === "--version"
+            ? "GIT_NOT_AVAILABLE"
+            : "GIT_COMMAND_FAILED",
+        message,
+        cwd,
+        command,
+        status: exitCode,
+        stderr,
+        details: { operation: failed },
+      });
+    }
+
+    const completed = this.history.complete(
+      operation.id,
+      stdout,
+      stderr,
+      exitCode,
+      null,
+    );
+    return {
+      operation: completed,
+      stdout,
+      stderr,
+      exitCode,
+      signal: null,
+    };
+  }
+}
+
+export function defaultCwd(): string {
+  return (
+    process.env.ELIZA_REPO_DIR ?? process.env.ELIZA_REPO_DIR ?? process.cwd()
+  );
+}
+
+function processEnv(): NodeJS.ProcessEnv {
+  return { ...process.env };
+}
+
+async function streamToString(
+  stream: ReadableStream<Uint8Array>,
+): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let output = "";
+  for (;;) {
+    const result = await reader.read();
+    if (result.done) break;
+    output += decoder.decode(result.value, { stream: true });
+  }
+  output += decoder.decode();
+  return output;
+}
+
+function normalizeTimeout(value: number | undefined, fallback: number): number {
+  if (value === undefined) return fallback;
+  if (!Number.isFinite(value) || value <= 0) return fallback;
+  return Math.floor(value);
+}
+
+function parsePositiveInt(value: string | undefined, fallback: number): number {
+  if (value === undefined || value.trim().length === 0) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return "Git command failed.";
+}

package/platforms/electrobun/remotes/git/src/bun/git-service.ts

@@ -0,0 +1,446 @@
+import { GitException, throwGitError } from "./errors.ts";
+import { defaultCwd, GitCommandRunner } from "./git-command.ts";
+import type {
+  GitAddParams,
+  GitBranch,
+  GitBranchCreateParams,
+  GitBranchDeleteParams,
+  GitCheckoutParams,
+  GitCommandResult,
+  GitCommandRunParams,
+  GitCommitParams,
+  GitDiffParams,
+  GitLogEntry,
+  GitLogParams,
+  GitOperation,
+  GitRemote,
+  GitRemoteOperationParams,
+  GitRepoInfo,
+  GitRepoParams,
+  GitRestoreParams,
+  GitStatusFile,
+  GitStatusPayload,
+  GitStatusResult,
+} from "./protocol.ts";
+
+const LOG_RECORD_SEPARATOR = "\x1e";
+const LOG_FIELD_SEPARATOR = "\x1f";
+
+export class GitRemoteService {
+  private readonly runner: GitCommandRunner;
+
+  constructor(options: { runner?: GitCommandRunner } = {}) {
+    this.runner = options.runner ?? new GitCommandRunner();
+  }
+
+  async status(): Promise<GitStatusPayload> {
+    const version = await this.runner.run({
+      name: "git.status",
+      args: ["--version"],
+      cwd: defaultCwd(),
+    });
+    return {
+      id: "eliza.git",
+      ok: true,
+      version: version.stdout.trim(),
+      defaultCwd: defaultCwd(),
+      operationCount: this.runner.history.count(),
+    };
+  }
+
+  async repoInfo(params: GitRepoParams = {}): Promise<GitRepoInfo> {
+    const cwd = params.cwd?.trim() || defaultCwd();
+    const root = await this.repoRoot(cwd);
+    const [branchResult, headResult, remoteResult] = await Promise.allSettled([
+      this.runner.run({
+        name: "git.branch.current",
+        cwd: root,
+        args: ["rev-parse", "--abbrev-ref", "HEAD"],
+      }),
+      this.runner.run({
+        name: "git.head",
+        cwd: root,
+        args: ["rev-parse", "HEAD"],
+      }),
+      this.runner.run({
+        name: "git.remote.origin",
+        cwd: root,
+        args: ["remote", "get-url", "origin"],
+      }),
+    ]);
+    return {
+      cwd,
+      root,
+      isRepo: true,
+      ...(branchResult.status === "fulfilled"
+        ? { branch: branchResult.value.stdout.trim() }
+        : {}),
+      ...(headResult.status === "fulfilled"
+        ? { head: headResult.value.stdout.trim() }
+        : {}),
+      ...(remoteResult.status === "fulfilled"
+        ? { remoteUrl: remoteResult.value.stdout.trim() }
+        : {}),
+    };
+  }
+
+  async statusRepo(params: GitRepoParams = {}): Promise<GitStatusResult> {
+    const repo = await this.repoInfo(params);
+    const result = await this.runner.run({
+      name: "git.status",
+      cwd: repo.root,
+      args: ["status", "--porcelain=v1", "--branch"],
+    });
+    return parseStatus(repo, result.stdout);
+  }
+
+  async branches(params: GitRepoParams = {}): Promise<GitBranch[]> {
+    const root = await this.repoRoot(params.cwd);
+    const result = await this.runner.run({
+      name: "git.branches",
+      cwd: root,
+      args: [
+        "for-each-ref",
+        "--format=%(refname)%00%(refname:short)%00%(HEAD)%00%(upstream:short)",
+        "refs/heads",
+        "refs/remotes",
+      ],
+    });
+    return result.stdout
+      .split(/\r?\n/)
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        const [refName, shortName, head, upstream] = line.split("\0");
+        return {
+          name: shortName ?? refName ?? "",
+          current: head === "*",
+          remote: refName?.startsWith("refs/remotes/") === true,
+          ...(upstream ? { upstream } : {}),
+        };
+      })
+      .filter(
+        (branch) => branch.name.length > 0 && !branch.name.endsWith("/HEAD"),
+      );
+  }
+
+  async remotes(params: GitRepoParams = {}): Promise<GitRemote[]> {
+    const root = await this.repoRoot(params.cwd);
+    const result = await this.runner.run({
+      name: "git.remotes",
+      cwd: root,
+      args: ["remote", "-v"],
+    });
+    const remotes = new Map<string, GitRemote>();
+    for (const line of result.stdout.split(/\r?\n/)) {
+      if (line.trim().length === 0) continue;
+      const match = /^(\S+)\s+(\S+)\s+\((fetch|push)\)$/.exec(line);
+      if (!match) continue;
+      const [, name, url, kind] = match;
+      const remote = remotes.get(name) ?? { name };
+      if (kind === "fetch") remote.fetchUrl = url;
+      else remote.pushUrl = url;
+      remotes.set(name, remote);
+    }
+    return [...remotes.values()];
+  }
+
+  async log(params: GitLogParams = {}): Promise<GitLogEntry[]> {
+    const root = await this.repoRoot(params.cwd);
+    const limit = clampLimit(params.limit, 20, 100);
+    const pretty = `%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s%x1f%b%x1e`;
+    const args = ["log", `--max-count=${limit}`, `--pretty=format:${pretty}`];
+    if (params.ref) args.push(params.ref);
+    const result = await this.runner.run({
+      name: "git.log",
+      cwd: root,
+      args,
+    });
+    return parseLog(result.stdout);
+  }
+
+  async diff(params: GitDiffParams = {}): Promise<{ raw: string }> {
+    const root = await this.repoRoot(params.cwd);
+    const args = ["diff"];
+    if (params.staged === true) args.push("--staged");
+    if (params.ref) args.push(params.ref);
+    if (params.path) args.push("--", params.path);
+    const result = await this.runner.run({
+      name: "git.diff",
+      cwd: root,
+      args,
+    });
+    return { raw: result.stdout };
+  }
+
+  async show(params: {
+    cwd?: string;
+    ref: string;
+    path?: string;
+  }): Promise<{ raw: string }> {
+    const root = await this.repoRoot(params.cwd);
+    if (!params.ref || params.ref.trim().length === 0) {
+      throwGitError({
+        code: "GIT_REQUEST_FAILED",
+        message: "git.show ref is required.",
+        cwd: root,
+      });
+    }
+    const args = ["show", params.ref.trim()];
+    if (params.path) args.push("--", params.path);
+    const result = await this.runner.run({
+      name: "git.show",
+      cwd: root,
+      args,
+    });
+    return { raw: result.stdout };
+  }
+
+  async add(params: GitAddParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    return this.commandResult("git.add", root, [
+      "add",
+      "--",
+      ...requiredPaths(params.paths),
+    ]);
+  }
+
+  async restore(params: GitRestoreParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const args = ["restore"];
+    if (params.staged === true) args.push("--staged");
+    if (params.source) args.push("--source", params.source);
+    args.push("--", ...requiredPaths(params.paths));
+    return this.commandResult("git.restore", root, args);
+  }
+
+  async checkout(params: GitCheckoutParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const ref = requiredString(params.ref, "checkout ref");
+    const args =
+      params.createBranch === true
+        ? ["checkout", "-b", ref]
+        : ["checkout", ref];
+    return this.commandResult("git.checkout", root, args);
+  }
+
+  async branchCreate(params: GitBranchCreateParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const name = requiredString(params.name, "branch name");
+    const args =
+      params.checkout === true ? ["checkout", "-b", name] : ["branch", name];
+    if (params.startPoint) args.push(params.startPoint);
+    return this.commandResult("git.branch.create", root, args);
+  }
+
+  async branchDelete(params: GitBranchDeleteParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const name = requiredString(params.name, "branch name");
+    return this.commandResult("git.branch.delete", root, [
+      "branch",
+      params.force === true ? "-D" : "-d",
+      name,
+    ]);
+  }
+
+  async commit(params: GitCommitParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    if (params.noVerify === true) {
+      throwGitError({
+        code: "GIT_REQUEST_FAILED",
+        message: "noVerify commits are not supported by this Git Remote.",
+        cwd: root,
+      });
+    }
+    const message = requiredString(params.message, "commit message");
+    const args = ["commit", "-m", message];
+    if (params.amend === true) args.push("--amend");
+    return this.commandResult("git.commit", root, args);
+  }
+
+  async fetch(
+    params: GitRemoteOperationParams = {},
+  ): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const args = ["fetch"];
+    if (params.remote) args.push(params.remote);
+    if (params.branch) args.push(params.branch);
+    args.push(...safeExtraArgs(params.extraArgs));
+    return this.commandResult("git.fetch", root, args);
+  }
+
+  async pull(params: GitRemoteOperationParams = {}): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const args = ["pull"];
+    if (params.remote) args.push(params.remote);
+    if (params.branch) args.push(params.branch);
+    args.push(...safeExtraArgs(params.extraArgs));
+    return this.commandResult("git.pull", root, args);
+  }
+
+  async push(params: GitRemoteOperationParams = {}): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    const args = ["push"];
+    if (params.setUpstream === true) args.push("-u");
+    if (params.remote) args.push(params.remote);
+    if (params.branch) args.push(params.branch);
+    args.push(...safeExtraArgs(params.extraArgs));
+    return this.commandResult("git.push", root, args);
+  }
+
+  async commandRun(params: GitCommandRunParams): Promise<GitCommandResult> {
+    const root = await this.repoRoot(params.cwd);
+    if (!Array.isArray(params.args) || params.args.length === 0) {
+      throwGitError({
+        code: "GIT_REQUEST_FAILED",
+        message: "git.command.run args must be a non-empty array.",
+        cwd: root,
+      });
+    }
+    const result = await this.runner.run({
+      name: "git.command.run",
+      cwd: root,
+      args: params.args,
+    });
+    return { operation: result.operation };
+  }
+
+  operationList(params: { limit?: number } = {}): Promise<GitOperation[]> {
+    return Promise.resolve(this.runner.history.list(params.limit));
+  }
+
+  operationGet(params: { operationId: string }): Promise<GitOperation> {
+    return Promise.resolve(this.runner.history.get(params.operationId));
+  }
+
+  private async commandResult(
+    name: string,
+    cwd: string,
+    args: string[],
+  ): Promise<GitCommandResult> {
+    const result = await this.runner.run({ name, cwd, args });
+    return { operation: result.operation };
+  }
+
+  private async repoRoot(cwd?: string): Promise<string> {
+    const resolved = cwd?.trim() || defaultCwd();
+    try {
+      const result = await this.runner.run({
+        name: "git.repo.root",
+        cwd: resolved,
+        args: ["rev-parse", "--show-toplevel"],
+      });
+      const root = result.stdout.trim();
+      if (root.length === 0) {
+        throwGitError({
+          code: "GIT_INVALID_REPO",
+          message: "Git returned an empty repository root.",
+          cwd: resolved,
+        });
+      }
+      return root;
+    } catch (error) {
+      if (error instanceof GitException) {
+        throwGitError({
+          code: "GIT_REPO_NOT_FOUND",
+          message: "Git repository was not found.",
+          cwd: resolved,
+          command: error.command,
+          status: error.status,
+          stderr: error.stderr,
+        });
+      }
+      throw error;
+    }
+  }
+}
+
+function parseStatus(repo: GitRepoInfo, raw: string): GitStatusResult {
+  const files: GitStatusFile[] = [];
+  let branch = repo.branch;
+  let ahead: number | undefined;
+  let behind: number | undefined;
+  for (const line of raw.split(/\r?\n/)) {
+    if (line.length === 0) continue;
+    if (line.startsWith("## ")) {
+      const branchLine = line.slice(3);
+      branch = branchLine.split(/[.\s]/)[0] || branch;
+      const aheadMatch = /ahead (\d+)/.exec(branchLine);
+      const behindMatch = /behind (\d+)/.exec(branchLine);
+      if (aheadMatch) ahead = Number.parseInt(aheadMatch[1], 10);
+      if (behindMatch) behind = Number.parseInt(behindMatch[1], 10);
+      continue;
+    }
+    const index = line[0] ?? " ";
+    const workingTree = line[1] ?? " ";
+    const filePath = line.slice(3);
+    files.push({
+      path: filePath,
+      index,
+      workingTree,
+      raw: line,
+    });
+  }
+  return {
+    repo,
+    ...(branch === undefined ? {} : { branch }),
+    ...(ahead === undefined ? {} : { ahead }),
+    ...(behind === undefined ? {} : { behind }),
+    files,
+    raw,
+  };
+}
+
+function parseLog(raw: string): GitLogEntry[] {
+  return raw
+    .split(LOG_RECORD_SEPARATOR)
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0)
+    .map((entry) => {
+      const [hash, shortHash, authorName, authorEmail, date, subject, body] =
+        entry.split(LOG_FIELD_SEPARATOR);
+      return {
+        hash: hash ?? "",
+        shortHash: shortHash ?? "",
+        ...(authorName ? { authorName } : {}),
+        ...(authorEmail ? { authorEmail } : {}),
+        ...(date ? { date } : {}),
+        subject: subject ?? "",
+        ...(body ? { body } : {}),
+      };
+    });
+}
+
+function requiredPaths(paths: string[]): string[] {
+  if (!Array.isArray(paths) || paths.length === 0) {
+    throwGitError({
+      code: "GIT_REQUEST_FAILED",
+      message: "At least one path is required.",
+    });
+  }
+  return paths.map((path) => requiredString(path, "path"));
+}
+
+function requiredString(value: string, label: string): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throwGitError({
+      code: "GIT_REQUEST_FAILED",
+      message: `${label} must be a non-empty string.`,
+    });
+  }
+  return value.trim();
+}
+
+function safeExtraArgs(args?: string[]): string[] {
+  if (args === undefined) return [];
+  return args.map((arg) => requiredString(arg, "extra arg"));
+}
+
+function clampLimit(
+  value: number | undefined,
+  defaultValue: number,
+  maxValue: number,
+): number {
+  if (value === undefined) return defaultValue;
+  if (!Number.isFinite(value) || value <= 0) return defaultValue;
+  return Math.min(Math.floor(value), maxValue);
+}