@minionry/minion 0.7.36

package/dist/server/services/sdk/git.js

@@ -0,0 +1,520 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolve, sep } from 'node:path';
+import { abortMerge, checkoutBranch, commit as commitCore, completeMerge, createBranch, createPullRequest, createTag, createWorktree, deleteBranch, discardMergeBlockers, discoverRepos, generatePrDescription, generateStagedCommitMessage, isSafeDiscardPath, isValidWorktreePath, listBranches, listTags, listWorktrees, MAX_COMMIT_MESSAGE_LENGTH, mergeWorktreeBranch, popMergeStashBySha, previewMerge, pull as pullCore, push as pushCore, pushTag, pushWorktree, readCommitDetail, readCommitFileDiff, readCurrentBranch, readFileDiff, readHeadSha, readLog, readRemoteInfo, readStatus, redactRemoteCredentials, removeWorktree, resolveMainWorktreePath, stagePaths, unstagePaths, } from '../git/index.js';
+import { getGrant } from './grant-store.js';
+import { listLiveSubscriptions, registerLiveSubscription } from './live-registry.js';
+import { SdkMethodError } from './registry.js';
+let gitHost = null;
+export function setSdkGitHost(host) {
+    gitHost = host;
+}
+export function resetSdkGitHost() {
+    gitHost = null;
+}
+function requireHost() {
+    if (!gitHost) {
+        throw new SdkMethodError('INTERNAL', 'git host is not wired — the WebSocket handler installs it at startup');
+    }
+    return gitHost;
+}
+function paramsObject(params) {
+    return typeof params === 'object' && params !== null && !Array.isArray(params)
+        ? params
+        : {};
+}
+function requireStringParam(raw, name, method) {
+    const value = raw[name];
+    if (typeof value !== 'string' || value === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires params { ${name} } — a non-empty string`);
+    }
+    return value;
+}
+function requireHashParam(raw, name, method) {
+    const value = requireStringParam(raw, name, method);
+    if (!/^[0-9a-f]{4,64}$/i.test(value)) {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: ${name} must be a 4-64 char hex commit hash`);
+    }
+    return value;
+}
+function requireRefParam(raw, name, method) {
+    const value = requireStringParam(raw, name, method);
+    if (value.startsWith('-') || /[\s\x00-\x1f\x7f]/.test(value)) {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: ${name} is not a valid ref name`);
+    }
+    return value;
+}
+function optionalRefParam(raw, name, method) {
+    return raw[name] === undefined ? undefined : requireRefParam(raw, name, method);
+}
+function optionalStringParam(raw, name, method) {
+    if (raw[name] === undefined)
+        return undefined;
+    const value = raw[name];
+    if (typeof value !== 'string') {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: ${name} must be a string when present`);
+    }
+    return value;
+}
+function requireStringArrayParam(raw, name, method) {
+    const value = raw[name];
+    if (!Array.isArray(value) || value.length === 0 || !value.every((p) => typeof p === 'string' && p !== '')) {
+        throw new SdkMethodError('BAD_REQUEST', `${method} requires params { ${name} } — a non-empty array of non-empty strings`);
+    }
+    return value;
+}
+function optionalBoundedInt(raw, name, method, bounds) {
+    const value = raw[name];
+    if (value === undefined)
+        return bounds.fallback;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < bounds.min || value > bounds.max) {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: ${name} must be an integer between ${bounds.min} and ${bounds.max}`);
+    }
+    return value;
+}
+function unwrap(result) {
+    if (!result.ok)
+        throw new SdkMethodError('INTERNAL', result.error);
+    return result.value;
+}
+async function resolveGitDir(args, raw) {
+    const worktree = raw.worktree;
+    if (worktree === undefined) {
+        return requireHost().activeGitDir(args.tabId, args.workingDir);
+    }
+    if (typeof worktree !== 'string' || worktree === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: worktree must be a non-empty string when present`);
+    }
+    const repoDir = requireHost().repoDir(args.tabId, args.workingDir);
+    if (!(await isValidWorktreePath(worktree, repoDir))) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${worktree}' is not a registered worktree of this Space's repository`);
+    }
+    return resolve(worktree);
+}
+function requireContainedPath(cwd, path, method) {
+    const root = resolve(cwd);
+    const target = resolve(cwd, path);
+    if (target !== root && !target.startsWith(root + sep)) {
+        throw new SdkMethodError('BAD_REQUEST', `${method}: path escapes the worktree`);
+    }
+}
+export async function gitStatusHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    const read = unwrap(await readStatus({ cwd }));
+    if (read.status.isDirty && gitHost) {
+        const headSha = await readHeadSha({ cwd });
+        const suggestion = headSha === null ? null : gitHost.commitSuggestionForStatus(cwd, headSha, read.porcelain);
+        if (suggestion)
+            return { ...read.status, commitSuggestion: suggestion };
+    }
+    return read.status;
+}
+const DEFAULT_LOG_LIMIT = 10;
+const MAX_LOG_LIMIT = 500;
+export async function gitLogHandler(args) {
+    const raw = paramsObject(args.params);
+    const limit = optionalBoundedInt(raw, 'limit', args.method, { min: 1, max: MAX_LOG_LIMIT, fallback: DEFAULT_LOG_LIMIT });
+    const skip = optionalBoundedInt(raw, 'skip', args.method, { min: 0, max: Number.MAX_SAFE_INTEGER, fallback: 0 });
+    if (raw.search !== undefined && typeof raw.search !== 'string') {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: search must be a string when present`);
+    }
+    const search = typeof raw.search === 'string' ? raw.search.trim() : '';
+    const cwd = await resolveGitDir(args, raw);
+    const page = unwrap(await readLog({ cwd, limit, skip, search }));
+    return { entries: page.entries, hasMore: page.hasMore, skip, search: search || undefined };
+}
+export async function gitDiffHandler(args) {
+    const raw = paramsObject(args.params);
+    const path = requireStringParam(raw, 'path', args.method);
+    const staged = raw.staged === true;
+    const cwd = await resolveGitDir(args, raw);
+    requireContainedPath(cwd, path, args.method);
+    const { original, modified } = await readFileDiff({ cwd, path, staged });
+    return { path, original, modified, staged };
+}
+export async function gitShowHandler(args) {
+    const raw = paramsObject(args.params);
+    const hash = requireHashParam(raw, 'hash', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await readCommitDetail({ cwd, hash }));
+}
+export async function gitCommitDiffHandler(args) {
+    const raw = paramsObject(args.params);
+    const hash = requireHashParam(raw, 'hash', args.method);
+    const path = requireStringParam(raw, 'path', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    const { original, modified } = await readCommitFileDiff({ cwd, hash, path });
+    return { hash, path, original, modified };
+}
+export async function gitBranchesListHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await listBranches({ cwd }));
+}
+export async function gitTagsListHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    return { tags: unwrap(await listTags({ cwd })) };
+}
+export async function gitRemoteInfoHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    const info = await readRemoteInfo({ cwd });
+    return info.remoteUrl === undefined ? info : { ...info, remoteUrl: redactRemoteCredentials(info.remoteUrl) };
+}
+export async function gitReposDiscoverHandler(args) {
+    const { repos, rootIsGitRepo } = await discoverRepos({ cwd: args.workingDir });
+    return { repos, rootIsGitRepo };
+}
+export async function gitWorktreesListHandler(args) {
+    const host = requireHost();
+    const worktrees = unwrap(await listWorktrees({ cwd: host.repoDir(args.tabId, args.workingDir) }));
+    return { worktrees, activeWorktreePath: host.activeWorktreePath(args.tabId, args.workingDir) };
+}
+export async function gitMergePreviewHandler(args) {
+    const raw = paramsObject(args.params);
+    const sourceBranch = requireRefParam(raw, 'sourceBranch', args.method);
+    const targetBranch = requireRefParam(raw, 'targetBranch', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return previewMerge({ cwd, sourceBranch, targetBranch });
+}
+export async function gitPrGenerateDescriptionHandler(args) {
+    const raw = paramsObject(args.params);
+    const baseBranch = raw.baseBranch === undefined ? 'main' : requireRefParam(raw, 'baseBranch', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await generatePrDescription({ cwd, baseBranch }));
+}
+function assertFreshSubscription(args) {
+    if (listLiveSubscriptions().some((sub) => sub.requestId === args.requestId)) {
+        throw new SdkMethodError('BAD_REQUEST', `requestId '${args.requestId}' already holds a live subscription`);
+    }
+}
+function subscriptionViewerId(args) {
+    return getGrant(args.appId, args.spaceKey) ? undefined : args.viewerId;
+}
+export function gitSubscribeBranchChangedHandler(args) {
+    assertFreshSubscription(args);
+    const host = requireHost();
+    let active = true;
+    const unsubscribe = host.subscribeBranchChanged((event) => {
+        if (!active)
+            return;
+        args.emit('branchChanged', event);
+    });
+    registerLiveSubscription({
+        requestId: args.requestId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        kind: 'git.subscribeBranchChanged',
+        viewerId: subscriptionViewerId(args),
+        teardown: () => {
+            active = false;
+            unsubscribe();
+        },
+    });
+    return { subscribed: true };
+}
+export function gitSubscribeCommitSuggestionHandler(args) {
+    assertFreshSubscription(args);
+    const host = requireHost();
+    let active = true;
+    const unsubscribe = host.subscribeCommitSuggestion((suggestion) => {
+        if (!active)
+            return;
+        args.emit('commitSuggestion', suggestion);
+    });
+    registerLiveSubscription({
+        requestId: args.requestId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        kind: 'git.subscribeCommitSuggestion',
+        viewerId: subscriptionViewerId(args),
+        teardown: () => {
+            active = false;
+            unsubscribe();
+        },
+    });
+    return { subscribed: true };
+}
+export function gitWorktreesSubscribeHandler(args) {
+    assertFreshSubscription(args);
+    const host = requireHost();
+    let active = true;
+    const unsubscribe = host.subscribeWorktreesChanged(() => {
+        if (!active)
+            return;
+        void listWorktrees({ cwd: host.repoDir(args.tabId, args.workingDir) })
+            .then((listed) => {
+            if (!active || !listed.ok)
+                return;
+            const payload = {
+                worktrees: listed.value,
+                activeWorktreePath: host.activeWorktreePath(args.tabId, args.workingDir),
+            };
+            args.emit('worktreesChanged', payload);
+        })
+            .catch(() => {
+        });
+    });
+    registerLiveSubscription({
+        requestId: args.requestId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        kind: 'git.worktrees.subscribe',
+        viewerId: subscriptionViewerId(args),
+        teardown: () => {
+            active = false;
+            unsubscribe();
+        },
+    });
+    return { subscribed: true };
+}
+export async function gitStageHandler(args) {
+    const raw = paramsObject(args.params);
+    const stageAll = raw.all === true;
+    const paths = stageAll ? undefined : requireStringArrayParam(raw, 'paths', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await stagePaths({ cwd, stageAll, paths }));
+}
+export async function gitUnstageHandler(args) {
+    const raw = paramsObject(args.params);
+    const paths = requireStringArrayParam(raw, 'paths', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await unstagePaths({ cwd, paths }));
+}
+export async function gitCommitHandler(args) {
+    const raw = paramsObject(args.params);
+    const message = requireStringParam(raw, 'message', args.method);
+    if (message.length > MAX_COMMIT_MESSAGE_LENGTH) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: message too long (${message.length} chars, max ${MAX_COMMIT_MESSAGE_LENGTH})`);
+    }
+    const cwd = await resolveGitDir(args, raw);
+    const result = await commitCore({ cwd, message });
+    if (!result.ok) {
+        throw new SdkMethodError(result.nothingToCommit ? 'BAD_REQUEST' : 'INTERNAL', result.error);
+    }
+    return { hash: result.hash };
+}
+export async function gitGenerateCommitMessageHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    const generated = await generateStagedCommitMessage({
+        cwd,
+        tabId: args.tabId,
+        startedAt: Date.now(),
+        autoCommit: false,
+    });
+    if (!generated.ok) {
+        throw new SdkMethodError(generated.error === 'No staged changes to commit' ? 'BAD_REQUEST' : 'INTERNAL', generated.error);
+    }
+    return { message: generated.value };
+}
+export async function gitCheckoutHandler(args) {
+    const raw = paramsObject(args.params);
+    const branch = requireRefParam(raw, 'branch', args.method);
+    const startPoint = optionalRefParam(raw, 'startPoint', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    const result = unwrap(await checkoutBranch({ cwd, branch, create: raw.create === true, startPoint }));
+    return { branch, previous: result.previous };
+}
+export async function gitBranchesCreateHandler(args) {
+    const raw = paramsObject(args.params);
+    const name = requireRefParam(raw, 'name', args.method);
+    const startPoint = optionalRefParam(raw, 'startPoint', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await createBranch({ cwd, name, startPoint, checkout: raw.checkout === true }));
+}
+export async function gitBranchesDeleteHandler(args) {
+    const raw = paramsObject(args.params);
+    const name = requireRefParam(raw, 'name', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await deleteBranch({ cwd, name, force: raw.force === true }));
+}
+export async function gitTagsCreateHandler(args) {
+    const raw = paramsObject(args.params);
+    const name = requireRefParam(raw, 'name', args.method);
+    const message = optionalStringParam(raw, 'message', args.method);
+    const commit = optionalRefParam(raw, 'commit', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await createTag({ cwd, name, message, commit }));
+}
+export async function gitWorktreesCreateHandler(args) {
+    const raw = paramsObject(args.params);
+    const branchName = requireRefParam(raw, 'branchName', args.method);
+    const baseBranch = optionalRefParam(raw, 'baseBranch', args.method);
+    const path = optionalStringParam(raw, 'path', args.method);
+    if (path !== undefined && (path === '' || path.startsWith('-'))) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: path is not a valid destination`);
+    }
+    const host = requireHost();
+    const cwd = host.repoDir(args.tabId, args.workingDir);
+    const created = unwrap(await createWorktree({ cwd, branchName, baseBranch, path }));
+    if (raw.assign === true) {
+        host.setActiveWorktree(args.tabId, args.workingDir, created.path, created.branch);
+    }
+    host.worktreesMutated();
+    return created;
+}
+export async function gitWorktreesRemoveHandler(args) {
+    const raw = paramsObject(args.params);
+    const path = requireStringParam(raw, 'path', args.method);
+    const host = requireHost();
+    const repoDir = host.repoDir(args.tabId, args.workingDir);
+    if (!(await isValidWorktreePath(path, repoDir))) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' is not a registered worktree of this Space's repository`);
+    }
+    const removed = unwrap(await removeWorktree({ cwd: repoDir, path: resolve(path), force: raw.force === true, deleteBranch: raw.deleteBranch === true }));
+    host.releaseWorktreeReferences(removed.path, args.workingDir);
+    host.worktreesMutated();
+    return removed;
+}
+let warnedSwitchActiveWorktreeAlias = false;
+export async function gitWorktreesSwitchActiveHandler(args) {
+    const raw = paramsObject(args.params);
+    const host = requireHost();
+    let path = null;
+    if ('path' in raw) {
+        path = raw.path;
+    }
+    else if ('worktree' in raw) {
+        if (!warnedSwitchActiveWorktreeAlias) {
+            warnedSwitchActiveWorktreeAlias = true;
+            console.warn(`[sdk] ${args.method}: params.worktree is deprecated, use params.path instead`);
+        }
+        path = raw.worktree;
+    }
+    if (path === null) {
+        host.setActiveWorktree(args.tabId, args.workingDir, null, null);
+        host.worktreesMutated();
+        return { path: null, worktreePath: null, branch: null };
+    }
+    if (typeof path !== 'string' || path === '') {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: path must be a non-empty string or null`);
+    }
+    if (!(await isValidWorktreePath(path, host.repoDir(args.tabId, args.workingDir)))) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${path}' is not a registered worktree of this Space's repository`);
+    }
+    const worktreePath = resolve(path);
+    const branch = await readCurrentBranch(worktreePath);
+    host.setActiveWorktree(args.tabId, args.workingDir, worktreePath, branch || null);
+    host.worktreesMutated();
+    return { path: worktreePath, worktreePath, branch: branch || null };
+}
+const MERGE_STRATEGIES = new Set(['merge', 'squash', 'rebase']);
+export async function gitMergeRunHandler(args) {
+    const raw = paramsObject(args.params);
+    const sourceBranch = requireRefParam(raw, 'sourceBranch', args.method);
+    const targetBranch = requireRefParam(raw, 'targetBranch', args.method);
+    const strategy = requireStringParam(raw, 'strategy', args.method);
+    if (!MERGE_STRATEGIES.has(strategy)) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: strategy must be one of merge, squash, rebase`);
+    }
+    const commitMessage = optionalStringParam(raw, 'commitMessage', args.method);
+    if (commitMessage !== undefined && commitMessage.length > MAX_COMMIT_MESSAGE_LENGTH) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: commitMessage too long (max ${MAX_COMMIT_MESSAGE_LENGTH})`);
+    }
+    const cwd = await resolveGitDir(args, raw);
+    const { data, removedWorktreePath } = await mergeWorktreeBranch({
+        cwd,
+        sourceBranch,
+        targetBranch,
+        strategy,
+        commitMessage,
+        deleteWorktree: raw.deleteWorktree === true,
+        deleteBranch: raw.deleteBranch === true,
+        stashFirst: raw.stashFirst === true,
+    });
+    if (removedWorktreePath) {
+        const host = requireHost();
+        host.releaseWorktreeReferences(removedWorktreePath, args.workingDir);
+        host.worktreesMutated();
+    }
+    return data;
+}
+async function resolveResolutionWorktree(args, raw, cwd) {
+    if (raw.targetWorktreePath !== undefined)
+        return resolveMergeTarget(args, raw);
+    return raw.worktree !== undefined ? cwd : undefined;
+}
+export async function gitMergeAbortHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    const targetWorktreePath = await resolveResolutionWorktree(args, raw, cwd);
+    unwrap(await abortMerge({ cwd, targetWorktreePath }));
+    return { aborted: true };
+}
+export async function gitMergeCompleteHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    const targetWorktreePath = await resolveResolutionWorktree(args, raw, cwd);
+    const result = unwrap(await completeMerge({ cwd, targetWorktreePath }));
+    return { success: true, mergeCommit: result.mergeCommit };
+}
+async function resolveMergeTarget(args, raw) {
+    const target = raw.targetWorktreePath;
+    if (target !== undefined) {
+        if (typeof target !== 'string' || target === '') {
+            throw new SdkMethodError('BAD_REQUEST', `${args.method}: targetWorktreePath must be a non-empty string when present`);
+        }
+        if (!(await isValidWorktreePath(target, requireHost().repoDir(args.tabId, args.workingDir)))) {
+            throw new SdkMethodError('BAD_REQUEST', `${args.method}: '${target}' is not a registered worktree of this Space's repository`);
+        }
+        return resolve(target);
+    }
+    return resolveMainWorktreePath(requireHost().activeGitDir(args.tabId, args.workingDir));
+}
+export async function gitMergeStashPopHandler(args) {
+    const raw = paramsObject(args.params);
+    const stashSha = requireHashParam(raw, 'stashSha', args.method);
+    const targetWorktreePath = await resolveMergeTarget(args, raw);
+    const result = await popMergeStashBySha(targetWorktreePath, stashSha);
+    if (result.exitCode !== 0) {
+        throw new SdkMethodError('INTERNAL', result.error || 'Failed to pop stash');
+    }
+    return { success: true, targetWorktreePath };
+}
+export async function gitMergeDiscardBlockersHandler(args) {
+    const raw = paramsObject(args.params);
+    const paths = requireStringArrayParam(raw, 'paths', args.method);
+    if (!paths.every(isSafeDiscardPath)) {
+        throw new SdkMethodError('BAD_REQUEST', `${args.method}: invalid path in discard list`);
+    }
+    const targetWorktreePath = await resolveMergeTarget(args, raw);
+    const result = unwrap(await discardMergeBlockers({ cwd: targetWorktreePath, paths }));
+    return { success: true, targetWorktreePath, paths: result.paths };
+}
+export async function gitPushHandler(args) {
+    const raw = paramsObject(args.params);
+    const remote = optionalRefParam(raw, 'remote', args.method);
+    const branch = optionalRefParam(raw, 'branch', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    if (remote !== undefined || branch !== undefined || raw.setUpstream !== undefined) {
+        return unwrap(await pushWorktree({ cwd, remote, branch, setUpstream: raw.setUpstream === true }));
+    }
+    return unwrap(await pushCore({ cwd }));
+}
+export async function gitPullHandler(args) {
+    const raw = paramsObject(args.params);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await pullCore({ cwd }));
+}
+export async function gitTagsPushHandler(args) {
+    const raw = paramsObject(args.params);
+    const all = raw.all === true;
+    const name = all ? undefined : requireRefParam(raw, 'name', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    return unwrap(await pushTag({ cwd, name, all }));
+}
+export async function gitPrCreateHandler(args) {
+    const raw = paramsObject(args.params);
+    const title = requireStringParam(raw, 'title', args.method);
+    const body = optionalStringParam(raw, 'body', args.method);
+    const baseBranch = optionalRefParam(raw, 'baseBranch', args.method);
+    const cwd = await resolveGitDir(args, raw);
+    const created = unwrap(await createPullRequest({ cwd, title, body, baseBranch, draft: raw.draft === true }));
+    return { url: created.url, method: created.method };
+}