@xmemo/client 0.4.155 → 0.4.157

package/src/config/profile.js

@@ -0,0 +1,533 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  CODEX_PROFILE_MARKER_END,
+  CODEX_PROFILE_MARKER_START,
+  CODEX_PROFILE_TARGET,
+  COMMAND_NAME,
+  MCP_SERVER_NAME,
+  PRODUCT_NAME,
+  PROFILE_MARKER_PREFIX,
+  TOKEN_ENV_VAR
+} from '../core/constants.js';
+import { UsageError } from '../core/errors.js';
+import { writeLine } from '../core/io.js';
+import { readTextIfExists } from '../core/runtime.js';
+
+export function codexMemoryProfile() {
+  return memoryBehaviorProfile('codex');
+}
+
+export function writeCodexMemoryProfile(profile, io) {
+  writeLine(io.stdout, `${PRODUCT_NAME} Codex memory behavior profile`);
+  writeLine(io.stdout, `Profile: ${profile.profileVersion}`);
+  writeLine(io.stdout, `MCP server: ${profile.mcpServerName}`);
+  writeLine(io.stdout, `Token env: ${profile.requiredTokenEnv}`);
+  writeLine(io.stdout, '');
+  writeLine(io.stdout, 'Recommended Codex instructions:');
+  for (const instruction of profile.instructions) {
+    writeLine(io.stdout, `- ${instruction}`);
+  }
+  writeLine(io.stdout, '');
+  writeLine(io.stdout, `Setup: ${profile.setupCommand}`);
+  writeLine(io.stdout, `Smoke test: ${profile.smokeCommand}`);
+}
+
+function codexProfileInstructionText() {
+  return profileInstructionText('codex');
+}
+
+function memoryBehaviorProfile(clientId) {
+  const config = profileClientConfig(clientId);
+  if (!config) {
+    throw new UsageError(`Unsupported profile client: ${clientId}`);
+  }
+  const instructions = [
+    'At the start of a non-trivial task, call XMemo recall/search for relevant project decisions, conventions, prior fixes, and active context unless the user explicitly asks not to use memory.',
+    'Use recalled memories as evidence, not as unquestioned truth. Prefer current repository files when memory conflicts with code.',
+    'After meaningful decisions, bug fixes, release steps, or durable conventions, write a concise XMemo memory with scope, source, and no secret values.',
+    'Never store tokens, API keys, cookies, private keys, raw credentials, or sensitive customer data in XMemo.',
+    'For routine or low-signal output, skip durable writes. Prefer summarized procedural or semantic memories over verbose logs.',
+    config.authInstruction
+  ];
+  return {
+    client: clientId,
+    label: config.label,
+    profileVersion: config.profileVersion,
+    mcpServerName: MCP_SERVER_NAME,
+    requiredTokenEnv: config.requiredTokenEnv ?? null,
+    objective: 'Use XMemo deliberately through MCP for project context recall and high-signal write-back.',
+    instructions,
+    setupCommand: `${COMMAND_NAME} setup ${config.setupAlias} --url "$XMEMO_URL"`,
+    smokeCommand: clientId === 'codex' ? `${COMMAND_NAME} smoke --client codex` : null
+  };
+}
+
+function profileInstructionText(clientId) {
+  const profile = memoryBehaviorProfile(clientId);
+  const lines = [
+    `## XMemo ${profile.label} profile`,
+    '',
+    `MCP server: \`${profile.mcpServerName}\``,
+  ];
+  if (profile.requiredTokenEnv) {
+    lines.push(`Token env var: \`${profile.requiredTokenEnv}\``);
+  }
+  lines.push(
+    '',
+    profile.objective,
+    '',
+    `Recommended ${profile.label} behavior:`
+  );
+  for (const instruction of profile.instructions) {
+    lines.push(`- ${instruction}`);
+  }
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
+export function profileClientConfig(clientId) {
+  const profileConfigs = {
+    codex: {
+      label: 'Codex',
+      setupAlias: 'codex',
+      profileVersion: 'codex-mcp-depth-v1',
+      requiredTokenEnv: TOKEN_ENV_VAR,
+      markerStart: CODEX_PROFILE_MARKER_START,
+      markerEnd: CODEX_PROFILE_MARKER_END,
+      defaultTarget: () => defaultCodexProfileTarget(),
+      authInstruction: `Keep XMemo authentication through the ${TOKEN_ENV_VAR} environment variable; do not paste token values into prompts, config files, or logs.`
+    },
+    cursor: {
+      label: 'Cursor',
+      setupAlias: 'cursor',
+      profileVersion: 'cursor-mcp-depth-v1',
+      requiredTokenEnv: TOKEN_ENV_VAR,
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:cursor:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:cursor:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.cursor')) || existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), '.cursor', 'rules', 'xmemo-memory.md');
+        }
+        return path.join(userHome(env), '.cursor', 'memory-profile.md');
+      },
+      authInstruction: `Keep XMemo authentication through the ${TOKEN_ENV_VAR} environment variable; do not paste token values into prompts, config files, or logs.`
+    },
+    'gemini-cli': {
+      label: 'Gemini CLI',
+      setupAlias: 'gemini',
+      profileVersion: 'gemini-cli-mcp-depth-v1',
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:gemini-cli:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:gemini-cli:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), 'GEMINI.md');
+        }
+        return path.join(userHome(env), '.gemini', 'GEMINI.md');
+      },
+      authInstruction: 'Use the client-managed MCP OAuth credential; do not paste token values into prompts, config files, or logs.'
+    },
+    antigravity: {
+      label: 'Antigravity',
+      setupAlias: 'antigravity',
+      profileVersion: 'antigravity-mcp-depth-v1',
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:antigravity:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:antigravity:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), 'GEMINI.md');
+        }
+        return path.join(userHome(env), '.gemini', 'antigravity', 'MEMORY.md');
+      },
+      authInstruction: 'Use the client-managed MCP OAuth credential; do not paste token values into prompts, config files, or logs.'
+    },
+    qwen: {
+      label: 'Qwen',
+      setupAlias: 'qwen',
+      profileVersion: 'qwen-mcp-depth-v1',
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:qwen:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:qwen:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), 'QWEN.md');
+        }
+        return path.join(userHome(env), '.qwen', 'QWEN.md');
+      },
+      authInstruction: `Keep XMemo authentication through the ${TOKEN_ENV_VAR} environment variable; do not paste token values into prompts, config files, or logs.`
+    },
+    opencode: {
+      label: 'OpenCode',
+      setupAlias: 'opencode',
+      profileVersion: 'opencode-mcp-depth-v1',
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:opencode:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:opencode:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), 'AGENTS.md');
+        }
+        return path.join(userHome(env), '.config', 'opencode', 'AGENTS.md');
+      },
+      authInstruction: 'Use the client-managed MCP OAuth credential; do not paste token values into prompts, config files, or logs.'
+    },
+    trae: {
+      label: 'Trae',
+      setupAlias: 'trae',
+      profileVersion: 'trae-mcp-depth-v1',
+      requiredTokenEnv: TOKEN_ENV_VAR,
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:trae:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:trae:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.trae')) || existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), '.trae', 'rules', 'xmemo-memory.md');
+        }
+        return path.join(userHome(env), '.trae', 'memory-profile.md');
+      },
+      authInstruction: `Keep XMemo authentication through the ${TOKEN_ENV_VAR} environment variable; do not paste token values into prompts, config files, or logs.`
+    },
+    'trae-solo': {
+      label: 'Trae Solo',
+      setupAlias: 'trae-solo',
+      profileVersion: 'trae-solo-mcp-depth-v1',
+      requiredTokenEnv: TOKEN_ENV_VAR,
+      markerStart: `<!-- ${PROFILE_MARKER_PREFIX}:trae-solo:start -->`,
+      markerEnd: `<!-- ${PROFILE_MARKER_PREFIX}:trae-solo:end -->`,
+      defaultTarget: (env) => {
+        const isTest = env.HOME && (env.HOME.includes('memory-os-') || env.HOME.includes('test'));
+        if (!isTest && (existsSync(path.join(process.cwd(), '.trae')) || existsSync(path.join(process.cwd(), '.git')) || existsSync(path.join(process.cwd(), 'package.json')))) {
+          return path.join(process.cwd(), '.trae', 'rules', 'xmemo-memory.md');
+        }
+        return path.join(userHome(env), '.trae', 'memory-profile.md');
+      },
+      authInstruction: `Keep XMemo authentication through the ${TOKEN_ENV_VAR} environment variable; do not paste token values into prompts, config files, or logs.`
+    }
+  };
+  return profileConfigs[clientId] ?? null;
+}
+
+export function supportedProfileClientIds() {
+  return ['codex', 'cursor', 'gemini', 'antigravity', 'qwen', 'opencode', 'trae', 'trae-solo'];
+}
+
+export function defaultProfileTarget(clientId, env) {
+  const config = profileClientConfig(clientId);
+  if (!config) {
+    throw new UsageError(`Unsupported profile client: ${clientId}`);
+  }
+  return config.defaultTarget(env);
+}
+
+export async function confirmProfileInstall(clientId, targetPath, io) {
+  const config = profileClientConfig(clientId);
+  writeLine(io.stdout, '');
+  writeLine(io.stdout, `Write XMemo memory behavior profile to ${targetPath}? [Y/n]`);
+  const answer = (await readLineFromStdin(io.stdin)).trim().toLowerCase();
+  if (answer === '' || answer === 'y' || answer === 'yes') {
+    return true;
+  }
+  if (answer === 'n' || answer === 'no') {
+    return false;
+  }
+  throw new UsageError(`Unsupported response for ${config.label} profile prompt: ${answer}`);
+}
+
+async function readLineFromStdin(stdin) {
+  let input = '';
+  for await (const chunk of stdin) {
+    input += chunk;
+    if (input.includes('\n')) {
+      break;
+    }
+  }
+  return input.split(/\r?\n/, 1)[0] ?? '';
+}
+
+function genericProfileMarkerBlock(clientId) {
+  const config = profileClientConfig(clientId);
+  return `${config.markerStart}\n${profileInstructionText(clientId)}${config.markerEnd}\n`;
+}
+
+export async function profileInstallResult(clientId, targetPath, options = {}) {
+  if (clientId === 'codex') {
+    return codexProfileInstallResult(targetPath, options);
+  }
+  const config = profileClientConfig(clientId);
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = profileMarkerBounds(existing, config);
+  const block = genericProfileMarkerBlock(clientId);
+  let nextText;
+
+  if (marker.present) {
+    nextText = `${existing.slice(0, marker.start)}${block}${existing.slice(marker.end)}`;
+  } else if (existing.trim().length === 0) {
+    nextText = block;
+  } else {
+    const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+    nextText = `${existing}${separator}${block}`;
+  }
+
+  const changed = nextText !== existing;
+  const write = Boolean(options.write);
+  if (write && changed) {
+    await fs.mkdir(path.dirname(resolvedTarget), { recursive: true });
+    await fs.writeFile(resolvedTarget, nextText);
+  }
+
+  return {
+    client: clientId,
+    action: 'install',
+    targetPath: resolvedTarget,
+    markerStart: config.markerStart,
+    markerEnd: config.markerEnd,
+    installed: marker.present || (write && changed),
+    written: write,
+    changed,
+    markerPresent: marker.present,
+    writesTokenValue: false
+  };
+}
+
+export async function profileStatusResult(clientId, targetPath) {
+  if (clientId === 'codex') {
+    return codexProfileStatusResult(targetPath);
+  }
+  const config = profileClientConfig(clientId);
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = profileMarkerBounds(existing, config);
+  return {
+    client: clientId,
+    action: 'status',
+    targetPath: resolvedTarget,
+    installed: marker.present,
+    markerPresent: marker.present,
+    markerStart: config.markerStart,
+    markerEnd: config.markerEnd,
+    writesTokenValue: false
+  };
+}
+
+export async function profileUninstallResult(clientId, targetPath, options = {}) {
+  if (clientId === 'codex') {
+    return codexProfileUninstallResult(targetPath, options);
+  }
+  const config = profileClientConfig(clientId);
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = profileMarkerBounds(existing, config);
+  const write = Boolean(options.write);
+  let changed = false;
+
+  if (marker.present) {
+    let nextText = `${existing.slice(0, marker.start)}${existing.slice(marker.end)}`;
+    nextText = nextText.replace(/\n{3,}/g, '\n\n');
+    if (nextText.trim().length === 0) {
+      nextText = '';
+    } else if (!nextText.endsWith('\n')) {
+      nextText = `${nextText}\n`;
+    }
+    changed = nextText !== existing;
+    if (write && changed) {
+      await fs.writeFile(resolvedTarget, nextText);
+    }
+  }
+
+  return {
+    client: clientId,
+    action: 'uninstall',
+    targetPath: resolvedTarget,
+    installed: marker.present && !(write && changed),
+    written: write,
+    changed,
+    markerPresent: marker.present,
+    markerStart: config.markerStart,
+    markerEnd: config.markerEnd,
+    writesTokenValue: false
+  };
+}
+
+function profileMarkerBounds(content, config) {
+  const start = content.indexOf(config.markerStart);
+  const end = content.indexOf(config.markerEnd);
+  if (start === -1 && end === -1) {
+    return { present: false, start: -1, end: -1 };
+  }
+
+  if (start === -1 || end === -1 || end < start) {
+    throw new UsageError(`${config.label} profile markers are incomplete or out of order; edit the target file manually before retrying.`);
+  }
+
+  if (
+    content.indexOf(config.markerStart, start + config.markerStart.length) !== -1
+    || content.indexOf(config.markerEnd, end + config.markerEnd.length) !== -1
+  ) {
+    throw new UsageError(`${config.label} profile markers appear more than once; edit the target file manually before retrying.`);
+  }
+
+  const afterEnd = end + config.markerEnd.length;
+  const trailingNewlineLength = content.slice(afterEnd, afterEnd + 2) === '\r\n'
+    ? 2
+    : content.slice(afterEnd, afterEnd + 1) === '\n'
+      ? 1
+      : 0;
+
+  return {
+    present: true,
+    start,
+    end: afterEnd + trailingNewlineLength
+  };
+}
+
+function userHome(env) {
+  return env.USERPROFILE || env.HOME || os.homedir();
+}
+
+function codexProfileMarkerBlock() {
+  return `${CODEX_PROFILE_MARKER_START}\n${codexProfileInstructionText()}${CODEX_PROFILE_MARKER_END}\n`;
+}
+
+function defaultCodexProfileTarget() {
+  return path.resolve(process.cwd(), CODEX_PROFILE_TARGET);
+}
+
+async function codexProfileInstallResult(targetPath, options = {}) {
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = markerBounds(existing);
+  const block = codexProfileMarkerBlock();
+  let nextText;
+
+  if (marker.present) {
+    nextText = `${existing.slice(0, marker.start)}${block}${existing.slice(marker.end)}`;
+  } else if (existing.trim().length === 0) {
+    nextText = block;
+  } else {
+    const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+    nextText = `${existing}${separator}${block}`;
+  }
+
+  const changed = nextText !== existing;
+  const write = Boolean(options.write);
+  if (write && changed) {
+    await fs.mkdir(path.dirname(resolvedTarget), { recursive: true });
+    await fs.writeFile(resolvedTarget, nextText);
+  }
+
+  return {
+    client: 'codex',
+    action: 'install',
+    targetPath: resolvedTarget,
+    markerStart: CODEX_PROFILE_MARKER_START,
+    markerEnd: CODEX_PROFILE_MARKER_END,
+    installed: marker.present || (write && changed),
+    written: write,
+    changed,
+    markerPresent: marker.present,
+    writesTokenValue: false
+  };
+}
+
+async function codexProfileStatusResult(targetPath) {
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = markerBounds(existing);
+  return {
+    client: 'codex',
+    action: 'status',
+    targetPath: resolvedTarget,
+    installed: marker.present,
+    markerPresent: marker.present,
+    markerStart: CODEX_PROFILE_MARKER_START,
+    markerEnd: CODEX_PROFILE_MARKER_END,
+    writesTokenValue: false
+  };
+}
+
+async function codexProfileUninstallResult(targetPath, options = {}) {
+  const resolvedTarget = path.resolve(targetPath);
+  const existing = await readTextIfExists(resolvedTarget);
+  const marker = markerBounds(existing);
+  const write = Boolean(options.write);
+  let changed = false;
+
+  if (marker.present) {
+    let nextText = `${existing.slice(0, marker.start)}${existing.slice(marker.end)}`;
+    nextText = nextText.replace(/\n{3,}/g, '\n\n');
+    if (nextText.trim().length === 0) {
+      nextText = '';
+    } else if (!nextText.endsWith('\n')) {
+      nextText = `${nextText}\n`;
+    }
+    changed = nextText !== existing;
+    if (write && changed) {
+      await fs.writeFile(resolvedTarget, nextText);
+    }
+  }
+
+  return {
+    client: 'codex',
+    action: 'uninstall',
+    targetPath: resolvedTarget,
+    installed: marker.present && !(write && changed),
+    written: write,
+    changed,
+    markerPresent: marker.present,
+    markerStart: CODEX_PROFILE_MARKER_START,
+    markerEnd: CODEX_PROFILE_MARKER_END,
+    writesTokenValue: false
+  };
+}
+
+function markerBounds(content) {
+  const start = content.indexOf(CODEX_PROFILE_MARKER_START);
+  const end = content.indexOf(CODEX_PROFILE_MARKER_END);
+  if (start === -1 && end === -1) {
+    return { present: false, start: -1, end: -1 };
+  }
+
+  if (start === -1 || end === -1 || end < start) {
+    throw new UsageError('Codex profile markers are incomplete or out of order; edit the target file manually before retrying.');
+  }
+
+  if (
+    content.indexOf(CODEX_PROFILE_MARKER_START, start + CODEX_PROFILE_MARKER_START.length) !== -1
+    || content.indexOf(CODEX_PROFILE_MARKER_END, end + CODEX_PROFILE_MARKER_END.length) !== -1
+  ) {
+    throw new UsageError('Codex profile markers appear more than once; edit the target file manually before retrying.');
+  }
+
+  const afterEnd = end + CODEX_PROFILE_MARKER_END.length;
+  const trailingNewlineLength = content.slice(afterEnd, afterEnd + 2) === '\r\n'
+    ? 2
+    : content.slice(afterEnd, afterEnd + 1) === '\n'
+      ? 1
+      : 0;
+
+  return {
+    present: true,
+    start,
+    end: afterEnd + trailingNewlineLength
+  };
+}
+
+export function writeProfileResult(action, result, io) {
+  const config = profileClientConfig(result.client);
+  writeLine(io.stdout, `${PRODUCT_NAME} ${config?.label ?? result.client} profile ${action}`);
+  writeLine(io.stdout, `  Target: ${result.targetPath}`);
+  writeLine(io.stdout, `  Installed: ${result.installed}`);
+  if ('written' in result) {
+    writeLine(io.stdout, `  Written: ${result.written}`);
+    writeLine(io.stdout, `  Changed: ${result.changed}`);
+  }
+  writeLine(io.stdout, '  Token value embedded: false');
+}
+

