wishforge-ide/scripts/cluster-poc.test.mjs
eust-w 13ceca5c8f
Some checks failed
CI / Format, types and tests (pull_request) Has been cancelled
CI / PostgreSQL migrations and integration tests (pull_request) Has been cancelled
🔀 Merge review/overhaul into feat/wiki-copilot-diagnostics
Brings the branch up to the current base (executor settings, project
skills, Chinese run messages, cloud IDE removal, wish attachments) and
resolves the ten conflicted files, keeping both sides:

- wish-refiner: the tenant's executor settings pick the models first,
  then the Copilot model setting; the tenant credential still goes
  before the operator's login
- worker providers: executor settings apply, and a run with its own
  credential still gets an empty home
- main.ts: Copilot screenshot uploads and wish attachments each keep
  their own body limit
- contracts, http, web types: default budget and skill auto-activation,
  Copilot and attachment entity kinds, ./text and ./attachments exports
- globals.css: Copilot styles and attachment styles, one after the other
- tests: the canceled-release reason is Chinese; the refiner's default
  models have no [1m] suffix, as this branch names them

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 00:39:05 +08:00

394 lines
18 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { parseAllDocuments } from 'yaml';
import {
buildFiles,
CARRIED,
clusterCaddyfile,
clusterHttpCaddyfile,
publicService,
clusterEnvironments,
clusterKubeconfig,
publicIPv4,
envFile,
fanyuKubeconfig,
fanyuProfile,
imageBuildPod,
renderPlatform,
} from './cluster-poc.mjs';
import { bindingsOf, clusterCheckCommands, endpoint, parseEnvFile, privateCopy } from './cluster-poc-entry.mjs';
const IMAGE = `ccr-29eug8s3-vpc.cnc.bj.baidubce.com/dataflow-poc/wishforge-cluster-poc@sha256:${'c'.repeat(64)}`;
const local = Object.fromEntries(CARRIED.map(key => [key, `value-of-${key.toLowerCase()}`]));
const runner = {
WF_RUNNER_TOKEN: 'runner-token',
WF_TENANT_ID: 'demo',
WF_ENVIRONMENT_ID: '6fabde42-b8e0-4398-80bb-be6ef78e5436',
WF_RUNNER_PUBLIC_KEYS: 'key',
WF_RUNNER_EXECUTE: 'true',
};
const generated = {
postgresPassword: 'p@ss/word',
appPassword: 'app-password-123456',
objectStorageUser: 'wishforge-user',
objectStoragePassword: 'object-storage-password',
};
test('the build sends only what Git tracks, never local agent settings or private state', () => {
const listing = [
'package.json',
'.claude/settings.local.json',
'.wishforge/local-access.json',
'.env.local',
'apps/web/.env.production',
'scripts/dev.mjs',
].join('\0');
assert.deepEqual(buildFiles(`${listing}\0`), ['package.json', 'scripts/dev.mjs']);
});
test('each container gets its own settings: no Mac path, and the executor no database or storage secret', () => {
const env = clusterEnvironments({ local, runner, image: IMAGE, generated, origins: ['https://120.48.1.2'] });
for (const values of Object.values(env))
assert.ok(!Object.values(values).some(value => value.includes('/Users/')), 'no Mac paths');
assert.equal(env.platform.DATABASE_ADMIN_URL, 'postgresql://wishforge:p%40ss%2Fword@127.0.0.1:5432/wishforge');
assert.equal(
env.platform.WF_LOCAL_ALLOWED_ORIGINS,
'http://127.0.0.1:3000,http://localhost:3000,http://127.0.0.1:13000,https://120.48.1.2',
);
assert.equal(env.platform.WF_VAULT_KEY, local.WF_VAULT_KEY);
for (const key of [
'DATABASE_URL',
'DATABASE_ADMIN_URL',
'S3_SECRET_ACCESS_KEY',
'WF_DEV_AUTH_TOKEN',
'WF_LOCAL_API_TOKEN',
'WF_VAULT_KEY',
])
assert.equal(env.executor[key], undefined, `executor has no ${key}`);
assert.equal(env.executor.WF_HOST_CHECK_POD_IMAGE, IMAGE);
assert.deepEqual(Object.keys(env.runner).sort(), [
'WF_CONTROL_PLANE_URL',
'WF_DEPLOYMENT_MODE',
'WF_ENVIRONMENT_ID',
'WF_POC_PROFILE_FILE',
'WF_RUNNER_ALLOW_LOCAL_HTTP',
'WF_RUNNER_EXECUTE',
'WF_RUNNER_PUBLIC_KEYS',
'WF_RUNNER_STATE_DIR',
'WF_RUNNER_TOKEN',
'WF_TENANT_ID',
]);
assert.equal(env.runner.WF_RUNNER_PUBLIC_KEYS, '/etc/wishforge/config/runner-public.json');
assert.throws(() => clusterEnvironments({ local: {}, runner, image: IMAGE, generated }), /Missing settings/);
assert.throws(() => clusterEnvironments({ local, runner, image: IMAGE, generated, origins: ['http://x'] }), /origin/);
});
test('the console receives the control plane credential under the name its launcher allows', () => {
const env = clusterEnvironments({
local: { ...local, WF_LOCAL_API_TOKEN: 'stale-mac-console-token' },
runner,
image: IMAGE,
generated,
});
assert.equal(env.platform.WF_LOCAL_API_TOKEN, env.platform.WF_DEV_AUTH_TOKEN);
assert.equal(env.platform.WF_WEB_SERVE_MODE, 'production');
assert.equal(env.executor.WF_LOCAL_API_TOKEN, undefined);
assert.equal(env.runner.WF_LOCAL_API_TOKEN, undefined);
});
test('settings files hold one value per line and read back the same', () => {
const text = envFile({ A: 'plain', B: 'with space #', C: 'postgresql://u:p%40@127.0.0.1:5432/db' });
assert.deepEqual(parseEnvFile(text), { A: 'plain', B: 'with space #', C: 'postgresql://u:p%40@127.0.0.1:5432/db' });
assert.throws(() => envFile({ A: 'two\nlines' }), /single-line/);
assert.throws(() => envFile({ A: "it's" }), /single-line/);
});
test('the public entry takes a public IPv4 only, never a URL, private or documentation address', () => {
assert.equal(publicIPv4('120.48.164.20'), '120.48.164.20');
for (const value of [
'https://8.8.8.8',
'localhost',
'127.0.0.1',
'10.0.0.1',
'192.168.1.2',
'172.16.2.1',
'100.64.1.2',
'169.254.169.254',
'203.0.113.1',
'198.51.100.1',
'224.0.0.1',
'8.8.8.8\n',
])
assert.throws(() => publicIPv4(value), value);
});
test('the public entry serves a Let’s Encrypt IP certificate and redirects to the standard HTTPS port', () => {
const caddy = clusterCaddyfile('120.48.1.2');
assert.match(caddy, /https_port 8443/);
assert.match(caddy, /redir @safe https:\/\/\{host\}\{uri\} 308/);
assert.match(caddy, /^https:\/\/120\.48\.1\.2:8443 \{$/m);
assert.match(caddy, /profile shortlived/);
assert.match(caddy, /disable_tlsalpn_challenge/);
assert.match(caddy, /acme-v02\.api\.letsencrypt\.org/);
assert.match(clusterCaddyfile('120.48.1.2', { staging: true }), /acme-staging-v02/);
assert.throws(() => clusterCaddyfile('192.168.1.2'));
});
test('a plain-HTTP entry serves only port 80, proxies the console and asks for no certificate', async () => {
const caddy = clusterHttpCaddyfile('120.48.1.2');
assert.match(caddy, /^http:\/\/120\.48\.1\.2:8080 \{$/m);
assert.match(caddy, /reverse_proxy 127\.0\.0\.1:3000/);
assert.match(caddy, /header_up X-Forwarded-Proto http$/m);
assert.match(caddy, /auto_https off/);
assert.doesNotMatch(caddy, /8443|tls|acme|https:\/\//);
assert.throws(() => clusterHttpCaddyfile('192.168.1.2'));
const template = await readFile(new URL('../infra/k8s/cluster-poc/public-service.yaml', import.meta.url), 'utf8');
const ports = text =>
parseAllDocuments(text)
.map(document => document.toJS())[0]
.spec.ports.map(port => port.port);
assert.deepEqual(ports(publicService(template)), [80, 443]);
assert.deepEqual(ports(publicService(template, { http: true })), [80]);
const env = clusterEnvironments({ local, runner, image: IMAGE, generated, origins: ['http://120.48.1.2'] });
assert.equal(env.platform.WF_PUBLIC_URL, 'http://120.48.1.2');
assert.ok(env.platform.WF_LOCAL_ALLOWED_ORIGINS.split(',').includes('http://120.48.1.2'));
});
test('the WishForge Pod is restricted everywhere and only Caddy listens beyond loopback', async () => {
const template = await readFile(new URL('../infra/k8s/cluster-poc/platform.yaml', import.meta.url), 'utf8');
const settings = 'a'.repeat(32);
assert.throws(() => renderPlatform(template, { image: 'wishforge:latest', settings }), /pinned/);
assert.throws(() => renderPlatform(template, { image: IMAGE }), /settings digest/);
const rendered = renderPlatform(template, { image: IMAGE, runnerDisabled: true, maintenance: false, settings });
const statefulSet = parseAllDocuments(rendered)
.map(document => document.toJS())
.find(object => object.kind === 'StatefulSet');
const pod = statefulSet.spec.template.spec;
assert.equal(statefulSet.spec.template.metadata.annotations['wishforge.io/settings'], settings);
assert.equal(pod.automountServiceAccountToken, false);
assert.deepEqual(pod.securityContext.seccompProfile, { type: 'RuntimeDefault' });
assert.equal(pod.securityContext.runAsNonRoot, true);
assert.ok(!pod.volumes.some(volume => volume.hostPath));
for (const container of [...pod.initContainers, ...pod.containers]) {
assert.equal(container.securityContext.allowPrivilegeEscalation, false, container.name);
assert.equal(container.securityContext.readOnlyRootFilesystem, true, container.name);
assert.deepEqual(container.securityContext.capabilities, { drop: ['ALL'] }, container.name);
}
const mounts = name =>
pod.containers.find(container => container.name === name).volumeMounts.map(mount => mount.name);
assert.deepEqual(
pod.containers.filter(container => container.ports).map(container => container.name),
['caddy'],
);
for (const name of ['executor', 'runner']) assert.ok(mounts(name).includes('kube-token'), name);
for (const name of ['postgres', 'temporal', 'minio', 'platform', 'caddy', 'backup', 'runner-fanyu'])
assert.ok(!mounts(name).includes('kube-token'), name);
// Fanyu's cluster credential reaches its builds (executor) and its Runner only.
assert.deepEqual(
pod.containers.filter(container => mounts(container.name).includes('fanyu-kube')).map(container => container.name),
['executor', 'runner-fanyu'],
);
const fanyuRunner = pod.containers.find(container => container.name === 'runner-fanyu');
assert.equal(
fanyuRunner.env.find(item => item.name === 'WF_ROLE_ENV_FILE').value,
'/etc/wishforge/env/runner-fanyu.env',
);
assert.equal(
fanyuRunner.volumeMounts.find(mount => mount.mountPath === '/var/lib/wishforge/runner-state').subPath,
'runner-state-fanyu',
);
for (const name of ['env-runner-fanyu', 'fanyu-kube'])
assert.equal(pod.volumes.find(volume => volume.name === name).secret.optional, true, name);
// The backup reads what it saves and writes only its own directory; no settings, keys or token.
const backup = pod.containers.find(container => container.name === 'backup');
assert.deepEqual(
backup.volumeMounts.filter(mount => mount.name === 'data' && !mount.readOnly).map(mount => mount.subPath),
['backups'],
);
assert.deepEqual(
backup.volumeMounts.filter(mount => mount.readOnly).map(mount => mount.subPath),
['git', 'minio', 'platform-state', 'poc-state', 'runner-state', 'runner-state-fanyu', 'temporal'],
);
assert.deepEqual([...new Set(mounts('backup'))], ['data', 'backup-tmp']);
assert.equal(backup.env.find(item => item.name === 'WF_IMAGE').value, IMAGE);
assert.match(pod.initContainers[0].args[0], / backups; do/);
assert.ok(!mounts('platform').includes('git-key') && mounts('executor').includes('git-key'));
assert.ok(mounts('platform').includes('env-platform') && !mounts('executor').includes('env-platform'));
const runnerEnv = pod.containers.find(container => container.name === 'runner').env;
assert.deepEqual(
runnerEnv.find(item => item.name === 'WF_RUNNER_DISABLED'),
{ name: 'WF_RUNNER_DISABLED', value: 'true' },
);
});
test('image builds run the POC’s Kaniko with only the registry credential and no token', () => {
const pod = imageBuildPod(
{
namespace: 'droboticflow',
registry: 'registry.example/ns',
registrySecret: 'droboticflow-registry',
kanikoImage: `gcr.io/kaniko-project/executor@sha256:${'d'.repeat(64)}`,
registryMirrors: ['mirror.gcr.io'],
},
{ name: 'wishforge-image-x', tag: 't' },
);
assert.equal(pod.spec.automountServiceAccountToken, false);
assert.deepEqual(
pod.spec.volumes.map(volume => Object.keys(volume).filter(key => key !== 'name')[0]),
['emptyDir', 'secret'],
);
assert.ok(pod.spec.containers[0].args.includes('--destination=registry.example/ns/wishforge-cluster-poc:t'));
assert.ok(pod.spec.containers[0].args.some(arg => arg.startsWith('--build-arg=MINIO_COMMIT=')));
});
test('the container entry reads service addresses and copies mounted files privately in one step', async t => {
assert.deepEqual(endpoint('postgresql://u:p@127.0.0.1:5432/db'), { host: '127.0.0.1', port: 5432 });
assert.deepEqual(endpoint('127.0.0.1:7233'), { host: '127.0.0.1', port: 7233 });
assert.deepEqual(endpoint('http://127.0.0.1:9000'), { host: '127.0.0.1', port: 9000 });
const directory = await mkdtemp(path.join(os.tmpdir(), 'wishforge-entry-'));
t.after(() => rm(directory, { recursive: true, force: true }));
const source = path.join(directory, 'mounted.json');
await writeFile(source, '{"a":1}', { mode: 0o644 });
const target = path.join(directory, 'private/copy.json');
await Promise.all([privateCopy(source, target), privateCopy(source, target)]);
assert.equal(await readFile(target, 'utf8'), '{"a":1}');
assert.equal((await stat(target)).mode & 0o777, 0o600);
});
test('a project migrated from the Mac runs its POC checks with this image’s Node and script', () => {
const node = '/usr/local/bin/node',
script = '/opt/wishforge/scripts/poc-project-check.mjs';
const mac = [
['/opt/homebrew/Cellar/node/26.7.0/bin/node', '/Users/me/wishforge-ide/scripts/poc-project-check.mjs', 'install'],
];
assert.deepEqual(clusterCheckCommands(mac, 'install', node, script), [[node, script, 'install']]);
const here = [[node, script, 'verify']];
assert.equal(clusterCheckCommands(here, 'verify', node, script), here);
for (const commands of [
[['npm', 'test']],
[mac[0], ['npm', 'test']],
[[mac[0][0], mac[0][1], 'verify']],
[[...mac[0], '--fast']],
[],
undefined,
])
assert.equal(clusterCheckCommands(commands, 'install', node, script), commands);
});
test('a domain the operator points at the load balancer becomes the console’s address, beside the IP', async () => {
const { publicDomain } = await import('./cluster-poc.mjs');
assert.equal(publicDomain(' WishForge.Example.cc '), 'wishforge.example.cc');
for (const name of ['x', 'http://wishforge.example.cc', '120.48.1.2', '-bad.example.cc', 'a..b.cc', undefined])
assert.throws(() => publicDomain(name), /domain/);
assert.match(
clusterHttpCaddyfile('120.48.1.2', { domain: 'wishforge.example.cc' }),
/^http:\/\/wishforge\.example\.cc:8080, http:\/\/120\.48\.1\.2:8080 \{$/m,
);
const https = clusterCaddyfile('120.48.1.2', { domain: 'wishforge.example.cc' });
assert.match(https, /^http:\/\/wishforge\.example\.cc:8080, http:\/\/120\.48\.1\.2:8080 \{$/m);
assert.match(https, /^https:\/\/wishforge\.example\.cc:8443, https:\/\/120\.48\.1\.2:8443 \{$/m);
assert.match(https, /default_sni 120\.48\.1\.2/);
const env = clusterEnvironments({
local,
runner,
image: IMAGE,
generated,
origins: ['http://wishforge.example.cc', 'http://120.48.1.2'],
});
assert.equal(env.platform.WF_PUBLIC_URL, 'http://wishforge.example.cc');
assert.deepEqual(env.platform.WF_LOCAL_ALLOWED_ORIGINS.split(',').slice(-2), [
'http://wishforge.example.cc',
'http://120.48.1.2',
]);
});
test('the public address is the load balancer’s public IPv4, never its VPC address', async () => {
const { publicAddressOf } = await import('./cluster-poc.mjs');
assert.equal(
publicAddressOf({ status: { loadBalancer: { ingress: [{ ip: '192.168.0.74' }, { ip: '120.48.164.20' }] } } }),
'120.48.164.20',
);
assert.equal(publicAddressOf({ status: { loadBalancer: {} } }), undefined);
assert.equal(publicAddressOf({ status: { loadBalancer: { ingress: [{ ip: '192.168.0.74' }] } } }), undefined);
});
test('a container in maintenance stays up until Kubernetes stops it', async () => {
const { spawn } = await import('node:child_process');
const child = spawn(process.execPath, [new URL('./cluster-poc-entry.mjs', import.meta.url).pathname, 'platform'], {
env: { PATH: process.env.PATH, WF_MAINTENANCE: 'true' },
stdio: 'ignore',
});
const exited = new Promise(resolve => child.once('exit', (code, signal) => resolve({ code, signal })));
await new Promise(resolve => setTimeout(resolve, 1500));
assert.equal(child.exitCode, null, 'still running');
child.kill('SIGTERM');
assert.deepEqual(await exited, { code: 0, signal: null });
});
test('the Claude CLI reaches the gateway by its Anthropic address with the requested models', async () => {
const { claudeSettings } = await import('./cluster-poc.mjs');
const pending = claudeSettings();
assert.equal(pending.env.ANTHROPIC_BASE_URL, 'https://ai-api.d-robotics.cc');
assert.equal(pending.env.ANTHROPIC_API_KEY, undefined);
assert.equal(pending.env.ANTHROPIC_MODEL, 'deepseek-pro@latest');
assert.equal(pending.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, 'deepseek-flash@latest');
assert.equal(pending.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC, '1');
assert.equal(claudeSettings('sk-fixture').env.ANTHROPIC_API_KEY, 'sk-fixture');
});
test('Fanyu’s Runner gets its own settings, keys, state and profile beside the POC’s', () => {
const env = clusterEnvironments({
local,
runner,
runnerFanyu: {
...runner,
WF_RUNNER_TOKEN: 'fanyu-token',
WF_ENVIRONMENT_ID: '9fabde42-b8e0-4398-80bb-be6ef78e5436',
},
image: IMAGE,
generated,
});
assert.equal(env.runner.WF_POC_PROFILE_FILE, '/var/lib/wishforge/poc-state/poc-profile.json');
assert.equal(env.runnerFanyu.WF_POC_PROFILE_FILE, '/var/lib/wishforge/poc-state/fanyu-profile.json');
assert.equal(env.runnerFanyu.WF_RUNNER_PUBLIC_KEYS, '/etc/wishforge/config/runner-fanyu-public.json');
assert.equal(env.runnerFanyu.WF_RUNNER_TOKEN, 'fanyu-token');
assert.equal(env.runnerFanyu.WF_RUNNER_STATE_DIR, env.runner.WF_RUNNER_STATE_DIR);
assert.equal(clusterEnvironments({ local, runner, image: IMAGE, generated }).runnerFanyu, undefined);
assert.throws(
() => clusterEnvironments({ local, runner, runnerFanyu: {}, image: IMAGE, generated }),
/Fanyu's Runner WF_RUNNER_TOKEN/,
);
});
test('WishForge reaches Fanyu’s cluster with its own token only, through a profile pinned to Fanyu', () => {
const kubeconfig = JSON.parse(fanyuKubeconfig({ certificateAuthorityData: 'Q0E=', token: 'eyJ.abc-def_1' }));
assert.equal(kubeconfig.clusters[0].cluster.server, 'https://180.76.138.88:6443');
assert.deepEqual(kubeconfig.users, [{ name: 'wishforge', user: { token: 'eyJ.abc-def_1' } }]);
assert.equal(kubeconfig.contexts[0].context.namespace, 'droboticflow-fanyu');
assert.throws(() => fanyuKubeconfig({ certificateAuthorityData: 'Q0E=', token: 'a b' }), /token/);
const profile = fanyuProfile({
poc: {
repository: 'git@gitea.d-robotics.cc:longtao.wu/droboticflow.git',
kanikoImage: 'k@sha256:1',
registryMirrors: ['mirror.gcr.io'],
},
namespaceUid: 'n',
deployments: { api: 'a' },
});
assert.equal(profile.branch, 'dev');
assert.equal(profile.kubeconfig, '/etc/wishforge/fanyu/kubeconfig');
assert.equal(profile.registry, 'ccr-29eug8s3-pub.cnc.bj.baidubce.com/fanyu');
assert.equal(profile.applicationUrl, 'http://120.48.180.80');
});
test('the containers read one binding or a list of them', () => {
assert.deepEqual(bindingsOf('{"projectId":"a"}'), [{ projectId: 'a' }]);
assert.deepEqual(
bindingsOf('[{"projectId":"a"},{"projectId":"b"}]').map(binding => binding.projectId),
['a', 'b'],
);
});