@mondaydotcomorg/z2h-cli 0.10.1 → 0.11.0

package/src/util/git/remote-options.ts

@@ -0,0 +1,37 @@
+import { defaultS3Remote } from './repo';
+
+export const REMOTE_TYPES = ['s3', 'github'] as const;
+
+export type RemoteType = (typeof REMOTE_TYPES)[number];
+
+export interface RemoteOptions {
+  remote?: RemoteType;
+  repoUrl?: string;
+}
+
+/**
+ * Validates --remote and --repo-url option values.
+ * Pass `requireRemote: true` when the flag is mandatory (e.g. create).
+ */
+export function validateRemoteOptions(opts: RemoteOptions, requireRemote = false): void {
+  if (!opts.remote) {
+    if (requireRemote) {
+      throw new Error(`--remote is required. Use --remote=s3 (shared storage) or --remote=github (your GitHub repo).`);
+    }
+    return;
+  }
+  if (!(REMOTE_TYPES as readonly string[]).includes(opts.remote)) {
+    throw new Error(`Unknown remote "${opts.remote}". Use ${REMOTE_TYPES.join(' or ')}.`);
+  }
+  if (opts.remote === 'github' && !opts.repoUrl) {
+    throw new Error('--repo-url is required when using --remote=github.');
+  }
+}
+
+/**
+ * Resolves the git remote URL from --remote / --repo-url options.
+ * Call after validateRemoteOptions.
+ */
+export function resolveRemoteUrl(remote: RemoteType, appName: string, repoUrl?: string): string {
+  return remote === 's3' ? defaultS3Remote(appName) : (repoUrl as string);
+}

package/src/util/git/repo.ts

@@ -4,6 +4,18 @@ import { execa } from 'execa';
 import { BUCKET_WRITE_NAME } from '../../constants';
 import { mfAppName } from '../app-name';
 
