lcclaude 1.0.0

package/dist/src/commands/ultraplan.js

@@ -0,0 +1,361 @@
+import { readFileSync } from "fs";
+import { REMOTE_CONTROL_DISCONNECTED_MSG } from "../bridge/types.js";
+import { DIAMOND_OPEN } from "../constants/figures.js";
+import { getRemoteSessionUrl } from "../constants/product.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../services/analytics/growthbook.js";
+import { logEvent } from "../services/analytics/index.js";
+import { checkRemoteAgentEligibility, formatPreconditionError, RemoteAgentTask, registerRemoteAgentTask } from "../tasks/RemoteAgentTask/RemoteAgentTask.js";
+import { logForDebugging } from "../utils/debug.js";
+import { errorMessage } from "../utils/errors.js";
+import { logError } from "../utils/log.js";
+import { enqueuePendingNotification } from "../utils/messageQueueManager.js";
+import { ALL_MODEL_CONFIGS } from "../utils/model/configs.js";
+import { updateTaskState } from "../utils/task/framework.js";
+import { archiveRemoteSession, teleportToRemote } from "../utils/teleport.js";
+import { pollForApprovedExitPlanMode, UltraplanPollError } from "../utils/ultraplan/ccrSession.js";
+const ULTRAPLAN_TIMEOUT_MS = 30 * 60 * 1000;
+export const CCR_TERMS_URL = "https://code.claude.com/docs/en/claude-code-on-the-web";
+function getUltraplanModel() {
+  return getFeatureValue_CACHED_MAY_BE_STALE("tengu_ultraplan_model", ALL_MODEL_CONFIGS.opus46.firstParty);
+}
+const _rawPrompt = require("../utils/ultraplan/prompt.txt.js");
+const DEFAULT_INSTRUCTIONS = (typeof _rawPrompt === "string" ? _rawPrompt : _rawPrompt.default).trimEnd();
+const ULTRAPLAN_INSTRUCTIONS = DEFAULT_INSTRUCTIONS;
+export function buildUltraplanPrompt(blurb, seedPlan) {
+  const parts = [];
+  if (seedPlan) {
+    parts.push("Here is a draft plan to refine:", "", seedPlan, "");
+  }
+  parts.push(ULTRAPLAN_INSTRUCTIONS);
+  if (blurb) {
+    parts.push("", blurb);
+  }
+  return parts.join(`
+`);
+}
+function startDetachedPoll(taskId, sessionId, url, getAppState, setAppState) {
+  const started = Date.now();
+  let failed = false;
+  (async () => {
+    try {
+      const {
+        plan,
+        rejectCount,
+        executionTarget
+      } = await pollForApprovedExitPlanMode(sessionId, ULTRAPLAN_TIMEOUT_MS, (phase) => {
+        if (phase === "needs_input")
+          logEvent("tengu_ultraplan_awaiting_input", {});
+        updateTaskState(taskId, setAppState, (t) => {
+          if (t.status !== "running")
+            return t;
+          const next = phase === "running" ? undefined : phase;
+          return t.ultraplanPhase === next ? t : {
+            ...t,
+            ultraplanPhase: next
+          };
+        });
+      }, () => getAppState().tasks?.[taskId]?.status !== "running");
+      logEvent("tengu_ultraplan_approved", {
+        duration_ms: Date.now() - started,
+        plan_length: plan.length,
+        reject_count: rejectCount,
+        execution_target: executionTarget
+      });
+      if (executionTarget === "remote") {
+        const task = getAppState().tasks?.[taskId];
+        if (task?.status !== "running")
+          return;
+        updateTaskState(taskId, setAppState, (t) => t.status !== "running" ? t : {
+          ...t,
+          status: "completed",
+          endTime: Date.now()
+        });
+        setAppState((prev) => prev.ultraplanSessionUrl === url ? {
+          ...prev,
+          ultraplanSessionUrl: undefined
+        } : prev);
+        enqueuePendingNotification({
+          value: [`Ultraplan approved — executing in Claude Code on the web. Follow along at: ${url}`, "", "Results will land as a pull request when the remote session finishes. There is nothing to do here."].join(`
+`),
+          mode: "task-notification"
+        });
+      } else {
+        setAppState((prev) => {
+          const task = prev.tasks?.[taskId];
+          if (!task || task.status !== "running")
+            return prev;
+          return {
+            ...prev,
+            ultraplanPendingChoice: {
+              plan,
+              sessionId,
+              taskId
+            }
+          };
+        });
+      }
+    } catch (e) {
+      const task = getAppState().tasks?.[taskId];
+      if (task?.status !== "running")
+        return;
+      failed = true;
+      logEvent("tengu_ultraplan_failed", {
+        duration_ms: Date.now() - started,
+        reason: e instanceof UltraplanPollError ? e.reason : "network_or_unknown",
+        reject_count: e instanceof UltraplanPollError ? e.rejectCount : undefined
+      });
+      enqueuePendingNotification({
+        value: `Ultraplan failed: ${errorMessage(e)}
+
+Session: ${url}`,
+        mode: "task-notification"
+      });
+      archiveRemoteSession(sessionId).catch((e) => logForDebugging(`ultraplan archive failed: ${String(e)}`));
+      setAppState((prev) => prev.ultraplanSessionUrl === url ? {
+        ...prev,
+        ultraplanSessionUrl: undefined
+      } : prev);
+    } finally {
+      if (failed) {
+        updateTaskState(taskId, setAppState, (t) => t.status !== "running" ? t : {
+          ...t,
+          status: "failed",
+          endTime: Date.now()
+        });
+      }
+    }
+  })();
+}
+function buildLaunchMessage(disconnectedBridge) {
+  const prefix = disconnectedBridge ? `${REMOTE_CONTROL_DISCONNECTED_MSG} ` : "";
+  return `${DIAMOND_OPEN} ultraplan
+${prefix}Starting Claude Code on the web…`;
+}
+function buildSessionReadyMessage(url) {
+  return `${DIAMOND_OPEN} ultraplan · Monitor progress in Claude Code on the web ${url}
+You can continue working — when the ${DIAMOND_OPEN} fills, press ↓ to view results`;
+}
+function buildAlreadyActiveMessage(url) {
+  return url ? `ultraplan: already polling. Open ${url} to check status, or wait for the plan to land here.` : "ultraplan: already launching. Please wait for the session to start.";
+}
+export async function stopUltraplan(taskId, sessionId, setAppState) {
+  await RemoteAgentTask.kill(taskId, setAppState);
+  setAppState((prev) => prev.ultraplanSessionUrl || prev.ultraplanPendingChoice || prev.ultraplanLaunching ? {
+    ...prev,
+    ultraplanSessionUrl: undefined,
+    ultraplanPendingChoice: undefined,
+    ultraplanLaunching: undefined
+  } : prev);
+  const url = getRemoteSessionUrl(sessionId, process.env.SESSION_INGRESS_URL);
+  enqueuePendingNotification({
+    value: `Ultraplan stopped.
+
+Session: ${url}`,
+    mode: "task-notification"
+  });
+  enqueuePendingNotification({
+    value: "The user stopped the ultraplan session above. Do not respond to the stop notification — wait for their next message.",
+    mode: "task-notification",
+    isMeta: true
+  });
+}
+export async function launchUltraplan(opts) {
+  const {
+    blurb,
+    seedPlan,
+    getAppState,
+    setAppState,
+    signal,
+    disconnectedBridge,
+    onSessionReady
+  } = opts;
+  const {
+    ultraplanSessionUrl: active,
+    ultraplanLaunching
+  } = getAppState();
+  if (active || ultraplanLaunching) {
+    logEvent("tengu_ultraplan_create_failed", {
+      reason: active ? "already_polling" : "already_launching"
+    });
+    return buildAlreadyActiveMessage(active);
+  }
+  if (!blurb && !seedPlan) {
+    return [
+      'Usage: /ultraplan \\<prompt\\>, or include "ultraplan" anywhere',
+      "in your prompt",
+      "",
+      "Advanced multi-agent plan mode with our most powerful model",
+      "(Opus). Runs in Claude Code on the web. When the plan is ready,",
+      "you can execute it in the web session or send it back here.",
+      "Terminal stays free while the remote plans.",
+      "Requires /login.",
+      "",
+      `Terms: ${CCR_TERMS_URL}`
+    ].join(`
+`);
+  }
+  setAppState((prev) => prev.ultraplanLaunching ? prev : {
+    ...prev,
+    ultraplanLaunching: true
+  });
+  launchDetached({
+    blurb,
+    seedPlan,
+    getAppState,
+    setAppState,
+    signal,
+    onSessionReady
+  });
+  return buildLaunchMessage(disconnectedBridge);
+}
+async function launchDetached(opts) {
+  const {
+    blurb,
+    seedPlan,
+    getAppState,
+    setAppState,
+    signal,
+    onSessionReady
+  } = opts;
+  let sessionId;
+  try {
+    const model = getUltraplanModel();
+    const eligibility = await checkRemoteAgentEligibility();
+    if (!eligibility.eligible) {
+      logEvent("tengu_ultraplan_create_failed", {
+        reason: "precondition",
+        precondition_errors: eligibility.errors.map((e) => e.type).join(",")
+      });
+      const reasons = eligibility.errors.map(formatPreconditionError).join(`
+`);
+      enqueuePendingNotification({
+        value: `ultraplan: cannot launch remote session —
+${reasons}`,
+        mode: "task-notification"
+      });
+      return;
+    }
+    const prompt = buildUltraplanPrompt(blurb, seedPlan);
+    let bundleFailMsg;
+    const session = await teleportToRemote({
+      initialMessage: prompt,
+      description: blurb || "Refine local plan",
+      model,
+      permissionMode: "plan",
+      ultraplan: true,
+      signal,
+      useDefaultEnvironment: true,
+      onBundleFail: (msg) => {
+        bundleFailMsg = msg;
+      }
+    });
+    if (!session) {
+      logEvent("tengu_ultraplan_create_failed", {
+        reason: bundleFailMsg ? "bundle_fail" : "teleport_null"
+      });
+      enqueuePendingNotification({
+        value: `ultraplan: session creation failed${bundleFailMsg ? ` — ${bundleFailMsg}` : ""}. See --debug for details.`,
+        mode: "task-notification"
+      });
+      return;
+    }
+    sessionId = session.id;
+    const url = getRemoteSessionUrl(session.id, process.env.SESSION_INGRESS_URL);
+    setAppState((prev) => ({
+      ...prev,
+      ultraplanSessionUrl: url,
+      ultraplanLaunching: undefined
+    }));
+    onSessionReady?.(buildSessionReadyMessage(url));
+    logEvent("tengu_ultraplan_launched", {
+      has_seed_plan: Boolean(seedPlan),
+      model
+    });
+    const {
+      taskId
+    } = registerRemoteAgentTask({
+      remoteTaskType: "ultraplan",
+      session: {
+        id: session.id,
+        title: blurb || "Ultraplan"
+      },
+      command: blurb,
+      context: {
+        abortController: new AbortController,
+        getAppState,
+        setAppState
+      },
+      isUltraplan: true
+    });
+    startDetachedPoll(taskId, session.id, url, getAppState, setAppState);
+  } catch (e) {
+    logError(e);
+    logEvent("tengu_ultraplan_create_failed", {
+      reason: "unexpected_error"
+    });
+    enqueuePendingNotification({
+      value: `ultraplan: unexpected error — ${errorMessage(e)}`,
+      mode: "task-notification"
+    });
+    if (sessionId) {
+      archiveRemoteSession(sessionId).catch((err) => logForDebugging("ultraplan: failed to archive orphaned session", err));
+      setAppState((prev) => prev.ultraplanSessionUrl ? {
+        ...prev,
+        ultraplanSessionUrl: undefined
+      } : prev);
+    }
+  } finally {
+    setAppState((prev) => prev.ultraplanLaunching ? {
+      ...prev,
+      ultraplanLaunching: undefined
+    } : prev);
+  }
+}
+const call = async (onDone, context, args) => {
+  const blurb = args.trim();
+  if (!blurb) {
+    const msg = await launchUltraplan({
+      blurb,
+      getAppState: context.getAppState,
+      setAppState: context.setAppState,
+      signal: context.abortController.signal
+    });
+    onDone(msg, {
+      display: "system"
+    });
+    return null;
+  }
+  const {
+    ultraplanSessionUrl: active,
+    ultraplanLaunching
+  } = context.getAppState();
+  if (active || ultraplanLaunching) {
+    logEvent("tengu_ultraplan_create_failed", {
+      reason: active ? "already_polling" : "already_launching"
+    });
+    onDone(buildAlreadyActiveMessage(active), {
+      display: "system"
+    });
+    return null;
+  }
+  context.setAppState((prev) => ({
+    ...prev,
+    ultraplanLaunchPending: {
+      blurb
+    }
+  }));
+  onDone(undefined, {
+    display: "skip"
+  });
+  return null;
+};
+export default {
+  type: "local-jsx",
+  name: "ultraplan",
+  description: `~10–30 min · Claude Code on the web drafts an advanced plan you can edit and approve. See ${CCR_TERMS_URL}`,
+  argumentHint: "<prompt>",
+  isEnabled: () => false,
+  load: () => Promise.resolve({
+    call
+  })
+};

