@xmemo/client 0.4.155 → 0.4.157

package/src/commands/setup.js

@@ -0,0 +1,191 @@
+import {
+  hasFlag,
+  optionValue,
+  parsePositiveInteger,
+  stringValue
+} from '../core/args.js';
+import { baseUrlOption } from '../network/base-url.js';
+import {
+  DEFAULT_PROXY_PORT
+} from '../core/constants.js';
+import {
+  buildSetupPlan,
+  ensureDiscoveryService
+} from '../network/discovery.js';
+import { UsageError } from '../core/errors.js';
+import {
+  endpointUrl,
+  fetchJson,
+  normalizeBaseUrl
+} from '../network/http.js';
+import { writeLine } from '../core/io.js';
+import {
+  MCP_CLIENTS,
+  supportedMcpClients
+} from '../mcp/clients.js';
+import { mergeCopilotMcpConfig } from '../mcp/proxy/copilot.js';
+import { detectClient } from '../mcp/clients/detect.js';
+import {
+  agentIdentity,
+  envReferenceIdentity
+} from '../mcp/identity/device.js';
+import {
+  confirmProfileInstall,
+  defaultProfileTarget,
+  profileClientConfig,
+  profileInstallResult
+} from '../config/profile.js';
+import {
+  clientSetupPlan,
+  copilotSetupPlan,
+  normalizeSetupClientId,
+  positionalClientArg,
+  supportedSetupClientIds,
+  writeSetupSummary
+} from '../ui/setup.js';
+
+export async function setupCommand(args, io) {
+  const positionalClientId = positionalClientArg(args, MCP_CLIENTS);
+  const optionArgs = positionalClientId ? args.slice(1) : args;
+  const baseUrl = normalizeBaseUrl(baseUrlOption(optionArgs, io.env));
+  const outputJson = hasFlag(optionArgs, '--json');
+  const shortClientSetup = Boolean(positionalClientId);
+  const setupAll = hasFlag(optionArgs, '--all');
+  
+  let clientId = null;
+  try {
+    clientId = normalizeSetupClientId(positionalClientId ?? optionValue(optionArgs, '--client'), MCP_CLIENTS);
+  } catch (error) {
+    if (!setupAll) {
+      throw error;
+    }
+  }
+
+  if (setupAll && clientId) {
+    throw new UsageError('Cannot specify both --all and a specific client.');
+  }
+
+  const dryRun = hasFlag(optionArgs, '--dry-run') || hasFlag(optionArgs, '--preview');
+  const writeConfig = !dryRun && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes') || shortClientSetup || (setupAll && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes'))));
+  const timeoutMs = parsePositiveInteger(optionValue(optionArgs, '--timeout-ms') ?? '5000', '--timeout-ms');
+
+  if (writeConfig && !clientId && !setupAll) {
+    throw new UsageError(`Setup --write requires --client <${supportedSetupClientIds(MCP_CLIENTS).join('|')}> or --all so the CLI never writes broad config implicitly.`);
+  }
+
+  const discoveryUrl = endpointUrl(baseUrl, '/.well-known/memory-os.json');
+  const discovery = await fetchJson(discoveryUrl, timeoutMs, io);
+  ensureDiscoveryService(discovery, discoveryUrl);
+
+  const statusUrl = stringValue(discovery, ['urls', 'onboarding_status'])
+    ?? stringValue(discovery, ['onboarding_status_url'])
+    ?? endpointUrl(baseUrl, '/v1/onboarding/status');
+  const status = await fetchJson(statusUrl, timeoutMs, io);
+  const setupPlan = buildSetupPlan({
+    baseUrl,
+    discoveryUrl,
+    statusUrl,
+    discovery,
+    status,
+    localClients: supportedMcpClients()
+  });
+
+  if (setupAll) {
+    setupPlan.detectedClients = [];
+    const scanIds = ['codex', 'cursor', 'copilot-cli', 'gemini-cli', 'antigravity', 'antigravity-ide', 'antigravity2', 'antigravity-cli', 'windsurf', 'cline', 'continue', 'claude-desktop', 'qwen', 'opencode', 'trae', 'trae-solo'];
+    for (const scanId of scanIds) {
+      const detection = await detectClient(scanId, io.env, MCP_CLIENTS);
+      if (detection.detected) {
+        let clientPlan;
+        if (scanId === 'copilot-cli') {
+          const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
+          clientPlan = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
+          clientPlan.configPath = detection.path;
+          if (writeConfig) {
+            await mergeCopilotMcpConfig(clientPlan.configPath, clientPlan.proxyUrl);
+            clientPlan.written = true;
+          }
+        } else {
+          const client = MCP_CLIENTS.get(scanId);
+          const identity = writeConfig ? await agentIdentity(scanId, io.env) : envReferenceIdentity(scanId);
+          clientPlan = clientSetupPlan(scanId, client, setupPlan.mcpUrl, io.env, identity);
+          clientPlan.configPath = detection.path;
+          if (writeConfig) {
+            await client.writeConfig(clientPlan.configPath, setupPlan.mcpUrl, identity);
+            clientPlan.written = true;
+            if (profileClientConfig(scanId)) {
+              const installProfile = hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '--profile');
+              if (installProfile) {
+                const profileTarget = defaultProfileTarget(scanId, io.env);
+                const profileResult = await profileInstallResult(scanId, profileTarget, { write: true });
+                clientPlan.behaviorProfile = profileResult;
+                if (scanId === 'codex') {
+                  clientPlan.codexProfile = profileResult;
+                }
+              }
+            }
+          }
+        }
+        setupPlan.detectedClients.push(clientPlan);
+      }
+    }
+  } else if (clientId) {
+    if (clientId === 'copilot-cli') {
+      const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
+      setupPlan.selectedClient = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
+      if (writeConfig) {
+        await mergeCopilotMcpConfig(setupPlan.selectedClient.configPath, setupPlan.selectedClient.proxyUrl);
+        setupPlan.selectedClient.written = true;
+      }
+    } else {
+      const client = MCP_CLIENTS.get(clientId);
+      if (!client) {
+        throw new UsageError(`Unsupported MCP client: ${clientId}. Supported clients: ${supportedSetupClientIds(MCP_CLIENTS).join(', ')}.`);
+      }
+
+      const identity = writeConfig ? await agentIdentity(clientId, io.env) : envReferenceIdentity(clientId);
+      setupPlan.selectedClient = clientSetupPlan(clientId, client, setupPlan.mcpUrl, io.env, identity);
+      if (writeConfig) {
+        await client.writeConfig(setupPlan.selectedClient.configPath, setupPlan.mcpUrl, identity);
+        setupPlan.selectedClient.written = true;
+      }
+
+      if (shortClientSetup && profileClientConfig(clientId)) {
+        const profileTarget = optionValue(optionArgs, '--profile-target')
+          ?? optionValue(optionArgs, '--target')
+          ?? defaultProfileTarget(clientId, io.env);
+        let installProfile = false;
+        let prompted = false;
+        let skipped = false;
+        if (hasFlag(optionArgs, '--no-profile')) {
+          skipped = true;
+        } else if (dryRun) {
+          installProfile = false;
+        } else if (writeConfig) {
+          installProfile = outputJson || hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '--profile');
+          if (!installProfile && !outputJson) {
+            prompted = true;
+            installProfile = await confirmProfileInstall(clientId, profileTarget, io);
+          }
+        }
+        const profileResult = await profileInstallResult(clientId, profileTarget, { write: installProfile });
+        profileResult.prompted = prompted;
+        profileResult.accepted = installProfile;
+        profileResult.skipped = skipped;
+        setupPlan.selectedClient.behaviorProfile = profileResult;
+        if (clientId === 'codex') {
+          setupPlan.selectedClient.codexProfile = profileResult;
+        }
+      }
+    }
+  }
+
+  if (outputJson) {
+    writeLine(io.stdout, JSON.stringify(setupPlan, null, 2));
+    return 0;
+  }
+
+  writeSetupSummary(setupPlan, io);
+  return 0;
+}
+

