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

package/lib/scheduling-policy.js

@@ -0,0 +1,66 @@
+// Explicit startup policy; never discovers files or rewrites existing configuration.
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function schedulingError(code, message) {
+  return Object.assign(new Error(message), { code, stage: 'prepare', category: 'rate_limit', acceptance: 'not_accepted' });
+}
+const invalid = message => { throw schedulingError('IRIS_SCHEDULER_CONFIG_INVALID', message); };
+function fields(value, names, where) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(name => !names.includes(name))) invalid(`${where} 包含无效字段`);
+}
+function integer(value, min, max, name) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) invalid(`${name} 需要 ${min}–${max} 的整数`);
+  return value;
+}
+function identity(value, where) {
+  if (typeof value !== 'string' || !value.trim() || value !== value.trim() || value.length > 256 || /[\x00-\x1f\x7f]/.test(value)) invalid(`${where} 无效`);
+  return value;
+}
+function limits(value, defaults = {}) {
+  return Object.fromEntries([
+    ['httpConcurrency', 1, 4], ['requestsPerSecond', 1, 1000], ['remoteLimit', 1, 1000]
+  ].flatMap(([key, min, max]) => value[key] === undefined && defaults[key] === undefined ? []
+    : [[key, integer(value[key] === undefined ? defaults[key] : value[key], min, max, key)]]));
+}
+export function checkedSchedulingPolicy(input) {
+  fields(input, ['schemaVersion', 'httpConcurrency', 'requestsPerSecond', 'remoteLimit', 'queueLimit', 'queueTimeoutMs', 'providers'], '调度策略');
+  if (input.schemaVersion !== 1) invalid('仅支持 scheduler schemaVersion=1；不会忽略或迁移其他版本');
+  const providers = input.providers === undefined ? [] : input.providers;
+  if (!Array.isArray(providers) || providers.length > 128) invalid('providers 需要至多 128 项的数组');
+  const seen = new Set();
+  return Object.freeze({ schemaVersion: 1, ...limits(input, { httpConcurrency: 4, requestsPerSecond: 2, remoteLimit: 8 }),
+    queueLimit: integer(input.queueLimit === undefined ? 32 : input.queueLimit, 8, 128, 'queueLimit'),
+    queueTimeoutMs: integer(input.queueTimeoutMs === undefined ? 30000 : input.queueTimeoutMs, 1, 300000, 'queueTimeoutMs'),
+    providers: Object.freeze(providers.map(provider => {
+      fields(provider, ['providerId', 'httpConcurrency', 'requestsPerSecond', 'remoteLimit', 'models'], '供应商策略');
+      const providerId = identity(provider.providerId, 'providerId');
+      if (seen.has(providerId)) invalid('providerId 重复'); seen.add(providerId);
+      const models = provider.models === undefined ? [] : provider.models, ids = new Set();
+      if (!Array.isArray(models) || models.length > 256) invalid('models 需要至多 256 项的数组');
+      return Object.freeze({ providerId, ...limits(provider), models: Object.freeze(models.map(model => {
+        fields(model, ['modelId', 'httpConcurrency', 'requestsPerSecond', 'remoteLimit'], '模型策略');
+        const modelId = identity(model.modelId, 'modelId');
+        if (ids.has(modelId)) invalid('modelId 重复'); ids.add(modelId);
+        return Object.freeze({ modelId, ...limits(model) });
+      })) });
+    })) });
+}
+export function readSchedulingPolicy(file) {
+  if (typeof file !== 'string' || !path.isAbsolute(file)) invalid('scheduler-config 需要明确的绝对路径');
+  let fd;
+  try {
+    fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > 262144) invalid('scheduler-config 必须是 ≤256 KiB 的普通文件');
+    if (process.platform !== 'win32' && (stat.mode & 0o077)) invalid('scheduler-config 请限制为仅当前用户可读写');
+    const bytes = fs.readFileSync(fd);
+    if (bytes.length > 262144) invalid('scheduler-config 过大');
+    let value;
+    try { value = JSON.parse(bytes.toString('utf8')); } catch { invalid('scheduler-config 不是有效 JSON'); }
+    return checkedSchedulingPolicy(value);
+  } catch (error) {
+    if (error.code === 'IRIS_SCHEDULER_CONFIG_INVALID') throw error;
+    throw schedulingError('IRIS_SCHEDULER_CONFIG_IO', '无法读取 scheduler-config；请检查路径、权限和文件状态，不会退回无调度模式');
+  } finally { if (fd !== undefined) fs.closeSync(fd); }
+}

