@xortex/xcode 3.0.1 → 3.0.2

package/commands/mcp/xaaIdpCommand.ts

@@ -0,0 +1,266 @@
+/**
+ * `claude mcp xaa` — manage the XAA (SEP-990) IdP connection.
+ *
+ * The IdP connection is user-level: configure once, all XAA-enabled MCP
+ * servers reuse it. Lives in settings.xaaIdp (non-secret) + a keychain slot
+ * keyed by issuer (secret). Separate trust domain from per-server AS secrets.
+ */
+import type { Command } from '@commander-js/extra-typings'
+import { cliError, cliOk } from '../../cli/exit.js'
+import {
+  acquireIdpIdToken,
+  clearIdpClientSecret,
+  clearIdpIdToken,
+  getCachedIdpIdToken,
+  getIdpClientSecret,
+  getXaaIdpSettings,
+  issuerKey,
+  saveIdpClientSecret,
+  saveIdpIdTokenFromJwt,
+} from '../../services/mcp/xaaIdpLogin.js'
+import { errorMessage } from '../../utils/errors.js'
+import { updateSettingsForSource } from '../../utils/settings/settings.js'
+
+export function registerMcpXaaIdpCommand(mcp: Command): void {
+  const xaaIdp = mcp
+    .command('xaa')
+    .description('Manage the XAA (SEP-990) IdP connection')
+
+  xaaIdp
+    .command('setup')
+    .description(
+      'Configure the IdP connection (one-time setup for all XAA-enabled servers)',
+    )
+    .requiredOption('--issuer <url>', 'IdP issuer URL (OIDC discovery)')
+    .requiredOption('--client-id <id>', "Claude Code's client_id at the IdP")
+    .option(
+      '--client-secret',
+      'Read IdP client secret from MCP_XAA_IDP_CLIENT_SECRET env var',
+    )
+    .option(
+      '--callback-port <port>',
+      'Fixed loopback callback port (only if IdP does not honor RFC 8252 port-any matching)',
+    )
+    .action(options => {
+      // Validate everything BEFORE any writes. An exit(1) mid-write leaves
+      // settings configured but keychain missing — confusing state.
+      // updateSettingsForSource doesn't schema-check on write; a non-URL
+      // issuer lands on disk and then poisons the whole userSettings source
+      // on next launch (SettingsSchema .url() fails → parseSettingsFile
+      // returns { settings: null }, dropping everything, not just xaaIdp).
+      let issuerUrl: URL
+      try {
+        issuerUrl = new URL(options.issuer)
+      } catch {
+        return cliError(
+          `Error: --issuer must be a valid URL (got "${options.issuer}")`,
+        )
+      }
+      // OIDC discovery + token exchange run against this host. Allow http://
+      // only for loopback (conformance harness mock IdP); anything else leaks
+      // the client secret and authorization code over plaintext.
+      if (
+        issuerUrl.protocol !== 'https:' &&
+        !(
+          issuerUrl.protocol === 'http:' &&
+          (issuerUrl.hostname === 'localhost' ||
+            issuerUrl.hostname === '127.0.0.1' ||
+            issuerUrl.hostname === '[::1]')
+        )
+      ) {
+        return cliError(
+          `Error: --issuer must use https:// (got "${issuerUrl.protocol}//${issuerUrl.host}")`,
+        )
+      }
+      const callbackPort = options.callbackPort
+        ? parseInt(options.callbackPort, 10)
+        : undefined
+      // callbackPort <= 0 fails Zod's .positive() on next launch — same
+      // settings-poisoning failure mode as the issuer check above.
+      if (
+        callbackPort !== undefined &&
+        (!Number.isInteger(callbackPort) || callbackPort <= 0)
+      ) {
+        return cliError('Error: --callback-port must be a positive integer')
+      }
+      const secret = options.clientSecret
+        ? process.env.MCP_XAA_IDP_CLIENT_SECRET
+        : undefined
+      if (options.clientSecret && !secret) {
+        return cliError(
+          'Error: --client-secret requires MCP_XAA_IDP_CLIENT_SECRET env var',
+        )
+      }
+
+      // Read old config now (before settings overwrite) so we can clear stale
+      // keychain slots after a successful write. `clear` can't do this after
+      // the fact — it reads the *current* settings.xaaIdp, which by then is
+      // the new one.
+      const old = getXaaIdpSettings()
+      const oldIssuer = old?.issuer
+      const oldClientId = old?.clientId
+
+      // callbackPort MUST be present (even as undefined) — mergeWith deep-merges
+      // and only deletes on explicit `undefined`, not on absent key. A conditional
+      // spread would leak a prior fixed port into a new IdP's config.
+      const { error } = updateSettingsForSource('userSettings', {
+        xaaIdp: {
+          issuer: options.issuer,
+          clientId: options.clientId,
+          callbackPort,
+        },
+      })
+      if (error) {
+        return cliError(`Error writing settings: ${error.message}`)
+      }
+
+      // Clear stale keychain slots only after settings write succeeded —
+      // otherwise a write failure leaves settings pointing at oldIssuer with
+      // its secret already gone. Compare via issuerKey(): trailing-slash or
+      // host-case differences normalize to the same keychain slot.
+      if (oldIssuer) {
+        if (issuerKey(oldIssuer) !== issuerKey(options.issuer)) {
+          clearIdpIdToken(oldIssuer)
+          clearIdpClientSecret(oldIssuer)
+        } else if (oldClientId !== options.clientId) {
+          // Same issuer slot but different OAuth client registration — the
+          // cached id_token's aud claim and the stored secret are both for the
+          // old client. `xaa login` would send {new clientId, old secret} and
+          // fail with opaque `invalid_client`; downstream SEP-990 exchange
+          // would fail aud validation. Keep both when clientId is unchanged:
+          // re-setup without --client-secret means "tweak port, keep secret".
+          clearIdpIdToken(oldIssuer)
+          clearIdpClientSecret(oldIssuer)
+        }
+      }
+
+      if (secret) {
+        const { success, warning } = saveIdpClientSecret(options.issuer, secret)
+        if (!success) {
+          return cliError(
+            `Error: settings written but keychain save failed${warning ? ` — ${warning}` : ''}. ` +
+              `Re-run with --client-secret once keychain is available.`,
+          )
+        }
+      }
+
+      cliOk(`XAA IdP connection configured for ${options.issuer}`)
+    })
+
+  xaaIdp
+    .command('login')
+    .description(
+      'Cache an IdP id_token so XAA-enabled MCP servers authenticate ' +
+        'silently. Default: run the OIDC browser login. With --id-token: ' +
+        'write a pre-obtained JWT directly (used by conformance/e2e tests ' +
+        'where the mock IdP does not serve /authorize).',
+    )
+    .option(
+      '--force',
+      'Ignore any cached id_token and re-login (useful after IdP-side revocation)',
+    )
+    // TODO(paulc): read the JWT from stdin instead of argv to keep it out of
+    // shell history. Fine for conformance (docker exec uses argv directly,
+    // no shell parser), but a real user would want `echo $TOKEN | ... --stdin`.
+    .option(
+      '--id-token <jwt>',
+      'Write this pre-obtained id_token directly to cache, skipping the OIDC browser login',
+    )
+    .action(async options => {
+      const idp = getXaaIdpSettings()
+      if (!idp) {
+        return cliError(
+          "Error: no XAA IdP connection. Run 'claude mcp xaa setup' first.",
+        )
+      }
+
+      // Direct-inject path: skip cache check, skip OIDC. Writing IS the
+      // operation. Issuer comes from settings (single source of truth), not
+      // a separate flag — one less thing to desync.
+      if (options.idToken) {
+        const expiresAt = saveIdpIdTokenFromJwt(idp.issuer, options.idToken)
+        return cliOk(
+          `id_token cached for ${idp.issuer} (expires ${new Date(expiresAt).toISOString()})`,
+        )
+      }
+
+      if (options.force) {
+        clearIdpIdToken(idp.issuer)
+      }
+
+      const wasCached = getCachedIdpIdToken(idp.issuer) !== undefined
+      if (wasCached) {
+        return cliOk(
+          `Already logged in to ${idp.issuer} (cached id_token still valid). Use --force to re-login.`,
+        )
+      }
+
+      process.stdout.write(`Opening browser for IdP login at ${idp.issuer}…\n`)
+      try {
+        await acquireIdpIdToken({
+          idpIssuer: idp.issuer,
+          idpClientId: idp.clientId,
+          idpClientSecret: getIdpClientSecret(idp.issuer),
+          callbackPort: idp.callbackPort,
+          onAuthorizationUrl: url => {
+            process.stdout.write(
+              `If the browser did not open, visit:\n  ${url}\n`,
+            )
+          },
+        })
+        cliOk(
+          `Logged in. MCP servers with --xaa will now authenticate silently.`,
+        )
+      } catch (e) {
+        cliError(`IdP login failed: ${errorMessage(e)}`)
+      }
+    })
+
+  xaaIdp
+    .command('show')
+    .description('Show the current IdP connection config')
+    .action(() => {
+      const idp = getXaaIdpSettings()
+      if (!idp) {
+        return cliOk('No XAA IdP connection configured.')
+      }
+      const hasSecret = getIdpClientSecret(idp.issuer) !== undefined
+      const hasIdToken = getCachedIdpIdToken(idp.issuer) !== undefined
+      process.stdout.write(`Issuer:        ${idp.issuer}\n`)
+      process.stdout.write(`Client ID:     ${idp.clientId}\n`)
+      if (idp.callbackPort !== undefined) {
+        process.stdout.write(`Callback port: ${idp.callbackPort}\n`)
+      }
+      process.stdout.write(
+        `Client secret: ${hasSecret ? '(stored in keychain)' : '(not set — PKCE-only)'}\n`,
+      )
+      process.stdout.write(
+        `Logged in:     ${hasIdToken ? 'yes (id_token cached)' : "no — run 'claude mcp xaa login'"}\n`,
+      )
+      cliOk()
+    })
+
+  xaaIdp
+    .command('clear')
+    .description('Clear the IdP connection config and cached id_token')
+    .action(() => {
+      // Read issuer first so we can clear the right keychain slots.
+      const idp = getXaaIdpSettings()
+      // updateSettingsForSource uses mergeWith: set to undefined (not delete)
+      // to signal key removal.
+      const { error } = updateSettingsForSource('userSettings', {
+        xaaIdp: undefined,
+      })
+      if (error) {
+        return cliError(`Error writing settings: ${error.message}`)
+      }
+      // Clear keychain only after settings write succeeded — otherwise a
+      // write failure leaves settings pointing at the IdP with its secrets
+      // already gone (same pattern as `setup`'s old-issuer cleanup).
+      if (idp) {
+        clearIdpIdToken(idp.issuer)
+        clearIdpClientSecret(idp.issuer)
+      }
+      cliOk('XAA IdP connection cleared')
+    })
+}

