@mokuyoaxis/dsh-iris 0.2.7 → 0.3.0-beta.1

package/templates/provider-starter/scripts/environment.mjs

@@ -0,0 +1,122 @@
+// Public CLI/HTTP acceptance. No private Core imports, Task writes or alternate queues.
+import assert from 'node:assert/strict';
+import { mkdtemp, chmod, readFile, writeFile, appendFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { spawn } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { setup } from './setup.mjs';
+import { coreCli, cleanEnvironment, runCli } from './core-cli.mjs';
+import { createFixture } from './fixture.mjs';
+
+export const credentialEnv = 'IRIS_B4_STARTER_FIXTURE_KEY';
+export const syntheticKey = 'synthetic-b4-starter-key';
+export async function createEnvironment({ proxyUrl } = {}) {
+  const work = await mkdtemp(path.join(os.tmpdir(), 'iris-provider-starter-')); await chmod(work, 0o700);
+  // Windows kill(SIGTERM) forces termination; exercise the public CLI's normal
+  // shutdown handler through the same isolated IPC preload used by Core tests.
+  const cooperativeSignals = process.platform === 'win32' || process.env.IRIS_TEST_CLI_SIGNAL_MODE === 'ipc';
+  const signalPreload = path.join(work, 'signal-preload.mjs');
+  if (cooperativeSignals) await writeFile(signalPreload, `process.on('message', message => {
+  if (message === 'iris-test-sigterm' && !process.emit('SIGTERM')) throw new Error('CLI SIGTERM handler is not installed');
+});
+process.channel.unref();
+`, { mode: 0o600 });
+  const fixture = await createFixture();
+  const prepared = await setup({ directory: path.join(work, 'demo'), endpoint: fixture.origin, credentialEnv });
+  let networkConfigPath;
+  if (proxyUrl) {
+    const url = new URL(proxyUrl);
+    assert(url.protocol === 'http:' && url.hostname === '127.0.0.1' && url.port && !url.username && !url.password && !url.search && !url.hash && url.pathname === '/',
+      'acceptance proxy must be an explicit credential-free loopback HTTP URL');
+    networkConfigPath = path.join(work, 'network.json');
+    const command = (...args) => runCli(['network', ...args, '--network-config', networkConfigPath]);
+    let value = await command('routing', 'init');
+    value = await command('nodes', 'add', '--input', JSON.stringify({ expectedRevision: value.revision,
+      node: { id: 'fixture-net', protocol: 'http', host: '127.0.0.1', port: Number(url.port) } }));
+    value = await command('pools', 'add', '--input', JSON.stringify({ expectedRevision: value.revision,
+      pool: { id: 'fixture-pool', mode: 'fixed', candidates: [{ kind: 'node', nodeId: 'fixture-net' }] } }));
+    const routed = path.join(prepared.directory, 'providers-routed.json');
+    await command('catalog', 'create', '--provider-config', prepared.providerConfigPath, '--output', routed);
+    await command('bindings', 'set', '--provider-config', routed, '--input', JSON.stringify({ expectedRevision: value.revision, providerId: 'wan-reference', poolId: 'fixture-pool' }));
+    prepared.providerConfigPath = routed;
+  }
+  const scheduler = path.join(work, 'scheduler.json');
+  const event = (phase, detail = {}) => appendFile(path.join(work, 'events.jsonl'), JSON.stringify({ phase, at: new Date().toISOString(), ...detail }) + '\n', { mode: 0o600 });
+  await writeFile(scheduler, JSON.stringify({ schemaVersion: 1, httpConcurrency: 2, requestsPerSecond: 100, remoteLimit: 4 }), { mode: 0o600 });
+  let child, exited, exit, started, sequence = 0, serviceStderr = () => '';
+  async function start({ present = true, version, key = syntheticKey } = {}) {
+    await event('starting', { present, ...(version ? { version } : {}) });
+    let entry = prepared.entry;
+    if (version) {
+      entry = path.join(work, 'version-' + version + '.mjs');
+      // Wrap this external template, never a private Iris implementation.
+      await writeFile(entry, `import plugin from ${JSON.stringify(pathToFileURL(prepared.entry).href)};\nexport default { ...plugin, manifest: { ...plugin.manifest, version: ${JSON.stringify(version)} } };\n`, { mode: 0o600 });
+    }
+    await writeFile(prepared.configPath, JSON.stringify({ schemaVersion: 0, entries: present ? [entry] : [] }) + '\n', { mode: 0o600 });
+    const tokenFile = path.join(work, 'owner-' + (++sequence)); let stdout = '', stderr = ''; exited = false;
+    serviceStderr = () => stderr;
+    child = spawn(process.execPath, [...(cooperativeSignals ? ['--import', pathToFileURL(signalPreload).href] : []), coreCli, 'web', 'serve', '--data-root', prepared.dataRoot,
+      '--plugin-config', prepared.configPath, '--provider-config', prepared.providerConfigPath, '--allow-execution', '--allow-provider-management',
+      '--connection-store', prepared.connectionStore, '--allow-connection-management', '--allow-mcp',
+      '--scheduler-config', scheduler, '--token-file', tokenFile, ...(networkConfigPath ? ['--network-config', networkConfigPath] : [])], {
+      stdio: ['ignore', 'pipe', 'pipe', ...(cooperativeSignals ? ['ipc'] : [])], env: { ...cleanEnvironment(), [credentialEnv]: key }
+    });
+    child.stdout.on('data', bytes => { stdout += bytes; }); child.stderr.on('data', bytes => { stderr += bytes; });
+    exit = new Promise(resolve => child.once('close', (code, signal) => { exited = true; resolve({ code, signal }); }));
+    const deadline = performance.now() + 15000;
+    while (!stdout.includes('\n') && !exited && performance.now() < deadline) await delay(10);
+    assert(stdout.includes('\n'), 'Core CLI startup failed: ' + stderr);
+    started = { ...JSON.parse(stdout.split('\n')[0]), accessToken: (await readFile(tokenFile, 'utf8')).trim() };
+    await event('started', { pid: child.pid });
+    child.once('close', () => { void writeFile(path.join(work, 'service-' + sequence + '.stderr.log'), stderr, { mode: 0o600 }); });
+    return started;
+  }
+  async function stop() {
+    if (child) await event('stopping', { pid: child.pid });
+    if (child && !exited) {
+      if (cooperativeSignals) child.send('iris-test-sigterm');
+      else child.kill('SIGTERM');
+    }
+    if (child) {
+      const result = await Promise.race([exit, delay(10000, undefined, { ref: false }).then(() => { throw new Error('Core CLI did not close within 10 seconds'); })]);
+      assert.equal(result.code, 143, JSON.stringify({ ...result, stderr: serviceStderr(), work }));
+      await event('stopped', result);
+    }
+    child = undefined;
+  }
+  async function raw(route, { value, key, headers, method = value === undefined ? 'GET' : 'POST' } = {}) {
+    // Each restarted service is a distinct acceptance instance; never reuse its predecessor's idle socket.
+    return fetch(started.origin + route, { method, headers: { Connection: 'close', Authorization: 'Bearer ' + started.accessToken,
+      ...(value === undefined ? {} : { 'Content-Type': 'application/json' }), ...(key ? { 'Idempotency-Key': key } : {}), ...headers },
+      ...(value === undefined ? {} : { body: JSON.stringify(value) }), signal: AbortSignal.timeout(20000) });
+  }
+  async function http(route, options, expected = 200) {
+    const response = await raw(route, options), value = await response.json();
+    assert.equal(response.status, expected, JSON.stringify(value)); assert(!JSON.stringify(value).includes(syntheticKey)); return value;
+  }
+  async function terminal(id) {
+    for (let i = 0; i < 500; i++) {
+      const operation = (await http('/api/v0/operations/' + id)).operation;
+      if (!['queued', 'running'].includes(operation.state)) return operation;
+      await delay(10);
+    }
+    assert.fail('Operation did not finish');
+  }
+  const base = '/api/v0/connection-management/connections';
+  const listConnections = async () => (await http(base)).connections;
+  async function connection(capabilities = ['image-generate']) {
+    const value = await http(base, { value: { key: crypto.randomUUID(), label: 'Provider starter acceptance',
+      scopes: ['read', 'create', 'execute', 'stop'], capabilities } }, 201);
+    return (await listConnections()).find(record => record.connectionId === value.connectionId);
+  }
+  const exported = async record => (await http(base + '/' + record.connectionId + '/export', { value: { transport: 'http', format: 'entry' } })).configuration;
+  async function reduce(record) {
+    const current = (await listConnections()).find(item => item.connectionId === record.connectionId);
+    return http(base + '/' + record.connectionId + '/update', { value: { expectedRevision: current.revision, label: current.label,
+      scopes: ['read'], capabilities: current.capabilities, tools: current.tools, pluginOperations: current.pluginOperations } });
+  }
+  return { work, prepared, fixture, start, stop, raw, http, terminal, connection, exported, reduce,
+    get started() { return started; }, async close() { try { await stop(); } finally { await fixture.close(); } } };
+}

package/templates/provider-starter/scripts/fixture.mjs

@@ -0,0 +1,54 @@
+// Local-only acceptance service. Never a real DashScope gateway.
+import http from 'node:http';
+import { once } from 'node:events';
+import { setTimeout as delay } from 'node:timers/promises';
+
+export const PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=', 'base64');
+export async function createFixture() {
+  const requests = [], errors = [], tasks = new Set(); let ready = false, mode = 'normal', active = 0, peak = 0, origin, cdnOrigin, submitGate, release;
+  const sockets = new Set();
+  const track = server => server.on('connection', socket => { sockets.add(socket); socket.once('close', () => sockets.delete(socket)); });
+  const cdn = http.createServer((req, res) => {
+    requests.push({ method: req.method, path: req.url, authorization: req.headers.authorization, cdn: true });
+    if (req.url === '/redirect') { res.writeHead(302, { Location: cdnOrigin + '/image.png' }); res.end(); }
+    else { res.writeHead(200, { 'Content-Type': 'image/png' }); res.end(PNG); }
+  }); track(cdn); cdn.listen(0, '127.0.0.1'); await once(cdn, 'listening'); cdnOrigin = `http://127.0.0.1:${cdn.address().port}`;
+  async function handle(req, res) {
+    const chunks = []; for await (const chunk of req) chunks.push(chunk);
+    const row = { method: req.method, path: req.url, authorization: req.headers.authorization,
+      async: req.headers['x-dashscope-async'], body: Buffer.concat(chunks).toString('utf8'), cdn: false };
+    requests.push(row); res.setHeader('Content-Type', 'application/json');
+    if (mode === 'redirect') { res.writeHead(302, { Location: cdnOrigin + '/image.png' }); res.end(); return; }
+    if (mode === 'rate-limit') { res.writeHead(429, { 'Retry-After': '2' }); res.end('{"error":"synthetic-private-upstream-detail"}'); return; }
+    if (mode === 'html') { res.end('<html>synthetic-private-upstream-detail</html>'); return; }
+    if (mode === 'large') { res.end('x'.repeat(1024 * 1024 + 1)); return; }
+    const url = new URL(req.url, origin);
+    if (url.pathname === '/api/v1/models') {
+      const page = Number(url.searchParams.get('page_no'));
+      const models = page === 1 ? Array.from({ length: 100 }, (_, i) => ({ model: 'unsupported-fixture-' + i })) : [{ model: 'wan2.6-t2i' }];
+      res.end(JSON.stringify({ output: { total: mode === 'bad-page' && page === 2 ? 102 : 101,
+        page_no: page, page_size: 100, models } })); return;
+    }
+    if (url.pathname === '/api/v1/services/aigc/image-generation/generation' && req.method === 'POST') {
+      active++; peak = Math.max(peak, active); if (submitGate) await submitGate; else await delay(120); active--;
+      if (mode === 'reset') { req.socket.destroy(); return; }
+      if (mode === 'missing-id') { res.end('{"output":{}}'); return; }
+      const id = 'original-remote-' + (tasks.size + 1); tasks.add(id);
+      res.end(JSON.stringify({ output: { task_id: id, task_status: 'PENDING' } })); return;
+    }
+    if (url.pathname.startsWith('/api/v1/tasks/')) {
+      const id = decodeURIComponent(url.pathname.slice('/api/v1/tasks/'.length));
+      if (!tasks.has(id)) { res.writeHead(404).end('{}'); return; }
+      res.end(JSON.stringify({ output: { task_id: id, task_status: ready ? 'SUCCEEDED' : 'RUNNING',
+        ...(ready ? { choices: mode === 'bad-poll' ? {} : [{ message: { content: [{ image: cdnOrigin + '/redirect' }] } }] } : {}) } })); return;
+    }
+    res.writeHead(404).end('{}');
+  }
+  const server = http.createServer((req, res) => { void handle(req, res).catch(error => { errors.push(error.message); res.destroy(); }); });
+  track(server); server.listen(0, '127.0.0.1'); await once(server, 'listening'); origin = `http://127.0.0.1:${server.address().port}`;
+  return { origin, cdnOrigin, requests, errors, tasks, get peak() { return peak; },
+    set mode(value) { mode = value; }, set ready(value) { ready = value; },
+    holdSubmits() { submitGate = new Promise(resolve => { release = resolve; }); },
+    releaseSubmits() { release?.(); submitGate = undefined; },
+    async close() { release?.(); for (const socket of sockets) socket.destroy(); await Promise.all([server, cdn].map(item => new Promise(resolve => item.close(resolve)))); } };
+}

package/templates/provider-starter/scripts/mcp-probe.mjs

@@ -0,0 +1,21 @@
+// Acceptance client only. Harnesses import Core's exported configuration; the server uses its official MCP SDK.
+export async function mcpProbe(configuration) {
+  let sequence = 0;
+  async function request(method, params, notification = false) {
+    const id = notification ? undefined : ++sequence;
+    const response = await fetch(configuration.url, { method: 'POST', headers: {
+      ...configuration.headers, Connection: 'close', 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream',
+      'MCP-Protocol-Version': '2025-11-25'
+    }, body: JSON.stringify({ jsonrpc: '2.0', ...(notification ? {} : { id }), method, params }), signal: AbortSignal.timeout(20_000) });
+    const text = await response.text();
+    if (notification && response.status === 202) return;
+    const messages = response.headers.get('content-type')?.startsWith('text/event-stream')
+      ? text.split('\n').filter(line => line.startsWith('data:')).map(line => JSON.parse(line.slice(5))) : [JSON.parse(text)];
+    const message = messages.find(item => item.id === id) || messages.at(-1);
+    if (!response.ok || message.error) throw new Error(message.error?.message || 'MCP HTTP ' + response.status);
+    return message.result;
+  }
+  await request('initialize', { protocolVersion: '2025-11-25', capabilities: {}, clientInfo: { name: 'iris-provider-starter-test', version: '0.1.0' } });
+  await request('notifications/initialized', {}, true);
+  return { request, call: (name, args) => request('tools/call', { name, arguments: args }) };
+}

package/templates/provider-starter/scripts/protocol-smoke.mjs

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createCorePluginRegistry, ProviderContractError } from '@mokuyoaxis/dsh-iris/plugins';
+import plugin, { PROVIDER_PROTOCOL, SUPPORTED_MODEL } from '../index.mjs';
+import { createFixture, PNG } from './fixture.mjs';
+
+const fixture = await createFixture(), registry = await createCorePluginRegistry({ plugins: [plugin] });
+const work = await mkdtemp(path.join(os.tmpdir(), 'iris-wan-protocol-'));
+const adapter = registry.providers.createAdapter(PROVIDER_PROTOCOL, { id: 'p', baseUrl: fixture.origin, apiKey: 'synthetic-private-upstream-detail' });
+const methods = adapter.operations, request = { capability: 'image', model: SUPPORTED_MODEL, input: { prompt: 'local fixture', n: 1 } };
+async function rejects(action, stage, acceptance, category = 'protocol') {
+  await assert.rejects(action, error => error instanceof ProviderContractError && error.stage === stage && error.acceptance === acceptance && error.category === category
+    && !error.message.includes('synthetic-private-upstream-detail'));
+}
+try {
+  assert.deepEqual((await methods.discover({})).models, [{ id: SUPPORTED_MODEL, capabilities: ['image-gen'] }]);
+  fixture.mode = 'bad-page'; await rejects(() => methods.discover({}), 'validate', 'not_accepted');
+  fixture.mode = 'normal'; const before = fixture.requests.length;
+  await rejects(() => methods.submit({ ...request, model: 'unsupported' }), 'validate', 'not_accepted', 'invalid_request');
+  await rejects(() => methods.submit({ ...request, input: { prompt: 'x', n: 5 } }), 'validate', 'not_accepted', 'invalid_request');
+  assert.equal(fixture.requests.length, before);
+  const accepted = await methods.submit(request), remote = { capability: 'image', remoteTaskId: accepted.remoteTaskId };
+  assert.equal((await methods.poll(remote)).kind, 'pending'); fixture.ready = true;
+  fixture.mode = 'bad-poll'; await rejects(() => methods.poll(remote), 'poll', 'accepted'); fixture.mode = 'normal';
+  const result = await methods.poll(remote), targetPath = path.join(work, 'image.png');
+  assert.equal((await methods.download({ capability: 'image', artifact: result.artifacts[0], targetPath })).bytes, PNG.length);
+  assert.deepEqual(await readFile(targetPath), PNG);
+  assert(fixture.requests.filter(row => row.cdn).every(row => row.authorization === undefined));
+  await assert.rejects(methods.download({ capability: 'image', artifact: result.artifacts[0], targetPath }), { code: 'EEXIST' });
+  for (const mode of ['missing-id', 'html', 'large']) {
+    fixture.mode = mode; await rejects(() => methods.submit(request), 'response', 'unknown');
+  }
+  fixture.mode = 'rate-limit';
+  await assert.rejects(methods.submit(request), error => error.acceptance === 'not_accepted' && error.category === 'rate_limit' && error.retryAfterMs === 2000);
+  fixture.mode = 'redirect'; const cdnBefore = fixture.requests.filter(row => row.cdn).length;
+  await assert.rejects(methods.submit(request), error => {
+    const mapped = methods.mapError(error, { stage: 'submit', acceptance: 'unknown' });
+    return mapped.acceptance === 'unknown' && !mapped.message.includes('synthetic-private-upstream-detail');
+  });
+  assert.equal(fixture.requests.filter(row => row.cdn).length, cdnBefore, 'authenticated API redirects are rejected');
+  fixture.mode = 'normal'; const controller = new AbortController(); controller.abort();
+  await assert.rejects(methods.discover({ signal: controller.signal }), error => methods.mapError(error, { stage: 'validate', acceptance: 'not_accepted' }).category === 'aborted');
+  assert.deepEqual(fixture.errors, []);
+  console.log(JSON.stringify({ ok: true, work, checks: ['complete directory and invalid pagination', 'explicit model/n validation before HTTP', 'accepted original task and pending/succeeded poll',
+    'bounded Core-target delivery, no overwrite and credential-free CDN', 'unknown acceptance on malformed/oversized response', '429 cooldown hint', 'no authenticated redirect or raw error echo', 'caller cancellation'] }, null, 2));
+} finally { await registry.dispose(); await fixture.close(); }

