unidesk-code-queue-runner
421 lines
14 KiB
JavaScript
421 lines
14 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import test from "node:test";
|
|
|
|
import { classifyCodeAgentStatusSummary } from "./code-agent-status.mjs";
|
|
|
|
const liveRevision = Object.freeze({
|
|
healthLive: {
|
|
ok: true,
|
|
status: 200,
|
|
data: {
|
|
serviceId: "hwlab-cloud-api",
|
|
status: "ok",
|
|
commitId: "7de6edd2c41f54e4265e822d2593fa67057fa41a"
|
|
}
|
|
}
|
|
});
|
|
|
|
test("summarizes long-lived Code Agent as green with current deployment revision only", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
live: liveRevision,
|
|
availability: {
|
|
status: "codex-stdio-feasible",
|
|
ready: true,
|
|
provider: "codex-stdio",
|
|
mode: "codex-stdio",
|
|
backend: "hwlab-cloud-api/codex-stdio",
|
|
capabilityLevel: "long-lived-codex-stdio-session",
|
|
sessionMode: "codex-mcp-stdio-long-lived",
|
|
session: {
|
|
status: "idle",
|
|
lastTraceId: "trc_ready"
|
|
},
|
|
longLivedSessionGate: {
|
|
status: "pass"
|
|
},
|
|
codexStdioFeasibility: {
|
|
canStartLongLivedCodexStdio: true
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "long-lived-session");
|
|
assert.equal(summary.label, "长会话可用");
|
|
assert.equal(summary.tone, "ok");
|
|
assert.equal(summary.codeAgentStatus, "codex-stdio-feasible");
|
|
assert.equal(summary.providerModeBackend, "codex-stdio / codex-stdio / hwlab-cloud-api/codex-stdio");
|
|
assert.equal(summary.capabilityLevel, "long-lived-codex-stdio-session");
|
|
assert.equal(summary.sessionSummary, "codex-mcp-stdio-long-lived / idle");
|
|
assert.equal(summary.readinessBlockers.length, 0);
|
|
assert.equal(summary.lastTraceId, "trc_ready");
|
|
assert.equal(summary.deploymentRevision, "7de6edd2c41f");
|
|
assert.equal(Object.keys(summary.fields).includes("sourceMain"), false);
|
|
});
|
|
|
|
test("does not mark Codex stdio-shaped fields green without runner and gate evidence", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
availability: {
|
|
status: "partial",
|
|
ready: true,
|
|
provider: "openai-responses",
|
|
mode: "openai",
|
|
backend: "hwlab-cloud-api/openai-responses",
|
|
capabilityLevel: "long-lived-codex-stdio-session",
|
|
sessionMode: "codex-mcp-stdio-long-lived",
|
|
runner: {
|
|
kind: "openai-responses-fallback",
|
|
codexStdio: false,
|
|
writeCapable: false
|
|
},
|
|
longLivedSessionGate: {
|
|
status: "blocked",
|
|
pass: false,
|
|
blockers: [{ code: "openai_responses_fallback_not_session" }]
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.notEqual(summary.kind, "long-lived-session");
|
|
assert.notEqual(summary.tone, "ok");
|
|
assert.equal(summary.readinessBlockers.includes("openai_responses_fallback_not_session"), true);
|
|
});
|
|
|
|
test("maps degraded readonly session tools to warning, not green", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
availability: {
|
|
status: "partial",
|
|
ready: false,
|
|
provider: "codex-readonly-runner",
|
|
backend: "hwlab-cloud-api/controlled-readonly-session-registry",
|
|
capabilityLevel: "read-only-session-tools",
|
|
sessionMode: "controlled-readonly-session-registry",
|
|
workspace: "/workspace/hwlab",
|
|
sandbox: "read-only",
|
|
session: {
|
|
sessionId: "ses_readonly",
|
|
status: "idle",
|
|
lastTraceId: "trc_readonly",
|
|
workspace: "/workspace/hwlab",
|
|
sandbox: "read-only",
|
|
runnerKind: "hwlab-readonly-runner",
|
|
sessionMode: "controlled-readonly-session-registry"
|
|
},
|
|
runner: {
|
|
kind: "hwlab-readonly-runner",
|
|
writeCapable: false
|
|
},
|
|
toolCalls: [{ name: "pwd", status: "completed" }],
|
|
skills: { status: "not_requested", count: 0 },
|
|
runnerTrace: {
|
|
traceId: "trc_readonly",
|
|
runnerKind: "hwlab-readonly-runner",
|
|
sessionMode: "controlled-readonly-session-registry",
|
|
turn: 1
|
|
},
|
|
blockers: [
|
|
{ code: "stdio_protocol_not_wired" }
|
|
]
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "read-only-session-tools");
|
|
assert.equal(summary.label, "只读长会话工具");
|
|
assert.equal(summary.tone, "warn");
|
|
assert.equal(summary.sessionId, "ses_readonly");
|
|
assert.equal(summary.sessionIdStatus, "ses_readonly / idle");
|
|
assert.equal(summary.workspace, "/workspace/hwlab");
|
|
assert.equal(summary.sandbox, "read-only");
|
|
assert.equal(summary.runnerKind, "hwlab-readonly-runner");
|
|
assert.equal(summary.toolCalls, "1/1 pwd(completed)");
|
|
assert.equal(summary.skills, "not_requested:count=0");
|
|
assert.match(summary.runnerTrace, /runnerKind=hwlab-readonly-runner/u);
|
|
assert.equal(summary.readinessBlockers.includes("stdio_protocol_not_wired"), true);
|
|
assert.equal(summary.lastTraceId, "trc_readonly");
|
|
});
|
|
|
|
test("summarizes Codex runtimeContract blockers from health availability", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
availability: {
|
|
status: "partial",
|
|
ready: false,
|
|
provider: "codex-readonly-runner",
|
|
backend: "hwlab-cloud-api/codex-readonly-runner",
|
|
capabilityLevel: "read-only-session-tools",
|
|
sessionMode: "controlled-readonly-session-registry",
|
|
runner: {
|
|
kind: "hwlab-readonly-runner",
|
|
writeCapable: false
|
|
},
|
|
runtimeContract: {
|
|
binary: { status: "missing" },
|
|
lifecycleSupervisor: { status: "blocked" },
|
|
stdioProtocol: { status: "blocked" }
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "read-only-session-tools");
|
|
assert.equal(summary.tone, "warn");
|
|
assert.equal(summary.readinessBlockers.includes("codex_cli_binary_missing"), true);
|
|
assert.equal(summary.readinessBlockers.includes("runner_lifecycle_missing"), true);
|
|
assert.equal(summary.readinessBlockers.includes("stdio_protocol_not_wired"), true);
|
|
});
|
|
|
|
test("maps text fallback to warning with safe labels", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
availability: {
|
|
status: "available",
|
|
ready: true,
|
|
provider: "openai-responses",
|
|
mode: "openai",
|
|
backend: "hwlab-cloud-api/openai-responses",
|
|
capabilityLevel: "text-chat-only",
|
|
runner: {
|
|
kind: "openai-responses-fallback"
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "fallback-text-chat-only");
|
|
assert.equal(summary.label, "文本备用通道");
|
|
assert.equal(summary.tone, "warn");
|
|
assert.equal(summary.provider, "openai-responses");
|
|
assert.equal(summary.capabilityLevel, "text-chat-only");
|
|
});
|
|
|
|
test("maps stateless one-shot runner separately from long-lived sessions", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "completed",
|
|
provider: "codex-cli",
|
|
backend: "hwlab-cloud-api/codex-cli",
|
|
capabilityLevel: "text-chat-only",
|
|
sessionMode: "ephemeral-one-shot",
|
|
runner: {
|
|
kind: "codex-cli-one-shot-ephemeral"
|
|
},
|
|
runnerLimitations: ["one-shot", "not-durable-session"],
|
|
traceId: "trc_one_shot"
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "stateless-one-shot");
|
|
assert.equal(summary.label, "一次性执行");
|
|
assert.equal(summary.tone, "warn");
|
|
assert.equal(summary.sessionMode, "ephemeral-one-shot");
|
|
assert.equal(summary.lastTraceId, "trc_one_shot");
|
|
});
|
|
|
|
test("summarizes active Code Agent running request as pending with trace and session context", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
role: "agent",
|
|
status: "running",
|
|
sourceKind: "PENDING",
|
|
traceId: "trc_pending_heavy_skills",
|
|
conversationId: "cnv_pending_heavy_skills",
|
|
sessionId: "cnv_pending_heavy_skills"
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "unverified");
|
|
assert.equal(summary.label, "探测中");
|
|
assert.equal(summary.tone, "pending");
|
|
assert.equal(summary.codeAgentStatus, "running");
|
|
assert.equal(summary.sessionId, "cnv_pending_heavy_skills");
|
|
assert.equal(summary.lastTraceId, "trc_pending_heavy_skills");
|
|
assert.equal(summary.readinessBlockers.length, 0);
|
|
});
|
|
|
|
test("maps HWLAB Skill CLI API control to distinct green state when ready", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "completed",
|
|
provider: "hwlab-skill-cli",
|
|
backend: "hwlab-cloud-api/hwlab-agent-runtime-skill-cli",
|
|
capabilityLevel: "hwlab-api-control-ready",
|
|
sessionMode: "controlled-m3-io-skill-cli",
|
|
session: {
|
|
status: "idle",
|
|
lastTraceId: "trc_skill"
|
|
},
|
|
toolCalls: [
|
|
{
|
|
type: "skill-cli",
|
|
route: "/v1/m3/io",
|
|
status: "completed",
|
|
controlReady: true
|
|
}
|
|
],
|
|
providerTrace: {
|
|
controlReady: true
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "skill-cli-api-control");
|
|
assert.equal(summary.label, "HWLAB Skill CLI 控制");
|
|
assert.equal(summary.tone, "ok");
|
|
assert.equal(summary.provider, "hwlab-skill-cli");
|
|
assert.equal(summary.capabilityLevel, "hwlab-api-control-ready");
|
|
});
|
|
|
|
test("maps blockers to blocked tone and redacts secret-like fields", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
availability: {
|
|
status: "blocked",
|
|
ready: false,
|
|
provider: "openai-responses",
|
|
backend: "Secret hwlab-code-agent-provider should not show",
|
|
capabilityLevel: "blocked",
|
|
reason: "OPENAI_API_KEY_missing",
|
|
error: {
|
|
code: "provider_unavailable",
|
|
providerStatus: 503
|
|
},
|
|
missingEnv: ["OPENAI_API_KEY"],
|
|
traceId: "trc_blocked"
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "blocked");
|
|
assert.equal(summary.label, "服务受阻");
|
|
assert.equal(summary.tone, "blocked");
|
|
assert.equal(summary.backend, "已隐藏");
|
|
assert.equal(summary.readinessBlockers.includes("provider_config_blocked"), true);
|
|
assert.equal(summary.readinessBlockers.includes("provider_unavailable"), true);
|
|
assert.equal(summary.readinessBlockers.includes("provider_http_503"), true);
|
|
assert.equal(summary.lastTraceId, "trc_blocked");
|
|
});
|
|
|
|
test("uses structured readiness current blockers and ignores stale provider blockers", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
live: {
|
|
restIndex: {
|
|
ok: true,
|
|
status: 200,
|
|
data: {
|
|
readiness: {
|
|
codeAgent: {
|
|
status: "blocked",
|
|
ready: false,
|
|
providerReady: true,
|
|
durableDbReady: true,
|
|
sessionRunnerReady: true,
|
|
codexStdioFeasible: false,
|
|
currentBlocker: "codex_stdio_supervisor_disabled",
|
|
currentBlockers: ["codex_stdio_supervisor_disabled"],
|
|
provider: {
|
|
status: "ready",
|
|
ready: true,
|
|
provider: "openai-responses",
|
|
backend: "hwlab-cloud-api/openai-responses",
|
|
mode: "openai",
|
|
blocker: null
|
|
},
|
|
dbDurable: {
|
|
status: "ready",
|
|
ready: true,
|
|
adapter: "postgres",
|
|
blocker: null,
|
|
queryResult: "durable_readiness_ready"
|
|
},
|
|
sessionRunner: {
|
|
status: "read_only_long_lived_ready",
|
|
ready: true,
|
|
kind: "hwlab-readonly-runner",
|
|
mode: "controlled-readonly-session-registry",
|
|
capabilityLevel: "read-only-session-tools",
|
|
longLivedSession: true,
|
|
durableSession: false,
|
|
codexStdio: false,
|
|
writeCapable: false,
|
|
blocker: null
|
|
},
|
|
codexStdio: {
|
|
status: "blocked",
|
|
ready: false,
|
|
feasible: false,
|
|
blocker: "codex_stdio_supervisor_disabled",
|
|
blockerCodes: ["codex_stdio_supervisor_disabled"]
|
|
}
|
|
}
|
|
},
|
|
codeAgent: {
|
|
status: "partial",
|
|
ready: false,
|
|
provider: "openai-responses",
|
|
backend: "hwlab-cloud-api/openai-responses",
|
|
capabilityLevel: "read-only-session-tools",
|
|
blockerCodes: [
|
|
"provider_unavailable",
|
|
"runtime_durable_adapter_auth_blocked"
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "read-only-session-tools");
|
|
assert.equal(summary.tone, "warn");
|
|
assert.equal(summary.provider, "openai-responses");
|
|
assert.equal(summary.capabilityLevel, "read-only-session-tools");
|
|
assert.deepEqual(summary.readinessBlockers, ["codex_stdio_supervisor_disabled"]);
|
|
assert.equal(summary.readinessBlockers.includes("provider_unavailable"), false);
|
|
assert.equal(summary.readinessBlockers.includes("runtime_durable_adapter_auth_blocked"), false);
|
|
});
|
|
|
|
test("structured readiness without codeAgent payload degrades into blocked status", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
live: {
|
|
healthLive: {
|
|
ok: true,
|
|
status: 200,
|
|
data: {
|
|
readiness: {
|
|
codeAgent: {
|
|
status: "blocked",
|
|
ready: false,
|
|
providerReady: false,
|
|
durableDbReady: true,
|
|
sessionRunnerReady: false,
|
|
codexStdioFeasible: false,
|
|
currentBlocker: "provider_config_blocked",
|
|
currentBlockers: ["provider_config_blocked"],
|
|
provider: {
|
|
status: "blocked",
|
|
ready: false,
|
|
provider: "openai-responses",
|
|
backend: "hwlab-cloud-api/openai-responses",
|
|
mode: "openai",
|
|
blocker: "provider_config_blocked"
|
|
},
|
|
sessionRunner: {
|
|
status: "blocked",
|
|
ready: false,
|
|
kind: "unknown",
|
|
mode: "unknown",
|
|
capabilityLevel: "blocked",
|
|
blocker: "session_runner_blocked"
|
|
},
|
|
codexStdio: {
|
|
status: "blocked",
|
|
ready: false,
|
|
blocker: "codex_stdio_supervisor_disabled",
|
|
blockerCodes: ["codex_stdio_supervisor_disabled"]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "blocked");
|
|
assert.equal(summary.label, "服务受阻");
|
|
assert.equal(summary.tone, "blocked");
|
|
assert.equal(summary.readinessBlockers.includes("provider_config_blocked"), true);
|
|
assert.equal(summary.provider, "openai-responses");
|
|
});
|