package/commands/memory/index.ts

@@ -0,0 +1,10 @@
+import type { Command } from '../../commands.js'
+
+const memory: Command = {
+  type: 'local-jsx',
+  name: 'memory',
+  description: 'Edit Claude memory files',
+  load: () => import('./memory.js'),
+}
+
+export default memory

package/commands/memory/memory.tsx

@@ -0,0 +1,90 @@
+import { mkdir, writeFile } from 'fs/promises';
+import * as React from 'react';
+import type { CommandResultDisplay } from '../../commands.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { MemoryFileSelector } from '../../components/memory/MemoryFileSelector.js';
+import { getRelativeMemoryPath } from '../../components/memory/MemoryUpdateNotification.js';
+import { Box, Link, Text } from '../../ink.js';
+import type { LocalJSXCommandCall } from '../../types/command.js';
+import { clearMemoryFileCaches, getMemoryFiles } from '../../utils/claudemd.js';
+import { getClaudeConfigHomeDir } from '../../utils/envUtils.js';
+import { getErrnoCode } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { editFileInEditor } from '../../utils/promptEditor.js';
+function MemoryCommand({
+  onDone
+}: {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay;
+  }) => void;
+}): React.ReactNode {
+  const handleSelectMemoryFile = async (memoryPath: string) => {
+    try {
+      // Create claude directory if it doesn't exist (idempotent with recursive)
+      if (memoryPath.includes(getClaudeConfigHomeDir())) {
+        await mkdir(getClaudeConfigHomeDir(), {
+          recursive: true
+        });
+      }
+
+      // Create file if it doesn't exist (wx flag fails if file exists,
+      // which we catch to preserve existing content)
+      try {
+        await writeFile(memoryPath, '', {
+          encoding: 'utf8',
+          flag: 'wx'
+        });
+      } catch (e: unknown) {
+        if (getErrnoCode(e) !== 'EEXIST') {
+          throw e;
+        }
+      }
+      await editFileInEditor(memoryPath);
+
+      // Determine which environment variable controls the editor
+      let editorSource = 'default';
+      let editorValue = '';
+      if (process.env.VISUAL) {
+        editorSource = '$VISUAL';
+        editorValue = process.env.VISUAL;
+      } else if (process.env.EDITOR) {
+        editorSource = '$EDITOR';
+        editorValue = process.env.EDITOR;
+      }
+      const editorInfo = editorSource !== 'default' ? `Using ${editorSource}="${editorValue}".` : '';
+      const editorHint = editorInfo ? `> ${editorInfo} To change editor, set $EDITOR or $VISUAL environment variable.` : `> To use a different editor, set the $EDITOR or $VISUAL environment variable.`;
+      onDone(`Opened memory file at ${getRelativeMemoryPath(memoryPath)}\n\n${editorHint}`, {
+        display: 'system'
+      });
+    } catch (error) {
+      logError(error);
+      onDone(`Error opening memory file: ${error}`);
+    }
+  };
+  const handleCancel = () => {
+    onDone('Cancelled memory editing', {
+      display: 'system'
+    });
+  };
+  return <Dialog title="Memory" onCancel={handleCancel} color="remember">
+      <Box flexDirection="column">
+        <React.Suspense fallback={null}>
+          <MemoryFileSelector onSelect={handleSelectMemoryFile} onCancel={handleCancel} />
+        </React.Suspense>
+
+        <Box marginTop={1}>
+          <Text dimColor>
+            Learn more: <Link url="https://code.claude.com/docs/en/memory" />
+          </Text>
+        </Box>
+      </Box>
+    </Dialog>;
+}
+export const call: LocalJSXCommandCall = async onDone => {
+  // Clear + prime before rendering — Suspense handles the unprimed case,
+  // but awaiting here avoids a fallback flash on initial open.
+  clearMemoryFileCaches();
+  await getMemoryFiles();
+  return <MemoryCommand onDone={onDone} />;
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mkdir","writeFile","React","CommandResultDisplay","Dialog","MemoryFileSelector","getRelativeMemoryPath","Box","Link","Text","LocalJSXCommandCall","clearMemoryFileCaches","getMemoryFiles","getClaudeConfigHomeDir","getErrnoCode","logError","editFileInEditor","MemoryCommand","onDone","result","options","display","ReactNode","handleSelectMemoryFile","memoryPath","includes","recursive","encoding","flag","e","editorSource","editorValue","process","env","VISUAL","EDITOR","editorInfo","editorHint","error","handleCancel","call"],"sources":["memory.tsx"],"sourcesContent":["import { mkdir, writeFile } from 'fs/promises'\nimport * as React from 'react'\nimport type { CommandResultDisplay } from '../../commands.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { MemoryFileSelector } from '../../components/memory/MemoryFileSelector.js'\nimport { getRelativeMemoryPath } from '../../components/memory/MemoryUpdateNotification.js'\nimport { Box, Link, Text } from '../../ink.js'\nimport type { LocalJSXCommandCall } from '../../types/command.js'\nimport { clearMemoryFileCaches, getMemoryFiles } from '../../utils/claudemd.js'\nimport { getClaudeConfigHomeDir } from '../../utils/envUtils.js'\nimport { getErrnoCode } from '../../utils/errors.js'\nimport { logError } from '../../utils/log.js'\nimport { editFileInEditor } from '../../utils/promptEditor.js'\n\nfunction MemoryCommand({\n  onDone,\n}: {\n  onDone: (\n    result?: string,\n    options?: { display?: CommandResultDisplay },\n  ) => void\n}): React.ReactNode {\n  const handleSelectMemoryFile = async (memoryPath: string) => {\n    try {\n      // Create claude directory if it doesn't exist (idempotent with recursive)\n      if (memoryPath.includes(getClaudeConfigHomeDir())) {\n        await mkdir(getClaudeConfigHomeDir(), { recursive: true })\n      }\n\n      // Create file if it doesn't exist (wx flag fails if file exists,\n      // which we catch to preserve existing content)\n      try {\n        await writeFile(memoryPath, '', { encoding: 'utf8', flag: 'wx' })\n      } catch (e: unknown) {\n        if (getErrnoCode(e) !== 'EEXIST') {\n          throw e\n        }\n      }\n\n      await editFileInEditor(memoryPath)\n\n      // Determine which environment variable controls the editor\n      let editorSource = 'default'\n      let editorValue = ''\n      if (process.env.VISUAL) {\n        editorSource = '$VISUAL'\n        editorValue = process.env.VISUAL\n      } else if (process.env.EDITOR) {\n        editorSource = '$EDITOR'\n        editorValue = process.env.EDITOR\n      }\n\n      const editorInfo =\n        editorSource !== 'default'\n          ? `Using ${editorSource}=\"${editorValue}\".`\n          : ''\n\n      const editorHint = editorInfo\n        ? `> ${editorInfo} To change editor, set $EDITOR or $VISUAL environment variable.`\n        : `> To use a different editor, set the $EDITOR or $VISUAL environment variable.`\n\n      onDone(\n        `Opened memory file at ${getRelativeMemoryPath(memoryPath)}\\n\\n${editorHint}`,\n        { display: 'system' },\n      )\n    } catch (error) {\n      logError(error)\n      onDone(`Error opening memory file: ${error}`)\n    }\n  }\n\n  const handleCancel = () => {\n    onDone('Cancelled memory editing', { display: 'system' })\n  }\n\n  return (\n    <Dialog title=\"Memory\" onCancel={handleCancel} color=\"remember\">\n      <Box flexDirection=\"column\">\n        <React.Suspense fallback={null}>\n          <MemoryFileSelector\n            onSelect={handleSelectMemoryFile}\n            onCancel={handleCancel}\n          />\n        </React.Suspense>\n\n        <Box marginTop={1}>\n          <Text dimColor>\n            Learn more: <Link url=\"https://code.claude.com/docs/en/memory\" />\n          </Text>\n        </Box>\n      </Box>\n    </Dialog>\n  )\n}\n\nexport const call: LocalJSXCommandCall = async onDone => {\n  // Clear + prime before rendering — Suspense handles the unprimed case,\n  // but awaiting here avoids a fallback flash on initial open.\n  clearMemoryFileCaches()\n  await getMemoryFiles()\n  return <MemoryCommand onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

package/commands/mobile/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const mobile = {
+  type: 'local-jsx',
+  name: 'mobile',
+  aliases: ['ios', 'android'],
+  description: 'Show QR code to download the Claude mobile app',
+  load: () => import('./mobile.js'),
+} satisfies Command
+
+export default mobile