package/src/core/args.js

@@ -0,0 +1,63 @@
+import { UsageError } from './errors.js';
+
+export function sameMajorMinor(left, right) {
+  const leftParts = left.split('.');
+  const rightParts = right.split('.');
+  return leftParts[0] === rightParts[0] && leftParts[1] === rightParts[1];
+}
+
+export function optionValue(args, name) {
+  const index = args.indexOf(name);
+  if (index === -1) {
+    return null;
+  }
+
+  const value = args[index + 1];
+  if (!value || value.startsWith('--')) {
+    throw new UsageError(`Option ${name} requires a value.`);
+  }
+
+  return value;
+}
+
+export function stringValue(source, keys) {
+  const value = valueAtPath(source, keys);
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+export function booleanValue(source, keys) {
+  const value = valueAtPath(source, keys);
+  return typeof value === 'boolean' ? value : null;
+}
+
+export function arrayValue(source, keys) {
+  const value = valueAtPath(source, keys);
+  return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : null;
+}
+
+export function valueAtPath(source, keys) {
+  let current = source;
+  for (const key of keys) {
+    if (!isPlainObject(current) || !(key in current)) {
+      return null;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+export function hasFlag(args, name) {
+  return args.includes(name);
+}
+
+export function parsePositiveInteger(value, name) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new UsageError(`${name} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/src/core/constants.js

@@ -0,0 +1,32 @@
+export const PRODUCT_NAME = 'XMemo';
+export const PACKAGE_NAME = '@xmemo/client';
+export const FALLBACK_PACKAGE_NAME = '@yonro/xmemo-client';
+export const COMMAND_NAME = 'xmemo';
+export const LEGACY_COMMAND_NAME = 'memory-os';
+export { CLI_VERSION } from './version.js';
+export const DEFAULT_SERVICE_URL = 'https://xmemo.dev';
+export const TOKEN_ENV_VAR = 'XMEMO_KEY';
+export const LEGACY_TOKEN_ENV_VAR = 'MEMORY_OS_MCP_TOKEN';
+export const AGENT_ID_ENV_VAR = 'XMEMO_AGENT_ID';
+export const AGENT_INSTANCE_ENV_VAR = 'XMEMO_AGENT_INSTANCE_ID';
+export const AGENT_ID_HEADER = 'X-Memory-OS-Agent-ID';
+export const AGENT_INSTANCE_HEADER = 'X-Memory-OS-Agent-Instance-ID';
+export const MCP_SERVER_NAME = 'XMemo';
+export const LEGACY_MCP_SERVER_NAMES = ['memory_os', 'memory-os'];
+export const CODEX_PROFILE_TARGET = 'AGENTS.md';
+export const CODEX_PROFILE_MARKER_START = '<!-- memory-os:codex-profile:start -->';
+export const CODEX_PROFILE_MARKER_END = '<!-- memory-os:codex-profile:end -->';
+export const CLIENT_PROFILE_TARGETS = {
+  cursor: '.cursor/rules/xmemo-memory.md',
+  'gemini-cli': 'GEMINI.md',
+  antigravity: 'GEMINI.md',
+  trae: '.trae/rules/xmemo-memory.md',
+  'trae-solo': '.trae/rules/xmemo-memory.md'
+};
+export const CLIENT_PROFILE_MARKER_START = '<!-- xmemo:profile:start -->';
+export const CLIENT_PROFILE_MARKER_END = '<!-- xmemo:profile:end -->';
+export const PROFILE_MARKER_PREFIX = 'memory-os:memory-profile';
+export const DEVICE_LOGIN_START_PATH = '/api/v1/auth/device/start';
+export const DEVICE_LOGIN_TOKEN_PATH = '/api/v1/auth/device/token';
+export const DEFAULT_PROXY_HOST = '127.0.0.1';
+export const DEFAULT_PROXY_PORT = 8765;

package/src/core/errors.js

@@ -0,0 +1,6 @@
+export class UsageError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'UsageError';
+  }
+}

package/src/core/io.js

@@ -0,0 +1,16 @@
+import { spawn } from 'node:child_process';
+
+export function defaultIo() {
+  return {
+    env: process.env,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    fetch: globalThis.fetch,
+    spawn
+  };
+}
+
+export function writeLine(stream, line) {
+  stream.write(`${line}\n`);
+}