@relayflows/sdk 2.0.56 → 2.0.58

package/src/cli/cli-probe.ts

@@ -1,12 +1,14 @@
 import { accessSync, constants, realpathSync } from 'node:fs';
 import { basename, isAbsolute, resolve } from 'node:path';
 import { execFile, spawnSync } from 'node:child_process';
+import { redactText } from '../agent-transcript.js';
 import { agentEnvironment, brokerEnvironment } from '../communication/environment.js';
 import { adapterIdentification, authenticationProbe, classifyModelProbeFailure, cliAdapterKind,
   displayInvocation, modelReadinessProbe, type CliInvocation } from '../cli-adapter.js';
 import { MODEL_ENV } from '../worker-cli.js';
 import { CliProbeError, type CliProbeResult } from '../preflight.js';
 import { pinCliAlias, pinCliAliasSync } from './pinned-cli-alias.js';
+import { prepareDevinRuntime } from '../devin-runtime.js';
 import { agentProbeEnvironment } from '../step-secrets.js';
 
 interface ProbeRequest {
@@ -40,15 +42,18 @@ function driveSync<T>(sequence: Generator<ProbeRequest, T, ProbeOutput>): T {
   while (!next.done) {
     const request = next.value;
     const pinned = pinCliAliasSync(request.executable, request.argv0 ?? basename(request.executable));
+    let prepared: ReturnType<typeof prepareProbe> | undefined;
     const result = (() => {
       try {
-        return spawnSync(pinned.executable, request.invocation.args, {
-          ...probeOptions(request),
+        prepared = prepareProbe(request);
+        return spawnSync(pinned.executable, prepared.args, {
+          ...probeOptions({ ...request, environment: prepared.env }),
           // Preserve the old synchronous probe contract: provider CLIs must not
           // inherit a readable stdin that can block auth/identify probes.
           stdio: ['ignore', 'pipe', 'pipe'],
         });
       } finally {
+        prepared?.close();
         pinned.release();
       }
     })();
@@ -69,9 +74,12 @@ function probeOptions({ argv0, directory, invocation, environment }: ProbeReques
 
 async function runProbeAsync(request: ProbeRequest): Promise<ProbeOutput> {
   const pinned = await pinCliAlias(request.executable, request.argv0 ?? basename(request.executable));
+  let prepared: ReturnType<typeof prepareProbe> | undefined;
   try {
+    prepared = prepareProbe(request);
+    const current = prepared;
     return await new Promise((resolve, reject) => {
-      const child = execFile(pinned.executable, request.invocation.args, probeOptions(request),
+      const child = execFile(pinned.executable, current.args, probeOptions({ ...request, environment: current.env }),
         (error, stdout, stderr) => {
           // Numeric exit codes are probe results; launch, timeout, signal and buffer
           // errors are failures to collect a fact, just as in the synchronous driver.
@@ -86,6 +94,7 @@ async function runProbeAsync(request: ProbeRequest): Promise<ProbeOutput> {
       child.stdin?.end();
     });
   } finally {
+    prepared?.close();
     await pinned.release();
   }
 }
@@ -133,12 +142,16 @@ function* probeSequence(
   const auth = authenticationProbe(kind);
   const authCommand = displayInvocation(cli, auth);
   if (model === undefined) {
+    const authProbe = yield probe(auth);
+    const authenticated = authProbe.status === 0;
     return {
       exists: true,
       supported: true,
-      authenticated: (yield probe(auth)).status === 0,
+      authenticated,
       executable,
       authCommand,
+      ...(authenticated ? {} : { authExitCode: authProbe.status,
+        authFailureDetail: redactProbeOutput(`${authProbe.stderr}${authProbe.stdout}`, sourceEnvironment).trim().slice(0, 500) }),
     };
   }
 
@@ -168,7 +181,7 @@ function* probeSequence(
   // because Claude Code prints the provider's API error there and its own
   // catalog warnings on stderr.
   const failure = classifyModelProbeFailure(kind, `${scopedProbe.stdout}\n${scopedProbe.stderr}`);
-  const modelDetail = redactProbeOutput(scopedProbe.stdout.trim() || scopedProbe.stderr.trim()).slice(0, 500);
+  const modelDetail = redactProbeOutput(scopedProbe.stdout.trim() || scopedProbe.stderr.trim(), sourceEnvironment).slice(0, 500);
   return {
     exists: true,
     supported: true,
@@ -187,7 +200,7 @@ function* probeSequence(
       : {
         authExitCode: authProbe.status,
         authFailureDetail: redactProbeOutput(
-          `${authProbe.stderr}${authProbe.stdout}`,
+          `${authProbe.stderr}${authProbe.stdout}`, sourceEnvironment,
         ).trim().slice(0, 500),
       }),
   };
@@ -201,11 +214,42 @@ function* probeSequence(
  * say WHY a probe failed, which survives redaction; leaking an identity into a
  * refusal message that gets pasted into issues does not.
  */
-function redactProbeOutput(text: string): string {
-  return text
-    .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, '<redacted-email>')
-    .replace(/\b(sk|pk|oat|rt)[-_][A-Za-z0-9._-]{8,}/gi, '<redacted-token>')
-    .replace(/\b[A-Fa-f0-9]{32,}\b/g, '<redacted-hex>');
+function redactProbeOutput(text: string, environment: NodeJS.ProcessEnv): string {
+  const key = environment.DEVIN_API_KEY?.trim();
+  const normalized = { ...environment, ...(key === undefined ? {} : { DEVIN_API_KEY: key }) };
+  // Preserve the shared redactor's known-value, header and cookie handling.
+  const redacted = redactText(text, normalized);
+  // One byte per diagnostic character bounds auxiliary memory even when a
+  // one-character credential matches the entire probe buffer. No span lists.
+  const covered = new Uint8Array(redacted.length);
+  const replacements = ['', '<redacted-email>', '<redacted-token>', '<redacted-hex>', '[redacted:DEVIN_API_KEY]'];
+  for (const [pattern, tag] of [
+    [/(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, 1],
+    [/\b(sk|pk|oat|rt)[-_][A-Za-z0-9._-]{8,}/gi, 2],
+    [/\b[A-Fa-f0-9]{32,}\b/g, 3],
+  ] as const) {
+    for (const match of redacted.matchAll(pattern)) covered.fill(tag, match.index, match.index + match[0].length);
+  }
+  // Mark short credentials AFTER the shapes, on the same text: replacing
+  // either first can split the other and leak a suffix. Connected marks are
+  // redacted together; a known credential's marker takes precedence.
+  if (key && key.length < 8) {
+    for (let start = redacted.indexOf(key); start !== -1; start = redacted.indexOf(key, start + 1)) {
+      covered.fill(4, start, start + key.length);
+    }
+  }
+  let result = ''; let cursor = 0;
+  for (let start = 0; start < covered.length;) {
+    if (covered[start] === 0) { start++; continue; }
+    let tag = covered[start]!; let end = start + 1;
+    while (end < covered.length && covered[end] !== 0) {
+      if (covered[end] === 4) tag = 4;
+      end++;
+    }
+    result += redacted.slice(cursor, start) + replacements[tag];
+    cursor = end; start = end;
+  }
+  return result + redacted.slice(cursor);
 }
 
 function* executableSequence(command: string, directory: string, environment: NodeJS.ProcessEnv): Generator<ProbeRequest, string | undefined, ProbeOutput> {
@@ -245,3 +289,13 @@ function classifySpawnFailure(
   }
   return signal === null ? undefined : new CliProbeError(`signal:${signal}`);
 }
+
+function prepareProbe(request: ProbeRequest) {
+  if (cliAdapterKind(request.argv0 ?? request.executable) === 'devin'
+      && request.environment.DEVIN_API_KEY !== undefined && !request.environment.DEVIN_API_KEY.trim()) {
+    throw new CliProbeError('devin_api_key_empty');
+  }
+  return cliAdapterKind(request.argv0 ?? request.executable) === 'devin'
+    ? prepareDevinRuntime(request.environment, request.invocation)
+    : { args: request.invocation.args, env: request.environment, close() {} };
+}

package/src/communication/environment.ts

@@ -25,6 +25,7 @@ const providerNames: Readonly<Record<string, readonly string[]>> = {
   // AgentWorkforce/cloud#4026's house-provider run contract gives Grok an
   // isolated home plus an xAI-compatible base URL. These remain Grok-scoped.
   grok: ['XAI_API_KEY', 'GROK_XAI_API_BASE_URL', 'GROK_HOME'],
+  devin: ['DEVIN_API_KEY', 'DEVIN_MODEL'],
   ...Object.fromEntries(['opencode', 'aider', 'goose', 'pi', 'deepagents'].map(cli => [cli, multiProvider])),
 };
 /** @internal Names-only test seam; credential lists remain private. */

package/src/communication/pty.ts

@@ -1,5 +1,6 @@
 import { mkdir, mkdtemp, rm, symlink } from 'node:fs/promises';
 import { basename, join } from 'node:path';
+import { prepareDevinRuntime } from '../devin-runtime.js';
 import { agentEnvironment } from './environment.js';
 import { resolveCliModel } from '../cli-adapter.js';
 import type { RelayBroker } from './relay.js';
@@ -19,6 +20,9 @@ export async function spawnFlowPty(broker: Pick<RelayBroker, 'spawnPty'>, option
   const argv0 = basename(identity);
   let command = options.cli;
   let link: string | undefined;
+  const environment = agentEnvironment(identity, options.environment ?? process.env,
+    options.secrets, options.scopeSecrets ?? true);
+  const prepared = argv0.replace(/\.exe$/i, '') === 'devin' ? prepareDevinRuntime(environment) : undefined;
   try {
     if (basename(command) !== argv0) {
       const root = join(options.dataDir, 'communication');
@@ -32,15 +36,15 @@ export async function spawnFlowPty(broker: Pick<RelayBroker, 'spawnPty'>, option
       ...(options.team === undefined ? {} : { team: options.team }),
       model: resolveCliModel(identity, options.model), cwd: options.cwd,
       harnessConfig: { runtime: 'pty', command: shellQuote(command), args: [], cwd: options.cwd,
-        env: { ...agentEnvironment(identity, options.environment ?? process.env,
-          options.secrets, options.scopeSecrets ?? true),
+        env: { ...(prepared?.env ?? environment),
           RELAYFLOW_COMMUNICATION_SOCKET: options.socket, RELAYFLOW_COMMUNICATION_TOKEN: options.token,
           ...(options.metadata === undefined ? {} : {
             RELAYFLOW_RUN_ID: options.metadata.runId, RELAYFLOW_FLOW_NAME: options.metadata.flow,
             RELAYFLOW_STEP_NAME: options.metadata.step,
           }) }, delivery: { mode: 'pty-injection', format: 'relay-block' } } });
-    return { handle, close: async () => { if (link) await rm(link, { recursive: true, force: true }); } };
+    return { handle, close: async () => { prepared?.close(); if (link) await rm(link, { recursive: true, force: true }); } };
   } catch (error) {
+    prepared?.close();
     if (link) await rm(link, { recursive: true, force: true });
     throw error;
   }

package/src/communication/skills.ts

@@ -7,8 +7,9 @@ const execute = promisify(execFile);
 export async function installBrokerSkills(skills: string[], cli: string, cwd: string, signal: AbortSignal): Promise<void> {
   if (!skills.length) return;
   const identity = basename(cli).replace(/\.exe$/i, '');
+  // Devin reads .windsurf/skills, which the canonical skills installer supports.
   const harness = ({ claude: 'claude-code', codex: 'codex', gemini: 'gemini-cli',
-    'cursor-agent': 'cursor', opencode: 'opencode' } as Record<string, string>)[identity];
+    'cursor-agent': 'cursor', opencode: 'opencode', devin: 'windsurf' } as Record<string, string>)[identity];
   if (!harness) throw new Error(`Skill installation is unsupported for broker CLI ${identity}`);
   await execute('npx', ['--yes', 'skills', 'add', 'https://github.com/AgentWorkforce/skills',
     '--skill', ...skills, '--agent', harness, '--yes', '--copy'],

package/src/devin-runtime.ts

@@ -0,0 +1,33 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { CliInvocation } from './adapters/base.js';
+
+/** Private attempt/probe state, never the user's interactive Devin login. */
+export function prepareDevinRuntime(environment: NodeJS.ProcessEnv, invocation?: CliInvocation) {
+  let root: string | undefined;
+  const env = { ...environment };
+  const args = [...(invocation?.args ?? [])];
+  const directory = () => root ??= mkdtempSync(join(environment.TMPDIR ?? tmpdir(), 'relayflows-devin-'));
+  const close = () => { if (root !== undefined) rmSync(root, { recursive: true, force: true }); };
+  try {
+    if (env.DEVIN_API_KEY !== undefined) {
+      const key = env.DEVIN_API_KEY.trim();
+      if (!key) throw new Error('DEVIN_API_KEY must not be empty');
+      const data = join(directory(), 'data');
+      mkdirSync(join(data, 'devin'), { recursive: true, mode: 0o700 });
+      writeFileSync(join(data, 'devin', 'credentials.toml'),
+        `windsurf_api_key = ${JSON.stringify(key)}\n`, { mode: 0o600 });
+      env.XDG_DATA_HOME = data;
+      env.XDG_CONFIG_HOME = join(directory(), 'config');
+      env.XDG_CACHE_HOME = join(directory(), 'cache');
+      delete env.DEVIN_API_KEY;
+    }
+    if (invocation?.promptFile !== undefined) {
+      const path = join(directory(), 'prompt.txt');
+      writeFileSync(path, invocation.promptFile, { mode: 0o600 });
+      args.push('--prompt-file', path);
+    }
+    return { env, args, close };
+  } catch (error) { close(); throw error; }
+}

package/src/preflight.ts

@@ -11,7 +11,7 @@ import type { TriggerSource } from '@relayflows/surface';
 import { acceptsAnyOutput, inspectStepGate, type StepGateInspection } from './gate-contract.js';
 import { compileSpec, CompileError } from './compile.js';
 import { helperCall } from './yaml-helpers.js';
-import { resolveCliModelSelection, type CliModelSource } from './cli-adapter.js';
+import { cliAdapterKind, resolveCliModelSelection, type CliModelSource } from './cli-adapter.js';
 import { isNamedGate, NAMED_GATE_FAILURE_KINDS, type NamedGateFailureKind } from './named-gates.js';
 import { namedGateScanCoverageDiagnostics } from './named-gate-preflight.js';
 import { compileScopes, type ScopeInput, type MountRegistry } from './scope-compiler.js';
@@ -65,6 +65,7 @@ export interface CliProbeResult {
 
 export type CliProbeFailureDetail =
   | 'spawn_failed'
+  | 'devin_api_key_empty'
   | `timeout:${number}ms`
   | `signal:${string}`;
 
@@ -286,6 +287,10 @@ export function resolvePreflight(flow: unknown, options: ResolutionOptions): Pre
         message: unresolvedCliMessage(step.id, options),
       });
     } else {
+      if (step.type === 'llm' && cliAdapterKind(resolution.cli) === 'devin') {
+        cliResolutionDiagnostics.push({ severity: 'refusal', kind: 'cli_unsupported', stepId: step.id,
+          cli: resolution.cli, message: `Step "${step.id}" uses Devin for an llm step; Devin supports agent steps only.` });
+      }
       resolutions.push(resolution);
       resolutionByStep.set(step.id, resolution);
     }
@@ -594,13 +599,16 @@ function probeResolvedCli(
       kind: 'cli_unsupported',
       stepId: resolution.stepId,
       cli: resolution.cli,
-      message: `Step "${resolution.stepId}" declares CLI "${resolution.cli}", but it is neither a supported raw Claude/Codex executable nor a conforming Relayflows wrapper; custom wrappers must identify with the relayflows-agent-cli-v1 contract.`,
+      message: `Step "${resolution.stepId}" declares CLI "${resolution.cli}", but it is neither a supported raw Claude/Codex/Devin executable nor a conforming Relayflows wrapper; custom wrappers must identify with the relayflows-agent-cli-v1 contract.`,
     });
   } else if (managed && result.authenticated === 'unverified') {
     diagnostics.push({ severity: 'warning', kind: 'managed_cli_unverified', stepId: resolution.stepId,
       message: `Step "${resolution.stepId}" uses Relay's interactive CLI transport. The executable exists, but authentication${resolution.model ? ' and access to model "' + resolution.model + '"' : ''} could not be verified before startup. The managed session must execute its task and report completion; startup or task failure fails the step.` });
   } else if (result.authenticated !== true) {
     const command = result.authCommand ?? `${resolution.cli} auth status`;
+    const loginHint = cliAdapterKind(resolution.cli) === 'devin'
+      ? ' For hosted flows, set FLOW_DEVIN_API_KEY to a Devin CLI login token; local runs use DEVIN_API_KEY. A REST API key is a different credential.'
+      : '';
     // Say what the probe reported. A refusal that names only the command turns
     // a transient provider rejection and a genuinely unauthenticated CLI into
     // the same message, and the difference decides whether retrying is
@@ -616,7 +624,7 @@ function probeResolvedCli(
       kind: 'cli_unauthenticated',
       stepId: resolution.stepId,
       cli: resolution.cli,
-      message: `Step "${resolution.stepId}" declares CLI "${resolution.cli}", but "${command}" exited non-zero${exitCode}; authenticate it or repair that adapter's authentication probe.${detail}`,
+      message: `Step "${resolution.stepId}" declares CLI "${resolution.cli}", but "${command}" exited non-zero${exitCode}; authenticate it or repair that adapter's authentication probe.${detail}${loginHint}`,
     });
   } else if (resolution.model !== undefined && result.modelAvailable !== true) {
     diagnostics.push(modelProbeRefusal(resolution as CliResolution & { model: string }, result));
@@ -668,6 +676,7 @@ function probeFailedMessage(
 ): string {
   const prefix = `Could not verify CLI "${resolution.cli}" for step "${resolution.stepId}"`;
   if (detail === undefined) return `${prefix}.`;
+  if (detail === 'devin_api_key_empty') return `${prefix}: DEVIN_API_KEY must contain a non-empty Devin CLI login token. For hosted flows, set FLOW_DEVIN_API_KEY.`;
   if (detail === 'spawn_failed') return `${prefix}: the probe process could not be started.`;
   if (detail.startsWith('signal:')) {
     return `${prefix}: the probe was terminated by signal "${detail.slice('signal:'.length)}".`;

package/src/step-secrets.ts

@@ -47,6 +47,7 @@ const CLI_LOGIN: Record<CliAdapterKind, readonly string[]> = {
     'AWS_SESSION_TOKEN', 'AWS_REGION', 'AWS_DEFAULT_REGION',
   ],
   codex: ['CODEX_HOME', 'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'OPENAI_API_BASE', 'OPENROUTER_API_KEY'],
+  devin: ['DEVIN_API_KEY', 'DEVIN_MODEL'],
   'relayflows-wrapper-v1': [],
 };
 

package/src/worker-cli.ts

@@ -45,6 +45,7 @@ import {
   type AgentTransport,
 } from './agent-relay-transport.js';
 import { pinCliAlias } from './cli/pinned-cli-alias.js';
+import { prepareDevinRuntime } from './devin-runtime.js';
 import { promptOperand } from './adapters/base.js';
 
 export type { CliTransportCause, CliTransportEvidence, CliTransportPhase } from './cli-transport-evidence.js';
@@ -277,15 +278,22 @@ export async function runAgentCli(
   // The flags go before the `--` that ends the task operand (promptOperand):
   // after it they would reach the CLI as task text, not options.
   const args = [...invocation.args];
-  args.splice(args.length - promptOperand('').length, 0, ...(kind === 'claude' ? ['--output-format', 'stream-json', '--verbose'] : ['--json']));
+  if (kind !== 'devin') args.splice(args.length - promptOperand('').length, 0, ...(kind === 'claude' ? ['--output-format', 'stream-json', '--verbose'] : ['--json']));
   const completion = kind === 'claude' ? claudeResultOutcome : undefined;
   // Retain the source values for output redaction even though the child
   // receives only its filtered environment. A provider can echo a value from
   // its prompt or fixture that was not granted as an environment variable.
-  const redactionEnvironment = { ...processEnvironment, ...env };
-  return requirePricedUsage(decodeProviderResult(await spawnInvocation(
-    cli, { ...invocation, args }, env, signal, sidechannel, cwd, completion, argv0, kind, redactionEnvironment,
-  ), kind, redactionEnvironment), effectiveModel);
+  const redactionEnvironment = { ...processEnvironment, ...env,
+    ...(kind === 'devin' && env.DEVIN_API_KEY !== undefined ? { DEVIN_API_KEY: env.DEVIN_API_KEY.trim() } : {}) };
+  const prepared = kind === 'devin' ? prepareDevinRuntime(env, { ...invocation, args }) : undefined;
+  try {
+    const result = await spawnInvocation(cli,
+      { ...invocation, args: prepared?.args ?? args }, prepared?.env ?? env,
+      signal, sidechannel, cwd, completion, argv0, kind, redactionEnvironment);
+    // Print mode has neither provider frames nor authoritative token counts.
+    return kind === 'devin' ? { ...result, stdout_tail: redactText(result.stdout_tail, redactionEnvironment) }
+      : requirePricedUsage(decodeProviderResult(result, kind, redactionEnvironment), effectiveModel);
+  } finally { prepared?.close(); }
   }
 }