@playcraft/cli 0.1.6 → 0.1.8

package/dist/workspace-runtime/server/desktop-host.js

@@ -2,6 +2,11 @@ import { connect as connectTcp } from 'node:net';
 import { WebSocket, WebSocketServer } from 'ws';
 import { desktopHealthSchema, desktopResourceName, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
+/**
+ * A takeover holds the desktop for this long, whether or not a page is watching, and ends on its
+ * own unless the user renews it.
+ */
+const HOLD_MS = 20 * 60_000;
 const sources = new WeakMap();
 const hosts = new WeakMap();
 export function setDesktopSource(state, source) {
@@ -33,6 +38,9 @@ export class DesktopHost {
     sockets = new WebSocketServer({ noServer: true });
     source;
     upstream = loopbackUpstream(process.env.PLAYCRAFT_DESKTOP_UPSTREAM);
+    holdMs = holdDuration(process.env.PLAYCRAFT_DESKTOP_HOLD_MS);
+    holdExpiresAt;
+    holdTimer;
     constructor(state) {
         this.state = state;
         this.source = sources.get(state);
@@ -46,6 +54,9 @@ export class DesktopHost {
             streamGeneration: this.generation,
             holder: this.holder,
             agentInput: this.holder === 'human' ? 'revoked' : 'open',
+            ...(this.holder === 'human' && this.holdExpiresAt
+                ? { holdExpiresAt: new Date(this.holdExpiresAt).toISOString() }
+                : {}),
         });
     }
     async refresh() {
@@ -71,12 +82,21 @@ export class DesktopHost {
             }
             this.holder = 'human';
             this.cutViewers();
+            this.hold();
+            writeJson(response, 200, this.snapshot());
+            return;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/desktop/renew') {
+            if (this.holder !== 'human') {
+                writeError(response, 'desktop_not_held');
+                return;
+            }
+            this.hold();
             writeJson(response, 200, this.snapshot());
             return;
         }
         if (request.method === 'DELETE' && url.pathname === '/runtime/desktop') {
-            this.holder = 'none';
-            this.cutViewers();
+            this.release();
             writeJson(response, 200, this.snapshot());
             return;
         }
@@ -114,9 +134,30 @@ export class DesktopHost {
         this.sockets.handleUpgrade(request, socket, head, (ws) => this.attach(ws, generation));
     }
     dispose() {
+        this.release();
+        this.sockets.close();
+    }
+    release() {
+        this.clearHold();
         this.holder = 'none';
         this.cutViewers();
-        this.sockets.close();
+    }
+    /** Starts or renews the hold; when it runs out the desktop is released as if by hand. */
+    hold() {
+        this.clearHold();
+        this.holdExpiresAt = Date.now() + this.holdMs;
+        this.holdTimer = setTimeout(() => {
+            this.holdTimer = undefined;
+            if (this.holder === 'human')
+                this.release();
+        }, this.holdMs);
+        this.holdTimer.unref?.();
+    }
+    clearHold() {
+        if (this.holdTimer)
+            clearTimeout(this.holdTimer);
+        this.holdTimer = undefined;
+        this.holdExpiresAt = undefined;
     }
     currentStatus() {
         if (this.source)
@@ -248,6 +289,7 @@ export function desktopRoute(pathname) {
     return (pathname === '/runtime/desktop/health' ||
         pathname === '/runtime/desktop/connect' ||
         pathname === '/runtime/desktop/takeover' ||
+        pathname === '/runtime/desktop/renew' ||
         pathname === '/runtime/desktop' ||
         pathname.startsWith('/runtime/desktop/resources/'));
 }
@@ -268,6 +310,10 @@ function loopbackUpstream(value) {
         return undefined;
     return { port };
 }
+function holdDuration(value) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : HOLD_MS;
+}
 function probePort(port) {
     return new Promise((resolve) => {
         const socket = connectTcp({ host: '127.0.0.1', port });

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

@@ -596,7 +596,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), parsed.data);
+        const sha = await commitWorkspaceGit(await workspaceRoot(state, operation.workspaceId), parsed.data, boundBranch(state, operation));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {
@@ -617,7 +617,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));
+        await pushWorkspaceGit(await workspaceRoot(state, operation.workspaceId), boundBranch(state, operation));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {
@@ -765,6 +765,10 @@ async function executeTerminalCreate(state, scopeKey, operation, payload) {
     ]);
     return persist(state, scopeKey, transitionOperation(accepted, 'completed', { terminalId, cwd: record.cwd }));
 }
+/** The branch a registered workspace is bound to; the single-workspace mode has none. */
+function boundBranch(state, operation) {
+    return operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId)?.branchName : undefined;
+}
 function gitErrorCode(error) {
     return error instanceof GitWorkspaceError ? error.code : 'git_command_failed';
 }

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

