@playcraft/cli 0.1.32 → 0.1.33

package/dist/workspace-runtime/server/dispatch.js

@@ -3,7 +3,7 @@ import { revisionScope, sessionWorkspaceRoot, workspaceRoot, workspaceSessions }
 import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../workspaces/turn-changes.js';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { PLATFORM_ROUTES, platformEndpoint, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { PLATFORM_ROUTES, platformEndpoint, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
@@ -17,7 +17,7 @@ import { NativePreparationError } from '../codex/native-adapter.js';
 import { disposeTerminalHost } from './terminal-host.js';
 import { disposeDesktopHost } from './desktop-host.js';
 import { InvalidWorkspacePathError, resolveWorkspaceFile, writeWorkspaceFile, } from '../workspaces/files.js';
-import { GitWorkspaceError, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, saveWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
+import { GitWorkspaceError, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, pullWorkspaceGit, abortWorkspaceMerge, saveWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
 import { ParameterEditError } from '../workspaces/json5-edit.js';
 import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces/parameters.js';
 import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPreviewPublish, } from '../previews/publish.js';
@@ -38,6 +38,8 @@ const LOCAL_KINDS = new Set([
     'file.write',
     'git.commit',
     'git.push',
+    'git.pull',
+    'git.merge.abort',
     'git.stage',
     'git.unstage',
     'git.discard',
@@ -93,6 +95,12 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'git.push') {
         return executeGitPush(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'git.pull') {
+        return executeGitPull(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'git.merge.abort') {
+        return executeGitMergeAbort(state, scopeKey, current, payload);
+    }
     if (operation.kind === 'git.stage' || operation.kind === 'git.unstage' || operation.kind === 'git.discard') {
         return executeGitIndex(state, scopeKey, current, payload);
     }
@@ -858,6 +866,39 @@ async function executeGitPush(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
     }
 }
+/** Conflicts complete the pull: the merge stays in progress for the user to resolve. */
+async function executeGitPull(state, scopeKey, operation, payload) {
+    if (!gitPullPayloadSchema.safeParse(payload ?? {}).success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'remote_not_configurable' }));
+    }
+    try {
+        const pulled = await pullWorkspaceGit(await workspaceRoot(state, operation.workspaceId, operation.directoryName), boundBranch(state, operation));
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+        await recordNativeEvents(state, accepted, [{
+                type: 'git.pulled',
+                payload: { remote: 'origin', outcome: pulled.outcome, conflicts: pulled.conflicts.slice(0, 100) },
+                occurredAt: new Date().toISOString(),
+            }]);
+        return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+    }
+    catch (error) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
+    }
+}
+async function executeGitMergeAbort(state, scopeKey, operation, payload) {
+    if (!gitMergeAbortPayloadSchema.safeParse(payload ?? {}).success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_git_merge_abort' }));
+    }
+    try {
+        await abortWorkspaceMerge(await workspaceRoot(state, operation.workspaceId, operation.directoryName));
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+        await recordNativeEvents(state, accepted, [{ type: 'git.merge.aborted', payload: {}, occurredAt: new Date().toISOString() }]);
+        return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+    }
+    catch (error) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
+    }
+}
 const GIT_INDEX_CHANGES = {
     'git.stage': { run: stageWorkspaceGit, event: 'git.staged' },
     'git.unstage': { run: unstageWorkspaceGit, event: 'git.unstaged' },

package/dist/workspace-runtime/workspaces/git.js

@@ -44,6 +44,7 @@ export async function readWorkspaceGitStatus(root) {
         ahead = Number.parseInt(right ?? '0', 10) || 0;
     }
     const porcelain = await git(rootReal, ['status', '--porcelain=v1', '--untracked-files=all', '-z']);
+    const merge = await mergeState(rootReal);
     // Line counts are a convenience; a repository without commits still lists its files.
     const [staged, unstaged] = await Promise.all([
         gitAllowFail(rootReal, ['diff', '--cached', '--numstat', '-z']),
@@ -57,6 +58,7 @@ export async function readWorkspaceGitStatus(root) {
         ahead,
         behind,
         hasUpstream: upstream.code === 0,
+        ...merge,
         files: parsePorcelain(porcelain).map((entry) => ({
             ...entry,
             ...(stagedCounts.has(entry.path) ? { staged: stagedCounts.get(entry.path) } : {}),
@@ -131,7 +133,8 @@ export async function diffWorkspaceTrees(root, before, after) {
 export async function readWorkspaceGitFile(root, path, ref) {
     const rootReal = await ensureWorkspaceGit(root);
     assertWorkspacePaths([path]);
-    const object = ref === 'INDEX' ? `:${path}` : `${ref}:${path}`;
+    const stage = { INDEX: 0, MERGE_BASE: 1, MERGE_OURS: 2, MERGE_THEIRS: 3 }[ref];
+    const object = stage === undefined ? `${ref}:${path}` : `:${stage}:${path}`;
     const absent = gitFileContentSchema.parse({ path, ref, exists: false, binary: false, content: '' });
     const size = await gitAllowFail(rootReal, ['cat-file', '-s', object]);
     if (size.code !== 0)
@@ -271,6 +274,9 @@ function pushRejection(stdout) {
 export async function commitWorkspaceGit(root, payload, boundBranch) {
     const rootReal = await ensureWorkspaceGit(root);
     await assertBoundBranch(rootReal, boundBranch);
+    // Adding a conflicted file would mark it resolved with its conflict markers in it.
+    if ((await unmergedPaths(rootReal)).length)
+        throw new GitWorkspaceError('git_conflicts_unresolved', 'unmerged');
     if (payload.stagedOnly) {
         // The index is the commit; nothing is added.
     }
@@ -334,6 +340,10 @@ export function isCredentialFile(path) {
 export async function saveWorkspaceGit(root, input) {
     const rootReal = await ensureWorkspaceGit(root);
     await assertBoundBranch(rootReal, input.boundBranch);
+    // A save during a merge would stage conflict markers as resolutions and conclude the merge. The
+    // user (or an agent) finishes the merge with an explicit commit; saves resume after it.
+    if ((await mergeState(rootReal)).merging)
+        return { pushed: false, withheld: [] };
     await git(rootReal, ['add', '-A'], 60000);
     const staged = (await git(rootReal, ['diff', '--cached', '--name-only', '-z'], 60000)).split('\0').filter(Boolean);
     const withheld = staged.filter(isCredentialFile);
@@ -353,6 +363,68 @@ export async function saveWorkspaceGit(root, input) {
     await recordPushedHead(rootReal);
     return { ...(commit ? { commit } : {}), pushed: true, withheld };
 }
+/**
+ * `git pull` with a merge, as VS Code runs it: fetch the bound branch from origin, then merge it.
+ * Uncommitted work is kept unless the incoming commits change the same files, in which case Git
+ * refuses before touching anything. Conflicts leave the merge in progress for the user to resolve.
+ */
+export async function pullWorkspaceGit(root, boundBranch) {
+    const rootReal = await ensureWorkspaceGit(root);
+    await assertBoundBranch(rootReal, boundBranch);
+    if ((await mergeState(rootReal)).merging)
+        throw new GitWorkspaceError('git_merge_in_progress', 'merge_in_progress');
+    if ((await gitAllowFail(rootReal, ['remote', 'get-url', 'origin'])).code !== 0) {
+        throw new GitWorkspaceError('remote_not_configured', 'origin');
+    }
+    const branch = (await gitAllowFail(rootReal, ['symbolic-ref', '--quiet', '--short', 'HEAD'])).stdout.trim();
+    const born = (await gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD^{commit}'])).code === 0;
+    if (!branch || !born)
+        throw new GitWorkspaceError('git_command_failed', 'git_branch_required');
+    // A fork clone has no fetch refspec for its own branch, so the tracking ref is named here.
+    const remoteRef = `refs/remotes/origin/${branch}`;
+    const fetched = await gitAllowFail(rootReal, ['fetch', '--no-tags', 'origin', `+refs/heads/${branch}:${remoteRef}`], 90000);
+    if (fetched.code !== 0)
+        throw new GitWorkspaceError(httpRefusal(fetched.stderr) ?? 'git_fetch_failed', 'git_fetch_failed');
+    if ((await gitAllowFail(rootReal, ['merge-base', '--is-ancestor', remoteRef, 'HEAD'])).code === 0) {
+        return { outcome: 'up_to_date', conflicts: [] };
+    }
+    // The short name gives the merge commit the message `git pull` would write.
+    const merged = await gitAllowFail(rootReal, [...(await commitIdentity(rootReal)), 'merge', '--no-edit', `origin/${branch}`], 60000);
+    if (merged.code === 0)
+        return { outcome: 'merged', conflicts: [] };
+    const conflicts = await unmergedPaths(rootReal);
+    if (conflicts.length)
+        return { outcome: 'conflicts', conflicts };
+    if (/would be overwritten by merge|untracked working tree files would be (?:overwritten|removed)/i.test(`${merged.stdout}\n${merged.stderr}`)) {
+        throw new GitWorkspaceError('git_pull_local_changes', 'local_changes');
+    }
+    throw new GitWorkspaceError('git_command_failed', merged.stderr.trim() || 'git_merge_failed');
+}
+/** `git merge --abort`: the work tree and index return to how they were before the merge began. */
+export async function abortWorkspaceMerge(root) {
+    const rootReal = await ensureWorkspaceGit(root);
+    if (!(await mergeState(rootReal)).merging)
+        throw new GitWorkspaceError('git_merge_not_in_progress', 'no_merge');
+    await git(rootReal, ['merge', '--abort'], 60000);
+}
+/** Paths with unmerged index entries, that is, conflicts not yet marked resolved. */
+async function unmergedPaths(rootReal) {
+    const listed = await gitAllowFail(rootReal, ['diff', '--name-only', '--diff-filter=U', '-z']);
+    return listed.code === 0 ? listed.stdout.split('\0').filter(Boolean) : [];
+}
+async function mergeState(rootReal) {
+    try {
+        await stat(join(rootReal, '.git', 'MERGE_HEAD'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+    const message = await readFile(join(rootReal, '.git', 'MERGE_MSG'), 'utf8').catch(() => '');
+    const text = message.split('\n').filter((line) => !line.startsWith('#')).join('\n').trim().slice(0, 4096);
+    return { merging: true, ...(text ? { mergeMessage: text } : {}) };
+}
 /**
  * Connects a standalone checkout to the repository it was just given, keeping all its history and
  * uncommitted work. The new repository holds one empty commit on `branch`; it becomes the base of an

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "private": false,
   "type": "module",
   "engines": {
@@ -50,8 +50,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.32",
-    "@playcraft/common": "^0.1.32",
+    "@playcraft/build": "^0.1.33",
+    "@playcraft/common": "^0.1.33",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",