Deploy ce29b5c to Docker Space

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

public/hf-space-deploy-marker.json

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

scripts/agent-skill-scripts.test.mjs

@@ -3234,6 +3234,8 @@ describe('Agent skill script argument validation', () => {
         assert.match(skillText, /\.env\.agent\.local\.example/);
         assert.match(skillText, /page_sse_real_smoke_status/);
         assert.match(skillText, /responses_image_backend_real_smoke_status/);
+        assert.match(skillText, /summary\.page_sse_real_smoke/);
+        assert.match(skillText, /兼容聚合状态/);
         assert.match(skillText, /summary\.responses_page_sse_generate_smoke/);
         assert.match(skillText, /summary\.real_smoke_checks/);
         assert.match(apiReference, /npm run first-run/);
@@ -3242,6 +3244,8 @@ describe('Agent skill script argument validation', () => {
         assert.match(apiReference, /\.env\.agent\.local\.example/);
         assert.match(apiReference, /page_sse_real_smoke_status/);
         assert.match(apiReference, /responses_image_backend_real_smoke_status/);
+        assert.match(apiReference, /summary\.page_sse_real_smoke/);
+        assert.match(apiReference, /兼容聚合状态/);
         assert.match(apiReference, /summary\.responses_page_sse_generate_smoke/);
         assert.match(apiReference, /summary\.real_smoke_checks/);
         assert.match(readmeText, /不要手动并行启动多个单张脚本/);

scripts/command-center.test.mjs

@@ -18,6 +18,7 @@ import {
 import { buildFirstRunReport, formatFirstRunText } from './first-run.mjs';
 import {
     buildAdminCommands,
+    buildImageUpstreamLocalEndpointStatus,
     buildImageUpstreamRealSmokeStatus,
     parseGitStatusEntries,
     readStatusEnvFromFiles,
@@ -221,6 +222,83 @@ describe('Command center scripts', () => {
         assert.doesNotMatch(JSON.stringify(status), /user:pass|original\.example|token=secret|original-secret/);
     });
 
+    it('checks local real smoke endpoints without exposing URL paths or credentials', async () => {
+        const status = await buildImageUpstreamLocalEndpointStatus(
+            {
+                IMAGE_REAL_SMOKE_ORIGINAL_BASE_URL: 'http://127.0.0.1:3010/v1?ignored=no',
+                IMAGE_REAL_SMOKE_ORIGINAL_API_KEY: 'original-secret',
+                IMAGE_REAL_SMOKE_GAOREN_BASE_URL: 'http://localhost:3001/v1',
+                IMAGE_REAL_SMOKE_GAOREN_API_KEY: 'gaoren-secret',
+                IMAGE_REAL_SMOKE_SUB2API_BASE_URL: 'https://sub2api.example/v1',
+                IMAGE_REAL_SMOKE_SUB2API_API_KEY: 'sub2api-secret'
+            },
+            {
+                probe: async (endpoint) => ({
+                    ok: endpoint.port === 3001,
+                    reason: endpoint.port === 3001 ? undefined : 'connection_refused'
+                })
+            }
+        );
+
+        assert.deepEqual(status, {
+            checked_count: 1,
+            unavailable_count: 0,
+            unavailable_cases: [],
+            results: [
+                {
+                    id: 'gaoren-images-sse',
+                    endpoint: 'localhost:3001',
+                    ok: true
+                }
+            ]
+        });
+        assert.doesNotMatch(JSON.stringify(status), /secret|\/v1|sub2api\.example|ignored=no/);
+    });
+
+    it('reports unavailable local real smoke endpoints by case id', async () => {
+        const status = await buildImageUpstreamLocalEndpointStatus(
+            {
+                IMAGE_REAL_SMOKE_SUB2API_BASE_URL: 'http://127.0.0.1:3021/v1',
+                IMAGE_REAL_SMOKE_SUB2API_API_KEY: 'sub2api-secret',
+                IMAGE_REAL_SMOKE_MATSCA_BASE_URL: 'http://[::1]:3090/v1',
+                IMAGE_REAL_SMOKE_MATSCA_API_KEY: 'matsca-secret'
+            },
+            {
+                probe: async (endpoint) => ({
+                    ok: false,
+                    reason: endpoint.port === 3021 ? 'connection_refused' : 'timeout'
+                })
+            }
+        );
+
+        assert.deepEqual(status, {
+            checked_count: 3,
+            unavailable_count: 3,
+            unavailable_cases: ['sub2api-images-sse', 'sub2api-responses-json', 'matsca-images-sse'],
+            results: [
+                {
+                    id: 'sub2api-images-sse',
+                    endpoint: '127.0.0.1:3021',
+                    ok: false,
+                    reason: 'connection_refused'
+                },
+                {
+                    id: 'sub2api-responses-json',
+                    endpoint: '127.0.0.1:3021',
+                    ok: false,
+                    reason: 'connection_refused'
+                },
+                {
+                    id: 'matsca-images-sse',
+                    endpoint: '::1:3090',
+                    ok: false,
+                    reason: 'timeout'
+                }
+            ]
+        });
+        assert.doesNotMatch(JSON.stringify(status), /secret|\/v1/);
+    });
+
     it('loads independent image upstream smoke readiness from env files without overriding shell env', async () => {
         const tempDir = await mkdtemp(path.join(os.tmpdir(), 'image-upstream-status-'));
         const localEnvPath = path.join(tempDir, '.env.local');
@@ -962,12 +1040,13 @@ describe('Command center scripts', () => {
                 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/
-                );
+                const pageSseOutput = body.layers
+                    .find((layer) => layer.name === 'billable_smoke')
+                    .checks.find((check) => check.name === 'responses_page_sse_generate_1k').output;
+                const pageSseFailure = parseJsonPayload(pageSseOutput, 'responses page SSE doctor smoke');
+                assert.equal(pageSseFailure.summary.selected_channel_id, null);
+                assert.equal(pageSseFailure.summary.upstream_host, null);
+                assert.match(pageSseOutput, /503 Service temporarily unavailable/);
             }
         );
     });

scripts/status.mjs

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 
 import { existsSync, readFileSync } from 'node:fs';
+import net from 'node:net';
 
 import { HF_SPACE_ID, HF_SPACE_URL } from './hf-space-doctor-utils.mjs';
 import { isMainModule, parseJsonPayload, printJson, runCommand, runCommandStrict } from './command-center-utils.mjs';
 
 const REMOTE_STATUS_TIMEOUT_MS = 30_000;
+const LOCAL_ENDPOINT_TIMEOUT_MS = 500;
 const IMAGE_UPSTREAM_REAL_SMOKE_CASES = [
     { id: 'original-images-json', prefix: 'IMAGE_REAL_SMOKE_ORIGINAL' },
     { id: 'gaoren-images-sse', prefix: 'IMAGE_REAL_SMOKE_GAOREN' },
@@ -127,6 +129,7 @@ function readTargetConfigured(testCase, env) {
     const baseUrlError = baseUrl ? readBaseUrlValidationError(baseUrl.value) : undefined;
     return {
         baseUrl: Boolean(baseUrl),
+        baseUrlValue: baseUrl?.value,
         apiKey: Boolean(apiKey),
         responsesModel: Boolean(responsesModel),
         invalidEnv: baseUrlError ? [{ key: baseUrl.key, reason: baseUrlError }] : []
@@ -175,6 +178,90 @@ export function buildImageUpstreamRealSmokeStatus(env = process.env) {
     };
 }
 
+function normalizeLocalHostname(hostname) {
+    return hostname.toLowerCase().replace(/^\[|\]$/g, '');
+}
+
+function isLocalHostname(hostname) {
+    const normalized = normalizeLocalHostname(hostname);
+    return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
+}
+
+function readUrlPort(url) {
+    if (url.port) return Number(url.port);
+    if (url.protocol === 'http:') return 80;
+    if (url.protocol === 'https:') return 443;
+    return undefined;
+}
+
+function readLocalEndpoint(testCase, env) {
+    const target = readTargetConfigured(testCase, env);
+    if (!target.baseUrlValue || target.invalidEnv.length > 0) return undefined;
+    const url = new URL(target.baseUrlValue);
+    if (!isLocalHostname(url.hostname)) return undefined;
+    const port = readUrlPort(url);
+    if (!port) return undefined;
+    return {
+        id: testCase.id,
+        host: normalizeLocalHostname(url.hostname),
+        port
+    };
+}
+
+function readLocalEndpointTargets(env) {
+    return IMAGE_UPSTREAM_REAL_SMOKE_CASES.map((testCase) => readLocalEndpoint(testCase, env)).filter(Boolean);
+}
+
+function formatEndpoint(endpoint) {
+    return `${endpoint.host}:${endpoint.port}`;
+}
+
+function readSocketFailureReason(error) {
+    if (error?.code === 'ECONNREFUSED') return 'connection_refused';
+    if (error?.code === 'ETIMEDOUT') return 'timeout';
+    if (error?.code === 'EHOSTUNREACH') return 'host_unreachable';
+    if (error?.code === 'ENETUNREACH') return 'network_unreachable';
+    return 'connection_failed';
+}
+
+function probeTcpEndpoint(endpoint, options = {}) {
+    const timeoutMs = options.timeoutMs || LOCAL_ENDPOINT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host: endpoint.host, port: endpoint.port });
+        let settled = false;
+        const finish = (result) => {
+            if (settled) return;
+            settled = true;
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(timeoutMs, () => finish({ ok: false, reason: 'timeout' }));
+        socket.once('connect', () => finish({ ok: true }));
+        socket.once('error', (error) => finish({ ok: false, reason: readSocketFailureReason(error) }));
+    });
+}
+
+export async function buildImageUpstreamLocalEndpointStatus(env = process.env, options = {}) {
+    const probe = options.probe || probeTcpEndpoint;
+    const results = [];
+    for (const endpoint of readLocalEndpointTargets(env)) {
+        const result = await probe(endpoint, options);
+        results.push({
+            id: endpoint.id,
+            endpoint: formatEndpoint(endpoint),
+            ok: result.ok === true,
+            ...(result.ok === true ? {} : { reason: result.reason || 'connection_failed' })
+        });
+    }
+    const unavailable = results.filter((item) => !item.ok);
+    return {
+        checked_count: results.length,
+        unavailable_count: unavailable.length,
+        unavailable_cases: unavailable.map((item) => item.id),
+        results
+    };
+}
+
 function parseArgs(argv) {
     const unknown = argv.find((arg) => !['--help', '-h', '--remote'].includes(arg));
     if (unknown) throw new Error(`Unknown option: ${unknown}`);
@@ -194,11 +281,13 @@ Options:
   --help         Show this help.`);
 }
 
-function buildLocalStatus() {
+async function buildLocalStatus() {
     const packageJson = JSON.parse(readFileSync('package.json', 'utf8'));
     const branch = runCommandStrict('git', ['branch', '--show-current']).trim();
     const head = runCommandStrict('git', ['rev-parse', '--short', 'HEAD']).trim();
     const changed = parseGitStatusEntries(runCommandStrict('git', ['status', '--porcelain=v1', '-z']));
+    const statusEnv = readStatusEnvFromFiles(process.env);
+    const imageUpstreamRealSmoke = buildImageUpstreamRealSmokeStatus(statusEnv);
     return {
         product: packageJson.name,
         version: packageJson.version,
@@ -216,7 +305,10 @@ function buildLocalStatus() {
             capabilities: '/api/agent/capabilities',
             skill: 'skills/gpt-image-playground-agent/SKILL.md'
         },
-        image_upstream_real_smoke: buildImageUpstreamRealSmokeStatus(readStatusEnvFromFiles(process.env))
+        image_upstream_real_smoke: {
+            ...imageUpstreamRealSmoke,
+            local_endpoint_checks: await buildImageUpstreamLocalEndpointStatus(statusEnv)
+        }
     };
 }
 
@@ -244,14 +336,14 @@ function readRemoteStatus() {
     );
 }
 
-function main() {
+async function main() {
     const options = parseArgs(process.argv.slice(2));
     if (options.help) {
         printHelp();
         return;
     }
 
-    const status = buildLocalStatus();
+    const status = await buildLocalStatus();
     printJson({
         ok: true,
         ...status,
@@ -259,9 +351,9 @@ function main() {
     });
 }
 
-try {
-    if (isMainModule(import.meta.url, process.argv[1])) main();
-} catch (error) {
-    printJson({ ok: false, error: error instanceof Error ? error.message : String(error) });
-    process.exit(1);
+if (isMainModule(import.meta.url, process.argv[1])) {
+    main().catch((error) => {
+        printJson({ ok: false, error: error instanceof Error ? error.message : String(error) });
+        process.exit(1);
+    });
 }

skills/gpt-image-playground-agent/SKILL.md

@@ -139,6 +139,7 @@ Authorization: Bearer <token>
 | `summary.page_sse_auth_ready` | `agent:doctor` | 页面 SSE 鉴权是否已满足；为 `false` 时不要运行 `--page-sse` 真实计费请求。 |
 | `page_sse_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 `/api/images` smoke；`state=not_run` 且 `billable=false` 表示它只是只读就绪检查。 |
 | `responses_image_backend_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 Responses image_generation smoke；不要把声明支持当作实测通过。 |
+| `summary.page_sse_real_smoke` | `agent:doctor` | Page SSE 真实 smoke 的兼容聚合状态；任一 Page SSE smoke 失败为 `failed`，任一通过且无失败为 `passed`，全部跳过为 `skipped`；精确判断优先看 `summary.real_smoke_checks`。 |
 | `summary.responses_page_sse_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + page SSE + `responses-sse` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
 | `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `agent_generate_1k`、`responses_page_sse_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
 | `private_agent_env.exists` | `first-run --json` | 本机是否存在 `.env.agent.local` 私有配置；Agent CLI 默认从当前仓库根目录读取该文件。 |

skills/gpt-image-playground-agent/references/api.md

@@ -554,6 +554,7 @@ node "<skill-root>/scripts/diagnose-request.mjs" --base-url https://your-space.h
 | `summary.page_sse_auth_ready` | `agent:doctor` | 页面 SSE 鉴权是否已满足；为 `false` 时不要运行 `--page-sse` 真实计费请求。 |
 | `page_sse_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 `/api/images` smoke；`state=not_run` 且 `billable=false` 表示它只是只读就绪检查。 |
 | `responses_image_backend_real_smoke_status` | `first-run --json` | 结构化说明 `first-run` 未执行真实 Responses image_generation smoke；不要把声明支持当作实测通过。 |
+| `summary.page_sse_real_smoke` | `agent:doctor` | Page SSE 真实 smoke 的兼容聚合状态；任一 Page SSE smoke 失败为 `failed`，任一通过且无失败为 `passed`，全部跳过为 `skipped`；精确判断优先看 `summary.real_smoke_checks`。 |
 | `summary.responses_page_sse_generate_smoke` | `agent:doctor` | `--allow-billable` 时对 `responses-image-generation` + page SSE + `responses-sse` 这条文生图路径的真实 smoke 状态；非计费时为 `skipped`。 |
 | `summary.real_smoke_checks` | `agent:doctor` | 各真实 smoke 的状态汇总，包含 `agent_generate_1k`、`responses_page_sse_generate_1k`、`agent_edit_1k` 和 `page_sse_edit_2k`。 |
 | `private_agent_env.exists` | `first-run --json` | 本机是否存在 `.env.agent.local` 私有配置；Agent CLI 默认从当前仓库根目录读取该文件。 |