package/dist/src/commands/upgrade/index.js

@@ -0,0 +1,11 @@
+import { getSubscriptionType } from "../../utils/auth.js";
+import { isEnvTruthy } from "../../utils/envUtils.js";
+const upgrade = {
+  type: "local-jsx",
+  name: "upgrade",
+  description: "Upgrade to Max for higher rate limits and more Opus",
+  availability: ["claude-ai"],
+  isEnabled: () => !isEnvTruthy(process.env.DISABLE_UPGRADE_COMMAND) && getSubscriptionType() !== "enterprise",
+  load: () => import("./upgrade.js")
+};
+export default upgrade;

package/dist/src/commands/upgrade/upgrade.js

@@ -0,0 +1,37 @@
+import * as React from "react";
+import { getOauthProfileFromOauthToken } from "../../services/oauth/getOauthProfile.js";
+import { getClaudeAIOAuthTokens, isClaudeAISubscriber } from "../../utils/auth.js";
+import { openBrowser } from "../../utils/browser.js";
+import { logError } from "../../utils/log.js";
+import { Login } from "../login/login.js";
+export async function call(onDone, context) {
+  try {
+    if (isClaudeAISubscriber()) {
+      const tokens = getClaudeAIOAuthTokens();
+      let isMax20x = false;
+      if (tokens?.subscriptionType && tokens?.rateLimitTier) {
+        isMax20x = tokens.subscriptionType === "max" && tokens.rateLimitTier === "default_claude_max_20x";
+      } else if (tokens?.accessToken) {
+        const profile = await getOauthProfileFromOauthToken(tokens.accessToken);
+        isMax20x = profile?.organization?.organization_type === "claude_max" && profile?.organization?.rate_limit_tier === "default_claude_max_20x";
+      }
+      if (isMax20x) {
+        setTimeout(onDone, 0, "You are already on the highest Max subscription plan. For additional usage, run /login to switch to an API usage-billed account.");
+        return null;
+      }
+    }
+    const url = "https://claude.ai/upgrade/max";
+    await openBrowser(url);
+    return jsxDEV_7x81h0kn(Login, {
+      startingMessage: "Starting new login following /upgrade. Exit with Ctrl-C to use existing account.",
+      onDone: (success) => {
+        context.onChangeAPIKey();
+        onDone(success ? "Login successful" : "Login interrupted");
+      }
+    }, undefined, false, undefined, this);
+  } catch (error) {
+    logError(error);
+    setTimeout(onDone, 0, "Failed to open browser. Please visit https://claude.ai/upgrade/max to upgrade.");
+  }
+  return null;
+}

