@hmj-ai/cflow 1.1.0

package/dist/src/runtime-manifest.js

@@ -0,0 +1,244 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+const builtinManifests = [
+    {
+        schemaVersion: 1,
+        id: 'codex',
+        name: 'Codex',
+        description: '用本机已登录的 Codex 来执行步骤。默认只读；能力声明 workspace 写入后可修改工作区文件。',
+        backend: 'acp',
+        command: 'codex-acp',
+        envAllowlist: ['HOME', 'PATH', 'LANG', 'LC_ALL', 'CODEX_HOME', 'OPENAI_API_KEY'],
+        capabilities: ['reasoning', 'code', 'structured-output', 'workspace-read'],
+        traits: { tokenAccounting: 'approximate' },
+    },
+    {
+        schemaVersion: 1,
+        id: 'claude-code',
+        name: 'Claude Code',
+        description: '用本机已登录的 Claude Code 来执行步骤。',
+        backend: 'acp',
+        command: 'claude-agent-acp',
+        envAllowlist: ['HOME', 'PATH', 'LANG', 'LC_ALL', 'ANTHROPIC_API_KEY'],
+        capabilities: ['reasoning', 'code', 'structured-output', 'workspace-read'],
+    },
+];
+const manifestHash = (manifest) => createHash('sha256').update(JSON.stringify(manifest)).digest('hex').slice(0, 16);
+const stringValue = (value, name, max) => {
+    if (typeof value !== 'string' || !value.trim() || value.length > max)
+        throw new Error(`${name}_INVALID`);
+    if (value.includes('\0'))
+        throw new Error(`${name}_INVALID`);
+    return value.trim();
+};
+const stringList = (value, name, maxItems) => {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length > maxItems)
+        throw new Error(`${name}_INVALID`);
+    return value.map((item) => stringValue(item, name, 500));
+};
+const numberValue = (value, name, minimum, maximum) => {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum)
+        throw new Error(`${name}_INVALID`);
+    return parsed;
+};
+const traitValue = (traits, key, allowed) => {
+    const value = traits[key];
+    if (value === undefined)
+        return undefined;
+    if (!allowed.includes(value))
+        throw new Error('TRAITS_INVALID');
+    return value;
+};
+const normalizeTraits = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('TRAITS_INVALID');
+    const traits = value;
+    const normalized = {
+        backendKind: traitValue(traits, 'backendKind', ['acp', 'process']),
+        sessionMode: traitValue(traits, 'sessionMode', ['stateless', 'per-cf-call', 'persistent']),
+        structuredOutput: traitValue(traits, 'structuredOutput', [true, false]),
+        streaming: traitValue(traits, 'streaming', [true, false]),
+        toolEvents: traitValue(traits, 'toolEvents', [true, false]),
+        permissionPrompts: traitValue(traits, 'permissionPrompts', [true, false]),
+        tokenAccounting: traitValue(traits, 'tokenAccounting', ['exact', 'approximate', 'unavailable']),
+        cancellation: traitValue(traits, 'cancellation', [
+            'cooperative',
+            'process-kill',
+            'unsupported',
+        ]),
+        filesystemIsolation: traitValue(traits, 'filesystemIsolation', [
+            'sandboxed',
+            'cwd-scoped',
+            'host-permissions',
+        ]),
+        networkIsolation: traitValue(traits, 'networkIsolation', [
+            'enforced',
+            'adapter-declared',
+            'unenforced',
+        ]),
+    };
+    return Object.fromEntries(Object.entries(normalized).filter(([, item]) => item !== undefined));
+};
+const normalizePermissionArgs = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('PERMISSION_ARGS_INVALID');
+    const input = value;
+    const output = {};
+    for (const mode of ['none', 'read', 'write', 'full']) {
+        const args = stringList(input[mode], 'PERMISSION_ARGS', 30);
+        if (args)
+            output[mode] = args;
+    }
+    return output;
+};
+const normalizeManifest = (value, baseDirectory) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('OBJECT_INVALID');
+    const input = value;
+    if (input.schemaVersion !== 1)
+        throw new Error('SCHEMA_VERSION_UNSUPPORTED');
+    const id = stringValue(input.id, 'ID', 64).toLowerCase();
+    if (!/^[a-z0-9][a-z0-9._-]{1,63}$/.test(id))
+        throw new Error('ID_INVALID');
+    const backend = input.backend;
+    if (backend !== 'acp' && backend !== 'cli')
+        throw new Error('BACKEND_INVALID');
+    const rawCommand = stringValue(input.command, 'COMMAND', 500);
+    const command = baseDirectory &&
+        !isAbsolute(rawCommand) &&
+        (rawCommand.startsWith('./') || rawCommand.startsWith('../'))
+        ? resolve(baseDirectory, rawCommand)
+        : rawCommand;
+    const promptTransport = input.promptTransport;
+    if (promptTransport !== undefined &&
+        promptTransport !== 'stdin' &&
+        promptTransport !== 'argument')
+        throw new Error('PROMPT_TRANSPORT_INVALID');
+    const outputMode = input.outputMode;
+    if (outputMode !== undefined && outputMode !== 'json' && outputMode !== 'text')
+        throw new Error('OUTPUT_MODE_INVALID');
+    const envAllowlist = stringList(input.envAllowlist, 'ENV_ALLOWLIST', 40);
+    if (envAllowlist?.some((name) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)))
+        throw new Error('ENV_ALLOWLIST_INVALID');
+    return {
+        schemaVersion: 1,
+        id,
+        name: stringValue(input.name, 'NAME', 80),
+        description: input.description === undefined
+            ? undefined
+            : stringValue(input.description, 'DESCRIPTION', 400),
+        backend,
+        command,
+        args: stringList(input.args, 'ARGS', 40),
+        versionArgs: stringList(input.versionArgs, 'VERSION_ARGS', 10),
+        promptTransport,
+        outputMode,
+        timeoutMs: numberValue(input.timeoutMs, 'TIMEOUT', 1_000, 3_600_000),
+        maxOutputBytes: numberValue(input.maxOutputBytes, 'OUTPUT_LIMIT', 1_024, 16_777_216),
+        envAllowlist,
+        capabilities: stringList(input.capabilities, 'CAPABILITIES', 40),
+        permissionArgs: normalizePermissionArgs(input.permissionArgs),
+        traits: normalizeTraits(input.traits),
+    };
+};
+const record = (value, source, manifestPath, baseDirectory) => {
+    const manifest = normalizeManifest(value, baseDirectory);
+    return { manifest, source, manifestPath, manifestHash: manifestHash(manifest) };
+};
+const manifestFiles = (directory) => {
+    if (!directory || !existsSync(directory))
+        return [];
+    return readdirSync(directory)
+        .filter((name) => name.endsWith('.json'))
+        .sort()
+        .map((name) => join(directory, name));
+};
+const packageJsonFiles = (packageRoot) => {
+    if (!packageRoot || !existsSync(packageRoot))
+        return [];
+    const files = [];
+    for (const name of readdirSync(packageRoot).sort()) {
+        if (name === '.bin' || name.startsWith('.'))
+            continue;
+        const candidate = join(packageRoot, name);
+        try {
+            if (name.startsWith('@') && statSync(candidate).isDirectory()) {
+                for (const child of readdirSync(candidate).sort())
+                    files.push(join(candidate, child, 'package.json'));
+            }
+            else
+                files.push(join(candidate, 'package.json'));
+        }
+        catch {
+            // Broken package links are ignored during discovery.
+        }
+    }
+    return files.filter(existsSync);
+};
+export function loadAgentManifestRecords(options = {}) {
+    const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    const userDirectory = options.userManifestDirectory === false
+        ? false
+        : resolve(options.userManifestDirectory ??
+            join(process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config'), 'cflow', 'agents.d'));
+    const projectDirectory = options.projectManifestDirectory === false
+        ? false
+        : resolve(options.projectManifestDirectory ?? join(projectRoot, '.cflow', 'agents.d'));
+    const packageRoot = options.packageRoot === false
+        ? false
+        : resolve(options.packageRoot ?? join(projectRoot, 'node_modules'));
+    const records = [];
+    const warnings = [];
+    if (options.includeBuiltins !== false)
+        for (const manifest of builtinManifests)
+            records.push(record(manifest, 'builtin', `builtin:${manifest.id}`));
+    const addValues = (values, source, manifestPath, baseDirectory) => {
+        const manifests = Array.isArray(values) ? values : [values];
+        for (const value of manifests) {
+            try {
+                records.push(record(value, source, manifestPath, baseDirectory));
+            }
+            catch (error) {
+                warnings.push(`${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+    for (const packageJson of packageJsonFiles(packageRoot)) {
+        try {
+            const value = JSON.parse(readFileSync(packageJson, 'utf8'));
+            if (value.cflowAgent !== undefined)
+                addValues(value.cflowAgent, 'package-manifest', packageJson, dirname(packageJson));
+        }
+        catch {
+            // A package without readable metadata is unrelated unless it advertises cflowAgent.
+        }
+    }
+    for (const [directory, source] of [
+        [userDirectory, 'user-manifest'],
+        [projectDirectory, 'project-manifest'],
+    ]) {
+        for (const manifestPath of manifestFiles(directory)) {
+            try {
+                addValues(JSON.parse(readFileSync(manifestPath, 'utf8')), source, manifestPath, dirname(manifestPath));
+            }
+            catch (error) {
+                warnings.push(`${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    const selected = new Map();
+    for (const candidate of records)
+        selected.set(candidate.manifest.id, candidate);
+    return { records: [...selected.values()], warnings };
+}

package/dist/src/runtime-process.js

@@ -0,0 +1,175 @@
+import { accessSync, constants, readdirSync, statSync } from 'node:fs';
+import { delimiter, isAbsolute, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Process-level helpers shared by the ACP and CLI runtime adapters: locating an
+ * executable without a shell, discovering ACP servers on PATH, and reading a
+ * structured answer out of an agent's stdout.
+ */
+/** Package root, so bundled adapter binaries resolve in dev and after build. */
+const runtimePackageRoot = (() => {
+    const currentDirectory = fileURLToPath(new URL('.', import.meta.url));
+    return currentDirectory.includes(`${sep}dist${sep}`)
+        ? resolve(currentDirectory, '..', '..')
+        : resolve(currentDirectory, '..');
+})();
+export const existingAbsoluteDirectory = (value, errorCode) => {
+    if (!isAbsolute(value))
+        throw new Error(errorCode);
+    try {
+        if (!statSync(value).isDirectory())
+            throw new Error(errorCode);
+    }
+    catch {
+        throw new Error(errorCode);
+    }
+    return resolve(value);
+};
+export const existingExecutable = (value) => {
+    try {
+        if (statSync(value).isFile()) {
+            accessSync(value, constants.X_OK);
+            return value;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+};
+export const executableExtensions = () => {
+    const raw = process.env.PATHEXT?.trim() || '.COM;.EXE;.BAT;.CMD;.PS1';
+    return [
+        ...new Set(raw
+            .split(';')
+            .map((extension) => extension.trim().toLowerCase())
+            .filter((extension) => extension.startsWith('.'))),
+    ];
+};
+export const stripExecutableExtension = (command) => {
+    const lower = command.toLowerCase();
+    const extension = executableExtensions()
+        .sort((a, b) => b.length - a.length)
+        .find((candidate) => lower.endsWith(candidate));
+    return extension ? command.slice(0, -extension.length) : command;
+};
+export const executableCandidates = (command) => {
+    const lower = command.toLowerCase();
+    if (executableExtensions().some((extension) => lower.endsWith(extension)))
+        return [command];
+    return [command, ...executableExtensions().map((extension) => `${command}${extension}`)];
+};
+export const normalizedAcpCommand = (command) => {
+    const normalized = stripExecutableExtension(command);
+    return isAcpCommandName(normalized) ? normalized : undefined;
+};
+export const discoverAcpCommands = (projectRoot = process.cwd()) => {
+    const projectBin = resolve(projectRoot, 'node_modules', '.bin');
+    const bundledBin = resolve(runtimePackageRoot, 'node_modules', '.bin');
+    const directories = [
+        bundledBin,
+        projectBin,
+        ...(process.env.PATH ?? '')
+            .split(delimiter)
+            .filter(Boolean)
+            .map((entry) => resolve(entry)),
+    ];
+    const commands = new Set();
+    const seen = new Set();
+    for (const directory of directories) {
+        if (seen.has(directory))
+            continue;
+        seen.add(directory);
+        try {
+            for (const entry of readdirSync(directory)) {
+                const command = normalizedAcpCommand(entry);
+                if (!command)
+                    continue;
+                if (existingExecutable(resolve(directory, entry)))
+                    commands.add(command);
+            }
+        }
+        catch {
+            // Missing PATH entries are normal on developer machines.
+        }
+    }
+    return [...commands];
+};
+export const isAcpCommandName = (command) => /^acp-[a-z0-9._-]+$/i.test(command) || /^[a-z0-9._-]+-acp$/i.test(command);
+export const runtimeIdFromCommand = (command) => command
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64);
+export const runtimeNameFromCommand = (command) => command
+    .replace(/[-_.]+/g, ' ')
+    .replace(/\bacp\b/gi, 'ACP')
+    .replace(/\b\w/g, (letter) => letter.toUpperCase());
+export const resolveExecutable = (command, env, options = {}) => {
+    if (isAbsolute(command)) {
+        for (const candidate of executableCandidates(command)) {
+            const executable = existingExecutable(candidate);
+            if (executable)
+                return executable;
+        }
+        return undefined;
+    }
+    if (command.includes(sep)) {
+        for (const candidate of executableCandidates(resolve(command))) {
+            const executable = existingExecutable(candidate);
+            if (executable)
+                return executable;
+        }
+        return undefined;
+    }
+    const localBins = [
+        resolve(runtimePackageRoot, 'node_modules', '.bin'),
+        resolve('node_modules', '.bin'),
+    ];
+    if (options.includeProjectBin) {
+        for (const directory of localBins) {
+            for (const candidate of executableCandidates(command)) {
+                const localExecutable = existingExecutable(resolve(directory, candidate));
+                if (localExecutable)
+                    return localExecutable;
+            }
+        }
+    }
+    for (const dir of (env.PATH ?? process.env.PATH ?? '').split(delimiter)) {
+        if (!dir)
+            continue;
+        if (!options.includeProjectBin && localBins.includes(resolve(dir)))
+            continue;
+        for (const candidate of executableCandidates(command)) {
+            const executable = existingExecutable(resolve(dir, candidate));
+            if (executable)
+                return executable;
+        }
+    }
+    return undefined;
+};
+export const needsWindowsShell = (executable) => process.platform === 'win32' && /\.(?:cmd|bat)$/i.test(executable);
+export const canChangeWorkspace = (effects) => effects.some((effect) => effect.type === 'file-write' || effect.type === 'command');
+export const parseJsonOutput = (text) => {
+    const trimmed = text.trim();
+    const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed)?.[1] ?? trimmed;
+    try {
+        return JSON.parse(fenced);
+    }
+    catch {
+        const start = Math.min(...['{', '['].map((token) => {
+            const index = fenced.indexOf(token);
+            return index < 0 ? Number.POSITIVE_INFINITY : index;
+        }));
+        const end = Math.max(fenced.lastIndexOf('}'), fenced.lastIndexOf(']'));
+        if (Number.isFinite(start) && end > start) {
+            try {
+                return JSON.parse(fenced.slice(start, end + 1));
+            }
+            catch {
+                // Fall through to a loud structured-output error.
+            }
+        }
+        throw new Error('RUNTIME_JSON_INVALID');
+    }
+};