@xfxstudio/claworld 0.2.12 → 0.2.14

package/src/openclaw/installer/workspace-contract.js

@@ -1,427 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
-import {
-  buildWorkspaceAgentsContent,
-  buildWorkspaceMemoryContent,
-  expandUserPath,
-  normalizeText,
-} from '../plugin/managed-config.js';
-
-export const CLAWORLD_MANAGED_WORKSPACE_METADATA_FILE = '.claworld-managed.json';
-export const CLAWORLD_MANAGED_WORKSPACE_CONTRACT_VERSION = 1;
-
-function resolveHomeDir(homeDir = null) {
-  const explicitHomeDir = normalizeText(homeDir, null);
-  if (explicitHomeDir) {
-    return explicitHomeDir;
-  }
-
-  const envHomeDir = normalizeText(
-    process.env.HOME,
-    normalizeText(
-      process.env.USERPROFILE,
-      normalizeText(
-        process.env.HOMEDRIVE && process.env.HOMEPATH
-          ? path.join(process.env.HOMEDRIVE, process.env.HOMEPATH)
-          : null,
-        null,
-      ),
-    ),
-  );
-
-  return envHomeDir || os.homedir();
-}
-
-function createHash(content) {
-  return crypto.createHash('sha256').update(String(content || ''), 'utf8').digest('hex');
-}
-
-async function readTextIfPresent(filePath) {
-  try {
-    return await fs.readFile(filePath, 'utf8');
-  } catch (error) {
-    if (error && error.code === 'ENOENT') return null;
-    throw error;
-  }
-}
-
-function createWorkspaceFileSpec(relativePath, policy, content) {
-  return {
-    relativePath,
-    policy,
-    content,
-    expectedHash: createHash(content),
-  };
-}
-
-function normalizeMetadata(source = {}) {
-  if (!source || typeof source !== 'object' || Array.isArray(source)) {
-    return null;
-  }
-  const files = source.files && typeof source.files === 'object' && !Array.isArray(source.files)
-    ? source.files
-    : {};
-  return {
-    channel: normalizeText(source.channel, null),
-    contractVersion: Number(source.contractVersion) || null,
-    workspaceOwner: normalizeText(source.workspaceOwner, null),
-    accountId: normalizeText(source.accountId, null),
-    updatedAt: normalizeText(source.updatedAt, null),
-    files,
-  };
-}
-
-export function resolveManagedWorkspacePath(workspace, homeDir = null) {
-  return path.resolve(expandUserPath(workspace, resolveHomeDir(homeDir)));
-}
-
-export function buildManagedWorkspaceContract(options = {}, homeDir = null) {
-  const resolvedHomeDir = resolveHomeDir(homeDir);
-  const workspacePath = resolveManagedWorkspacePath(options.workspace, resolvedHomeDir);
-  const files = [
-    createWorkspaceFileSpec('AGENTS.md', 'refreshable', buildWorkspaceAgentsContent(options)),
-    createWorkspaceFileSpec('MEMORY.md', 'durable', buildWorkspaceMemoryContent(options)),
-  ];
-  return {
-    channel: 'claworld',
-    contractVersion: CLAWORLD_MANAGED_WORKSPACE_CONTRACT_VERSION,
-    workspacePath,
-    metadataPath: path.join(workspacePath, CLAWORLD_MANAGED_WORKSPACE_METADATA_FILE),
-    workspaceOwner: normalizeText(options.agentId, null),
-    accountId: normalizeText(options.accountId, null),
-    files: files.map((file) => ({
-      ...file,
-      absolutePath: path.join(workspacePath, file.relativePath),
-    })),
-  };
-}
-
-export async function loadManagedWorkspaceMetadata(workspacePath, homeDir = null) {
-  const resolvedWorkspacePath = resolveManagedWorkspacePath(workspacePath, homeDir);
-  const metadataPath = path.join(resolvedWorkspacePath, CLAWORLD_MANAGED_WORKSPACE_METADATA_FILE);
-  const raw = await readTextIfPresent(metadataPath);
-  if (raw == null) {
-    return {
-      exists: false,
-      metadataPath,
-      value: null,
-      parseError: null,
-    };
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    return {
-      exists: true,
-      metadataPath,
-      value: normalizeMetadata(parsed),
-      parseError: null,
-    };
-  } catch (error) {
-    return {
-      exists: true,
-      metadataPath,
-      value: null,
-      parseError: error,
-    };
-  }
-}
-
-function toMetadataFileState({
-  file,
-  managedHash,
-  observedHash,
-  state,
-}) {
-  return {
-    policy: file.policy,
-    expectedHash: file.expectedHash,
-    managedHash,
-    observedHash,
-    state,
-  };
-}
-
-function evaluateRefreshableFile({
-  file,
-  currentContent,
-  previousRecord = null,
-}) {
-  if (currentContent == null) {
-    return {
-      action: 'create',
-      nextContent: file.content,
-      nextRecord: toMetadataFileState({
-        file,
-        managedHash: file.expectedHash,
-        observedHash: file.expectedHash,
-        state: 'managed_current',
-      }),
-      inspectState: 'missing',
-    };
-  }
-
-  const currentHash = createHash(currentContent);
-  if (currentHash === file.expectedHash) {
-    return {
-      action: 'keep',
-      nextContent: null,
-      nextRecord: toMetadataFileState({
-        file,
-        managedHash: file.expectedHash,
-        observedHash: currentHash,
-        state: 'managed_current',
-      }),
-      inspectState: 'managed_current',
-    };
-  }
-
-  if (previousRecord?.managedHash && currentHash === previousRecord.managedHash) {
-    return {
-      action: 'refresh',
-      nextContent: file.content,
-      nextRecord: toMetadataFileState({
-        file,
-        managedHash: file.expectedHash,
-        observedHash: file.expectedHash,
-        state: 'managed_current',
-      }),
-      inspectState: 'managed_stale',
-    };
-  }
-
-  return {
-    action: 'preserve',
-    nextContent: null,
-    nextRecord: toMetadataFileState({
-      file,
-      managedHash: previousRecord?.managedHash || null,
-      observedHash: currentHash,
-      state: 'customized',
-    }),
-    inspectState: 'customized',
-  };
-}
-
-function evaluateDurableFile({
-  file,
-  currentContent,
-  previousRecord = null,
-}) {
-  if (currentContent == null) {
-    return {
-      action: 'create',
-      nextContent: file.content,
-      nextRecord: toMetadataFileState({
-        file,
-        managedHash: file.expectedHash,
-        observedHash: file.expectedHash,
-        state: 'durable_present',
-      }),
-      inspectState: 'missing',
-    };
-  }
-
-  const currentHash = createHash(currentContent);
-  return {
-    action: 'preserve',
-    nextContent: null,
-    nextRecord: toMetadataFileState({
-      file,
-      managedHash: previousRecord?.managedHash || (currentHash === file.expectedHash ? file.expectedHash : null),
-      observedHash: currentHash,
-      state: currentHash === file.expectedHash ? 'durable_present' : 'durable_customized',
-    }),
-    inspectState: currentHash === file.expectedHash ? 'durable_present' : 'durable_customized',
-  };
-}
-
-export async function seedManagedWorkspaceContract(options = {}, dryRun = false, homeDir = null) {
-  const resolvedHomeDir = resolveHomeDir(homeDir);
-  const contract = buildManagedWorkspaceContract(options, resolvedHomeDir);
-  const agentDirPath = options.agentDirExplicit && options.agentDir
-    ? path.resolve(expandUserPath(options.agentDir, resolvedHomeDir))
-    : null;
-  const metadataState = await loadManagedWorkspaceMetadata(contract.workspacePath, resolvedHomeDir);
-  const previousFiles = metadataState.value?.files || {};
-  const actions = [];
-
-  if (dryRun) {
-    actions.push(`mkdir -p ${contract.workspacePath}`);
-    if (agentDirPath) {
-      actions.push(`mkdir -p ${agentDirPath}`);
-    }
-    for (const file of contract.files) {
-      actions.push(`${file.policy === 'refreshable' ? 'refresh' : 'seed'} ${file.absolutePath} when contract allows`);
-    }
-    actions.push(`write ${contract.metadataPath}`);
-    return actions;
-  }
-
-  await fs.mkdir(contract.workspacePath, { recursive: true });
-  actions.push(`ensured ${contract.workspacePath}`);
-  if (agentDirPath) {
-    await fs.mkdir(agentDirPath, { recursive: true });
-    actions.push(`ensured ${agentDirPath}`);
-  }
-
-  const nextMetadata = {
-    channel: contract.channel,
-    contractVersion: contract.contractVersion,
-    workspaceOwner: contract.workspaceOwner,
-    accountId: contract.accountId,
-    updatedAt: new Date().toISOString(),
-    files: {},
-  };
-
-  for (const file of contract.files) {
-    const currentContent = await readTextIfPresent(file.absolutePath);
-    const previousRecord = previousFiles[file.relativePath] || null;
-    const decision = file.policy === 'refreshable'
-      ? evaluateRefreshableFile({ file, currentContent, previousRecord })
-      : evaluateDurableFile({ file, currentContent, previousRecord });
-
-    if (decision.nextContent != null) {
-      await fs.writeFile(file.absolutePath, decision.nextContent, 'utf8');
-    }
-
-    if (decision.action === 'create') {
-      actions.push(`created ${file.absolutePath}`);
-    } else if (decision.action === 'refresh') {
-      actions.push(`refreshed ${file.absolutePath}`);
-    } else if (decision.action === 'preserve' && file.policy === 'durable') {
-      actions.push(`kept durable ${file.absolutePath}`);
-    } else if (decision.action === 'preserve') {
-      actions.push(`preserved customized ${file.absolutePath}`);
-    } else {
-      actions.push(`kept current ${file.absolutePath}`);
-    }
-
-    nextMetadata.files[file.relativePath] = decision.nextRecord;
-  }
-
-  await fs.writeFile(contract.metadataPath, `${JSON.stringify(nextMetadata, null, 2)}\n`, 'utf8');
-  actions.push(`wrote ${contract.metadataPath}`);
-  return actions;
-}
-
-export async function inspectManagedWorkspaceContract(options = {}, homeDir = os.homedir()) {
-  const contract = buildManagedWorkspaceContract(options, homeDir);
-  const metadataState = await loadManagedWorkspaceMetadata(contract.workspacePath, homeDir);
-  const files = [];
-  const issues = [];
-  let workspaceExists = true;
-
-  try {
-    const stat = await fs.stat(contract.workspacePath);
-    workspaceExists = stat.isDirectory();
-  } catch (error) {
-    if (error && error.code === 'ENOENT') {
-      workspaceExists = false;
-    } else {
-      throw error;
-    }
-  }
-
-  if (!workspaceExists) {
-    issues.push({
-      code: 'workspace_missing',
-      message: `Managed workspace is missing: ${contract.workspacePath}`,
-      severity: 'fail',
-    });
-  }
-
-  if (!metadataState.exists) {
-    issues.push({
-      code: 'workspace_metadata_missing',
-      message: `Managed workspace metadata is missing: ${contract.metadataPath}`,
-      severity: 'fail',
-    });
-  } else if (metadataState.parseError || !metadataState.value) {
-    issues.push({
-      code: 'workspace_metadata_invalid',
-      message: `Managed workspace metadata is invalid: ${contract.metadataPath}`,
-      severity: 'fail',
-    });
-  } else if (metadataState.value.contractVersion !== contract.contractVersion) {
-    issues.push({
-      code: 'workspace_metadata_version_mismatch',
-      message: `Managed workspace metadata version is ${metadataState.value.contractVersion}; expected ${contract.contractVersion}.`,
-      severity: 'warn',
-    });
-  }
-
-  const metadataFiles = metadataState.value?.files || {};
-  for (const file of contract.files) {
-    const currentContent = await readTextIfPresent(file.absolutePath);
-    const currentHash = currentContent == null ? null : createHash(currentContent);
-    const metadataFile = metadataFiles[file.relativePath] || null;
-    let state = 'missing';
-    let healthy = false;
-    let message = `${file.relativePath} is missing.`;
-
-    if (currentContent != null) {
-      if (file.policy === 'durable') {
-        state = currentHash === file.expectedHash ? 'durable_present' : 'durable_customized';
-        healthy = true;
-        message = state === 'durable_present'
-          ? `${file.relativePath} matches the durable seed.`
-          : `${file.relativePath} exists and is protected durable state.`;
-      } else if (currentHash === file.expectedHash) {
-        state = 'managed_current';
-        healthy = true;
-        message = `${file.relativePath} matches the managed seed.`;
-      } else if (metadataFile?.managedHash && currentHash === metadataFile.managedHash) {
-        state = 'managed_stale';
-        message = `${file.relativePath} still matches an older managed seed and can be refreshed.`;
-        issues.push({
-          code: 'workspace_refreshable_stale',
-          message,
-          severity: 'warn',
-          file: file.relativePath,
-        });
-      } else {
-        state = 'customized';
-        message = `${file.relativePath} differs from the managed seed and was preserved.`;
-        issues.push({
-          code: 'workspace_refreshable_customized',
-          message,
-          severity: 'warn',
-          file: file.relativePath,
-        });
-      }
-    } else {
-      issues.push({
-        code: 'workspace_seed_file_missing',
-        message,
-        severity: 'fail',
-        file: file.relativePath,
-      });
-    }
-
-    files.push({
-      relativePath: file.relativePath,
-      absolutePath: file.absolutePath,
-      policy: file.policy,
-      exists: currentContent != null,
-      state,
-      healthy,
-      expectedHash: file.expectedHash,
-      observedHash: currentHash,
-      metadata: metadataFile,
-      message,
-    });
-  }
-
-  return {
-    ok: issues.every((issue) => issue.severity !== 'fail'),
-    workspaceExists,
-    workspacePath: contract.workspacePath,
-    metadataPath: contract.metadataPath,
-    contractVersion: contract.contractVersion,
-    metadata: metadataState,
-    files,
-    issues,
-  };
-}