+type GitEnv = Record<string, string | undefined>;
+
+function execGit(args: string[], dir: string, env?: GitEnv) {
+  return execa('git', args, { cwd: dir, env });
+}
+
+async function execGitLines(args: string[], dir: string, env?: GitEnv): Promise<string[]> {
+  return execGit(args, dir, env)
+    .then(r => r.stdout.split('\n').filter(Boolean))
+    .catch(() => []);
+}
+
 export class GitConflictError extends Error {
   constructor(message: string) {
     super(message);
@@ -11,7 +23,14 @@ export class GitConflictError extends Error {
   }
 }
 
+export interface ConflictInfo {
+  localCommits: string[];
+  remoteCommits: string[];
+  conflictingFiles: string[];
+}
+
 const REQUIRED_GITIGNORE_ENTRIES = ['node_modules/', '.zth/', 'build/'];
+const LOCAL_HOOKS_DIR = '.zth/hooks';
 
 export function defaultS3Remote(app: string): string {
   return `s3://${BUCKET_WRITE_NAME}/${mfAppName(app)}/git`;
@@ -19,26 +38,40 @@ export function defaultS3Remote(app: string): string {
 
 export async function initRepo(dir: string, remote: string): Promise<void> {
   await ensureGitignore(dir);
-  await execa('git', ['init', '-b', 'master'], { cwd: dir });
-  await execa('git', ['add', '.'], { cwd: dir });
-  await execa('git', ['commit', '-m', 'Initial commit'], { cwd: dir });
-  await execa('git', ['remote', 'add', 'origin', remote], { cwd: dir });
+  await execGit(['init', '-b', 'master'], dir);
+  await overrideGlobalHooks(dir);
+  await execGit(['add', '.'], dir);
+  await execGit(['commit', '-m', 'Initial commit'], dir);
+  await execGit(['remote', 'add', 'origin', remote], dir);
 }
 
 export async function getRemoteUrl(dir: string): Promise<string | undefined> {
-  return execa('git', ['remote', 'get-url', 'origin'], { cwd: dir })
+  return execGit(['remote', 'get-url', 'origin'], dir)
     .then(r => r.stdout.trim() || undefined)
     .catch(() => undefined);
 }
 
-export async function cloneRepo(remote: string, dir: string): Promise<void> {
-  await execa('git', ['clone', remote, dir]);
+/**
+ * Throws if the working tree has uncommitted changes. Call only on a known git
+ * repo (e.g. guarded by a resolved remote) — a failing `git status` propagates
+ * rather than being silently treated as "clean".
+ */
+export async function guardCleanTree(dir: string): Promise<void> {
+  const { stdout } = await execGit(['status', '--porcelain'], dir);
+  if (stdout.trim()) {
+    throw new Error('You have uncommitted changes — commit your changes before deploying.');
+  }
+}
+
+export async function cloneRepo(remote: string, dir: string, env: Record<string, string> = {}): Promise<void> {
+  await execa('git', ['clone', remote, dir], { env: { ...process.env, ...env } });
+  await overrideGlobalHooks(dir);
 }
 
 export async function safeBackupIfDirty(dir: string): Promise<void> {
   let status: string;
   try {
-    ({ stdout: status } = await execa('git', ['status', '--porcelain'], { cwd: dir }));
+    ({ stdout: status } = await execGit(['status', '--porcelain'], dir));
   } catch {
     return;
   }
@@ -51,19 +84,55 @@ export async function safeBackupIfDirty(dir: string): Promise<void> {
   await fs.copy(dir, backupDir, { overwrite: false });
 }
 
-export async function pullAndResolve(dir: string): Promise<void> {
+export async function pullAndResolve(dir: string, env?: Record<string, string>): Promise<void> {
+  const gitEnv = env ? { ...process.env, ...env } : undefined;
   try {
-    await execa('git', ['pull', '--ff-only'], { cwd: dir });
-  } catch {
-    // TODO(Phase 7): safeBackupIfDirty(dir) → resolveDivergence(dir) instead of throwing
-    throw new GitConflictError(
-      'This app changed while you were working — please re-open it to get the latest version.'
-    );
+    await execGit(['pull', '--ff-only'], dir, gitEnv);
+  } catch (err) {
+    // First deploy: remote exists but has no commits yet — not a conflict.
+    const e = err as Error & { stderr?: string };
+    const msg = `${e.message ?? ''} ${e.stderr ?? ''}`;
+    if (/couldn't find remote ref|no tracking information|does not appear to be a git repository/i.test(msg)) {
+      return;
+    }
+    await safeBackupIfDirty(dir);
+    const info = await gatherConflictInfo(dir, gitEnv);
+    throw new GitConflictError(JSON.stringify(info));
+  }
+}
+
+/**
+ * Pushes the local master branch to origin. On a rejected (non-fast-forward) push —
+ * i.e. a deploy landed while we were building — gathers structured conflict info and
+ * throws GitConflictError so the deploy stops before anything goes live (spec: push
+ * must stop the deploy before the bundle upload). The skill re-resolves and re-runs,
+ * which rebuilds against the latest. Non-conflict push errors re-throw as-is.
+ */
+export async function pushToRemote(dir: string, env?: Record<string, string>): Promise<void> {
+  const gitEnv = env ? { ...process.env, ...env } : undefined;
+  try {
+    await execGit(['push', '-u', 'origin', 'master'], dir, gitEnv);
+  } catch (err) {
+    // execa puts the command in message but stderr in a separate field.
+    const e = err as Error & { stderr?: string };
+    const msg = `${e.message ?? ''} ${e.stderr ?? ''}`;
+    const isRejected = /\[rejected\]|non-fast-forward/.test(msg);
+    // git-remote-s3 emits EPIPE when git closes its stdin after a completed
+    // push (new commits or already-up-to-date). Treat EPIPE without a
+    // rejection marker as success — the push went through.
+    if (/EPIPE/.test(msg) && !isRejected) {
+      return;
+    }
+    if (isRejected) {
+      const info = await gatherConflictInfo(dir, gitEnv);
+      throw new GitConflictError(JSON.stringify(info));
+    }
+    throw err;
   }
 }
 
 export async function remoteHead(dir: string): Promise<string> {
-  const { stdout } = await execa('git', ['ls-remote', 'origin', 'refs/heads/master'], { cwd: dir });
+  const { stdout } = await execGit(['ls-remote', 'origin', 'refs/heads/master'], dir);
   const sha = stdout.split('\t')[0]?.trim();
   if (!sha) {
     throw new Error('could not read remote head — is the remote reachable?');
@@ -72,43 +141,48 @@ export async function remoteHead(dir: string): Promise<string> {
 }
 
 export async function localHead(dir: string): Promise<string> {
-  const { stdout } = await execa('git', ['rev-parse', 'HEAD'], { cwd: dir });
+  const { stdout } = await execGit(['rev-parse', 'HEAD'], dir);
   return stdout.trim();
 }
 
-export async function commitDetailedAndPush(dir: string, version: number): Promise<void> {
-  const { stdout: branch } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: dir });
-  if (branch.trim() !== 'master') {
-    throw new Error(`expected branch "master" but you are on "${branch.trim()}" — switch back before deploying.`);
-  }
-  await execa('git', ['add', '.'], { cwd: dir });
-  const { stdout: staged } = await execa('git', ['diff', '--cached', '--name-only'], { cwd: dir });
-  if (!staged.trim()) {
-    throw new Error('Nothing new to deploy — no files have changed since the last deploy.');
+async function gatherConflictInfo(dir: string, gitEnv?: GitEnv): Promise<ConflictInfo> {
+  await execGit(['fetch', 'origin'], dir, gitEnv).catch(() => {});
+
+  const [localCommits, remoteCommits, conflictingFiles] = await Promise.all([
+    execGitLines(['log', 'origin/master..HEAD', '--oneline'], dir, gitEnv),
+    execGitLines(['log', 'HEAD..origin/master', '--oneline'], dir, gitEnv),
+    execGitLines(['diff', '--name-only', 'HEAD', 'origin/master'], dir, gitEnv),
+  ]);
+
+  return { localCommits, remoteCommits, conflictingFiles };
+}
+
+/**
+ * If the user has a global core.hooksPath (e.g. ~/.global-git-hooks with a
+ * prevent-push-to-master script), override it locally so Z2H's non-interactive
+ * pushes aren't blocked. Other repos on the machine stay protected.
+ */
+async function overrideGlobalHooks(dir: string): Promise<void> {
+  if (await fs.pathExists(path.join(dir, LOCAL_HOOKS_DIR))) {
+    return;
   }
-  const message = await buildCommitMessage(dir, version);
-  await execa('git', ['commit', '-m', message], { cwd: dir });
-  try {
-    await execa('git', ['push', '-u', 'origin', 'master'], { cwd: dir });
-  } catch (err) {
-    if (/\[rejected\]|non-fast-forward/.test((err as Error).message)) {
-      throw new GitConflictError('push rejected — remote has new commits');
-    }
-    throw err;
+
+  const globalHooksPath = await execGit(['config', '--global', 'core.hooksPath'], dir)
+    .then(r => r.stdout.trim())
+    .catch(() => '');
+
+  if (!globalHooksPath) {
+    return;
   }
-}
 
-async function buildCommitMessage(dir: string, version: number): Promise<string> {
-  // TODO(Phase 7): replace with LLM-generated summary using git diff + commit messages
-  const { stdout } = await execa('git', ['status', '--short'], { cwd: dir });
-  const files = stdout
-    .split('\n')
-    .map(line => line.slice(3).trim())
-    .filter(Boolean);
-  const fileList = files.length
-    ? files.slice(0, 5).join(', ') + (files.length > 5 ? ` (+${files.length - 5} more)` : '')
-    : 'no changes';
-  return `v${version}: deploy — ${fileList}`;
+  await fs.ensureDir(path.join(dir, LOCAL_HOOKS_DIR));
+  await execGit(['config', '--local', 'core.hooksPath', LOCAL_HOOKS_DIR], dir);
+
+  // eslint-disable-next-line no-console
+  console.warn(
+    `⚠️  Detected global git hooks at ${globalHooksPath}\n` +
+      `   Overriding locally for this Z2H project (your other repos are unaffected).`
+  );
 }
 
 async function ensureGitignore(dir: string): Promise<void> {

package/src/util/s3/client.ts

@@ -1,23 +1,16 @@
 import { S3Client } from '@aws-sdk/client-s3';
-import { brokerCredentialProvider } from '../auth/broker-credential-provider';
 import { REGION } from '../../constants';
+import type { AwsCredentialIdentity } from '@aws-sdk/types';
 
 let client: S3Client | null = null;
 
-/**
- * Initialize the per-process S3 client with broker-issued credentials scoped
- * to the given app's S3 prefix. Must be called once before any `getS3Client`.
- */
-export function setupS3Client({ appName }: { appName: string }): void {
-  client = new S3Client({
-    region: REGION,
-    credentials: brokerCredentialProvider({ appName }),
-  });
+export function setupS3Client(credentials: AwsCredentialIdentity): void {
+  client = new S3Client({ region: REGION, credentials });
 }
 
 export function getS3Client(): S3Client {
   if (!client) {
-    throw new Error('S3 client not initialized — call setupS3Client({ appName }) first.');
+    throw new Error('S3 client not initialized — call setupS3Client(credentials) first.');
   }
   return client;
 }