@@ -171,8 +171,34 @@ function splitLogLine(line) {
         return [line.slice(0, first), line.slice(first + 1), ''];
     return [line.slice(0, first), line.slice(first + 1, second), line.slice(second + 1)];
 }
-export async function commitWorkspaceGit(root, payload) {
+/**
+ * Commit and push stay on the branch the workspace is bound to. A switch made in a shell or by an
+ * agent is reported, never followed, so work cannot land on another Remix.
+ */
+async function assertBoundBranch(rootReal, boundBranch) {
+    if (!boundBranch)
+        return;
+    const current = await gitAllowFail(rootReal, ['symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const branch = current.code === 0 ? current.stdout.trim() : '';
+    if (branch !== boundBranch) {
+        throw new GitWorkspaceError('workspace_branch_mismatch', branch || 'detached HEAD');
+    }
+}
+/**
+ * A push the remote refused for this ref is a definite outcome, unlike a lost response. Porcelain
+ * output marks the ref with "!" and says whether the remote has commits this checkout lacks.
+ */
+function pushRejection(stdout) {
+    const line = stdout.split('\n').find((item) => item.startsWith('!\t'));
+    if (!line)
+        return undefined;
+    if (/\[rejected\] \((?:non-fast-forward|fetch first)\)/.test(line))
+        return 'git_push_remote_ahead';
+    return 'git_push_rejected';
+}
+export async function commitWorkspaceGit(root, payload, boundBranch) {
     const rootReal = await ensureWorkspaceGit(root);
+    await assertBoundBranch(rootReal, boundBranch);
     if (payload.stagedOnly) {
         // The index is the commit; nothing is added.
     }
@@ -190,8 +216,9 @@ export async function commitWorkspaceGit(root, payload) {
     await git(rootReal, ['commit', '-m', payload.message], 20000);
     return (await git(rootReal, ['rev-parse', 'HEAD'])).trim();
 }
-export async function pushWorkspaceGit(root) {
+export async function pushWorkspaceGit(root, boundBranch) {
     const rootReal = await ensureWorkspaceGit(root);
+    await assertBoundBranch(rootReal, boundBranch);
     const origin = await gitAllowFail(rootReal, ['remote', 'get-url', 'origin']);
     if (origin.code !== 0) {
         throw new GitWorkspaceError('remote_not_configured', 'origin');
@@ -200,12 +227,16 @@ export async function pushWorkspaceGit(root) {
     if (!ref.startsWith('refs/heads/'))
         throw new GitWorkspaceError('git_command_failed', 'git_branch_required');
     const commit = (await git(rootReal, ['rev-parse', '--verify', 'HEAD^{commit}'])).trim();
+    let pushed;
     try {
-        const pushed = await gitAllowFail(rootReal, ['push', '--porcelain', 'origin', `${commit}:${ref}`], 90000);
-        if (pushed.code === 0)
-            return;
+        pushed = await gitAllowFail(rootReal, ['push', '--porcelain', 'origin', `${commit}:${ref}`], 90000);
     }
     catch { /* A lost response does not prove the remote rejected the update. */ }
+    if (pushed?.code === 0)
+        return;
+    const rejected = pushed ? pushRejection(pushed.stdout) : undefined;
+    if (rejected)
+        throw new GitWorkspaceError(rejected, rejected);
     try {
         const remote = await gitAllowFail(rootReal, ['ls-remote', '--refs', 'origin', ref], 20000);
         if (remote.code === 0 && remote.stdout.trim() === `${commit}\t${ref}`)

package/package.json

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