@delexec/ops 0.1.0

package/node_modules/@delexec/responder-controller/src/server.js

@@ -0,0 +1,254 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  createHotlineRouterExecutor,
+  createResponderControllerServer,
+  createResponderState,
+  hydrateResponderState,
+  serializeResponderState,
+  startResponderHeartbeatLoop
+} from "@delexec/responder-runtime-core";
+import { createSqliteSnapshotStore } from "@delexec/sqlite-store";
+import { createEmailEngineTransportAdapter } from "@delexec/transport-emailengine";
+import { createGmailTransportAdapter } from "@delexec/transport-gmail";
+import { createRelayHttpTransportAdapter } from "@delexec/transport-relay-http";
+import { buildOpsEnvSearchPaths, getOpsConfigFile, getResponderConfigFile, loadEnvFiles, readJsonFile } from "@delexec/runtime-utils";
+
+export * from "@delexec/responder-runtime-core";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, "../../..");
+
+loadEnvFiles(buildOpsEnvSearchPaths(ROOT_DIR, "responder"));
+
+function isDirectRun() {
+  if (!process.argv[1]) {
+    return false;
+  }
+  return fs.realpathSync.native(path.resolve(process.argv[1])) === fs.realpathSync.native(__filename);
+}
+
+function decodePemEnv(value) {
+  if (!value) {
+    return null;
+  }
+  return value.replace(/\\n/g, "\n");
+}
+
+function loadResponderStateFromEnv() {
+  const responderId = process.env.RESPONDER_ID || null;
+  const hotlineIds = (process.env.HOTLINE_IDS || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const publicKeyPem = decodePemEnv(process.env.RESPONDER_SIGNING_PUBLIC_KEY_PEM);
+  const privateKeyPem = decodePemEnv(process.env.RESPONDER_SIGNING_PRIVATE_KEY_PEM);
+
+  if (!responderId && hotlineIds.length === 0 && !publicKeyPem && !privateKeyPem) {
+    return createResponderState();
+  }
+
+  const stateOptions = {};
+  if (responderId) {
+    stateOptions.responderId = responderId;
+  }
+  if (hotlineIds.length > 0) {
+    stateOptions.hotlineIds = hotlineIds;
+  }
+  if (publicKeyPem || privateKeyPem) {
+    if (!publicKeyPem || !privateKeyPem) {
+      throw new Error("responder_signing_key_pair_incomplete");
+    }
+    stateOptions.signing = {
+      publicKeyPem,
+      privateKeyPem
+    };
+  }
+
+  return createResponderState(stateOptions);
+}
+
+function loadResponderConfigFromDisk() {
+  const opsConfig = readJsonFile(getOpsConfigFile(), null);
+  if (opsConfig?.responder) {
+    return {
+      responder_id: opsConfig.responder.responder_id || null,
+      display_name: opsConfig.responder.display_name || null,
+      enabled: opsConfig.responder.enabled !== false,
+      hotlines: Array.isArray(opsConfig.responder.hotlines) ? opsConfig.responder.hotlines : []
+    };
+  }
+  return readJsonFile(getResponderConfigFile(), { responder_id: null, display_name: null, enabled: true, hotlines: [] });
+}
+
+function mergeConfigHotlinesIntoState(state, config) {
+  const configuredIds = Array.isArray(config?.hotlines)
+    ? config.hotlines.map((item) => item?.hotline_id).filter(Boolean)
+    : [];
+  if (configuredIds.length === 0) {
+    return state;
+  }
+  const merged = new Set([...(state.identity.hotline_ids || []), ...configuredIds]);
+  state.identity.hotline_ids = Array.from(merged);
+  if (!state.identity.responder_id && config?.responder_id) {
+    state.identity.responder_id = config.responder_id;
+  }
+  state.hotlines = Array.isArray(config?.hotlines) ? config.hotlines : [];
+  return state;
+}
+
+function createExecutorFromConfig(config) {
+  const hotlines = Array.isArray(config?.hotlines) ? config.hotlines : [];
+  if (hotlines.length === 0) {
+    return null;
+  }
+  return createHotlineRouterExecutor(hotlines);
+}
+
+function loadPlatformConfigFromEnv() {
+  const baseUrl = process.env.PLATFORM_API_BASE_URL || null;
+  if (!baseUrl) {
+    return null;
+  }
+
+  return {
+    baseUrl,
+    apiKey: process.env.RESPONDER_PLATFORM_API_KEY || process.env.PLATFORM_API_KEY || null,
+    responderId: process.env.RESPONDER_ID || null
+  };
+}
+
+function loadResponderGuardrailsFromEnv() {
+  const allowedTaskTypes = (process.env.RESPONDER_ALLOWED_TASK_TYPES || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const maxHardTimeoutS = process.env.RESPONDER_MAX_HARD_TIMEOUT_S || null;
+
+  return {
+    maxHardTimeoutS: maxHardTimeoutS ? Number(maxHardTimeoutS) : null,
+    allowedTaskTypes: allowedTaskTypes.length > 0 ? allowedTaskTypes : null
+  };
+}
+
+function loadTransportConfigFromEnv() {
+  const transportType = process.env.TRANSPORT_TYPE || (process.env.TRANSPORT_BASE_URL ? "relay_http" : null);
+  if (transportType === "email") {
+    const provider = process.env.TRANSPORT_EMAIL_PROVIDER || process.env.TRANSPORT_PROVIDER || "unknown";
+    if (provider === "emailengine") {
+      return createEmailEngineTransportAdapter({
+        baseUrl: process.env.TRANSPORT_EMAILENGINE_BASE_URL,
+        account: process.env.TRANSPORT_EMAILENGINE_ACCOUNT,
+        accessToken: process.env.TRANSPORT_EMAILENGINE_ACCESS_TOKEN,
+        sender: process.env.TRANSPORT_EMAIL_SENDER || process.env.TRANSPORT_EMAILENGINE_ACCOUNT || null,
+        receiver: process.env.TRANSPORT_EMAIL_RECEIVER || process.env.RESPONDER_ID || null
+      });
+    }
+    if (provider === "gmail") {
+      return createGmailTransportAdapter({
+        clientId: process.env.TRANSPORT_GMAIL_CLIENT_ID,
+        clientSecret: process.env.TRANSPORT_GMAIL_CLIENT_SECRET,
+        refreshToken: process.env.TRANSPORT_GMAIL_REFRESH_TOKEN,
+        user: process.env.TRANSPORT_GMAIL_USER,
+        sender: process.env.TRANSPORT_EMAIL_SENDER || process.env.TRANSPORT_GMAIL_USER || null,
+        receiver: process.env.TRANSPORT_EMAIL_RECEIVER || process.env.RESPONDER_ID || null
+      });
+    }
+    throw new Error(`TRANSPORT_NOT_IMPLEMENTED: email transport provider ${provider} is not implemented yet`);
+  }
+  const baseUrl = process.env.TRANSPORT_BASE_URL || null;
+  if (!baseUrl || !transportType) {
+    return null;
+  }
+
+  return createRelayHttpTransportAdapter({
+    baseUrl,
+    receiver: process.env.TRANSPORT_RECEIVER || process.env.RESPONDER_ID || "responder-controller"
+  });
+}
+
+async function createOptionalPersistence(serviceName) {
+  const sqlitePath = process.env.SQLITE_DATABASE_PATH || null;
+  if (!sqlitePath) {
+    return null;
+  }
+
+  const store = await createSqliteSnapshotStore({
+    databasePath: sqlitePath,
+    serviceName
+  });
+  await store.migrate();
+  return store;
+}
+
+if (isDirectRun()) {
+  const port = Number(process.env.PORT || 8082);
+  const serviceName = process.env.SERVICE_NAME || "responder-controller";
+  const responderConfig = loadResponderConfigFromDisk();
+  const state = mergeConfigHotlinesIntoState(loadResponderStateFromEnv(), responderConfig);
+  const platform = loadPlatformConfigFromEnv();
+  const transport = loadTransportConfigFromEnv();
+  const executor = createExecutorFromConfig(responderConfig);
+  const persistence = await createOptionalPersistence(serviceName);
+  if (persistence) {
+    hydrateResponderState(state, await persistence.loadSnapshot());
+  }
+  let stopHeartbeat = () => {};
+  const persistSnapshot = persistence
+    ? async (currentState) => {
+        await persistence.saveSnapshot(serializeResponderState(currentState));
+      }
+    : null;
+
+  function restartHeartbeatLoop() {
+    stopHeartbeat();
+    if (platform?.baseUrl && platform?.apiKey) {
+      stopHeartbeat = startResponderHeartbeatLoop({
+        state,
+        platform,
+        intervalMs: Number(process.env.RESPONDER_HEARTBEAT_INTERVAL_MS || 30000),
+        onStateChanged: persistSnapshot
+      });
+      return;
+    }
+    stopHeartbeat = () => {};
+  }
+
+  const server = createResponderControllerServer({
+    serviceName,
+    state,
+    transport,
+    platform,
+    ...(executor ? { executor } : {}),
+    guardrails: loadResponderGuardrailsFromEnv(),
+    background: {
+      enabled: Boolean(transport),
+      receiver: process.env.TRANSPORT_RECEIVER || state.identity.responder_id,
+      inboxPollIntervalMs: Number(process.env.RESPONDER_INBOX_POLL_INTERVAL_MS || 250),
+      workerConcurrency: Number(process.env.RESPONDER_WORKER_CONCURRENCY || state.workerConcurrency || 1)
+    },
+    onStateChanged: persistSnapshot,
+    onPlatformConfigured: async () => {
+      restartHeartbeatLoop();
+      if (persistSnapshot) {
+        await persistSnapshot(state);
+      }
+    }
+  });
+
+  server.listen(port, "0.0.0.0", () => {
+    restartHeartbeatLoop();
+    console.log(`[${serviceName}] listening on ${port}`);
+  });
+
+  server.on("close", () => {
+    stopHeartbeat();
+    if (persistence) {
+      void persistence.saveSnapshot(serializeResponderState(state));
+      void persistence.close();
+    }
+  });
+}

package/node_modules/@delexec/responder-runtime-core/README.md

@@ -0,0 +1,3 @@
+# @delexec/responder-runtime-core
+
+Core responder runtime logic for delegated execution clients.

package/node_modules/@delexec/responder-runtime-core/README.zh-CN.md

@@ -0,0 +1,6 @@
+# @delexec/responder-runtime-core
+
+> 英文版：README.md
+> 说明：中文文档为准。
+
+委托执行客户端的 responder 运行时核心逻辑。

package/node_modules/@delexec/responder-runtime-core/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@delexec/responder-runtime-core",
+  "version": "0.1.0",
+  "description": "Responder runtime core logic for delegated execution",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "delegated-execution",
+    "responder",
+    "runtime"
+  ],
+  "dependencies": {
+    "@delexec/contracts": "^0.1.0"
+  }
+}

