@xortex/xcode 3.0.1 → 3.0.3

package/commands/remote-setup/api.ts

@@ -0,0 +1,182 @@
+import axios from 'src/utils/axios.js'
+import { getOauthConfig } from '../../constants/oauth.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { getOAuthHeaders, prepareApiRequest } from '../../utils/teleport/api.js'
+import { fetchEnvironments } from '../../utils/teleport/environments.js'
+
+const CCR_BYOC_BETA_HEADER = 'ccr-byoc-2025-07-29'
+
+/**
+ * Wraps a raw GitHub token so that its string representation is redacted.
+ * `String(token)`, template literals, `JSON.stringify(token)`, and any
+ * attached error messages will show `[REDACTED:gh-token]` instead of the
+ * token value. Call `.reveal()` only at the single point where the raw
+ * value is placed into an HTTP body.
+ */
+export class RedactedGithubToken {
+  readonly #value: string
+  constructor(raw: string) {
+    this.#value = raw
+  }
+  reveal(): string {
+    return this.#value
+  }
+  toString(): string {
+    return '[REDACTED:gh-token]'
+  }
+  toJSON(): string {
+    return '[REDACTED:gh-token]'
+  }
+  [Symbol.for('nodejs.util.inspect.custom')](): string {
+    return '[REDACTED:gh-token]'
+  }
+}
+
+export type ImportTokenResult = {
+  github_username: string
+}
+
+export type ImportTokenError =
+  | { kind: 'not_signed_in' }
+  | { kind: 'invalid_token' }
+  | { kind: 'server'; status: number }
+  | { kind: 'network' }
+
+/**
+ * POSTs a GitHub token to the CCR backend, which validates it against
+ * GitHub's /user endpoint and stores it Fernet-encrypted in sync_user_tokens.
+ * The stored token satisfies the same read paths as an OAuth token, so
+ * clone/push in claude.ai/code works immediately after this succeeds.
+ */
+export async function importGithubToken(
+  token: RedactedGithubToken,
+): Promise<
+  | { ok: true; result: ImportTokenResult }
+  | { ok: false; error: ImportTokenError }
+> {
+  let accessToken: string, orgUUID: string
+  try {
+    ;({ accessToken, orgUUID } = await prepareApiRequest())
+  } catch {
+    return { ok: false, error: { kind: 'not_signed_in' } }
+  }
+
+  const url = `${getOauthConfig().BASE_API_URL}/v1/code/github/import-token`
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    'anthropic-beta': CCR_BYOC_BETA_HEADER,
+    'x-organization-uuid': orgUUID,
+  }
+
+  try {
+    const response = await axios.post<ImportTokenResult>(
+      url,
+      { token: token.reveal() },
+      { headers, timeout: 15000, validateStatus: () => true },
+    )
+    if (response.status === 200) {
+      return { ok: true, result: response.data }
+    }
+    if (response.status === 400) {
+      return { ok: false, error: { kind: 'invalid_token' } }
+    }
+    if (response.status === 401) {
+      return { ok: false, error: { kind: 'not_signed_in' } }
+    }
+    logForDebugging(`import-token returned ${response.status}`, {
+      level: 'error',
+    })
+    return { ok: false, error: { kind: 'server', status: response.status } }
+  } catch (err) {
+    if (axios.isAxiosError(err)) {
+      // err.config.data would contain the POST body with the raw token.
+      // Do not include it in any log. The error code alone is enough.
+      logForDebugging(`import-token network error: ${err.code ?? 'unknown'}`, {
+        level: 'error',
+      })
+    }
+    return { ok: false, error: { kind: 'network' } }
+  }
+}
+
+async function hasExistingEnvironment(): Promise<boolean> {
+  try {
+    const envs = await fetchEnvironments()
+    return envs.length > 0
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Best-effort default environment creation. Mirrors the web onboarding's
+ * DEFAULT_CLOUD_ENVIRONMENT_REQUEST so a first-time user lands on the
+ * composer instead of env-setup. Checks for existing environments first
+ * so re-running /web-setup doesn't pile up duplicates. Failures are
+ * non-fatal — the token import already succeeded, and the web state
+ * machine falls back to env-setup on next load.
+ */
+export async function createDefaultEnvironment(): Promise<boolean> {
+  let accessToken: string, orgUUID: string
+  try {
+    ;({ accessToken, orgUUID } = await prepareApiRequest())
+  } catch {
+    return false
+  }
+
+  if (await hasExistingEnvironment()) {
+    return true
+  }
+
+  // The /private/organizations/{org}/ path rejects CLI OAuth tokens (wrong
+  // auth dep). The public path uses build_flexible_auth — same path
+  // fetchEnvironments() uses. Org is passed via x-organization-uuid header.
+  const url = `${getOauthConfig().BASE_API_URL}/v1/environment_providers/cloud/create`
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    'x-organization-uuid': orgUUID,
+  }
+
+  try {
+    const response = await axios.post(
+      url,
+      {
+        name: 'Default',
+        kind: 'anthropic_cloud',
+        description: 'Default - trusted network access',
+        config: {
+          environment_type: 'anthropic',
+          cwd: '/home/user',
+          init_script: null,
+          environment: {},
+          languages: [
+            { name: 'python', version: '3.11' },
+            { name: 'node', version: '20' },
+          ],
+          network_config: {
+            allowed_hosts: [],
+            allow_default_hosts: true,
+          },
+        },
+      },
+      { headers, timeout: 15000, validateStatus: () => true },
+    )
+    return response.status >= 200 && response.status < 300
+  } catch {
+    return false
+  }
+}
+
+/** Returns true when the user has valid Claude OAuth credentials. */
+export async function isSignedIn(): Promise<boolean> {
+  try {
+    await prepareApiRequest()
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function getCodeWebUrl(): string {
+  return `${getOauthConfig().CLAUDE_AI_ORIGIN}/code`
+}

package/commands/remote-setup/index.ts

@@ -0,0 +1,20 @@
+import type { Command } from '../../commands.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'
+import { isPolicyAllowed } from '../../services/policyLimits/index.js'
+
+const web = {
+  type: 'local-jsx',
+  name: 'web-setup',
+  description:
+    'Setup Claude Code on the web (requires connecting your GitHub account)',
+  availability: ['claude-ai'],
+  isEnabled: () =>
+    getFeatureValue_CACHED_MAY_BE_STALE('tengu_cobalt_lantern', false) &&
+    isPolicyAllowed('allow_remote_sessions'),
+  get isHidden() {
+    return !isPolicyAllowed('allow_remote_sessions')
+  },
+  load: () => import('./remote-setup.js'),
+} satisfies Command
+
+export default web

package/commands/remote-setup/remote-setup.tsx

@@ -0,0 +1,187 @@
+import { execa } from 'execa';
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { Select } from '../../components/CustomSelect/index.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { LoadingState } from '../../components/design-system/LoadingState.js';
+import { Box, Text } from '../../ink.js';
+import { logEvent, type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS as SafeString } from '../../services/analytics/index.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { openBrowser } from '../../utils/browser.js';
+import { getGhAuthStatus } from '../../utils/github/ghAuthStatus.js';
+import { createDefaultEnvironment, getCodeWebUrl, type ImportTokenError, importGithubToken, isSignedIn, RedactedGithubToken } from './api.js';
+type CheckResult = {
+  status: 'not_signed_in';
+} | {
+  status: 'has_gh_token';
+  token: RedactedGithubToken;
+} | {
+  status: 'gh_not_installed';
+} | {
+  status: 'gh_not_authenticated';
+};
+async function checkLoginState(): Promise<CheckResult> {
+  if (!(await isSignedIn())) {
+    return {
+      status: 'not_signed_in'
+    };
+  }
+  const ghStatus = await getGhAuthStatus();
+  if (ghStatus === 'not_installed') {
+    return {
+      status: 'gh_not_installed'
+    };
+  }
+  if (ghStatus === 'not_authenticated') {
+    return {
+      status: 'gh_not_authenticated'
+    };
+  }
+
+  // ghStatus === 'authenticated'. getGhAuthStatus spawns with stdout:'ignore'
+  // (telemetry-safe); spawn once more with stdout:'pipe' to read the token.
+  const {
+    stdout
+  } = await execa('gh', ['auth', 'token'], {
+    stdout: 'pipe',
+    stderr: 'ignore',
+    timeout: 5000,
+    reject: false
+  });
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return {
+      status: 'gh_not_authenticated'
+    };
+  }
+  return {
+    status: 'has_gh_token',
+    token: new RedactedGithubToken(trimmed)
+  };
+}
+function errorMessage(err: ImportTokenError, codeUrl: string): string {
+  switch (err.kind) {
+    case 'not_signed_in':
+      return `Login failed. Please visit ${codeUrl} and login using the GitHub App`;
+    case 'invalid_token':
+      return 'GitHub rejected that token. Run `gh auth login` and try again.';
+    case 'server':
+      return `Server error (${err.status}). Try again in a moment.`;
+    case 'network':
+      return "Couldn't reach the server. Check your connection.";
+  }
+}
+type Step = {
+  name: 'checking';
+} | {
+  name: 'confirm';
+  token: RedactedGithubToken;
+} | {
+  name: 'uploading';
+};
+function Web({
+  onDone
+}: {
+  onDone: LocalJSXCommandOnDone;
+}) {
+  const [step, setStep] = useState<Step>({
+    name: 'checking'
+  });
+  useEffect(() => {
+    logEvent('tengu_remote_setup_started', {});
+    void checkLoginState().then(async result => {
+      switch (result.status) {
+        case 'not_signed_in':
+          logEvent('tengu_remote_setup_result', {
+            result: 'not_signed_in' as SafeString
+          });
+          onDone('Not signed in to Claude. Run /login first.');
+          return;
+        case 'gh_not_installed':
+        case 'gh_not_authenticated':
+          {
+            const url = `${getCodeWebUrl()}/onboarding?step=alt-auth`;
+            await openBrowser(url);
+            logEvent('tengu_remote_setup_result', {
+              result: result.status as SafeString
+            });
+            onDone(result.status === 'gh_not_installed' ? `GitHub CLI not found. Install it via https://cli.github.com/, then run \`gh auth login\`, or connect GitHub on the web: ${url}` : `GitHub CLI not authenticated. Run \`gh auth login\` and try again, or connect GitHub on the web: ${url}`);
+            return;
+          }
+        case 'has_gh_token':
+          setStep({
+            name: 'confirm',
+            token: result.token
+          });
+      }
+    });
+    // onDone is stable across renders; intentionally not in deps.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  const handleCancel = () => {
+    logEvent('tengu_remote_setup_result', {
+      result: 'cancelled' as SafeString
+    });
+    onDone();
+  };
+  const handleConfirm = async (token: RedactedGithubToken) => {
+    setStep({
+      name: 'uploading'
+    });
+    const result = await importGithubToken(token);
+    if (!result.ok) {
+      logEvent('tengu_remote_setup_result', {
+        result: 'import_failed' as SafeString,
+        error_kind: result.error.kind as SafeString
+      });
+      onDone(errorMessage(result.error, getCodeWebUrl()));
+      return;
+    }
+
+    // Token import succeeded. Environment creation is best-effort — if it
+    // fails, the web state machine routes to env-setup on landing, which is
+    // one extra click but still better than the OAuth dance.
+    await createDefaultEnvironment();
+    const url = getCodeWebUrl();
+    await openBrowser(url);
+    logEvent('tengu_remote_setup_result', {
+      result: 'success' as SafeString
+    });
+    onDone(`Connected as ${result.result.github_username}. Opened ${url}`);
+  };
+  if (step.name === 'checking') {
+    return <LoadingState message="Checking login status…" />;
+  }
+  if (step.name === 'uploading') {
+    return <LoadingState message="Connecting GitHub to Claude…" />;
+  }
+  const token = step.token;
+  return <Dialog title="Connect Claude on the web to GitHub?" onCancel={handleCancel} hideInputGuide>
+      <Box flexDirection="column">
+        <Text>
+          Claude on the web requires connecting to your GitHub account to clone
+          and push code on your behalf.
+        </Text>
+        <Text dimColor>
+          Your local credentials are used to authenticate with GitHub
+        </Text>
+      </Box>
+      <Select options={[{
+      label: 'Continue',
+      value: 'send'
+    }, {
+      label: 'Cancel',
+      value: 'cancel'
+    }]} onChange={value => {
+      if (value === 'send') {
+        void handleConfirm(token);
+      } else {
+        handleCancel();
+      }
+    }} onCancel={handleCancel} />
+    </Dialog>;
+}
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  return <Web onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["execa","React","useEffect","useState","Select","Dialog","LoadingState","Box","Text","logEvent","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","SafeString","LocalJSXCommandOnDone","openBrowser","getGhAuthStatus","createDefaultEnvironment","getCodeWebUrl","ImportTokenError","importGithubToken","isSignedIn","RedactedGithubToken","CheckResult","status","token","checkLoginState","Promise","ghStatus","stdout","stderr","timeout","reject","trimmed","trim","errorMessage","err","codeUrl","kind","Step","name","Web","onDone","step","setStep","then","result","url","handleCancel","handleConfirm","ok","error_kind","error","github_username","label","value","call","ReactNode"],"sources":["remote-setup.tsx"],"sourcesContent":["import { execa } from 'execa'\nimport * as React from 'react'\nimport { useEffect, useState } from 'react'\nimport { Select } from '../../components/CustomSelect/index.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { LoadingState } from '../../components/design-system/LoadingState.js'\nimport { Box, Text } from '../../ink.js'\nimport {\n  logEvent,\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS as SafeString,\n} from '../../services/analytics/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { openBrowser } from '../../utils/browser.js'\nimport { getGhAuthStatus } from '../../utils/github/ghAuthStatus.js'\nimport {\n  createDefaultEnvironment,\n  getCodeWebUrl,\n  type ImportTokenError,\n  importGithubToken,\n  isSignedIn,\n  RedactedGithubToken,\n} from './api.js'\n\ntype CheckResult =\n  | { status: 'not_signed_in' }\n  | { status: 'has_gh_token'; token: RedactedGithubToken }\n  | { status: 'gh_not_installed' }\n  | { status: 'gh_not_authenticated' }\n\nasync function checkLoginState(): Promise<CheckResult> {\n  if (!(await isSignedIn())) {\n    return { status: 'not_signed_in' }\n  }\n\n  const ghStatus = await getGhAuthStatus()\n  if (ghStatus === 'not_installed') {\n    return { status: 'gh_not_installed' }\n  }\n  if (ghStatus === 'not_authenticated') {\n    return { status: 'gh_not_authenticated' }\n  }\n\n  // ghStatus === 'authenticated'. getGhAuthStatus spawns with stdout:'ignore'\n  // (telemetry-safe); spawn once more with stdout:'pipe' to read the token.\n  const { stdout } = await execa('gh', ['auth', 'token'], {\n    stdout: 'pipe',\n    stderr: 'ignore',\n    timeout: 5000,\n    reject: false,\n  })\n  const trimmed = stdout.trim()\n  if (!trimmed) {\n    return { status: 'gh_not_authenticated' }\n  }\n  return { status: 'has_gh_token', token: new RedactedGithubToken(trimmed) }\n}\n\nfunction errorMessage(err: ImportTokenError, codeUrl: string): string {\n  switch (err.kind) {\n    case 'not_signed_in':\n      return `Login failed. Please visit ${codeUrl} and login using the GitHub App`\n    case 'invalid_token':\n      return 'GitHub rejected that token. Run `gh auth login` and try again.'\n    case 'server':\n      return `Server error (${err.status}). Try again in a moment.`\n    case 'network':\n      return \"Couldn't reach the server. Check your connection.\"\n  }\n}\n\ntype Step =\n  | { name: 'checking' }\n  | { name: 'confirm'; token: RedactedGithubToken }\n  | { name: 'uploading' }\n\nfunction Web({ onDone }: { onDone: LocalJSXCommandOnDone }) {\n  const [step, setStep] = useState<Step>({ name: 'checking' })\n\n  useEffect(() => {\n    logEvent('tengu_remote_setup_started', {})\n    void checkLoginState().then(async result => {\n      switch (result.status) {\n        case 'not_signed_in':\n          logEvent('tengu_remote_setup_result', {\n            result: 'not_signed_in' as SafeString,\n          })\n          onDone('Not signed in to Claude. Run /login first.')\n          return\n        case 'gh_not_installed':\n        case 'gh_not_authenticated': {\n          const url = `${getCodeWebUrl()}/onboarding?step=alt-auth`\n          await openBrowser(url)\n          logEvent('tengu_remote_setup_result', {\n            result: result.status as SafeString,\n          })\n          onDone(\n            result.status === 'gh_not_installed'\n              ? `GitHub CLI not found. Install it via https://cli.github.com/, then run \\`gh auth login\\`, or connect GitHub on the web: ${url}`\n              : `GitHub CLI not authenticated. Run \\`gh auth login\\` and try again, or connect GitHub on the web: ${url}`,\n          )\n          return\n        }\n        case 'has_gh_token':\n          setStep({ name: 'confirm', token: result.token })\n      }\n    })\n    // onDone is stable across renders; intentionally not in deps.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  const handleCancel = () => {\n    logEvent('tengu_remote_setup_result', {\n      result: 'cancelled' as SafeString,\n    })\n    onDone()\n  }\n\n  const handleConfirm = async (token: RedactedGithubToken) => {\n    setStep({ name: 'uploading' })\n\n    const result = await importGithubToken(token)\n    if (!result.ok) {\n      logEvent('tengu_remote_setup_result', {\n        result: 'import_failed' as SafeString,\n        error_kind: result.error.kind as SafeString,\n      })\n      onDone(errorMessage(result.error, getCodeWebUrl()))\n      return\n    }\n\n    // Token import succeeded. Environment creation is best-effort — if it\n    // fails, the web state machine routes to env-setup on landing, which is\n    // one extra click but still better than the OAuth dance.\n    await createDefaultEnvironment()\n\n    const url = getCodeWebUrl()\n    await openBrowser(url)\n\n    logEvent('tengu_remote_setup_result', {\n      result: 'success' as SafeString,\n    })\n    onDone(`Connected as ${result.result.github_username}. Opened ${url}`)\n  }\n\n  if (step.name === 'checking') {\n    return <LoadingState message=\"Checking login status…\" />\n  }\n\n  if (step.name === 'uploading') {\n    return <LoadingState message=\"Connecting GitHub to Claude…\" />\n  }\n\n  const token = step.token\n  return (\n    <Dialog\n      title=\"Connect Claude on the web to GitHub?\"\n      onCancel={handleCancel}\n      hideInputGuide\n    >\n      <Box flexDirection=\"column\">\n        <Text>\n          Claude on the web requires connecting to your GitHub account to clone\n          and push code on your behalf.\n        </Text>\n        <Text dimColor>\n          Your local credentials are used to authenticate with GitHub\n        </Text>\n      </Box>\n      <Select\n        options={[\n          { label: 'Continue', value: 'send' },\n          { label: 'Cancel', value: 'cancel' },\n        ]}\n        onChange={value => {\n          if (value === 'send') {\n            void handleConfirm(token)\n          } else {\n            handleCancel()\n          }\n        }}\n        onCancel={handleCancel}\n      />\n    </Dialog>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n): Promise<React.ReactNode> {\n  return <Web onDone={onDone} />\n}\n"],"mappings":"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","ignoreList":[]}

package/commands/rename/generateSessionName.ts

@@ -0,0 +1,67 @@
+import { queryHaiku } from '../../services/api/gemini.js'
+import type { Message } from '../../types/message.js'
+import { logForDebugging } from '../../utils/debug.js'
+import { errorMessage } from '../../utils/errors.js'
+import { safeParseJSON } from '../../utils/json.js'
+import { extractTextContent } from '../../utils/messages.js'
+import { extractConversationText } from '../../utils/sessionTitle.js'
+import { asSystemPrompt } from '../../utils/systemPromptType.js'
+
+export async function generateSessionName(
+  messages: Message[],
+  signal: AbortSignal,
+): Promise<string | null> {
+  const conversationText = extractConversationText(messages)
+  if (!conversationText) {
+    return null
+  }
+
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([
+        'Generate a short kebab-case name (2-4 words) that captures the main topic of this conversation. Use lowercase words separated by hyphens. Examples: "fix-login-bug", "add-auth-feature", "refactor-api-client", "debug-test-failures". Return JSON with a "name" field.',
+      ]),
+      userPrompt: conversationText,
+      outputFormat: {
+        type: 'json_schema',
+        schema: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+          },
+          required: ['name'],
+          additionalProperties: false,
+        },
+      },
+      signal,
+      options: {
+        querySource: 'rename_generate_name',
+        agents: [],
+        isNonInteractiveSession: false,
+        hasAppendSystemPrompt: false,
+        mcpTools: [],
+      },
+    })
+
+    const content = extractTextContent(result.message.content)
+
+    const response = safeParseJSON(content)
+    if (
+      response &&
+      typeof response === 'object' &&
+      'name' in response &&
+      typeof (response as { name: unknown }).name === 'string'
+    ) {
+      return (response as { name: string }).name
+    }
+    return null
+  } catch (error) {
+    // Haiku timeout/rate-limit/network are expected operational failures —
+    // logForDebugging, not logError. Called automatically on every 3rd bridge
+    // message (initReplBridge.ts), so errors here would flood the error file.
+    logForDebugging(`generateSessionName failed: ${errorMessage(error)}`, {
+      level: 'error',
+    })
+    return null
+  }
+}

