Deploy fa03242 to Docker Space

Source: MisonL/gpt-image-playground-customer@fa03242bd6b72fa8fe64e177f690cb8f81ba2a8c

public/hf-space-deploy-marker.json

@@ -0,0 +1,5 @@
+{
+  "schema_version": 1,
+  "local_sha": "fa03242bd6b72fa8fe64e177f690cb8f81ba2a8c",
+  "created_at": "2026-06-20T10:52:58.463Z"
+}

scripts/agent-doctor.mjs

@@ -350,7 +350,7 @@ function buildSummary({ capabilities, runtime, contract, smoke }) {
             capabilities.ok && capabilities.body?.agent_streaming?.page_sse?.auth?.required === true
                 ? Boolean(process.env.GPT_IMAGE_APP_PASSWORD_HASH)
                 : capabilities.ok,
-        page_sse_real_smoke: summarizeSmokeCheck(smoke, PAGE_SSE_GENERATE_SMOKE_NAME),
+        page_sse_real_smoke: summarizePageSseSmoke(smoke),
         responses_page_sse_generate_smoke: summarizeSmokeCheck(smoke, PAGE_SSE_GENERATE_SMOKE_NAME),
         real_smoke_checks: summarizeSmokeChecks(smoke),
         responses_gpt2image_ready:
@@ -371,6 +371,13 @@ function summarizeSmokeCheck(smoke, name) {
     return check.ok ? 'passed' : 'failed';
 }
 
+function summarizePageSseSmoke(smoke) {
+    const states = [PAGE_SSE_GENERATE_SMOKE_NAME, 'page_sse_edit_2k'].map((name) => summarizeSmokeCheck(smoke, name));
+    if (states.includes('failed')) return 'failed';
+    if (states.includes('passed')) return 'passed';
+    return 'skipped';
+}
+
 function summarizeSmokeChecks(smoke) {
     return {
         agent_generate_1k: summarizeSmokeCheck(smoke, 'generate_1k'),

scripts/command-center.test.mjs

@@ -882,6 +882,96 @@ describe('Command center scripts', () => {
         );
     });
 
+    it('reports failed agent:doctor page SSE smoke checks without hiding the failure', async () => {
+        await withServer(
+            (request, response) => {
+                if (request.url === '/api/agent/capabilities') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            defaults: { state_backend: 'memory' },
+                            storage: { image_storage_mode: 'indexeddb', postgres_configured: false },
+                            agent_streaming: { page_sse: { supported: true } },
+                            agent_jobs: { supported: true },
+                            routing_rules: {},
+                            supported: {
+                                image_backend_requirements: {
+                                    'responses-image-generation': {
+                                        supported: true,
+                                        enabled: true,
+                                        missing_env: []
+                                    }
+                                }
+                            }
+                        })
+                    );
+                    return;
+                }
+                if (request.url === '/api/runtime-capabilities') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            streaming: {
+                                defaultMode: 'auto',
+                                unavailableMarkScope: 'channel+backend+strategy+operation'
+                            },
+                            streamingBatch: { enabled: true },
+                            responsesImageBackend: { enabled: true, mode: 'experimental' }
+                        })
+                    );
+                    return;
+                }
+                if (request.url === '/api/agent/images/generate') {
+                    response.writeHead(200, { 'content-type': 'application/json' });
+                    response.end(JSON.stringify({ images: [{ id: 'doctor-generate', filename: 'doctor.png' }] }));
+                    return;
+                }
+                if (request.url === '/api/images') {
+                    response.writeHead(503, { 'content-type': 'text/plain' });
+                    response.end('503 Service temporarily unavailable');
+                    return;
+                }
+                if (request.url === '/api/agent/jobs/images/generate') {
+                    response.writeHead(400, { 'content-type': 'application/json' });
+                    response.end(
+                        JSON.stringify({
+                            error: {
+                                code: 'idempotency_key_required',
+                                message: 'missing key',
+                                retryable: false
+                            }
+                        })
+                    );
+                    return;
+                }
+                response.writeHead(404, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({ error: 'missing' }));
+            },
+            async (baseUrl) => {
+                const result = await runNodeCommandAsync(
+                    ['scripts/agent-doctor.mjs', '--base-url', baseUrl, '--allow-billable'],
+                    { timeoutMs: 15_000 }
+                );
+
+                assert.equal(result.ok, false);
+                const body = parseJsonPayload(result.stdout, 'agent doctor');
+                assert.equal(body.ok, false);
+                assert.equal(body.summary.billable_smoke, 'failed');
+                assert.equal(body.summary.page_sse_real_smoke, 'failed');
+                assert.equal(body.summary.responses_page_sse_generate_smoke, 'failed');
+                assert.equal(body.summary.real_smoke_checks.agent_generate_1k, 'passed');
+                assert.equal(body.summary.real_smoke_checks.responses_page_sse_generate_1k, 'failed');
+                assert.equal(body.summary.real_smoke_checks.page_sse_edit_2k, 'skipped');
+                assert.match(
+                    body.layers
+                        .find((layer) => layer.name === 'billable_smoke')
+                        .checks.find((check) => check.name === 'responses_page_sse_generate_1k').output,
+                    /503 Service temporarily unavailable/
+                );
+            }
+        );
+    });
+
     it('prints localized agent:doctor help and option errors', async () => {
         const help = await runNodeCommandAsync(['scripts/agent-doctor.mjs', '--help'], {
             env: process.env,

scripts/deploy-hf-space.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
@@ -13,6 +13,8 @@ const STATUS_POLL_ATTEMPTS = 40;
 const STATUS_POLL_INTERVAL_MS = 10_000;
 const PUBLIC_ENDPOINT_TIMEOUT_MS = 10_000;
 const HF_CLI_TIMEOUT_MS = 120_000;
+const DEPLOY_MARKER_REPO_PATH = 'public/hf-space-deploy-marker.json';
+const DEPLOY_MARKER_PUBLIC_PATH = '/hf-space-deploy-marker.json';
 export const GIT_ARCHIVE_MAX_BUFFER_BYTES = 256 * 1024 * 1024;
 
 function parseArgs(argv) {
@@ -138,8 +140,30 @@ export function findRemoteDeletePaths(localFiles, remoteFiles) {
     return [...remoteFiles].filter((filename) => !localFiles.has(filename)).sort();
 }
 
+export function buildDeployMarker(localSha, createdAt = new Date()) {
+    if (!/^[0-9a-f]{40}$/.test(String(localSha || ''))) throw new Error('localSha must be a full git commit SHA.');
+    return {
+        schema_version: 1,
+        local_sha: localSha,
+        created_at: createdAt.toISOString()
+    };
+}
+
+function writeDeployMarker(sourceDir, marker) {
+    const markerPath = join(sourceDir, DEPLOY_MARKER_REPO_PATH);
+    mkdirSync(join(sourceDir, 'public'), { recursive: true });
+    writeFileSync(markerPath, `${JSON.stringify(marker, null, 2)}\n`, 'utf8');
+}
+
+function readLocalGitFilesWithDeployMarker() {
+    const files = readLocalGitFiles();
+    files.add(DEPLOY_MARKER_REPO_PATH);
+    return files;
+}
+
 function uploadSourceTree(sourceDir, localSha) {
-    const deletePaths = findRemoteDeletePaths(readLocalGitFiles(), readRemoteFilePaths());
+    writeDeployMarker(sourceDir, buildDeployMarker(localSha));
+    const deletePaths = findRemoteDeletePaths(readLocalGitFilesWithDeployMarker(), readRemoteFilePaths());
     const output = runText('hf', buildUploadArgs({ sourceDir, localSha, repoSlug: readRepositorySlug(), deletePaths }));
     return extractUploadCommitSha(output);
 }
@@ -149,7 +173,7 @@ function readSpaceInfo() {
     return parseJsonPayload(output, 'hf spaces info');
 }
 
-async function waitForRunning(spaceCommitSha) {
+async function waitForRunning(spaceCommitSha, localSha) {
     let lastStage = 'unknown';
     let lastSha = 'unknown';
     for (let attempt = 1; attempt <= STATUS_POLL_ATTEMPTS; attempt += 1) {
@@ -162,13 +186,33 @@ async function waitForRunning(spaceCommitSha) {
         }
         await delay(STATUS_POLL_INTERVAL_MS);
     }
-    throw new Error(`Space did not reach RUNNING for ${spaceCommitSha}; last stage=${lastStage} sha=${lastSha}`);
+    const marker = await verifyDeployMarker(localSha);
+    return {
+        stage: lastStage,
+        sha: lastSha,
+        management_status: 'runtime_stage_not_running',
+        service_marker_verified: true,
+        warning: `Space did not reach RUNNING for ${spaceCommitSha}; last stage=${lastStage} sha=${lastSha}`,
+        marker
+    };
 }
 
 async function fetchJson(path) {
     return fetchJsonWithTimeout(new URL(path, HF_SPACE_URL), { timeoutMs: PUBLIC_ENDPOINT_TIMEOUT_MS });
 }
 
+async function verifyDeployMarker(localSha) {
+    const marker = await fetchJson(`${DEPLOY_MARKER_PUBLIC_PATH}?t=${Date.now()}`);
+    if (marker?.schema_version !== 1) throw new Error('deploy marker schema_version was not 1.');
+    if (marker.local_sha !== localSha) {
+        throw new Error(`deploy marker local_sha mismatch: expected ${localSha}, received ${marker.local_sha || 'missing'}.`);
+    }
+    if (typeof marker.created_at !== 'string' || !marker.created_at.trim()) {
+        throw new Error('deploy marker created_at was missing.');
+    }
+    return marker;
+}
+
 async function verifyPublicEndpoints() {
     const authStatus = await fetchJson('/api/auth-status');
     const capabilities = await fetchJson('/api/agent/capabilities');
@@ -199,7 +243,7 @@ async function deploy() {
     const sourceDir = prepareSourceTree();
     try {
         const spaceCommitSha = uploadSourceTree(sourceDir, localSha);
-        const runtime = await waitForRunning(spaceCommitSha);
+        const runtime = await waitForRunning(spaceCommitSha, localSha);
         const verification = await verifyPublicEndpoints();
         console.log(
             JSON.stringify(

scripts/deploy-hf-space.test.mjs

@@ -3,6 +3,7 @@ import { describe, it } from 'node:test';
 
 import {
     GIT_ARCHIVE_MAX_BUFFER_BYTES,
+    buildDeployMarker,
     buildUploadArgs,
     extractUploadCommitSha,
     findRemoteDeletePaths,
@@ -125,4 +126,30 @@ describe('HF Space deploy script', () => {
             ['old.md']
         );
     });
+
+    it('builds a non-secret deploy marker for service-side deployment verification', () => {
+        const marker = buildDeployMarker('3333333333333333333333333333333333333333', new Date('2026-06-20T10:00:00.000Z'));
+
+        assert.deepEqual(marker, {
+            schema_version: 1,
+            local_sha: '3333333333333333333333333333333333333333',
+            created_at: '2026-06-20T10:00:00.000Z'
+        });
+        assert.doesNotMatch(JSON.stringify(marker), /key|token|secret|password/i);
+    });
+
+    it('rejects short deploy marker commit shas before upload', () => {
+        assert.throws(() => buildDeployMarker('3333333'), /full git commit SHA/);
+    });
+
+    it('keeps the generated deploy marker from being deleted on upload', () => {
+        assert.deepEqual(
+            findRemoteDeletePaths(new Set(['README.md', 'public/hf-space-deploy-marker.json']), [
+                'README.md',
+                'public/hf-space-deploy-marker.json',
+                'old.md'
+            ]),
+            ['old.md']
+        );
+    });
 });