corporateai 0.0.1

package/server/src/adapters/http/execute.ts

@@ -0,0 +1,42 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "../types.js";
+import { asString, asNumber, parseObject } from "../utils.js";
+
+export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult> {
+  const { config, runId, agent, context } = ctx;
+  const url = asString(config.url, "");
+  if (!url) throw new Error("HTTP adapter missing url");
+
+  const method = asString(config.method, "POST");
+  const timeoutMs = asNumber(config.timeoutMs, 0);
+  const headers = parseObject(config.headers) as Record<string, string>;
+  const payloadTemplate = parseObject(config.payloadTemplate);
+  const body = { ...payloadTemplate, agentId: agent.id, runId, context };
+
+  const controller = new AbortController();
+  const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: {
+        "content-type": "application/json",
+        ...headers,
+      },
+      body: JSON.stringify(body),
+      ...(timer ? { signal: controller.signal } : {}),
+    });
+
+    if (!res.ok) {
+      throw new Error(`HTTP invoke failed with status ${res.status}`);
+    }
+
+    return {
+      exitCode: 0,
+      signal: null,
+      timedOut: false,
+      summary: `HTTP ${method} ${url}`,
+    };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}

package/server/src/adapters/http/index.ts

@@ -0,0 +1,21 @@
+import type { ServerAdapterModule } from "../types.js";
+import { execute } from "./execute.js";
+import { testEnvironment } from "./test.js";
+
+export const httpAdapter: ServerAdapterModule = {
+  type: "http",
+  execute,
+  testEnvironment,
+  models: [],
+  agentConfigurationDoc: `# http agent configuration
+
+Adapter: http
+
+Core fields:
+- url (string, required): endpoint to invoke
+- method (string, optional): HTTP method, default POST
+- headers (object, optional): request headers
+- payloadTemplate (object, optional): JSON payload template
+- timeoutSec (number, optional): request timeout in seconds
+`,
+};

package/server/src/adapters/http/test.ts