package/templates/provider-starter/scripts/setup.mjs

@@ -0,0 +1,44 @@
+import { mkdir, writeFile, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import plugin, { PROVIDER_PROTOCOL } from '../index.mjs';
+import { coreCli, runCore } from './core-cli.mjs';
+
+export async function setup({ directory, endpoint, credentialEnv }) {
+  if (!path.isAbsolute(directory)) throw new Error('--directory must be an absolute path to a new directory.');
+  if (typeof credentialEnv !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(credentialEnv)) throw new Error('--credential-env must be an environment variable name, never a key value.');
+  const url = new URL(endpoint);
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash
+      || /\/(?:api\/v1|compatible-mode\/v1)\/?$/.test(url.pathname)) throw new Error('--endpoint must be the explicit workspace API root, without credentials, query or /api/v1.');
+  // Resolve the existing parent so a symlink cannot put private data in the distributed project.
+  const projectRoot = await realpath(fileURLToPath(new URL('..', import.meta.url)));
+  const target = path.join(await realpath(path.dirname(directory)), path.basename(directory));
+  const relative = path.relative(projectRoot, target);
+  if (relative === '' || relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative)) throw new Error('Demo data must be outside the plugin project.');
+  // Reject all existing directories, including empty ones; leave partial output for diagnosis on failure.
+  await mkdir(target, { mode: 0o700 });
+  const dataRoot = path.join(target, 'core'), providerConfigPath = path.join(target, 'providers.json'),
+    configPath = path.join(target, 'plugins.json'), connectionStore = path.join(target, 'connections');
+  const entry = fileURLToPath(new URL('../index.mjs', import.meta.url));
+  await writeFile(configPath, JSON.stringify({ schemaVersion: 0, entries: [entry] }, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+  await writeFile(providerConfigPath, JSON.stringify({ providers: [{ id: 'wan-reference', name: 'Wan reference',
+    enabled: true, baseUrl: endpoint.replace(/\/+$/, ''), apiKeyEnv: credentialEnv, mediaProtocol: PROVIDER_PROTOCOL, models: [] }],
+    assignments: { 'image-gen': { mode: 'disabled', models: [] } } }, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+  await runCore(dataRoot, 'flow', 'init');
+  await runCore(dataRoot, 'execution', 'init', '--image-generation');
+  return { directory: target, dataRoot, configPath, providerConfigPath, connectionStore, entry,
+    pluginId: plugin.manifest.id,
+    startArgv: [process.execPath, coreCli, 'web', 'serve', '--data-root', dataRoot, '--plugin-config', configPath,
+      '--provider-config', providerConfigPath, '--allow-provider-management', '--allow-execution',
+      '--connection-store', connectionStore, '--allow-connection-management', '--allow-mcp', '--port', '3182'] };
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) {
+  const args = process.argv.slice(2), allowed = ['--directory', '--endpoint', '--credential-env'];
+  if (args.length !== 6 || allowed.some(name => args.filter(item => item === name).length !== 1)
+      || args.some((value, index) => index % 2 === 0 && !allowed.includes(value))) {
+    throw new Error('Usage: npm run setup -- --directory /absolute/new-private-directory --endpoint https://YOUR-WORKSPACE-API-ROOT --credential-env YOUR_KEY_VARIABLE');
+  }
+  const options = Object.fromEntries(args.reduce((pairs, value, index) => index % 2 ? [...pairs, [args[index - 1].slice(2), value]] : pairs, []));
+  console.log(JSON.stringify(await setup({ directory: options.directory, endpoint: options.endpoint, credentialEnv: options['credential-env'] }), null, 2));
+}

package/templates/provider-starter/scripts/smoke.mjs

@@ -0,0 +1,145 @@
+import assert from 'node:assert/strict';
+import { readFile, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { createEnvironment, credentialEnv, syntheticKey } from './environment.mjs';
+import { setup } from './setup.mjs';
+import { runCore } from './core-cli.mjs';
+import { mcpProbe } from './mcp-probe.mjs';
+import { PNG } from './fixture.mjs';
+
+const args = process.argv.slice(2);
+assert(args.length === 0 || args.length === 2 && args[0] === '--proxy-url', 'Usage: node scripts/smoke.mjs [--proxy-url http://127.0.0.1:PORT]');
+const env = await createEnvironment({ proxyUrl: args[1] }), checks = [];
+const parsed = result => { assert(!result.isError, JSON.stringify(result)); return result.structuredContent ?? JSON.parse(result.content.find(item => item.type === 'text').text); };
+const postCount = () => env.fixture.requests.filter(item => item.method === 'POST').length;
+const prefix = '/api/v0/provider-management/';
+async function continuation(runId) {
+  const view = await env.http('/api/v0/runs/' + runId);
+  const accepted = await env.http('/api/v0/runs/' + runId + '/continue', { key: crypto.randomUUID(), value: { expectedRevision: view.revision } }, 202);
+  return env.terminal(accepted.operation.id);
+}
+async function noCredentialFiles(directory) {
+  for (const item of await readdir(directory, { withFileTypes: true })) {
+    const file = path.join(directory, item.name);
+    if (item.isDirectory()) await noCredentialFiles(file);
+    else { const bytes = await readFile(file); assert(!bytes.includes(Buffer.from(syntheticKey)), 'synthetic provider credential persisted: ' + item.name); }
+  }
+}
+try {
+  const original = await readFile(env.prepared.providerConfigPath);
+  const options = { directory: env.prepared.directory, endpoint: env.fixture.origin, credentialEnv };
+  await assert.rejects(setup(options), { code: 'EEXIST' });
+  await assert.rejects(setup({ ...options, directory: path.resolve('private-demo') }), /outside the plugin project/);
+  assert.deepEqual(await readFile(env.prepared.providerConfigPath), original);
+  const originalConfig = JSON.parse(original).catalog ?? JSON.parse(original);
+  assert.equal(originalConfig.providers[0].apiKey, undefined);
+  assert.deepEqual(originalConfig.providers[0].models, []);
+  checks.push('new-directory setup rejects overwrite and package-local data; stores only the environment name with no enabled model pool');
+
+  await env.start({ key: '' });
+  let settings = await env.http(prefix + 'settings');
+  await env.http(prefix + 'discover', { value: { providerId: 'wan-reference', expectedRevision: settings.revision } }, 409);
+  assert.equal(env.fixture.requests.length, 0);
+  await env.stop(); await env.start();
+  settings = await env.http(prefix + 'settings');
+  assert(settings.protocols.some(item => item.id === 'example.wan-image.images'));
+  const discovered = await env.http(prefix + 'discover', { value: { providerId: 'wan-reference', expectedRevision: settings.revision } });
+  assert.equal(discovered.persisted, false); assert.deepEqual(discovered.models.map(item => item.id), ['wan2.6-t2i']);
+  assert.equal(env.fixture.requests.filter(item => item.path.startsWith('/api/v1/models')).length, 2);
+  assert.deepEqual(await readFile(env.prepared.providerConfigPath), original);
+  checks.push('actual Core CLI exposes the contributed protocol; missing credentials make zero requests; complete two-page directory is read without silently applying it');
+
+  const record = settings.providers[0];
+  const provider = Object.fromEntries(['id', 'name', 'baseUrl', 'mediaBaseUrl', 'mediaProtocol', 'enabled', 'auth'].map(field => [field, record[field]]));
+  provider.models = discovered.models;
+  settings = await env.http(prefix + 'save', { value: { expectedRevision: settings.revision, provider, credential: { action: 'keep' },
+    assignments: { 'image-gen': { mode: 'manual', models: ['wan-reference::wan2.6-t2i'] } } } });
+  const none = await env.connection([]), unselected = await mcpProbe(await env.exported(none));
+  assert(!(await unselected.request('tools/list', {})).tools.some(item => item.name === 'iris_core_create_generation'));
+  const connection = await env.connection(); let client = await mcpProbe(await env.exported(connection));
+  let names = (await client.request('tools/list', {})).tools.map(item => item.name);
+  assert(names.includes('iris_core_create_generation')); assert(!names.includes('iris_core_plugin_call')); assert(!names.includes('iris_core_create_video'));
+  checks.push('user explicitly applies the discovered model and manual pool; selecting image generation controls ordinary MCP media tools without a separate Provider tool whitelist');
+
+  const flows = [];
+  for (let i = 0; i < 2; i++) flows.push(parsed(await client.call('iris_core_create_generation', {
+    key: crypto.randomUUID(), modelRef: 'wan-reference::wan2.6-t2i', prompt: 'controlled local Provider starter ' + i
+  })).flow);
+  assert.equal(postCount(), 0);
+  const requests = flows.map(flow => ({ key: crypto.randomUUID(), runId: flow.id, expectedRevision: flow.revision }));
+  env.fixture.holdSubmits();
+  const accepted = await Promise.all(requests.map(value => client.call('iris_core_continue', value).then(parsed)));
+  const deadline = performance.now() + 5000;
+  while (postCount() < 2 && performance.now() < deadline) await delay(10);
+  env.fixture.releaseSubmits();
+  for (const value of accepted) assert.equal((await env.terminal(value.operation.id)).state, 'succeeded');
+  assert.equal(postCount(), 2); assert.equal(env.fixture.peak, 2);
+  const submitted = env.fixture.requests.filter(item => item.method === 'POST');
+  assert(submitted.every(item => item.async === 'enable' && JSON.parse(item.body).parameters.n === 1));
+  await env.stop();
+  const tasks = [];
+  for (const flow of flows) {
+    const view = await runCore(env.prepared.dataRoot, 'flow', 'inspect', flow.id);
+    const task = (await runCore(env.prepared.dataRoot, 'task', 'inspect', view.task.id)).task;
+    assert.equal(task.acceptance, 'accepted'); assert(env.fixture.tasks.has(task.remoteTaskId));
+    assert.equal(task.pluginDependency.pluginVersion, '0.1.0'); assert.equal(task.pluginDependency.contributionId, 'example.wan-image.images');
+    assert.deepEqual(task.pluginDependency, task.attempts[0].pluginDependency); tasks.push(task.id);
+    if (args.length) { assert.equal(task.semanticsVersion, 3); assert(task.networkRoutes.some(route => route.operation === 'submit' && route.nodeId === 'fixture-net')); }
+  }
+  checks.push('two real local HTTP submissions overlap under Core scheduling; public CLI reads accepted Task/Attempt with exact plugin identity and original remote IDs');
+
+  for (const selection of [{ present: false }, { version: '0.1.1' }]) {
+    await env.start(selection); const before = env.fixture.requests.length;
+    for (const flow of flows) {
+      const view = await env.http('/api/v0/runs/' + flow.id); assert(tasks.includes(view.task.id));
+      const result = await continuation(flow.id); assert.equal(result.state, 'failed', JSON.stringify(result));
+    }
+    assert.equal(env.fixture.requests.length, before, 'missing/mismatched plugin must not contact any upstream');
+    await env.stop();
+  }
+  checks.push('absent or differently versioned plugin keeps saved history readable and blocks continuation before any upstream request');
+
+  env.fixture.ready = true;
+  const rotated = syntheticKey + '-rotated'; await env.start({ key: rotated }); client = await mcpProbe(await env.exported(connection));
+  for (let i = 0; i < flows.length; i++) {
+    const view = parsed(await client.call('iris_core_run', { runId: flows[i].id }));
+    const operation = parsed(await client.call('iris_core_continue', { key: crypto.randomUUID(), runId: view.id, expectedRevision: view.revision })).operation;
+    assert.equal((await env.terminal(operation.id)).state, 'succeeded');
+    const delivered = parsed(await client.call('iris_core_run', { runId: view.id }));
+    assert.equal(delivered.task.id, tasks[i]); assert.equal(delivered.task.attemptCount, 1); assert.equal(delivered.task.deliveryState, 'ready');
+    const image = (await client.call('iris_core_image', { artifactId: delivered.output.artifactId })).content.find(item => item.type === 'image');
+    assert.deepEqual(Buffer.from(image.data, 'base64'), PNG);
+  }
+  assert.equal(postCount(), 2);
+  const polls = env.fixture.requests.filter(item => item.path.startsWith('/api/v1/tasks/'));
+  assert(polls.length >= 2 && polls.every(item => item.authorization === 'Bearer ' + rotated));
+  assert(env.fixture.requests.filter(item => item.cdn).every(item => item.authorization === undefined));
+  checks.push('restoring the exact plugin after restart uses the rotated environment value to poll original remote tasks and follow credential-free CDN redirects; no repeated POST');
+
+  env.fixture.mode = 'missing-id';
+  const ambiguous = (await env.http('/api/v0/generations', { key: crypto.randomUUID(), value: {
+    modelRef: 'wan-reference::wan2.6-t2i', prompt: 'controlled ambiguous response'
+  } }, 201)).flow;
+  await continuation(ambiguous.id);
+  let ambiguousView = await env.http('/api/v0/runs/' + ambiguous.id);
+  assert.equal(ambiguousView.task.acceptance, 'unknown'); assert.equal(ambiguousView.task.attemptCount, 1);
+  const ambiguousTask = ambiguousView.task.id, count = postCount(); assert.equal(count, 3);
+  await env.stop(); env.fixture.mode = 'normal'; await env.start({ key: rotated });
+  const requestCount = env.fixture.requests.length; await continuation(ambiguous.id);
+  ambiguousView = await env.http('/api/v0/runs/' + ambiguous.id);
+  assert.equal(ambiguousView.task.id, ambiguousTask); assert.equal(ambiguousView.task.acceptance, 'unknown');
+  assert.equal(env.fixture.requests.length, requestCount); assert.equal(postCount(), count);
+  checks.push('a submission without remote identity persists unknown acceptance; restart and explicit continuation neither retry POST nor invent a poll ID');
+
+  await env.reduce(connection); client = await mcpProbe(await env.exported(connection));
+  names = (await client.request('tools/list', {})).tools.map(item => item.name);
+  assert(!names.includes('iris_core_continue')); assert(!names.includes('iris_core_create_generation'));
+  assert.equal(parsed(await client.call('iris_core_run', { runId: flows[0].id })).task.deliveryState, 'ready');
+  await assert.rejects(client.call('iris_core_continue', requests[0]), /Tool iris_core_continue not found/);
+  assert.equal(postCount(), count); checks.push('reducing connection authority removes and rejects new execution while retaining authorized original history');
+  await env.stop(); await noCredentialFiles(env.prepared.directory); assert.deepEqual(env.fixture.errors, []);
+  checks.push('normal CLI SIGTERM completes across restarts; provider credentials are absent from Core records, provider configuration and backups');
+  console.log(JSON.stringify({ ok: true, work: env.work, checks, taskIds: tasks, paidCalls: 0, submits: postCount(), peakHttp: env.fixture.peak,
+    proxy: args.length ? 'explicit-loopback-CONNECT' : 'inherit' }, null, 2));
+} finally { await env.close(); }

package/user_guide.md

@@ -64,6 +64,10 @@ DSH 已配好同一媒体服务时，可在第 1 步选择连接来源，明确
 
 保存供应商和修改能力分配都会立即生效，不需要重启 DSH。
 
+## ComfyUI 工作台（0.3 beta）
+
+稳定npm 0.2.7尚不含此界面；安装0.3.0-beta.1后可在“+ 添加供应商”选择“ComfyUI · 已有服务”，保存地址/认证后导入 API 图或 Iris 参数模板，明确节点和公开参数；检查、保存不生成图片。画图时选择具体工作流，可调整 LoRA 双权重、种子等声明参数，并从只读检查取得可用选项。Iris 不安装 ComfyUI 或模型，静态检查不等于真实 GPU 验收。完整操作与限制见 [DSH ComfyUI 入口](docs/IMAGE_GENERATION.md#dsh-工作台入口03-alpha)。
+
 ## 供应商与协议
 
 Iris 当前支持两类调用路径：
@@ -220,7 +224,7 @@ $DSH_HOME/iris/v1/providers.json
 
 `mediaBaseUrl` 可以省略或留空，此时媒体调用沿用 `baseUrl`。`assignments` 可以省略，但从 0.2.4 起缺失分配不发起对应功能的新调用；0.2.6 也不会将其静默改为自动池。包含特殊字符的 provider 或模型引用会经过 URL 编码，复杂引用建议在工作台中生成，不要手写。
 
-可为明确不需要认证的本地端点设置 `"auth": "none"` 并省略 `apiKey`；缺省或 `"auth": "bearer"` 仍要求 Key，保持旧配置行为。无认证模式不会发送 Authorization 头，已有的旧 Key 也不会被带入该模式的媒体请求。工作台尚无专门的无认证开关，需要按上述停机原则编辑私有配置；不要对需要认证的公网端点使用 `auth:none`。
+可为明确不需要认证的本地端点设置 `"auth": "none"` 并省略 `apiKey`；缺省或 `"auth": "bearer"` 仍要求 Key，保持旧配置行为。无认证模式不会发送 Authorization 头，已有的旧 Key 也不会被带入该模式的媒体请求。0.2.7 工作台尚无专门的无认证开关，需按上述停机原则编辑私有配置；beta.1已在添加供应商与认证设置中提供选择。不要对需要认证的公网端点使用 `auth:none`。
 
 API Key 以明文保存在宿主侧的 `providers.json` 中。POSIX 上 Iris 目录为 `0700`、文件为 `0600`，0.1.1 首次启动会收紧既有 Iris 树但不修改内容或跟随符号链接；Windows 的 mode 不能替代 ACL。状态接口和界面只返回掩码，不会显示完整 Key。不要把这个文件提交到版本库或发给他人。