package/lib/skill-installation.js

@@ -1,9 +1,10 @@
-/** Explicit, copy-based installation of the bundled Core skill. No host/model I/O. */
+/** Explicit installation of the bundled Core skill or a rendered connection snapshot. No host/model I/O. */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
+import { connectionSkillResources } from './connection-skill.js';
 
 const PACKAGE_ROOT = fileURLToPath(new URL('../', import.meta.url));
 const SKILL = 'iris-core';
@@ -58,10 +59,10 @@ function sameTree(tree, recorded) {
     && JSON.stringify(tree.directories) === JSON.stringify([...recorded.directories].sort());
 }
 
-function validReceipt(value, packageName) {
+function validReceipt(value, packageName, skillName) {
   const relative = name => typeof name === 'string' && name.length > 0 && !name.includes('\\')
     && !name.includes('\0') && !name.split('/').some(part => !part || part === '.' || part === '..');
-  return value?.schemaVersion === 1 && value.packageName === packageName && value.skillName === SKILL
+  return value?.schemaVersion === 1 && value.packageName === packageName && value.skillName === skillName
     && typeof value.packageVersion === 'string' && value.packageVersion.length > 0
     && value.files && !Array.isArray(value.files) && typeof value.files === 'object'
     && Object.hasOwn(value.files, 'SKILL.md') && !Object.hasOwn(value.files, RECEIPT)
@@ -77,7 +78,18 @@ function packageResources(packageRoot) {
   if (!tree.files['SKILL.md'] || tree.files[RECEIPT]) {
     throw error('IRIS_SKILL_PACKAGE_INVALID', '包内缺少 Skill 入口，或含有不应发布的安装记录');
   }
-  return { source, metadata, ...tree };
+  return { skillName: SKILL, source, metadata, ...tree };
+}
+
+function bundleResources(file, packageRoot) {
+  if (typeof file !== 'string' || !path.isAbsolute(file)) throw error('IRIS_SKILL_OPTIONS_INVALID', '--bundle 必须是绝对路径');
+  const entry = fs.lstatSync(file);
+  if (!entry.isFile() || entry.isSymbolicLink() || entry.size > 16384) throw error('IRIS_SKILL_BUNDLE_INVALID', 'Skill 交付文件必须是最多 16 KiB 的普通 JSON 文件');
+  let value;
+  try { value = JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (cause) { if (!(cause instanceof SyntaxError)) throw cause; throw error('IRIS_SKILL_BUNDLE_INVALID', 'Skill 交付文件不是有效 JSON'); }
+  const metadata = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  return { ...connectionSkillResources(value, metadata), source: fs.realpathSync(file) };
 }
 
 function inspect(destination, resources) {
@@ -92,7 +104,7 @@ function inspect(destination, resources) {
     if (!(cause instanceof SyntaxError)) throw cause;
     return { status: 'unmanaged', reason: 'invalid_receipt' };
   }
-  if (!validReceipt(receipt, resources.metadata.name)) return { status: 'unmanaged', reason: 'invalid_receipt' };
+  if (!validReceipt(receipt, resources.metadata.name, resources.skillName)) return { status: 'unmanaged', reason: 'invalid_receipt' };
   const base = { installedVersion: receipt.packageVersion };
   let tree;
   try { tree = readTree(destination, { installed: true, expected: receipt.files }); }
@@ -125,7 +137,7 @@ function ensureDirectory(directory) {
 
 function archive(destination, control, action) {
   const transaction = fs.mkdtempSync(path.join(control, 'backup-'));
-  const backupPath = path.join(transaction, SKILL);
+  const backupPath = path.join(transaction, path.basename(destination));
   fs.writeFileSync(path.join(transaction, 'move.json'), JSON.stringify({ schemaVersion: 1, action,
     at: new Date().toISOString(), origin: destination, backupPath }, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
   fs.renameSync(destination, backupPath);
@@ -137,24 +149,24 @@ function copyResources(destination, resources) {
   for (const relative of resources.directories) fs.mkdirSync(path.join(destination, relative), { recursive: true, mode: 0o700 });
   for (const [relative, bytes] of Object.entries(resources.bytes)) fs.writeFileSync(path.join(destination, relative), bytes, { flag: 'wx', mode: 0o600 });
   fs.writeFileSync(path.join(destination, RECEIPT), JSON.stringify({ schemaVersion: 1,
-    packageName: resources.metadata.name, packageVersion: resources.metadata.version, skillName: SKILL,
+    packageName: resources.metadata.name, packageVersion: resources.metadata.version, skillName: resources.skillName,
     installedAt: new Date().toISOString(), files: resources.files, directories: resources.directories
   }, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
 }
 
 /** Internal CLI service. Explicit mutations only; no postinstall or public SDK export. */
-export function manageCoreSkill({ action, target, directory, dryRun = false }, {
+export function manageCoreSkill({ action, target, directory, bundle, dryRun = false }, {
   packageRoot = PACKAGE_ROOT, env = process.env, home = os.homedir()
 } = {}) {
   if (!['install', 'status', 'uninstall'].includes(action) || action === 'status' && dryRun) {
     throw error('IRIS_SKILL_OPTIONS_INVALID', '使用 skills install/status/uninstall；status 不接受 --dry-run');
   }
-  const resources = packageResources(packageRoot);
-  const resolved = resolveDirectory({ target, directory, env, home }), destination = path.join(resolved, SKILL);
+  const resources = bundle === undefined ? packageResources(packageRoot) : bundleResources(bundle, packageRoot);
+  const resolved = resolveDirectory({ target, directory, env, home }), destination = path.join(resolved, resources.skillName);
   if (isWithin(resources.source, destination) || isWithin(destination, resources.source)) {
     throw error('IRIS_SKILL_OPTIONS_INVALID', '安装目标不能与包内 Skill 源目录重叠');
   }
-  const base = { skill: SKILL, target: target || 'directory', directory: resolved, destination,
+  const base = { skill: resources.skillName, target: target || 'directory', directory: resolved, destination,
     packageVersion: resources.metadata.version, discovery: 'not_checked' };
   const before = inspect(destination, resources);
   const result = { ...base, ...before };

package/lib/tasks.js

@@ -718,7 +718,7 @@ export async function submitGuard(task, fn) {
 /**
  * 重启恢复：接管仍在运行的远程任务。DSH 重启期间百炼任务在服务端继续跑，
  * 结果 URL 存活 24h，重启后重新盯守即可落袋。
- * @param {(task) => deps|null} depsFor 返回盯守依赖；null 表示无法接管（如供应商已删除）
+ * @param {(task) => deps|null} depsFor 返回盯守依赖；null 仅暂停接管（如连接暂不可用），不证明远端失败
  * @returns {string[]} 成功接管的任务 id
  */
 export function resumePending(depsFor) {
@@ -737,9 +737,10 @@ export function resumePending(depsFor) {
         }
         const deps = depsFor(t);
         if (!deps) {
-          update(t.id, { status: 'failed', error: '无法恢复：对应供应商不可用' });
+          update(t.id, { error: '无法恢复盯守：对应供应商不可用；远端任务状态未改变，可在连接恢复后再次接管' });
           continue;
         }
+        if (t.error) update(t.id, { error: undefined });
         watch(t, deps);
         resumed.push(t.id);
         continue;

package/lib/video-flow-input.js

@@ -0,0 +1,16 @@
+import { normalizeGenerationInput } from './generation-input.js';
+import { parseModelRef } from './models.js';
+
+export const VIDEO_RECIPE = 'video-generate/v0';
+export const MAX_VIDEO_BYTES = 32 * 1024 * 1024;
+export const VIDEO_TYPES = Object.freeze({ 'video/mp4': 'mp4', 'video/webm': 'webm' });
+export function normalizeVideoFlowInput(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)
+      || Object.keys(input).some(key => !['model_ref', 'prompt', 'size', 'duration'].includes(key))
+      || !parseModelRef(input.model_ref) || /s2v/i.test(parseModelRef(input.model_ref).modelId)
+      || input.duration !== undefined && (typeof input.duration !== 'number' || !Number.isFinite(input.duration))) {
+    throw Object.assign(new Error('文生视频仅接受明确模型、prompt 和可选 size/duration；不接受首帧、S2V 或路径'), { code: 'IRIS_VIDEO_FLOW_INPUT_INVALID' });
+  }
+  const value = normalizeGenerationInput('video', input);
+  return { model_ref: value.modelRef, ...value.providerInput };
+}

package/lib/video-input.js

@@ -7,19 +7,26 @@ import { parseModelRef } from './models.js';
 import { prepareProviderInput } from './provider-adapter.js';
 import { ProviderContractError } from './provider-contract.js';
 
+/** Recognized input families constrain routing; opaque compatible IDs keep their existing t2v/i2v support. */
+export function videoModelSupportsMode(modelId, mode) {
+  const family = /(?:^|[-_.])(t2v|i2v|s2v|r2v)(?=$|[-_.])/i.exec(modelId)?.[1].toLowerCase();
+  if (family) return family === mode;
+  return mode === 't2v' || mode === 'i2v';
+}
+
 export function videoTaskCandidates(candidates, normalized) {
   const s2v = normalized.videoMode === 's2v';
-  const compatible = candidates.filter(candidate => /s2v/i.test(parseModelRef(candidate.model)?.modelId || '') === s2v);
+  const compatible = candidates.filter(candidate => videoModelSupportsMode(parseModelRef(candidate.model)?.modelId || '', normalized.videoMode));
   if (!compatible.length) throw new GenerationInputError(s2v
-    ? 'audio_path 只能配合 s2v 数字人模型' : 's2v 模型需要首帧和音频输入');
+    ? 'audio_path 只能配合 s2v 数字人模型' : '没有与 ' + normalized.videoMode + ' 输入匹配的视频模型；s2v 模型需要首帧和音频输入');
   return compatible.map(candidate => ({ ...candidate,
-    ...(normalized.firstFramePath ? { async prepareInput({ signal }) {
+    ...(normalized.firstFramePath ? { async prepareInput({ signal, taskId, attemptId, networkBudget, recordNetworkRoute }) {
       if (signal.aborted) throw new ProviderContractError('视频输入准备已取消', { stage: 'prepare', category: 'aborted', acceptance: 'not_accepted' });
       if (s2v) {
         const model = parseModelRef(candidate.model).modelId;
-        const image = await prepareProviderInput(candidate.adapter, { model, filePath: normalized.firstFramePath, signal });
+        const image = await prepareProviderInput(candidate.adapter, { model, filePath: normalized.firstFramePath, signal }, { taskId, attemptId, networkBudget, recordNetworkRoute });
         if (signal.aborted) throw new ProviderContractError('视频输入准备已取消', { stage: 'upload', category: 'aborted', acceptance: 'not_accepted' });
-        const audio = await prepareProviderInput(candidate.adapter, { model, filePath: normalized.audioPath, signal });
+        const audio = await prepareProviderInput(candidate.adapter, { model, filePath: normalized.audioPath, signal }, { taskId, attemptId, networkBudget, recordNetworkRoute });
         return { ...normalized.providerInput, imgDataUrl: image.url, audioUrl: audio.url };
       }
       const mime = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp', '.gif': 'image/gif' }[path.extname(normalized.firstFramePath).toLowerCase()];

package/lib/vision-model-routing.js

@@ -12,6 +12,7 @@ import { modelAvailabilityBinding, modelUnavailable } from './model-directory.js
 import { completeVision, VISION_BUDGET } from './vision-core.js';
 import { open } from 'node:fs/promises';
 import { DEFAULT_VISION_INPUT, visionInputLimits } from './vision-image-input.js';
+import { providerNetworkRequirement, networkPolicyError } from './network-policy.js';
 
 const features = Object.freeze({ system: 'unknown', temperature: 'unknown', maxOutputTokens: 'unknown', reasoning: 'unknown' });
 
@@ -50,6 +51,7 @@ function deferredDshPort(host, { prepareImages, orientImages, prepareImageReques
 /** 配置只绑定一个自持模型；CLI 不附加宿主候选。 */
 export function createConfiguredVisionModelPort(provider, model, { allowRateLimited = false, onRateLimit, onModelAvailability, prepareImages = false,
   orientImages = false, prepareImageRequest } = {}) {
+  if (providerNetworkRequirement(provider)) throw networkPolicyError('IRIS_NETWORK_CAPABILITY_UNSUPPORTED', '独立视觉尚未接入此网络目录；已停止调用，不会默认直连。请保留原视觉配置');
   const parsed = parseModelRef(resolveModelRef(provider, 'vision', model));
   const id = 'iris-provider:' + encodeURIComponent(provider.id);
   if (!parsed) return unavailablePort(id);
@@ -61,6 +63,9 @@ export function createConfiguredVisionModelPort(provider, model, { allowRateLimi
     orientImages, prepareImageRequest,
     ...(prepareImages ? { imageInput: visionInputLimits(provider, parsed.modelId) } : {}) });
   const availability = result => {
+    // Ordinary vision/OCR is read-only for provider configuration. Explicit probes
+    // and definitive failures still update availability through the existing hook.
+    if (result.ok === true && !allowRateLimited) return;
     const event = { ...result, stage: 'submit', source: allowRateLimited ? 'probe' : 'task',
       binding: modelAvailabilityBinding(provider, parsed.modelId, 'vision') };
     if (!recordModelAvailability(provider, parsed.modelId, 'vision', event)) return;