package/dist/src/commands/usage/index.js

@@ -0,0 +1,7 @@
+export default {
+  type: "local-jsx",
+  name: "usage",
+  description: "Show plan usage limits",
+  availability: ["claude-ai"],
+  load: () => import("./usage.js")
+};

package/dist/src/commands/usage/usage.js

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { Settings } from "../../components/Settings/Settings.js";
+export const call = async (onDone, context) => {
+  return jsxDEV_7x81h0kn(Settings, {
+    onClose: onDone,
+    context,
+    defaultTab: "Usage"
+  }, undefined, false, undefined, this);
+};

package/dist/src/commands/version.js

@@ -0,0 +1,15 @@
+const call = async () => {
+  return {
+    type: "text",
+    value: MACRO.BUILD_TIME ? `${MACRO.VERSION} (built ${MACRO.BUILD_TIME})` : MACRO.VERSION
+  };
+};
+const version = {
+  type: "local",
+  name: "version",
+  description: "Print the version this session is running (not what autoupdate downloaded)",
+  isEnabled: () => process.env.USER_TYPE === "ant",
+  supportsNonInteractive: true,
+  load: () => Promise.resolve({ call })
+};
+export default version;

package/dist/src/commands/vim/index.js

@@ -0,0 +1,8 @@
+const command = {
+  name: "vim",
+  description: "Toggle between Vim and Normal editing modes",
+  supportsNonInteractive: false,
+  type: "local",
+  load: () => import("./vim.js")
+};
+export default command;