package/commands/rename/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const rename = {
+  type: 'local-jsx',
+  name: 'rename',
+  description: 'Rename the current conversation',
+  immediate: true,
+  argumentHint: '[name]',
+  load: () => import('./rename.js'),
+} satisfies Command
+
+export default rename

package/commands/rename/rename.ts

@@ -0,0 +1,87 @@
+import type { UUID } from 'crypto'
+import { getSessionId } from '../../bootstrap/state.js'
+import {
+  getBridgeBaseUrlOverride,
+  getBridgeTokenOverride,
+} from '../../bridge/bridgeConfig.js'
+import type { ToolUseContext } from '../../Tool.js'
+import type {
+  LocalJSXCommandContext,
+  LocalJSXCommandOnDone,
+} from '../../types/command.js'
+import { getMessagesAfterCompactBoundary } from '../../utils/messages.js'
+import {
+  getTranscriptPath,
+  saveAgentName,
+  saveCustomTitle,
+} from '../../utils/sessionStorage.js'
+import { isTeammate } from '../../utils/teammate.js'
+import { generateSessionName } from './generateSessionName.js'
+
+export async function call(
+  onDone: LocalJSXCommandOnDone,
+  context: ToolUseContext & LocalJSXCommandContext,
+  args: string,
+): Promise<null> {
+  // Prevent teammates from renaming - their names are set by team leader
+  if (isTeammate()) {
+    onDone(
+      'Cannot rename: This session is a swarm teammate. Teammate names are set by the team leader.',
+      { display: 'system' },
+    )
+    return null
+  }
+
+  let newName: string
+  if (!args || args.trim() === '') {
+    const generated = await generateSessionName(
+      getMessagesAfterCompactBoundary(context.messages),
+      context.abortController.signal,
+    )
+    if (!generated) {
+      onDone(
+        'Could not generate a name: no conversation context yet. Usage: /rename <name>',
+        { display: 'system' },
+      )
+      return null
+    }
+    newName = generated
+  } else {
+    newName = args.trim()
+  }
+
+  const sessionId = getSessionId() as UUID
+  const fullPath = getTranscriptPath()
+
+  // Always save the custom title (session name)
+  await saveCustomTitle(sessionId, newName, fullPath)
+
+  // Sync title to bridge session on claude.ai/code (best-effort, non-blocking).
+  // v2 env-less bridge stores cse_* in replBridgeSessionId —
+  // updateBridgeSessionTitle retags internally for the compat endpoint.
+  const appState = context.getAppState()
+  const bridgeSessionId = appState.replBridgeSessionId
+  if (bridgeSessionId) {
+    const tokenOverride = getBridgeTokenOverride()
+    void import('../../bridge/createSession.js').then(
+      ({ updateBridgeSessionTitle }) =>
+        updateBridgeSessionTitle(bridgeSessionId, newName, {
+          baseUrl: getBridgeBaseUrlOverride(),
+          getAccessToken: tokenOverride ? () => tokenOverride : undefined,
+        }).catch(() => {}),
+    )
+  }
+
+  // Also persist as the session's agent name for prompt-bar display
+  await saveAgentName(sessionId, newName, fullPath)
+  context.setAppState(prev => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: newName,
+    },
+  }))
+
+  onDone(`Session renamed to: ${newName}`, { display: 'system' })
+  return null
+}

package/commands/reset-limits/index.js

@@ -0,0 +1,4 @@
+const stub = { isEnabled: () => false, isHidden: true, name: 'stub' };
+export default stub;
+export const resetLimits = stub;
+export const resetLimitsNonInteractive = stub;

package/commands/resume/index.ts

@@ -0,0 +1,12 @@
+import type { Command } from '../../commands.js'
+
+const resume: Command = {
+  type: 'local-jsx',
+  name: 'resume',
+  description: 'Resume a previous conversation',
+  aliases: ['continue'],
+  argumentHint: '[conversation id or search term]',
+  load: () => import('./resume.js'),
+}
+
+export default resume