package/src/commands/update.js

@@ -0,0 +1,58 @@
+import { hasFlag } from '../core/args.js';
+import {
+  COMMAND_NAME,
+  PACKAGE_NAME
+} from '../core/constants.js';
+import { UsageError } from '../core/errors.js';
+import { writeLine } from '../core/io.js';
+import {
+  npmExecutable,
+  runProcess
+} from '../core/runtime.js';
+
+export async function updateCommand(args, io) {
+  const outputJson = hasFlag(args, '--json');
+  const dryRun = hasFlag(args, '--dry-run');
+  const npmCommand = npmExecutable();
+  const npmArgs = ['install', '-g', `${PACKAGE_NAME}@latest`];
+  const report = {
+    package: PACKAGE_NAME,
+    command: [npmCommand, ...npmArgs],
+    dryRun,
+    tokenSent: false,
+    projectFilesModified: false
+  };
+
+  const commandToDisplay = report.command.map(c => c === 'npm.cmd' ? 'npm' : c).join(' ');
+
+  if (dryRun) {
+    if (outputJson) {
+      writeLine(io.stdout, JSON.stringify(report, null, 2));
+    } else {
+      writeLine(io.stdout, `Update command: ${commandToDisplay}`);
+      writeLine(io.stdout, 'Dry run only; no changes made.');
+    }
+    return 0;
+  }
+
+  if (!outputJson) {
+    writeLine(io.stdout, `Updating ${PACKAGE_NAME} to the latest version...`);
+    writeLine(io.stdout, `Running: ${commandToDisplay}`);
+  }
+  const result = await runProcess(npmCommand, npmArgs, io, { stream: !outputJson });
+  report.exitCode = result.code;
+  report.completed = result.code === 0;
+
+  if (outputJson) {
+    writeLine(io.stdout, JSON.stringify(report, null, 2));
+  }
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+    throw new UsageError(`Update failed: ${detail}`);
+  }
+  if (!outputJson) {
+    writeLine(io.stdout, `Update complete. Run \`${COMMAND_NAME} --version\` to confirm.`);
+  }
+  return 0;
+}
+

