lyon
572 lines
19 KiB
JavaScript
572 lines
19 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-app-server-stdio-long-lived",
|
|
implementationType: "repo-owned-codex-app-server-stdio-session",
|
|
session: {
|
|
status: "idle",
|
|
lastTraceId: "trc_ready"
|
|
},
|
|
runner: {
|
|
kind: "codex-app-server-stdio-runner",
|
|
codexStdio: true
|
|
},
|
|
longLivedSessionGate: {
|
|
status: "pass"
|
|
},
|
|
codexStdioFeasibility: {
|
|
canStartLongLivedCodexStdio: true
|
|
},
|
|
providerTrace: {
|
|
protocol: "codex-app-server-jsonrpc-stdio",
|
|
command: "codex app-server --listen stdio://",
|
|
terminalStatus: "completed",
|
|
wireApi: "responses"
|
|
}
|
|
}
|
|
});
|
|
|
|
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-app-server-stdio-long-lived / idle / idle");
|
|
assert.equal(summary.sessionLifecycleStatus, "idle");
|
|
assert.match(summary.sessionLifecycleHint, /新会话已建立/u);
|
|
assert.equal(summary.runnerKind, "codex-app-server-stdio-runner");
|
|
assert.equal(summary.protocol, "codex-app-server-jsonrpc-stdio");
|
|
assert.equal(summary.implementationType, "repo-owned-codex-app-server-stdio-session");
|
|
assert.equal(summary.providerTraceCommand, "codex app-server --listen stdio://");
|
|
assert.equal(summary.providerTraceTerminalStatus, "completed");
|
|
assert.match(summary.runtimePathLabel, /repo-owned Codex app-server stdio/u);
|
|
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("summarizes Codex app-server stdio thread as reusable long-lived session", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "completed",
|
|
provider: "codex-stdio",
|
|
mode: "codex-stdio",
|
|
backend: "hwlab-cloud-api/codex-app-server-stdio",
|
|
capabilityLevel: "long-lived-codex-stdio-session",
|
|
sessionMode: "codex-app-server-stdio-long-lived",
|
|
implementationType: "repo-owned-codex-app-server-stdio-session",
|
|
session: {
|
|
sessionId: "ses_app_server",
|
|
threadId: "thread_app_server",
|
|
status: "idle",
|
|
lastTraceId: "trc_app_server",
|
|
codexStdio: true
|
|
},
|
|
sessionReuse: {
|
|
sessionId: "ses_app_server",
|
|
threadId: "thread_app_server",
|
|
reused: true,
|
|
turn: 2
|
|
},
|
|
runner: {
|
|
kind: "codex-app-server-stdio-runner",
|
|
codexStdio: true,
|
|
writeCapable: true,
|
|
durableSession: true
|
|
},
|
|
longLivedSessionGate: {
|
|
status: "pass"
|
|
},
|
|
providerTrace: {
|
|
protocol: "codex-app-server-jsonrpc-stdio",
|
|
threadId: "thread_app_server",
|
|
terminalStatus: "completed"
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "long-lived-session");
|
|
assert.equal(summary.tone, "ok");
|
|
assert.equal(summary.sessionIdStatus, "ses_app_server / thread_app_server / idle / idle");
|
|
assert.equal(summary.sessionLifecycleLabel, "继续当前会话");
|
|
assert.match(summary.sessionLifecycleHint, /可继续当前会话/u);
|
|
assert.equal(summary.fields.threadId, "thread_app_server");
|
|
});
|
|
|
|
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 / 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");
|
|
assert.equal(summary.sessionLifecycleStatus, "failed");
|
|
assert.match(summary.sessionLifecycleHint, /fallback\/text-only\/read-only/u);
|
|
});
|
|
|
|
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, "busy");
|
|
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.sessionLifecycleStatus, "busy");
|
|
assert.match(summary.sessionLifecycleHint, /会话忙\/请等待/u);
|
|
assert.equal(summary.lastTraceId, "trc_pending_heavy_skills");
|
|
assert.equal(summary.readinessBlockers.length, 0);
|
|
});
|
|
|
|
test("summarizes canceled Code Agent request with preserved retry context", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
role: "agent",
|
|
status: "canceled",
|
|
traceId: "trc_cancel_keep_context",
|
|
conversationId: "cnv_cancel_keep_context",
|
|
sessionId: "ses_cancel_keep_context",
|
|
session: {
|
|
sessionId: "ses_cancel_keep_context",
|
|
status: "canceled"
|
|
},
|
|
runnerTrace: {
|
|
traceId: "trc_cancel_keep_context",
|
|
sessionStatus: "canceled",
|
|
lastEvent: {
|
|
type: "cancel",
|
|
label: "cancel:canceled",
|
|
status: "canceled"
|
|
}
|
|
},
|
|
error: {
|
|
code: "codex_stdio_canceled",
|
|
message: "请求已取消"
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "canceled");
|
|
assert.equal(summary.label, "请求已取消");
|
|
assert.equal(summary.tone, "blocked");
|
|
assert.equal(summary.codeAgentStatus, "canceled");
|
|
assert.equal(summary.sessionId, "ses_cancel_keep_context");
|
|
assert.equal(summary.sessionStatus, "canceled");
|
|
assert.equal(summary.sessionLifecycleStatus, "interrupted");
|
|
assert.match(summary.sessionLifecycleHint, /已中断/u);
|
|
assert.equal(summary.lastTraceId, "trc_cancel_keep_context");
|
|
});
|
|
|
|
test("summarizes timed out Code Agent request with preserved trace context", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
role: "agent",
|
|
status: "timeout",
|
|
traceId: "trc_timeout_keep_context",
|
|
conversationId: "cnv_timeout_keep_context",
|
|
sessionId: "ses_timeout_keep_context",
|
|
session: {
|
|
sessionId: "ses_timeout_keep_context",
|
|
status: "timeout"
|
|
},
|
|
runnerTrace: {
|
|
traceId: "trc_timeout_keep_context",
|
|
sessionStatus: "timeout",
|
|
lastEvent: {
|
|
type: "session",
|
|
label: "session:timeout",
|
|
status: "timeout"
|
|
}
|
|
},
|
|
error: {
|
|
code: "codex_stdio_timeout",
|
|
message: "请求超时"
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.equal(summary.kind, "timeout");
|
|
assert.equal(summary.label, "等待超时");
|
|
assert.equal(summary.tone, "blocked");
|
|
assert.equal(summary.codeAgentStatus, "timeout");
|
|
assert.equal(summary.sessionId, "ses_timeout_keep_context");
|
|
assert.equal(summary.sessionStatus, "timeout");
|
|
assert.equal(summary.sessionLifecycleStatus, "failed");
|
|
assert.equal(summary.lastTraceId, "trc_timeout_keep_context");
|
|
});
|
|
|
|
test("surfaces expired and failed Code Agent session lifecycle hints", () => {
|
|
const expired = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "failed",
|
|
provider: "codex-stdio",
|
|
session: {
|
|
sessionId: "ses_expired_ui",
|
|
status: "expired",
|
|
codexStdio: true
|
|
},
|
|
error: {
|
|
code: "session_expired"
|
|
}
|
|
}
|
|
});
|
|
assert.equal(expired.kind, "session-expired");
|
|
assert.equal(expired.label, "会话已过期");
|
|
assert.equal(expired.sessionLifecycleStatus, "expired");
|
|
assert.match(expired.sessionLifecycleHint, /重新发送建立新的 Code Agent session/u);
|
|
|
|
const failed = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "failed",
|
|
provider: "codex-stdio",
|
|
session: {
|
|
sessionId: "ses_failed_ui",
|
|
status: "failed",
|
|
codexStdio: true
|
|
},
|
|
error: {
|
|
code: "session_failed"
|
|
}
|
|
}
|
|
});
|
|
assert.equal(failed.kind, "session-failed");
|
|
assert.equal(failed.label, "会话失败");
|
|
assert.equal(failed.sessionLifecycleStatus, "failed");
|
|
assert.match(failed.sessionLifecycleHint, /需重新发送建立新会话/u);
|
|
});
|
|
|
|
test("missing Code Agent session evidence is shown as lifecycle degradation", () => {
|
|
const summary = classifyCodeAgentStatusSummary({
|
|
latestMessage: {
|
|
status: "completed",
|
|
provider: "codex-stdio",
|
|
capabilityLevel: "long-lived-codex-stdio-session",
|
|
sessionMode: "codex-app-server-stdio-long-lived",
|
|
implementationType: "repo-owned-codex-app-server-stdio-session",
|
|
runner: {
|
|
kind: "codex-app-server-stdio-runner",
|
|
codexStdio: true,
|
|
writeCapable: true
|
|
},
|
|
blocker: {
|
|
code: "code_agent_session_evidence_missing"
|
|
}
|
|
}
|
|
});
|
|
|
|
assert.notEqual(summary.tone, "ok");
|
|
assert.equal(summary.sessionLifecycleLabel, "会话降级");
|
|
assert.match(summary.sessionLifecycleHint, /会话证据不完整/u);
|
|
});
|
|
|
|
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");
|
|
});
|