@pushpalsdev/cli 1.0.67 → 1.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.67",
+  "version": "1.0.68",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/apps/workerpals/src/execute_job.ts

@@ -7,13 +7,17 @@ import { existsSync, readFileSync, rmSync, unlinkSync } from "fs";
 import { resolve } from "path";
 import {
   deriveAutonomyComponentArea,
+  buildGitCommitArgs as buildSourceControlGitCommitArgs,
+  explicitSourceControlCommitIdentityFromEnv,
   loadPromptTemplate,
   loadPushPalsConfig,
   matchesGlob,
   normalizeAutonomyComponentArea,
   normalizeTargetPath,
+  sanitizeSourceControlIdentityField,
   validateScopeInvariants,
   type AutonomyComponentArea,
+  type SourceControlCommitIdentity,
 } from "shared";
 import { resolveExecutor, type WorkerpalsRuntimeConfig } from "./common/executor_backend.js";
 import type { JobPublishBlockedInfo, JobResult } from "./common/types.js";
@@ -1432,6 +1436,35 @@ export async function git(
 // ─── Git commit creation ─────────────────────────────────────────────────────
 
 /** Create commit for job result and return commit info */
+export type WorkerGitCommitIdentity = SourceControlCommitIdentity;
+
+export const explicitWorkerCommitIdentityFromEnv = explicitSourceControlCommitIdentityFromEnv;
+
+async function resolveGitConfigValue(repo: string, key: string): Promise<string> {
+  const value = await git(repo, ["config", "--get", key]);
+  return value.ok ? sanitizeSourceControlIdentityField(value.stdout) : "";
+}
+
+export async function resolveWorkerCommitIdentity(
+  repo: string,
+  _runtimeConfig: WorkerpalsRuntimeConfig = DEFAULT_CONFIG,
+): Promise<WorkerGitCommitIdentity | null> {
+  const fallbackEmail = await resolveGitConfigValue(repo, "user.email");
+  const explicit = explicitWorkerCommitIdentityFromEnv(process.env, fallbackEmail);
+  if (explicit) return explicit;
+
+  const name = await resolveGitConfigValue(repo, "user.name");
+  if (name && fallbackEmail) return { name, email: fallbackEmail, source: "source-control-config" };
+  return null;
+}
+
+export function buildGitCommitArgs(
+  commitMsg: string,
+  identity: WorkerGitCommitIdentity | null,
+): string[] {
+  return buildSourceControlGitCommitArgs(commitMsg, identity);
+}
+
 export interface CreateJobCommitResult {
   ok: boolean;
   branch?: string;
@@ -1574,8 +1607,10 @@ export async function createJobCommit(
     }
     const commitMsg = llmCommitMsg ?? buildWorkerCommitMessage(workerId, job, changedPaths);
 
-    // Commit changes
-    result = await git(repo, ["commit", "-m", commitMsg]);
+    // Commit changes with a PushPals-resolved author so generated commits use
+    // source-control identity instead of falling through to the host account.
+    const commitIdentity = await resolveWorkerCommitIdentity(repo, runtimeConfig);
+    result = await git(repo, buildGitCommitArgs(commitMsg, commitIdentity));
     if (!result.ok) {
       return { ok: false, error: `Failed to commit: ${result.stderr}` };
     }
@@ -2484,7 +2519,8 @@ async function createMergeConflictJobCommit(
       );
     }
     const commitMsg = llmCommitMsg ?? buildWorkerCommitMessage(workerId, job, changedPaths);
-    const commit = await git(repo, ["commit", "-m", commitMsg]);
+    const commitIdentity = await resolveWorkerCommitIdentity(repo, runtimeConfig);
+    const commit = await git(repo, buildGitCommitArgs(commitMsg, commitIdentity));
     if (!commit.ok) {
       return { ok: false, error: `Failed to commit merge-conflict resolution: ${commit.stderr}` };
     }

package/runtime/sandbox/packages/shared/src/index.ts

@@ -43,6 +43,17 @@ export {
   type GitTokenSource,
   type ResolveGitTokenOptions,
 } from "./git_backend.js";
+export {
+  assertSupportedSourceControlProvider,
+  buildGitCommitArgs,
+  explicitSourceControlCommitIdentityFromEnv,
+  normalizeSourceControlProvider,
+  resolveSourceControlProvider,
+  sanitizeSourceControlIdentityField,
+  type SourceControlCommitIdentity,
+  type SourceControlCommitIdentitySource,
+  type SourceControlProvider,
+} from "./source_control_api.js";
 export {
   DEFAULT_WORKERPALS_EXECUTOR,
   invalidatePushPalsConfigCache,

package/runtime/sandbox/packages/shared/src/source_control_api.ts

@@ -0,0 +1,117 @@
+export type SourceControlProvider = "git" | "sapling" | "mercurial";
+
+export type SourceControlCommitIdentitySource = "env" | "source-control-config";
+
+export interface SourceControlCommitIdentity {
+  name: string;
+  email: string;
+  source: SourceControlCommitIdentitySource;
+}
+
+export function normalizeSourceControlProvider(value: unknown): SourceControlProvider | null {
+  const normalized = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[_\s]+/g, "-");
+
+  if (!normalized) return null;
+  if (normalized === "auto") return "git";
+  if (normalized === "git") return "git";
+  if (normalized === "sapling" || normalized === "sl") return "sapling";
+  if (normalized === "mercurial" || normalized === "mercury" || normalized === "hg") {
+    return "mercurial";
+  }
+  return null;
+}
+
+function hasSourceControlProviderValue(value: unknown): boolean {
+  return String(value ?? "").trim().length > 0;
+}
+
+function formatUnknownSourceControlProvider(value: unknown): string {
+  return String(value ?? "").trim() || "(empty)";
+}
+
+export function resolveSourceControlProvider(
+  value?: unknown,
+  env: Record<string, string | undefined> = process.env as Record<string, string | undefined>,
+): SourceControlProvider {
+  if (hasSourceControlProviderValue(value)) {
+    const explicit = normalizeSourceControlProvider(value);
+    if (explicit) return explicit;
+    throw new Error(`Unknown source control provider '${formatUnknownSourceControlProvider(value)}'.`);
+  }
+
+  const envValue = env.PUSHPALS_SOURCE_CONTROL_PROVIDER ?? env.SOURCE_CONTROL_PROVIDER;
+  if (hasSourceControlProviderValue(envValue)) {
+    const fromEnv = normalizeSourceControlProvider(envValue);
+    if (fromEnv) return fromEnv;
+    throw new Error(
+      `Unknown source control provider '${formatUnknownSourceControlProvider(envValue)}'.`,
+    );
+  }
+
+  return "git";
+}
+
+export function assertSupportedSourceControlProvider(provider: SourceControlProvider): "git" {
+  if (provider === "git") return "git";
+  throw new Error(
+    `Source control provider '${provider}' is recognized but not supported yet. PushPals currently supports git only.`,
+  );
+}
+
+function firstNonEmptyString(...values: Array<string | null | undefined>): string {
+  for (const value of values) {
+    const trimmed = String(value ?? "").trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+
+export function sanitizeSourceControlIdentityField(value: unknown): string {
+  return String(value ?? "")
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/[<>]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function explicitSourceControlCommitIdentityFromEnv(
+  env: Record<string, string | undefined>,
+  fallbackEmail = "",
+): SourceControlCommitIdentity | null {
+  const name = sanitizeSourceControlIdentityField(
+    firstNonEmptyString(
+      env.WORKERPALS_GIT_AUTHOR_NAME,
+      env.PUSHPALS_GIT_AUTHOR_NAME,
+      env.GIT_AUTHOR_NAME,
+    ),
+  );
+  const email = sanitizeSourceControlIdentityField(
+    firstNonEmptyString(
+      env.WORKERPALS_GIT_AUTHOR_EMAIL,
+      env.PUSHPALS_GIT_AUTHOR_EMAIL,
+      env.GIT_AUTHOR_EMAIL,
+      fallbackEmail,
+    ),
+  );
+  if (!name || !email) return null;
+  return { name, email, source: "env" };
+}
+
+export function buildGitCommitArgs(
+  commitMsg: string,
+  identity: SourceControlCommitIdentity | null,
+): string[] {
+  const args: string[] = [];
+  if (identity?.name && identity.email) {
+    args.push("-c", `user.name=${identity.name}`, "-c", `user.email=${identity.email}`);
+  }
+  args.push("commit");
+  if (identity?.name && identity.email) {
+    args.push("--author", `${identity.name} <${identity.email}>`);
+  }
+  args.push("-m", commitMsg);
+  return args;
+}