package/src/config/env.js

@@ -0,0 +1,82 @@
+import { hasFlag, optionValue } from '../core/args.js';
+import { baseUrlOption } from '../network/base-url.js';
+import {
+  AGENT_ID_ENV_VAR,
+  AGENT_INSTANCE_ENV_VAR,
+  COMMAND_NAME,
+  PRODUCT_NAME,
+  TOKEN_ENV_VAR
+} from '../core/constants.js';
+import { UsageError } from '../core/errors.js';
+import { normalizeBaseUrl } from '../network/http.js';
+import { writeLine } from '../core/io.js';
+
+export function envCommand(args, io) {
+  const subcommand = args[0] ?? 'help';
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    writeLine(io.stdout, 'Env commands:');
+    writeLine(io.stdout, `  ${COMMAND_NAME} env example [--shell bash|powershell|cmd] [--base-url <url>] [--json]`);
+    return 0;
+  }
+  if (subcommand !== 'example') {
+    throw new UsageError(`Unknown env command: ${subcommand}`);
+  }
+
+  const baseUrl = normalizeBaseUrl(baseUrlOption(args.slice(1), io.env));
+  const outputJson = hasFlag(args, '--json');
+  const shell = optionValue(args, '--shell') ?? (process.platform === 'win32' ? 'powershell' : 'bash');
+  const placeholder = '<paste-token-from-your-secret-store>';
+  const payload = {
+    XMEMO_URL: baseUrl,
+    XMEMO_BASE_URL: baseUrl,
+    MEMORY_OS_URL: baseUrl,
+    MEMORY_OS_BASE_URL: baseUrl,
+    [TOKEN_ENV_VAR]: placeholder,
+    [AGENT_ID_ENV_VAR]: '<agent-family>',
+    [AGENT_INSTANCE_ENV_VAR]: '<stable-random-id-for-this-local-agent>'
+  };
+
+  if (outputJson) {
+    writeLine(io.stdout, JSON.stringify(payload, null, 2));
+    return 0;
+  }
+
+  if (shell === 'powershell') {
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('XMEMO_URL', '${baseUrl}', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('XMEMO_BASE_URL', '${baseUrl}', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('MEMORY_OS_URL', '${baseUrl}', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('MEMORY_OS_BASE_URL', '${baseUrl}', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('${TOKEN_ENV_VAR}', '${placeholder}', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('${AGENT_ID_ENV_VAR}', '<agent-family>', 'User')`);
+    writeLine(io.stdout, `[Environment]::SetEnvironmentVariable('${AGENT_INSTANCE_ENV_VAR}', '<stable-random-id-for-this-local-agent>', 'User')`);
+  } else if (shell === 'cmd') {
+    writeLine(io.stdout, `setx XMEMO_URL "${baseUrl}"`);
+    writeLine(io.stdout, `setx XMEMO_BASE_URL "${baseUrl}"`);
+    writeLine(io.stdout, `setx MEMORY_OS_URL "${baseUrl}"`);
+    writeLine(io.stdout, `setx MEMORY_OS_BASE_URL "${baseUrl}"`);
+    writeLine(io.stdout, `setx ${TOKEN_ENV_VAR} "${placeholder}"`);
+    writeLine(io.stdout, `setx ${AGENT_ID_ENV_VAR} "<agent-family>"`);
+    writeLine(io.stdout, `setx ${AGENT_INSTANCE_ENV_VAR} "<stable-random-id-for-this-local-agent>"`);
+  } else {
+    writeLine(io.stdout, `export XMEMO_URL="${baseUrl}"`);
+    writeLine(io.stdout, `export XMEMO_BASE_URL="${baseUrl}"`);
+    writeLine(io.stdout, `export MEMORY_OS_URL="${baseUrl}"`);
+    writeLine(io.stdout, `export MEMORY_OS_BASE_URL="${baseUrl}"`);
+    writeLine(io.stdout, `export ${TOKEN_ENV_VAR}="${placeholder}"`);
+    writeLine(io.stdout, `export ${AGENT_ID_ENV_VAR}="<agent-family>"`);
+    writeLine(io.stdout, `export ${AGENT_INSTANCE_ENV_VAR}="<stable-random-id-for-this-local-agent>"`);
+  }
+  return 0;
+}
+
+export function writePrivacy(io) {
+  writeLine(io.stdout, `${PRODUCT_NAME} CLI privacy and security defaults:`);
+  writeLine(io.stdout, '- No telemetry or analytics.');
+  writeLine(io.stdout, '- `status` does not send tokens.');
+  writeLine(io.stdout, `- MCP configs reference ${TOKEN_ENV_VAR}; token values are not embedded.`);
+  writeLine(io.stdout, `- Agent instance IDs are non-secret and stored in user-scoped config outside git.`);
+  writeLine(io.stdout, '- `login` and `token add` store credentials in the user-scoped XMemo CLI config directory.');
+  writeLine(io.stdout, '- Legacy `token set` plaintext storage requires explicit --allow-plaintext.');
+  writeLine(io.stdout, '- npm publishing is restricted by package.json files whitelist.');
+}
+

package/src/config/paths.js

@@ -0,0 +1,26 @@
+export {
+  configRoot,
+  defaultAntigravity2ConfigPath,
+  defaultAntigravityCliConfigPath,
+  defaultAntigravityConfigPath,
+  defaultAntigravityIdeConfigPath,
+  defaultClaudeConfigPath,
+  defaultClaudecodeConfigPath,
+  defaultClineConfigPath,
+  defaultCodexConfigPath,
+  defaultContinueConfigPath,
+  defaultCopilotConfigPath,
+  defaultCursorConfigPath,
+  defaultGeminiConfigPath,
+  defaultHermesConfigPath,
+  defaultJetbrainsConfigPath,
+  defaultKiroConfigPath,
+  defaultOpencodeConfigPath,
+  defaultOpenclawConfigPath,
+  defaultQwenConfigPath,
+  defaultTraeConfigPath,
+  defaultTraeSoloConfigPath,
+  defaultWindsurfConfigPath,
+  defaultZedConfigPath
+} from '../mcp/identity/paths.js';
+