@@ -0,0 +1,116 @@
+import type {
+  AdapterEnvironmentCheck,
+  AdapterEnvironmentTestContext,
+  AdapterEnvironmentTestResult,
+} from "../types.js";
+import { asString, parseObject } from "../utils.js";
+
+function summarizeStatus(checks: AdapterEnvironmentCheck[]): AdapterEnvironmentTestResult["status"] {
+  if (checks.some((check) => check.level === "error")) return "fail";
+  if (checks.some((check) => check.level === "warn")) return "warn";
+  return "pass";
+}
+
+function normalizeMethod(input: string): string {
+  const trimmed = input.trim();
+  return trimmed.length > 0 ? trimmed.toUpperCase() : "POST";
+}
+
+export async function testEnvironment(
+  ctx: AdapterEnvironmentTestContext,
+): Promise<AdapterEnvironmentTestResult> {
+  const checks: AdapterEnvironmentCheck[] = [];
+  const config = parseObject(ctx.config);
+  const urlValue = asString(config.url, "");
+  const method = normalizeMethod(asString(config.method, "POST"));
+
+  if (!urlValue) {
+    checks.push({
+      code: "http_url_missing",
+      level: "error",
+      message: "HTTP adapter requires a URL.",
+      hint: "Set adapterConfig.url to an absolute http(s) endpoint.",
+    });
+    return {
+      adapterType: ctx.adapterType,
+      status: summarizeStatus(checks),
+      checks,
+      testedAt: new Date().toISOString(),
+    };
+  }
+
+  let url: URL | null = null;
+  try {
+    url = new URL(urlValue);
+  } catch {
+    checks.push({
+      code: "http_url_invalid",
+      level: "error",
+      message: `Invalid URL: ${urlValue}`,
+    });
+  }
+
+  if (url && url.protocol !== "http:" && url.protocol !== "https:") {
+    checks.push({
+      code: "http_url_protocol_invalid",
+      level: "error",
+      message: `Unsupported URL protocol: ${url.protocol}`,
+      hint: "Use an http:// or https:// endpoint.",
+    });
+  }
+
+  if (url) {
+    checks.push({
+      code: "http_url_valid",
+      level: "info",
+      message: `Configured endpoint: ${url.toString()}`,
+    });
+  }
+
+  checks.push({
+    code: "http_method_configured",
+    level: "info",
+    message: `Configured method: ${method}`,
+  });
+
+  if (url && (url.protocol === "http:" || url.protocol === "https:")) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    try {
+      const response = await fetch(url, {
+        method: "HEAD",
+        signal: controller.signal,
+      });
+      if (!response.ok && response.status !== 405 && response.status !== 501) {
+        checks.push({
+          code: "http_endpoint_probe_unexpected_status",
+          level: "warn",
+          message: `Endpoint probe returned HTTP ${response.status}.`,
+          hint: "Verify the endpoint is reachable from the Corporate server host.",
+        });
+      } else {
+        checks.push({
+          code: "http_endpoint_probe_ok",
+          level: "info",
+          message: "Endpoint responded to a HEAD probe.",
+        });
+      }
+    } catch (err) {
+      checks.push({
+        code: "http_endpoint_probe_failed",
+        level: "warn",
+        message: err instanceof Error ? err.message : "Endpoint probe failed",
+        hint: "This may be expected in restricted networks; verify connectivity when invoking runs.",
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  return {
+    adapterType: ctx.adapterType,
+    status: summarizeStatus(checks),
+    checks,
+    testedAt: new Date().toISOString(),
+  };
+}

package/server/src/adapters/index.ts

@@ -0,0 +1,18 @@
+export { getServerAdapter, listAdapterModels, listServerAdapters, findServerAdapter } from "./registry.js";
+export type {
+  ServerAdapterModule,
+  AdapterExecutionContext,
+  AdapterExecutionResult,
+  AdapterInvocationMeta,
+  AdapterEnvironmentCheckLevel,
+  AdapterEnvironmentCheck,
+  AdapterEnvironmentTestStatus,
+  AdapterEnvironmentTestResult,
+  AdapterEnvironmentTestContext,
+  AdapterSessionCodec,
+  UsageSummary,
+  AdapterAgent,
+  AdapterRuntime,
+} from "@corporateai/adapter-utils";
+export { runningProcesses } from "./utils.js";
+

package/server/src/adapters/process/execute.ts

@@ -0,0 +1,77 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "../types.js";
+import {
+  asString,
+  asNumber,
+  asStringArray,
+  parseObject,
+  buildPaperclipEnv,
+  redactEnvForLogs,
+  runChildProcess,
+} from "../utils.js";
+
+export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult> {
+  const { runId, agent, config, onLog, onMeta } = ctx;
+  const command = asString(config.command, "");
+  if (!command) throw new Error("Process adapter missing command");
+
+  const args = asStringArray(config.args);
+  const cwd = asString(config.cwd, process.cwd());
+  const envConfig = parseObject(config.env);
+  const env: Record<string, string> = { ...buildPaperclipEnv(agent) };
+  for (const [k, v] of Object.entries(envConfig)) {
+    if (typeof v === "string") env[k] = v;
+  }
+
+  const timeoutSec = asNumber(config.timeoutSec, 0);
+  const graceSec = asNumber(config.graceSec, 15);
+
+  if (onMeta) {
+    await onMeta({
+      adapterType: "process",
+      command,
+      cwd,
+      commandArgs: args,
+      env: redactEnvForLogs(env),
+    });
+  }
+
+  const proc = await runChildProcess(runId, command, args, {
+    cwd,
+    env,
+    timeoutSec,
+    graceSec,
+    onLog,
+  });
+
+  if (proc.timedOut) {
+    return {
+      exitCode: proc.exitCode,
+      signal: proc.signal,
+      timedOut: true,
+      errorMessage: `Timed out after ${timeoutSec}s`,
+    };
+  }
+
+  if ((proc.exitCode ?? 0) !== 0) {
+    return {
+      exitCode: proc.exitCode,
+      signal: proc.signal,
+      timedOut: false,
+      errorMessage: `Process exited with code ${proc.exitCode ?? -1}`,
+      resultJson: {
+        stdout: proc.stdout,
+        stderr: proc.stderr,
+      },
+    };
+  }
+
+  return {
+    exitCode: proc.exitCode,
+    signal: proc.signal,
+    timedOut: false,
+    resultJson: {
+      stdout: proc.stdout,
+      stderr: proc.stderr,
+    },
+  };
+}

package/server/src/adapters/process/index.ts

@@ -0,0 +1,24 @@
+import type { ServerAdapterModule } from "../types.js";
+import { execute } from "./execute.js";
+import { testEnvironment } from "./test.js";
+
+export const processAdapter: ServerAdapterModule = {
+  type: "process",
+  execute,
+  testEnvironment,
+  models: [],
+  agentConfigurationDoc: `# process agent configuration
+
+Adapter: process
+
+Core fields:
+- command (string, required): command to execute
+- args (string[] | string, optional): command arguments
+- cwd (string, optional): absolute working directory
+- env (object, optional): KEY=VALUE environment variables
+
+Operational fields:
+- timeoutSec (number, optional): run timeout in seconds
+- graceSec (number, optional): SIGTERM grace period in seconds
+`,
+};

package/server/src/adapters/process/test.ts

@@ -0,0 +1,89 @@
+import type {
+  AdapterEnvironmentCheck,
+  AdapterEnvironmentTestContext,
+  AdapterEnvironmentTestResult,
+} from "../types.js";
+import {
+  asString,
+  parseObject,
+  ensureAbsoluteDirectory,
+  ensureCommandResolvable,
+  ensurePathInEnv,
+} from "../utils.js";
+
+function summarizeStatus(checks: AdapterEnvironmentCheck[]): AdapterEnvironmentTestResult["status"] {
+  if (checks.some((check) => check.level === "error")) return "fail";
+  if (checks.some((check) => check.level === "warn")) return "warn";
+  return "pass";
+}
+
+export async function testEnvironment(
+  ctx: AdapterEnvironmentTestContext,
+): Promise<AdapterEnvironmentTestResult> {
+  const checks: AdapterEnvironmentCheck[] = [];
+  const config = parseObject(ctx.config);
+  const command = asString(config.command, "");
+  const cwd = asString(config.cwd, process.cwd());
+
+  if (!command) {
+    checks.push({
+      code: "process_command_missing",
+      level: "error",
+      message: "Process adapter requires a command.",
+      hint: "Set adapterConfig.command to an executable command.",
+    });
+  } else {
+    checks.push({
+      code: "process_command_present",
+      level: "info",
+      message: `Configured command: ${command}`,
+    });
+  }
+
+  try {
+    await ensureAbsoluteDirectory(cwd);
+    checks.push({
+      code: "process_cwd_valid",
+      level: "info",
+      message: `Working directory is valid: ${cwd}`,
+    });
+  } catch (err) {
+    checks.push({
+      code: "process_cwd_invalid",
+      level: "error",
+      message: err instanceof Error ? err.message : "Invalid working directory",
+      detail: cwd,
+    });
+  }
+
+  if (command) {
+    const envConfig = parseObject(config.env);
+    const env: Record<string, string> = {};
+    for (const [key, value] of Object.entries(envConfig)) {
+      if (typeof value === "string") env[key] = value;
+    }
+    const runtimeEnv = ensurePathInEnv({ ...process.env, ...env });
+    try {
+      await ensureCommandResolvable(command, cwd, runtimeEnv);
+      checks.push({
+        code: "process_command_resolvable",
+        level: "info",
+        message: `Command is executable: ${command}`,
+      });
+    } catch (err) {
+      checks.push({
+        code: "process_command_unresolvable",
+        level: "error",
+        message: err instanceof Error ? err.message : "Command is not executable",
+        detail: command,
+      });
+    }
+  }
+
+  return {
+    adapterType: ctx.adapterType,
+    status: summarizeStatus(checks),
+    checks,
+    testedAt: new Date().toISOString(),
+  };
+}

package/server/src/adapters/registry.ts

@@ -0,0 +1,225 @@
+import type { ServerAdapterModule } from "./types.js";
+import { getAdapterSessionManagement } from "@corporateai/adapter-utils";
+import {
+  execute as claudeExecute,
+  listClaudeSkills,
+  syncClaudeSkills,
+  testEnvironment as claudeTestEnvironment,
+  sessionCodec as claudeSessionCodec,
+  getQuotaWindows as claudeGetQuotaWindows,
+} from "@corporateai/adapter-claude-local/server";
+import { agentConfigurationDoc as claudeAgentConfigurationDoc, models as claudeModels } from "@corporateai/adapter-claude-local";
+import {
+  execute as codexExecute,
+  listCodexSkills,
+  syncCodexSkills,
+  testEnvironment as codexTestEnvironment,
+  sessionCodec as codexSessionCodec,
+  getQuotaWindows as codexGetQuotaWindows,
+} from "@corporateai/adapter-codex-local/server";
+import { agentConfigurationDoc as codexAgentConfigurationDoc, models as codexModels } from "@corporateai/adapter-codex-local";
+import {
+  execute as cursorExecute,
+  listCursorSkills,
+  syncCursorSkills,
+  testEnvironment as cursorTestEnvironment,
+  sessionCodec as cursorSessionCodec,
+} from "@corporateai/adapter-cursor-local/server";
+import { agentConfigurationDoc as cursorAgentConfigurationDoc, models as cursorModels } from "@corporateai/adapter-cursor-local";
+import {
+  execute as geminiExecute,
+  listGeminiSkills,
+  syncGeminiSkills,
+  testEnvironment as geminiTestEnvironment,
+  sessionCodec as geminiSessionCodec,
+} from "@corporateai/adapter-gemini-local/server";
+import { agentConfigurationDoc as geminiAgentConfigurationDoc, models as geminiModels } from "@corporateai/adapter-gemini-local";
+import {
+  execute as openCodeExecute,
+  listOpenCodeSkills,
+  syncOpenCodeSkills,
+  testEnvironment as openCodeTestEnvironment,
+  sessionCodec as openCodeSessionCodec,
+  listOpenCodeModels,
+} from "@corporateai/adapter-opencode-local/server";
+import {
+  agentConfigurationDoc as openCodeAgentConfigurationDoc,
+} from "@corporateai/adapter-opencode-local";
+import {
+  execute as openclawGatewayExecute,
+  testEnvironment as openclawGatewayTestEnvironment,
+} from "@corporateai/adapter-openclaw-gateway/server";
+import {
+  agentConfigurationDoc as openclawGatewayAgentConfigurationDoc,
+  models as openclawGatewayModels,
+} from "@corporateai/adapter-openclaw-gateway";
+import { listCodexModels } from "./codex-models.js";
+import { listCursorModels } from "./cursor-models.js";
+import {
+  execute as piExecute,
+  listPiSkills,
+  syncPiSkills,
+  testEnvironment as piTestEnvironment,
+  sessionCodec as piSessionCodec,
+  listPiModels,
+} from "@corporateai/adapter-pi-local/server";
+import {
+  agentConfigurationDoc as piAgentConfigurationDoc,
+} from "@corporateai/adapter-pi-local";
+import {
+  execute as hermesExecute,
+  testEnvironment as hermesTestEnvironment,
+  sessionCodec as hermesSessionCodec,
+} from "hermes-paperclip-adapter/server";
+import {
+  agentConfigurationDoc as hermesAgentConfigurationDoc,
+  models as hermesModels,
+} from "hermes-paperclip-adapter";
+import { processAdapter } from "./process/index.js";
+import { httpAdapter } from "./http/index.js";
+
+const claudeLocalAdapter: ServerAdapterModule = {
+  type: "claude_local",
+  execute: claudeExecute,
+  testEnvironment: claudeTestEnvironment,
+  listSkills: listClaudeSkills,
+  syncSkills: syncClaudeSkills,
+  sessionCodec: claudeSessionCodec,
+  sessionManagement: getAdapterSessionManagement("claude_local") ?? undefined,
+  models: claudeModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: claudeAgentConfigurationDoc,
+  getQuotaWindows: claudeGetQuotaWindows,
+};
+
+const codexLocalAdapter: ServerAdapterModule = {
+  type: "codex_local",
+  execute: codexExecute,
+  testEnvironment: codexTestEnvironment,
+  listSkills: listCodexSkills,
+  syncSkills: syncCodexSkills,
+  sessionCodec: codexSessionCodec,
+  sessionManagement: getAdapterSessionManagement("codex_local") ?? undefined,
+  models: codexModels,
+  listModels: listCodexModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: codexAgentConfigurationDoc,
+  getQuotaWindows: codexGetQuotaWindows,
+};
+
+const cursorLocalAdapter: ServerAdapterModule = {
+  type: "cursor",
+  execute: cursorExecute,
+  testEnvironment: cursorTestEnvironment,
+  listSkills: listCursorSkills,
+  syncSkills: syncCursorSkills,
+  sessionCodec: cursorSessionCodec,
+  sessionManagement: getAdapterSessionManagement("cursor") ?? undefined,
+  models: cursorModels,
+  listModels: listCursorModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: cursorAgentConfigurationDoc,
+};
+
+const geminiLocalAdapter: ServerAdapterModule = {
+  type: "gemini_local",
+  execute: geminiExecute,
+  testEnvironment: geminiTestEnvironment,
+  listSkills: listGeminiSkills,
+  syncSkills: syncGeminiSkills,
+  sessionCodec: geminiSessionCodec,
+  sessionManagement: getAdapterSessionManagement("gemini_local") ?? undefined,
+  models: geminiModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: geminiAgentConfigurationDoc,
+};
+
+const openclawGatewayAdapter: ServerAdapterModule = {
+  type: "openclaw_gateway",
+  execute: openclawGatewayExecute,
+  testEnvironment: openclawGatewayTestEnvironment,
+  models: openclawGatewayModels,
+  supportsLocalAgentJwt: false,
+  agentConfigurationDoc: openclawGatewayAgentConfigurationDoc,
+};
+
+const openCodeLocalAdapter: ServerAdapterModule = {
+  type: "opencode_local",
+  execute: openCodeExecute,
+  testEnvironment: openCodeTestEnvironment,
+  listSkills: listOpenCodeSkills,
+  syncSkills: syncOpenCodeSkills,
+  sessionCodec: openCodeSessionCodec,
+  sessionManagement: getAdapterSessionManagement("opencode_local") ?? undefined,
+  models: [],
+  listModels: listOpenCodeModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: openCodeAgentConfigurationDoc,
+};
+
+const piLocalAdapter: ServerAdapterModule = {
+  type: "pi_local",
+  execute: piExecute,
+  testEnvironment: piTestEnvironment,
+  listSkills: listPiSkills,
+  syncSkills: syncPiSkills,
+  sessionCodec: piSessionCodec,
+  sessionManagement: getAdapterSessionManagement("pi_local") ?? undefined,
+  models: [],
+  listModels: listPiModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: piAgentConfigurationDoc,
+};
+
+const hermesLocalAdapter: ServerAdapterModule = {
+  type: "hermes_local",
+  execute: hermesExecute,
+  testEnvironment: hermesTestEnvironment,
+  sessionCodec: hermesSessionCodec,
+  models: hermesModels,
+  supportsLocalAgentJwt: true,
+  agentConfigurationDoc: hermesAgentConfigurationDoc,
+};
+
+const adaptersByType = new Map<string, ServerAdapterModule>(
+  [
+    claudeLocalAdapter,
+    codexLocalAdapter,
+    openCodeLocalAdapter,
+    piLocalAdapter,
+    cursorLocalAdapter,
+    geminiLocalAdapter,
+    openclawGatewayAdapter,
+    hermesLocalAdapter,
+    processAdapter,
+    httpAdapter,
+  ].map((a) => [a.type, a]),
+);
+
+export function getServerAdapter(type: string): ServerAdapterModule {
+  const adapter = adaptersByType.get(type);
+  if (!adapter) {
+    // Fall back to process adapter for unknown types
+    return processAdapter;
+  }
+  return adapter;
+}
+
+export async function listAdapterModels(type: string): Promise<{ id: string; label: string }[]> {
+  const adapter = adaptersByType.get(type);
+  if (!adapter) return [];
+  if (adapter.listModels) {
+    const discovered = await adapter.listModels();
+    if (discovered.length > 0) return discovered;
+  }
+  return adapter.models ?? [];
+}
+
+export function listServerAdapters(): ServerAdapterModule[] {
+  return Array.from(adaptersByType.values());
+}
+
+export function findServerAdapter(type: string): ServerAdapterModule | null {
+  return adaptersByType.get(type) ?? null;
+}
+

package/server/src/adapters/server-utils-compat.ts

@@ -0,0 +1,57 @@
+import * as adapterServerUtils from "@corporateai/adapter-utils/server-utils";
+
+type SkillSyncPreference = {
+  desiredSkills: string[];
+};
+
+function normalizeDesiredSkills(input: unknown): string[] {
+  if (!Array.isArray(input)) return [];
+  return Array.from(
+    new Set(
+      input
+        .map((value) => (typeof value === "string" ? value.trim() : ""))
+        .filter(Boolean),
+    ),
+  );
+}
+
+export function readPaperclipSkillSyncPreference(config: Record<string, unknown>): SkillSyncPreference {
+  const readFn = (adapterServerUtils as any).readPaperclipSkillSyncPreference as
+    | ((value: Record<string, unknown>) => SkillSyncPreference)
+    | undefined;
+  if (typeof readFn === "function") {
+    return readFn(config);
+  }
+
+  const raw =
+    config && typeof config === "object"
+      ? (config.paperclipSkillSync as { desiredSkills?: unknown } | undefined)
+      : undefined;
+
+  return {
+    desiredSkills: normalizeDesiredSkills(raw?.desiredSkills),
+  };
+}
+
+export function writePaperclipSkillSyncPreference(
+  config: Record<string, unknown>,
+  desiredSkills: string[],
+): Record<string, unknown> {
+  const writeFn = (adapterServerUtils as any).writePaperclipSkillSyncPreference as
+    | ((value: Record<string, unknown>, desired: string[]) => Record<string, unknown>)
+    | undefined;
+  if (typeof writeFn === "function") {
+    return writeFn(config, desiredSkills);
+  }
+
+  return {
+    ...config,
+    paperclipSkillSync: {
+      ...(config.paperclipSkillSync && typeof config.paperclipSkillSync === "object"
+        ? (config.paperclipSkillSync as Record<string, unknown>)
+        : {}),
+      desiredSkills: normalizeDesiredSkills(desiredSkills),
+    },
+  };
+}
+