package/dist/src/commands/vim/vim.js

@@ -0,0 +1,24 @@
+import {
+  logEvent
+} from "../../services/analytics/index.js";
+import { getGlobalConfig, saveGlobalConfig } from "../../utils/config.js";
+export const call = async () => {
+  const config = getGlobalConfig();
+  let currentMode = config.editorMode || "normal";
+  if (currentMode === "emacs") {
+    currentMode = "normal";
+  }
+  const newMode = currentMode === "normal" ? "vim" : "normal";
+  saveGlobalConfig((current) => ({
+    ...current,
+    editorMode: newMode
+  }));
+  logEvent("tengu_editor_mode_changed", {
+    mode: newMode,
+    source: "command"
+  });
+  return {
+    type: "text",
+    value: `Editor mode set to ${newMode}. ${newMode === "vim" ? "Use Escape key to toggle between INSERT and NORMAL modes." : "Using standard (readline) keyboard bindings."}`
+  };
+};

package/dist/src/commands/voice/index.js

@@ -0,0 +1,17 @@
+import {
+  isVoiceGrowthBookEnabled,
+  isVoiceModeEnabled
+} from "../../voice/voiceModeEnabled.js";
+const voice = {
+  type: "local",
+  name: "voice",
+  description: "Toggle voice mode",
+  availability: ["claude-ai"],
+  isEnabled: () => isVoiceGrowthBookEnabled(),
+  get isHidden() {
+    return !isVoiceModeEnabled();
+  },
+  supportsNonInteractive: false,
+  load: () => import("./voice.js")
+};
+export default voice;