package/node_modules/@delexec/responder-runtime-core/src/executors.js

@@ -0,0 +1,326 @@
+import { spawn } from "node:child_process";
+
+export function deferTask(reason = "deferred") {
+  return {
+    deferred: true,
+    reason
+  };
+}
+
+function normalizeExecutionResult(result) {
+  if (!result || typeof result !== "object") {
+    return {
+      status: "error",
+      error: {
+        code: "HOTLINE_INVALID_RESULT",
+        message: "hotline returned an invalid result payload",
+        retryable: false
+      },
+      schema_valid: true,
+      usage: { tokens_in: 0, tokens_out: 0 }
+    };
+  }
+
+  if (result.status === "ok" || result.status === "error" || result.deferred === true) {
+    return result;
+  }
+
+  return {
+    status: "ok",
+    output: result,
+    schema_valid: true,
+    usage: { tokens_in: 0, tokens_out: 0 }
+  };
+}
+
+export function createFunctionExecutor(fn, { name = "function-executor", allowedTaskTypes = null } = {}) {
+  if (typeof fn !== "function") {
+    throw new TypeError("responder_executor_fn_required");
+  }
+
+  return {
+    name,
+    allowedTaskTypes: Array.isArray(allowedTaskTypes) ? [...allowedTaskTypes] : null,
+    async execute(context) {
+      return normalizeExecutionResult(await fn(context));
+    }
+  };
+}
+
+async function runProcessAdapter(adapter, context) {
+  if (!adapter?.cmd) {
+    throw new Error("process_adapter_cmd_required");
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(adapter.cmd, {
+      cwd: adapter.cwd || process.cwd(),
+      env: {
+        ...process.env,
+        ...(adapter.env || {})
+      },
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+
+    child.on("error", reject);
+
+    child.on("close", (code) => {
+      if (code !== 0) {
+        resolve({
+          status: "error",
+          error: {
+            code: "HOTLINE_PROCESS_EXITED",
+            message: stderr.trim() || `process exited with code ${code}`,
+            retryable: false
+          },
+          schema_valid: true,
+          usage: { tokens_in: 0, tokens_out: 0 }
+        });
+        return;
+      }
+
+      try {
+        const parsed = stdout.trim() ? JSON.parse(stdout) : null;
+        resolve(normalizeExecutionResult(parsed));
+      } catch {
+        resolve({
+          status: "error",
+          error: {
+            code: "HOTLINE_PROCESS_INVALID_JSON",
+            message: "process adapter must emit a single JSON payload on stdout",
+            retryable: false
+          },
+          schema_valid: true,
+          usage: { tokens_in: 0, tokens_out: 0 }
+        });
+      }
+    });
+
+    child.stdin.write(
+      JSON.stringify({
+        request_id: context.requestId,
+        responder_id: context.responderId,
+        hotline_id: context.hotlineId,
+        task_type: context.taskType,
+        input: context.taskInput,
+        payload: context.payload,
+        constraints: context.constraints,
+        task: context.task
+      })
+    );
+    child.stdin.end();
+  });
+}
+
+async function runHttpAdapter(adapter, context) {
+  if (!adapter?.url) {
+    throw new Error("http_adapter_url_required");
+  }
+
+  const response = await fetch(adapter.url, {
+    method: adapter.method || "POST",
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+      ...(adapter.headers || {})
+    },
+    body: JSON.stringify({
+      request_id: context.requestId,
+      responder_id: context.responderId,
+      hotline_id: context.hotlineId,
+      task_type: context.taskType,
+      input: context.taskInput,
+      payload: context.payload,
+      constraints: context.constraints,
+      task: context.task
+    })
+  });
+
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+    return {
+      status: "error",
+      error: {
+        code: "HOTLINE_HTTP_INVALID_JSON",
+        message: "http adapter must return JSON",
+        retryable: false
+      },
+      schema_valid: true,
+      usage: { tokens_in: 0, tokens_out: 0 }
+    };
+  }
+
+  if (!response.ok) {
+    return {
+      status: "error",
+      error: {
+        code: "HOTLINE_HTTP_FAILED",
+        message: body?.error?.message || body?.message || `http adapter returned ${response.status}`,
+        retryable: false
+      },
+      schema_valid: true,
+      usage: { tokens_in: 0, tokens_out: 0 }
+    };
+  }
+
+  return normalizeExecutionResult(body);
+}
+
+export function createConfiguredHotlineExecutor(hotline) {
+  const allowedTaskTypes = Array.isArray(hotline?.task_types) ? [...hotline.task_types] : null;
+
+  if (hotline?.adapter_type === "http") {
+    return {
+      name: `http-adapter:${hotline.hotline_id}`,
+      allowedTaskTypes,
+      async execute(context) {
+        return runHttpAdapter(hotline.adapter, context);
+      }
+    };
+  }
+
+  if (hotline?.adapter_type === "function" && typeof hotline?.adapter?.fn === "function") {
+    return createFunctionExecutor(hotline.adapter.fn, {
+      name: `function-adapter:${hotline.hotline_id}`,
+      allowedTaskTypes
+    });
+  }
+
+  return {
+    name: `process-adapter:${hotline?.hotline_id || "unknown"}`,
+    allowedTaskTypes,
+    async execute(context) {
+      return runProcessAdapter(hotline?.adapter || {}, context);
+    }
+  };
+}
+
+export function createHotlineRouterExecutor(hotlines = [], fallback = createSimulatorExecutor()) {
+  const enabled = new Map(
+    (Array.isArray(hotlines) ? hotlines : [])
+      .filter((item) => item?.hotline_id)
+      .map((item) => [item.hotline_id, { definition: item, executor: createConfiguredHotlineExecutor(item) }])
+  );
+
+  return {
+    name: "hotline-router-executor",
+    listHotlines() {
+      return Array.from(enabled.values()).map(({ definition }) => ({
+        hotline_id: definition.hotline_id,
+        display_name: definition.display_name || definition.hotline_id,
+        enabled: definition.enabled !== false,
+        adapter_type: definition.adapter_type || "process",
+        task_types: definition.task_types || [],
+        capabilities: definition.capabilities || [],
+        tags: definition.tags || []
+      }));
+    },
+    getAllowedTaskTypes(hotlineId) {
+      return enabled.get(hotlineId)?.executor.allowedTaskTypes || fallback?.allowedTaskTypes || null;
+    },
+    async execute(context) {
+      const selected = enabled.get(context.hotlineId);
+      if (!selected || selected.definition.enabled === false) {
+        if (fallback?.execute) {
+          return fallback.execute(context);
+        }
+        return {
+          status: "error",
+          error: {
+            code: "HOTLINE_NOT_CONFIGURED",
+            message: `hotline '${context.hotlineId}' is not configured locally`,
+            retryable: false
+          },
+          schema_valid: true,
+          usage: { tokens_in: 0, tokens_out: 0 }
+        };
+      }
+      return selected.executor.execute(context);
+    }
+  };
+}
+
+export function createSimulatorExecutor() {
+  return createFunctionExecutor(
+    async ({ task }) => {
+      if (task.simulate === "timeout") {
+        return deferTask("timeout");
+      }
+
+      if (task.simulate === "token_expired") {
+        return {
+          status: "error",
+          error: {
+            code: "AUTH_TOKEN_EXPIRED",
+            message: "Token expired during responder validation",
+            retryable: false
+          },
+          schema_valid: true,
+          usage: { tokens_in: 0, tokens_out: 0 }
+        };
+      }
+
+      if (task.simulate === "schema_invalid") {
+        return {
+          status: "ok",
+          output: { malformed_field: true },
+          schema_valid: false,
+          usage: { tokens_in: 12, tokens_out: 6 }
+        };
+      }
+
+      if (task.simulate === "reject") {
+        return {
+          status: "error",
+          error: {
+            code: "CONTRACT_REJECTED",
+            message: "Responder guardrail rejected this task",
+            retryable: false
+          },
+          schema_valid: true,
+          usage: { tokens_in: 0, tokens_out: 0 }
+        };
+      }
+
+      return {
+        status: "ok",
+        output: {
+          summary: "Task completed",
+          task_id: task.task_id
+        },
+        schema_valid: true,
+        usage: { tokens_in: 42, tokens_out: 24 }
+      };
+    },
+    { name: "simulator-executor" }
+  );
+}
+
+export function createExampleFunctionExecutor() {
+  return createFunctionExecutor(
+    async ({ taskInput, task }) => ({
+      status: "ok",
+      output: {
+        summary: `Handled ${task.task_type || "task"} for ${task.hotline_id}`,
+        received: taskInput ?? null
+      },
+      schema_valid: true,
+      usage: { tokens_in: 1, tokens_out: 1 }
+    }),
+    { name: "example-function-executor" }
+  );
+}