package/src/product-shell/agent-cards/card-routes.js

@@ -1,64 +0,0 @@
-import { resolveAuthenticatedAgentId } from '../../lib/http-auth.js';
-
-function sendAgentCardError(res, error) {
-  const status = Number.isInteger(error?.status) ? error.status : 500;
-  if (error?.responseBody && typeof error.responseBody === 'object') {
-    return res.status(status).json(error.responseBody);
-  }
-  const code = typeof error?.code === 'string' ? error.code : 'internal_error';
-  return res.status(status).json({ error: code, message: error?.message || code });
-}
-
-function buildAbsoluteUrl(req, publicPath) {
-  return `${req.protocol}://${req.get('host')}${publicPath}`;
-}
-
-export function registerAgentCardRoutes(app, { store, agentCardService }) {
-  app.get('/v1/meta/agent-cards', (_req, res) => {
-    res.json(agentCardService.getManifest());
-  });
-
-  app.post('/v1/agent-cards/render', async (req, res) => {
-    const resolvedAgent = resolveAuthenticatedAgentId({
-      store,
-      req,
-      providedAgentId: req.body?.agentId || null,
-      fieldName: 'agentId',
-    });
-    if (!resolvedAgent.ok) {
-      return res.status(resolvedAgent.status).json(resolvedAgent.body);
-    }
-
-    try {
-      const result = await agentCardService.renderCard({
-        agentId: resolvedAgent.agentId,
-        publicHandle: req.body?.publicHandle,
-        displayName: req.body?.displayName,
-        templateId: req.body?.templateId,
-        templateVersion: req.body?.templateVersion,
-        themeId: req.body?.themeId,
-        title: req.body?.title,
-        subtitle: req.body?.subtitle,
-        ctaLines: req.body?.ctaLines,
-        qrTargetUrl: req.body?.qrTargetUrl,
-        footerLabel: req.body?.footerLabel,
-        badgeText: req.body?.badgeText,
-        expiresInSeconds: req.body?.expiresInSeconds,
-        forceRegenerate: req.body?.forceRegenerate === true,
-      });
-
-      const imageUrl = result.card.imageUrl || (result.card.publicPath ? buildAbsoluteUrl(req, result.card.publicPath) : null);
-      const downloadUrl = result.card.downloadUrl || imageUrl;
-      return res.status(result.cacheHit ? 200 : 201).json({
-        ...result,
-        card: {
-          ...result.card,
-          ...(imageUrl ? { imageUrl } : {}),
-          ...(downloadUrl ? { downloadUrl } : {}),
-        },
-      });
-    } catch (error) {
-      return sendAgentCardError(res, error);
-    }
-  });
-}