@playcraft/cli 0.1.32 → 0.1.34

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

@@ -1,9 +1,10 @@
 import { withObservedFile } from '../workspaces/revisions.js';
 import { revisionScope, sessionWorkspaceRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
 import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../workspaces/turn-changes.js';
+import { shareWorkspaceGit } from '../workspaces/shared-git.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 +18,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 +39,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 +96,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);
     }
@@ -781,7 +790,7 @@ async function executeGitCommit(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_git_commit' }));
     }
     try {
-        const sha = await commitWorkspaceGit(await workspaceRoot(state, operation.workspaceId, operation.directoryName), parsed.data, boundBranch(state, operation));
+        const sha = await commitWorkspaceGit(await gitWorkspaceRoot(state, operation), parsed.data, boundBranch(state, operation));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {
@@ -818,7 +827,7 @@ async function executeWorkspaceSave(state, scopeKey, operation, payload) {
     }
     const binding = operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId) : undefined;
     try {
-        const saved = await saveWorkspaceGit(await workspaceRoot(state, operation.workspaceId, operation.directoryName), {
+        const saved = await saveWorkspaceGit(await gitWorkspaceRoot(state, operation), {
             message: parsed.data.trigger === 'auto' ? 'Autosave workspace' : 'Save workspace',
             push: savePushesBranch(binding?.targetKind, operation.directoryName),
             boundBranch: boundBranch(state, operation),
@@ -843,7 +852,7 @@ async function executeGitPush(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'remote_not_configurable' }));
     }
     try {
-        await pushWorkspaceGit(await workspaceRoot(state, operation.workspaceId, operation.directoryName), boundBranch(state, operation));
+        await pushWorkspaceGit(await gitWorkspaceRoot(state, operation), boundBranch(state, operation));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {
@@ -858,6 +867,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 gitWorkspaceRoot(state, operation), 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 gitWorkspaceRoot(state, operation));
+        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' },
@@ -871,7 +913,7 @@ async function executeGitIndex(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_git_paths' }));
     }
     try {
-        await change.run(await workspaceRoot(state, operation.workspaceId, operation.directoryName), parsed.data);
+        await change.run(await gitWorkspaceRoot(state, operation), parsed.data);
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             { type: change.event, payload: { paths: parsed.data.paths }, occurredAt: new Date().toISOString() },
@@ -1002,8 +1044,16 @@ function boundBranch(state, operation) {
         : binding.branchName ?? undefined;
 }
 function gitErrorCode(error) {
+    // The code is all an operation records; Git's own message stays in the runtime log.
+    console.warn('[workspace-runtime] git operation failed:', error instanceof Error ? error.message : error);
     return error instanceof GitWorkspaceError ? error.code : 'git_command_failed';
 }
+/** The workspace checkout, prepared so this process and the development user can both write it. */
+async function gitWorkspaceRoot(state, operation) {
+    const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
+    await shareWorkspaceGit(state, root);
+    return root;
+}
 function parameterPatchError(error) {
     if (error instanceof ParameterEditError)
         return error.code;

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
@@ -443,6 +515,18 @@ export async function ensureWorkspaceGit(root) {
     await excludeFromGit(rootReal, '/.tmp/user_uploads/');
     return rootReal;
 }
+/**
+ * The control user and the development user (terminal, Codex) both write this repository. Git
+ * creates directories with the writer's umask, so a directory one user made can refuse the
+ * other's objects. With `core.sharedRepository=group` Git makes new directories group-writable for
+ * both; the image puts the control user in the development group.
+ */
+export async function shareWorkspaceRepository(root) {
+    const rootReal = await existingWorkspaceGit(root);
+    const current = await gitAllowFail(rootReal, ['config', '--get', 'core.sharedRepository']);
+    if (current.stdout.trim() !== 'group')
+        await git(rootReal, ['config', 'core.sharedRepository', 'group']);
+}
 /** Turn snapshots never create a repository; a directory without one simply has no turn changes. */
 async function existingWorkspaceGit(root) {
     const rootReal = await realpath(root);

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

@@ -0,0 +1,40 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { launcherSocket, runDeveloperCommand } from './developer-command.js';
+import { shareWorkspaceRepository } from './git.js';
+/**
+ * Directories under `.git` this process cannot write: another user created them without group
+ * write. Only their owner can change that, so they are reported rather than fixed here.
+ */
+export async function foreignUnwritableGitDirectories(root) {
+    const uid = typeof process.getuid === 'function' ? process.getuid() : undefined;
+    const found = [];
+    const visit = async (path) => {
+        const stat = await lstat(path).catch(() => undefined);
+        if (!stat?.isDirectory())
+            return;
+        if (stat.uid !== uid && (stat.mode & 0o020) === 0)
+            found.push(path);
+        for (const entry of await readdir(path).catch(() => []))
+            await visit(join(path, entry));
+    };
+    await visit(join(root, '.git'));
+    return found;
+}
+/**
+ * Prepares a workspace repository for a Git write by this process: new directories become group
+ * writable, and directories the development user already made without group write are opened by
+ * that user through the launcher. Without a launcher (local runs) both users are the same.
+ */
+export async function shareWorkspaceGit(state, root) {
+    await shareWorkspaceRepository(root).catch(() => undefined);
+    if (!launcherSocket(state) || !(await foreignUnwritableGitDirectories(root)).length)
+        return;
+    await runDeveloperCommand(state, {
+        processId: `git-share-${Date.now().toString(36)}`,
+        cwd: root,
+        command: 'find .git -type d -uid "$(id -u)" ! -perm -g+w -exec chmod g+ws {} +',
+        timeoutMs: 30_000,
+        onOutput: () => undefined,
+    }).catch(() => undefined);
+}

package/dist/workspace-runtime/workspaces/turn-changes.js

@@ -1,5 +1,6 @@
 import { TURN_FILES_CHANGED_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
 import { diffWorkspaceTrees, retainTurnSnapshots, snapshotWorkspaceTree } from './git.js';
+import { shareWorkspaceGit } from './shared-git.js';
 const TURN_ENDS = new Set(['turn/completed', 'turn.completed', 'turn.interrupted', 'turn.failed']);
 /**
  * Snapshots taken when a session's turn starts, until that turn ends. Kept in memory only: a
@@ -20,6 +21,7 @@ export async function beginTurnChanges(state, sessionId, input) {
     turnsOf(state).delete(sessionId);
     if (input.directoryName === 'root')
         return;
+    await shareWorkspaceGit(state, input.root).catch(() => undefined);
     const before = await snapshotWorkspaceTree(input.root).catch(() => undefined);
     if (before)
         turnsOf(state).set(sessionId, { ...input, before });
@@ -42,6 +44,7 @@ export async function finishTurnChanges(state, event) {
         return [];
     turnsOf(state).delete(session.sessionId);
     try {
+        await shareWorkspaceGit(state, start.root);
         const after = await snapshotWorkspaceTree(start.root);
         const { files, truncated } = await diffWorkspaceTrees(start.root, start.before, after);
         if (!files.length)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "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.34",
+    "@playcraft/common": "^0.1.34",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",