package/dist/src/commands/voice/voice.js

@@ -0,0 +1,117 @@
+import { normalizeLanguageForSTT } from "../../hooks/useVoice.js";
+import { getShortcutDisplay } from "../../keybindings/shortcutFormat.js";
+import { logEvent } from "../../services/analytics/index.js";
+import { isAnthropicAuthEnabled } from "../../utils/auth.js";
+import { getGlobalConfig, saveGlobalConfig } from "../../utils/config.js";
+import { settingsChangeDetector } from "../../utils/settings/changeDetector.js";
+import {
+  getInitialSettings,
+  updateSettingsForSource
+} from "../../utils/settings/settings.js";
+import { isVoiceModeEnabled } from "../../voice/voiceModeEnabled.js";
+const LANG_HINT_MAX_SHOWS = 2;
+export const call = async () => {
+  if (!isVoiceModeEnabled()) {
+    if (!isAnthropicAuthEnabled()) {
+      return {
+        type: "text",
+        value: "Voice mode requires a Claude.ai account. Please run /login to sign in."
+      };
+    }
+    return {
+      type: "text",
+      value: "Voice mode is not available."
+    };
+  }
+  const currentSettings = getInitialSettings();
+  const isCurrentlyEnabled = currentSettings.voiceEnabled === true;
+  if (isCurrentlyEnabled) {
+    const result = updateSettingsForSource("userSettings", {
+      voiceEnabled: false
+    });
+    if (result.error) {
+      return {
+        type: "text",
+        value: "Failed to update settings. Check your settings file for syntax errors."
+      };
+    }
+    settingsChangeDetector.notifyChange("userSettings");
+    logEvent("tengu_voice_toggled", { enabled: false });
+    return {
+      type: "text",
+      value: "Voice mode disabled."
+    };
+  }
+  const { isVoiceStreamAvailable } = await import("../../services/voiceStreamSTT.js");
+  const { checkRecordingAvailability } = await import("../../services/voice.js");
+  const recording = await checkRecordingAvailability();
+  if (!recording.available) {
+    return {
+      type: "text",
+      value: recording.reason ?? "Voice mode is not available in this environment."
+    };
+  }
+  if (!isVoiceStreamAvailable()) {
+    return {
+      type: "text",
+      value: "Voice mode requires a Claude.ai account. Please run /login to sign in."
+    };
+  }
+  const { checkVoiceDependencies, requestMicrophonePermission } = await import("../../services/voice.js");
+  const deps = await checkVoiceDependencies();
+  if (!deps.available) {
+    const hint = deps.installCommand ? `
+Install audio recording tools? Run: ${deps.installCommand}` : `
+Install SoX manually for audio recording.`;
+    return {
+      type: "text",
+      value: `No audio recording tool found.${hint}`
+    };
+  }
+  if (!await requestMicrophonePermission()) {
+    let guidance;
+    if (process.platform === "win32") {
+      guidance = "Settings → Privacy → Microphone";
+    } else if (process.platform === "linux") {
+      guidance = "your system's audio settings";
+    } else {
+      guidance = "System Settings → Privacy & Security → Microphone";
+    }
+    return {
+      type: "text",
+      value: `Microphone access is denied. To enable it, go to ${guidance}, then run /voice again.`
+    };
+  }
+  const result = updateSettingsForSource("userSettings", { voiceEnabled: true });
+  if (result.error) {
+    return {
+      type: "text",
+      value: "Failed to update settings. Check your settings file for syntax errors."
+    };
+  }
+  settingsChangeDetector.notifyChange("userSettings");
+  logEvent("tengu_voice_toggled", { enabled: true });
+  const key = getShortcutDisplay("voice:pushToTalk", "Chat", "Space");
+  const stt = normalizeLanguageForSTT(currentSettings.language);
+  const cfg = getGlobalConfig();
+  const langChanged = cfg.voiceLangHintLastLanguage !== stt.code;
+  const priorCount = langChanged ? 0 : cfg.voiceLangHintShownCount ?? 0;
+  const showHint = !stt.fellBackFrom && priorCount < LANG_HINT_MAX_SHOWS;
+  let langNote = "";
+  if (stt.fellBackFrom) {
+    langNote = ` Note: "${stt.fellBackFrom}" is not a supported dictation language; using English. Change it via /config.`;
+  } else if (showHint) {
+    langNote = ` Dictation language: ${stt.code} (/config to change).`;
+  }
+  if (langChanged || showHint) {
+    saveGlobalConfig((prev) => ({
+      ...prev,
+      voiceLangHintShownCount: priorCount + (showHint ? 1 : 0),
+      voiceLangHintLastLanguage: stt.code
+    }));
+  }
+  return {
+    type: "text",
+    value: `Voice mode enabled. Hold ${key} to record.${langNote}`
+  };
+};