@xelauvas/xela-cli 0.1.0

package/src/cli/handlers/util.tsx

@@ -0,0 +1,110 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Miscellaneous subcommand handlers — extracted from main.tsx for lazy loading.
+ * setup-token, doctor, install
+ */
+/* eslint-disable custom-rules/no-process-exit -- CLI subcommand handlers intentionally exit */
+
+import { cwd } from 'process';
+import React from 'react';
+import { WelcomeV2 } from '../../components/LogoV2/WelcomeV2.js';
+import { useManagePlugins } from '../../hooks/useManagePlugins.js';
+import type { Root } from '../../ink.js';
+import { Box, Text } from '../../ink.js';
+import { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { MCPConnectionManager } from '../../services/mcp/MCPConnectionManager.js';
+import { AppStateProvider } from '../../state/AppState.js';
+import { onChangeAppState } from '../../state/onChangeAppState.js';
+import { isAnthropicAuthEnabled } from '../../utils/auth.js';
+export async function setupTokenHandler(root: Root): Promise<void> {
+  logEvent('tengu_setup_token_command', {});
+  const showAuthWarning = !isAnthropicAuthEnabled();
+  const {
+    ConsoleOAuthFlow
+  } = await import('../../components/ConsoleOAuthFlow.js');
+  await new Promise<void>(resolve => {
+    root.render(<AppStateProvider onChangeAppState={onChangeAppState}>
+        <KeybindingSetup>
+          <Box flexDirection="column" gap={1}>
+            <WelcomeV2 />
+            {showAuthWarning && <Box flexDirection="column">
+                <Text color="warning">
+                  Warning: You already have authentication configured via
+                  environment variable or API key helper.
+                </Text>
+                <Text color="warning">
+                  The setup-token command will create a new OAuth token which
+                  you can use instead.
+                </Text>
+              </Box>}
+            <ConsoleOAuthFlow onDone={() => {
+            void resolve();
+          }} mode="setup-token" startingMessage="This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required." />
+          </Box>
+        </KeybindingSetup>
+      </AppStateProvider>);
+  });
+  root.unmount();
+  process.exit(0);
+}
+
+// DoctorWithPlugins wrapper + doctor handler
+const DoctorLazy = React.lazy(() => import('../../screens/Doctor.js').then(m => ({
+  default: m.Doctor
+})));
+function DoctorWithPlugins(t0) {
+  const $ = _c(2);
+  const {
+    onDone
+  } = t0;
+  useManagePlugins();
+  let t1;
+  if ($[0] !== onDone) {
+    t1 = <React.Suspense fallback={null}><DoctorLazy onDone={onDone} /></React.Suspense>;
+    $[0] = onDone;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  return t1;
+}
+export async function doctorHandler(root: Root): Promise<void> {
+  logEvent('tengu_doctor_command', {});
+  await new Promise<void>(resolve => {
+    root.render(<AppStateProvider>
+        <KeybindingSetup>
+          <MCPConnectionManager dynamicMcpConfig={undefined} isStrictMcpConfig={false}>
+            <DoctorWithPlugins onDone={() => {
+            void resolve();
+          }} />
+          </MCPConnectionManager>
+        </KeybindingSetup>
+      </AppStateProvider>);
+  });
+  root.unmount();
+  process.exit(0);
+}
+
+// install handler
+export async function installHandler(target: string | undefined, options: {
+  force?: boolean;
+}): Promise<void> {
+  const {
+    setup
+  } = await import('../../setup.js');
+  await setup(cwd(), 'default', false, false, undefined, false);
+  const {
+    install
+  } = await import('../../commands/install.js');
+  await new Promise<void>(resolve => {
+    const args: string[] = [];
+    if (target) args.push(target);
+    if (options.force) args.push('--force');
+    void install.call(result => {
+      void resolve();
+      process.exit(result.includes('failed') ? 1 : 0);
+    }, {}, args);
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["cwd","React","WelcomeV2","useManagePlugins","Root","Box","Text","KeybindingSetup","logEvent","MCPConnectionManager","AppStateProvider","onChangeAppState","isAnthropicAuthEnabled","setupTokenHandler","root","Promise","showAuthWarning","ConsoleOAuthFlow","resolve","render","unmount","process","exit","DoctorLazy","lazy","then","m","default","Doctor","DoctorWithPlugins","t0","$","_c","onDone","t1","doctorHandler","undefined","installHandler","target","options","force","setup","install","args","push","call","result","includes"],"sources":["util.tsx"],"sourcesContent":["/**\n * Miscellaneous subcommand handlers — extracted from main.tsx for lazy loading.\n * setup-token, doctor, install\n */\n/* eslint-disable custom-rules/no-process-exit -- CLI subcommand handlers intentionally exit */\n\nimport { cwd } from 'process'\nimport React from 'react'\nimport { WelcomeV2 } from '../../components/LogoV2/WelcomeV2.js'\nimport { useManagePlugins } from '../../hooks/useManagePlugins.js'\nimport type { Root } from '../../ink.js'\nimport { Box, Text } from '../../ink.js'\nimport { KeybindingSetup } from '../../keybindings/KeybindingProviderSetup.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { MCPConnectionManager } from '../../services/mcp/MCPConnectionManager.js'\nimport { AppStateProvider } from '../../state/AppState.js'\nimport { onChangeAppState } from '../../state/onChangeAppState.js'\nimport { isAnthropicAuthEnabled } from '../../utils/auth.js'\n\nexport async function setupTokenHandler(root: Root): Promise<void> {\n  logEvent('tengu_setup_token_command', {})\n\n  const showAuthWarning = !isAnthropicAuthEnabled()\n  const { ConsoleOAuthFlow } = await import(\n    '../../components/ConsoleOAuthFlow.js'\n  )\n  await new Promise<void>(resolve => {\n    root.render(\n      <AppStateProvider onChangeAppState={onChangeAppState}>\n        <KeybindingSetup>\n          <Box flexDirection=\"column\" gap={1}>\n            <WelcomeV2 />\n            {showAuthWarning && (\n              <Box flexDirection=\"column\">\n                <Text color=\"warning\">\n                  Warning: You already have authentication configured via\n                  environment variable or API key helper.\n                </Text>\n                <Text color=\"warning\">\n                  The setup-token command will create a new OAuth token which\n                  you can use instead.\n                </Text>\n              </Box>\n            )}\n            <ConsoleOAuthFlow\n              onDone={() => {\n                void resolve()\n              }}\n              mode=\"setup-token\"\n              startingMessage=\"This will guide you through long-lived (1-year) auth token setup for your Claude account. Claude subscription required.\"\n            />\n          </Box>\n        </KeybindingSetup>\n      </AppStateProvider>,\n    )\n  })\n  root.unmount()\n  process.exit(0)\n}\n\n// DoctorWithPlugins wrapper + doctor handler\nconst DoctorLazy = React.lazy(() =>\n  import('../../screens/Doctor.js').then(m => ({ default: m.Doctor })),\n)\n\nfunction DoctorWithPlugins({\n  onDone,\n}: {\n  onDone: () => void\n}): React.ReactNode {\n  useManagePlugins()\n  return (\n    <React.Suspense fallback={null}>\n      <DoctorLazy onDone={onDone} />\n    </React.Suspense>\n  )\n}\n\nexport async function doctorHandler(root: Root): Promise<void> {\n  logEvent('tengu_doctor_command', {})\n\n  await new Promise<void>(resolve => {\n    root.render(\n      <AppStateProvider>\n        <KeybindingSetup>\n          <MCPConnectionManager\n            dynamicMcpConfig={undefined}\n            isStrictMcpConfig={false}\n          >\n            <DoctorWithPlugins\n              onDone={() => {\n                void resolve()\n              }}\n            />\n          </MCPConnectionManager>\n        </KeybindingSetup>\n      </AppStateProvider>,\n    )\n  })\n  root.unmount()\n  process.exit(0)\n}\n\n// install handler\nexport async function installHandler(\n  target: string | undefined,\n  options: { force?: boolean },\n): Promise<void> {\n  const { setup } = await import('../../setup.js')\n  await setup(cwd(), 'default', false, false, undefined, false)\n  const { install } = await import('../../commands/install.js')\n  await new Promise<void>(resolve => {\n    const args: string[] = []\n    if (target) args.push(target)\n    if (options.force) args.push('--force')\n\n    void install.call(\n      result => {\n        void resolve()\n        process.exit(result.includes('failed') ? 1 : 0)\n      },\n      {},\n      args,\n    )\n  })\n}\n"],"mappings":"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","ignoreList":[]}

package/src/cli/ndjsonSafeStringify.ts

@@ -0,0 +1,32 @@
+import { jsonStringify } from '../utils/slowOperations.js'
+
+// JSON.stringify emits U+2028/U+2029 raw (valid per ECMA-404). When the
+// output is a single NDJSON line, any receiver that uses JavaScript
+// line-terminator semantics (ECMA-262 §11.3 — \n \r U+2028 U+2029) to
+// split the stream will cut the JSON mid-string. ProcessTransport now
+// silently skips non-JSON lines rather than crashing (gh-28405), but
+// the truncated fragment is still lost — the message is silently dropped.
+//
+// The \uXXXX form is equivalent JSON (parses to the same string) but
+// can never be mistaken for a line terminator by ANY receiver. This is
+// what ES2019's "Subsume JSON" proposal and Node's util.inspect do.
+//
+// Single regex with alternation: the callback's one dispatch per match
+// is cheaper than two full-string scans.
+const JS_LINE_TERMINATORS = /\u2028|\u2029/g
+
+function escapeJsLineTerminators(json: string): string {
+  return json.replace(JS_LINE_TERMINATORS, c =>
+    c === '\u2028' ? '\\u2028' : '\\u2029',
+  )
+}
+
+/**
+ * JSON.stringify for one-message-per-line transports. Escapes U+2028
+ * LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR so the serialized output
+ * cannot be broken by a line-splitting receiver. Output is still valid
+ * JSON and parses to the same value.
+ */
+export function ndjsonSafeStringify(value: unknown): string {
+  return escapeJsLineTerminators(jsonStringify(value))
+}