feat: improve clone UX and default sdk full access

Mack Ding · Mack Ding · commit 5147ae6e3ce3 · 2026-03-23T11:32:31.000Z
diff --git a/.env.example b/.env.example
@@ -14,8 +14,8 @@ WORKSPACE_ROOT=.
 CODEX_WORKDIR=.
 CODEX_SDK_CONFIG={}
 CODEX_SDK_SKIP_GIT_REPO_CHECK=true
-CODEX_SDK_SANDBOX_MODE=workspace-write
-CODEX_SDK_APPROVAL_POLICY=
+CODEX_SDK_SANDBOX_MODE=danger-full-access
+CODEX_SDK_APPROVAL_POLICY=never
 CODEX_SDK_REASONING_EFFORT=
 CODEX_SDK_NETWORK_ACCESS_ENABLED=
 CODEX_SDK_WEB_SEARCH_MODE=
diff --git a/README.md b/README.md
@@ -78,7 +78,6 @@ Key design goals:
 
 ## Screenshot
 
-
 ### Install
 
 ```bash
@@ -364,15 +363,15 @@ SDK-related options:
 CODEX_BACKEND=sdk
 CODEX_SDK_CONFIG={}
 CODEX_SDK_SKIP_GIT_REPO_CHECK=true
-CODEX_SDK_SANDBOX_MODE=workspace-write
+CODEX_SDK_SANDBOX_MODE=danger-full-access
 CODEX_SDK_APPROVAL_POLICY=never
 CODEX_SDK_REASONING_EFFORT=high
 CODEX_SDK_NETWORK_ACCESS_ENABLED=true
 CODEX_SDK_WEB_SEARCH_MODE=live
 CODEX_SDK_ADDITIONAL_DIRECTORIES=["/abs/path/extra-worktree"]
 ```
 
-If `CODEX_SDK_SANDBOX_MODE` is unset, the bot now defaults SDK threads to `workspace-write` so normal coding tasks can modify files inside the active repo. Set it explicitly to `read-only` only if you want analysis-only behavior.
+If `CODEX_SDK_SANDBOX_MODE` is unset, the bot now defaults SDK threads to Full Access: `danger-full-access` with `approvalPolicy=never`. Set it explicitly to `workspace-write` or `read-only` only if you want a more restricted mode.
 
 CLI-related options:
 
diff --git a/scripts/telegramSmoke.ts b/scripts/telegramSmoke.ts
@@ -1,9 +1,8 @@
 import "dotenv/config";
 import process from "node:process";
 import {
-  buildTelegramApiUrl,
-  createTelegramFetchDispatcher,
-  normalizeTelegramApiBase
+  normalizeTelegramApiBase,
+  requestTelegramJson
 } from "../src/lib/telegramApi.js";
 
 interface TelegramBotUser {
@@ -34,25 +33,24 @@ const expectedUsername = String(process.env.TELEGRAM_EXPECTED_USERNAME || "")
   .replace(/^@/, "");
 const smokeChatId = String(process.env.TELEGRAM_SMOKE_CHAT_ID || "").trim();
 const apiBase = normalizeTelegramApiBase(process.env.TELEGRAM_API_BASE);
-const dispatcher = createTelegramFetchDispatcher(
-  process.env.TELEGRAM_PROXY_URL
-);
+const proxyUrl = process.env.TELEGRAM_PROXY_URL;
 
 if (!token) {
   console.error("Missing BOT_TOKEN.");
   process.exit(1);
 }
 
-const getMeResponse = await fetch(
-  buildTelegramApiUrl(apiBase, token, "getMe"),
-  dispatcher ? { dispatcher } : undefined
-);
-const getMePayload =
-  (await getMeResponse.json()) as TelegramApiResponse<TelegramBotUser>;
+const { statusCode: getMeStatusCode, payload: getMePayload } =
+  await requestTelegramJson<TelegramApiResponse<TelegramBotUser>>({
+    apiBase,
+    token,
+    method: "getMe",
+    proxyUrl
+  });
 
-if (!getMeResponse.ok || !getMePayload?.ok) {
+if (getMeStatusCode < 200 || getMeStatusCode >= 300 || !getMePayload?.ok) {
   console.error(
-    `Telegram getMe failed: ${getMePayload?.description || getMeResponse.status}`
+    `Telegram getMe failed: ${getMePayload?.description || getMeStatusCode}`
   );
   process.exit(1);
 }
@@ -68,26 +66,21 @@ if (expectedUsername && botUser.username !== expectedUsername) {
 
 if (smokeChatId) {
   const message = `codex-telegram-claws smoke check ${new Date().toISOString()}`;
-  const sendResponse = await fetch(
-    buildTelegramApiUrl(apiBase, token, "sendMessage"),
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
+  const { statusCode: sendStatusCode, payload: sendPayload } =
+    await requestTelegramJson<TelegramApiResponse<TelegramSendMessageResult>>({
+      apiBase,
+      token,
+      method: "sendMessage",
+      proxyUrl,
+      body: {
         chat_id: smokeChatId,
         text: message
-      }),
-      ...(dispatcher ? { dispatcher } : {})
-    }
-  );
-  const sendPayload =
-    (await sendResponse.json()) as TelegramApiResponse<TelegramSendMessageResult>;
+      }
+    });
 
-  if (!sendResponse.ok || !sendPayload?.ok) {
+  if (sendStatusCode < 200 || sendStatusCode >= 300 || !sendPayload?.ok) {
     console.error(
-      `Telegram sendMessage failed: ${sendPayload?.description || sendResponse.status}`
+      `Telegram sendMessage failed: ${sendPayload?.description || sendStatusCode}`
     );
     process.exit(1);
   }
diff --git a/src/bot/handlers.ts b/src/bot/handlers.ts
@@ -1,3 +1,4 @@
+import path from "node:path";
 import { Markup } from "telegraf";
 import {
   buildPlanPrompt,
@@ -15,7 +16,10 @@ import type { Scheduler } from "../cron/scheduler.js";
 import { toErrorMessage } from "../lib/errors.js";
 import type { Router } from "../orchestrator/router.js";
 import type { PtyManager } from "../runner/ptyManager.js";
-import type { ShellManager } from "../runner/shellManager.js";
+import type {
+  ShellExecutionResult,
+  ShellManager
+} from "../runner/shellManager.js";
 import type { DevServerManager } from "../runner/devServerManager.js";
 import type { SkillRegistry } from "../orchestrator/skillRegistry.js";
 
@@ -145,6 +149,65 @@ function suggestProjectName(
   return suggestClosestWord(input, candidates, threshold);
 }
 
+function isInsideWorkspaceRoot(root: string, candidate: string): boolean {
+  const target = path.resolve(candidate);
+  const relative = path.relative(root, target);
+
+  return (
+    relative === "" ||
+    (!relative.startsWith("..") && !path.isAbsolute(relative))
+  );
+}
+
+function extractCloneTarget(
+  result: Pick<
+    ShellExecutionResult,
+    "status" | "command" | "output" | "workdir"
+  >
+): string | null {
+  if (
+    result.status !== "passed" ||
+    !result.command ||
+    !result.output ||
+    !result.workdir ||
+    !/^git\s+clone(?:\s|$)/i.test(result.command)
+  ) {
+    return null;
+  }
+
+  const match = result.output.match(/Cloning into '([^']+)'\.\.\./i);
+  if (!match?.[1]) {
+    return null;
+  }
+
+  return path.resolve(result.workdir, match[1]);
+}
+
+function buildShellSuccessFollowUp(
+  locale: Locale,
+  result: Pick<
+    ShellExecutionResult,
+    "status" | "command" | "output" | "workdir"
+  >,
+  workspaceRoot: string
+): string | null {
+  const cloneTarget = extractCloneTarget(result);
+  if (!cloneTarget) {
+    return null;
+  }
+
+  const relativePath = path.relative(workspaceRoot, cloneTarget) || ".";
+  const repoCommand = isInsideWorkspaceRoot(workspaceRoot, cloneTarget)
+    ? `/repo ${relativePath}`
+    : "";
+
+  return t(locale, "shellCloneSucceeded", {
+    relativePath,
+    workdir: cloneTarget,
+    repoCommand
+  });
+}
+
 export function registerHandlers({
   bot,
   router,
@@ -509,6 +572,15 @@ export function registerHandlers({
     }
 
     await sendChunkedMarkdown(ctx, t(locale, "shellResult", { result }));
+
+    const followUp = buildShellSuccessFollowUp(
+      locale,
+      result,
+      status.workspaceRoot
+    );
+    if (followUp) {
+      await sendChunkedMarkdown(ctx, followUp);
+    }
   });
 
   bot.command("dev", async (ctx: any) => {
diff --git a/src/bot/i18n.ts b/src/bot/i18n.ts
@@ -282,6 +282,15 @@ const MESSAGES: Record<Locale, TranslationCatalog> = {
         "output:",
         result.output
       ]),
+    shellCloneSucceeded: ({ relativePath, workdir, repoCommand }) =>
+      joinLines([
+        "Clone completed.",
+        `project: ${relativePath}`,
+        `workdir: ${workdir}`,
+        repoCommand
+          ? `next: switch to it with ${repoCommand}`
+          : "next: switch to the cloned repo with /repo <name>"
+      ]),
     modelCurrent: ({ model }) =>
       `Current model: ${model || "inherit codex default"}`,
     modelReset: ({ closed }) =>
@@ -752,6 +761,15 @@ const MESSAGES: Record<Locale, TranslationCatalog> = {
         "output:",
         result.output
       ]),
+    shellCloneSucceeded: ({ relativePath, workdir, repoCommand }) =>
+      joinLines([
+        "仓库拉取完成。",
+        `project: ${relativePath}`,
+        `workdir: ${workdir}`,
+        repoCommand
+          ? `下一步: 使用 ${repoCommand} 切换到这个仓库`
+          : "下一步: 使用 /repo <name> 切换到新仓库"
+      ]),
     modelCurrent: ({ model }) =>
       `当前模型: ${model || "inherit codex default"}`,
     modelReset: ({ closed }) =>
diff --git a/src/config.ts b/src/config.ts
@@ -339,11 +339,14 @@ export function loadConfig(): AppConfig {
         "read-only",
         "workspace-write",
         "danger-full-access"
-      ]) || (runnerBackend === "sdk" ? "workspace-write" : undefined),
-    approvalPolicy: parseEnum<CodexApprovalPolicy>(
-      process.env.CODEX_SDK_APPROVAL_POLICY,
-      ["never", "on-request", "on-failure", "untrusted"]
-    ),
+      ]) || (runnerBackend === "sdk" ? "danger-full-access" : undefined),
+    approvalPolicy:
+      parseEnum<CodexApprovalPolicy>(process.env.CODEX_SDK_APPROVAL_POLICY, [
+        "never",
+        "on-request",
+        "on-failure",
+        "untrusted"
+      ]) || (runnerBackend === "sdk" ? "never" : undefined),
     modelReasoningEffort: parseEnum<CodexReasoningEffort>(
       process.env.CODEX_SDK_REASONING_EFFORT,
       ["minimal", "low", "medium", "high", "xhigh"]
diff --git a/src/lib/telegramApi.ts b/src/lib/telegramApi.ts
@@ -1,6 +1,6 @@
 import type { Agent as HttpAgent } from "node:http";
 import type { Dispatcher } from "undici";
-import { ProxyAgent } from "undici";
+import { ProxyAgent, request } from "undici";
 import { HttpsProxyAgent } from "https-proxy-agent";
 
 const DEFAULT_TELEGRAM_API_BASE = "https://api.telegram.org";
@@ -22,8 +22,7 @@ export function buildTelegramApiUrl(
   method: string
 ): string {
   const normalized = normalizeTelegramApiBase(apiBase);
-  const baseUrl = new URL(`${normalized}/`);
-  return new URL(`bot${token}/${method}`, baseUrl).toString();
+  return `${normalized}/bot${token}/${method}`;
 }
 
 export function createTelegramApiAgent(
@@ -41,3 +40,48 @@ export function createTelegramFetchDispatcher(
   if (!normalized) return undefined;
   return new ProxyAgent(normalized);
 }
+
+interface TelegramRequestResponse<T> {
+  statusCode: number;
+  payload: T;
+}
+
+type TelegramRequestImpl = typeof request;
+
+export async function requestTelegramJson<T>(
+  {
+    apiBase,
+    token,
+    method,
+    proxyUrl,
+    body
+  }: {
+    apiBase: string;
+    token: string;
+    method: string;
+    proxyUrl?: string;
+    body?: unknown;
+  },
+  requestImpl: TelegramRequestImpl = request
+): Promise<TelegramRequestResponse<T>> {
+  const dispatcher = createTelegramFetchDispatcher(proxyUrl);
+  const response = await requestImpl(
+    buildTelegramApiUrl(apiBase, token, method),
+    {
+      method: body ? "POST" : "GET",
+      headers: body
+        ? {
+            "content-type": "application/json"
+          }
+        : undefined,
+      body: body ? JSON.stringify(body) : undefined,
+      dispatcher
+    }
+  );
+  const rawBody = await response.body.text();
+
+  return {
+    statusCode: response.statusCode,
+    payload: JSON.parse(rawBody) as T
+  };
+}
diff --git a/src/ops/healthcheck.ts b/src/ops/healthcheck.ts
@@ -6,10 +6,7 @@ import type { AppConfig } from "../config.js";
 import { repairNodePtySpawnHelperPermissions } from "../runner/ptyPreflight.js";
 import { extractCodexExecResponse } from "../bot/formatter.js";
 import { toErrorMessage } from "../lib/errors.js";
-import {
-  buildTelegramApiUrl,
-  createTelegramFetchDispatcher
-} from "../lib/telegramApi.js";
+import { requestTelegramJson } from "../lib/telegramApi.js";
 
 export type HealthcheckStatus = "pass" | "warn" | "fail";
 
@@ -295,20 +292,19 @@ export async function runHealthcheck(
   const liveTelegramCheck = Boolean(options.telegramLiveCheck);
   if (liveTelegramCheck) {
     try {
-      const url = buildTelegramApiUrl(
-        config.telegram.apiBase,
-        config.telegram.botToken,
-        "getMe"
-      );
-      const dispatcher = createTelegramFetchDispatcher(
-        config.telegram.proxyUrl
-      );
-      const response = await fetch(
-        url,
-        dispatcher ? { dispatcher } : undefined
-      );
-      const payload = (await response.json()) as TelegramGetMeResponse;
-      if (response.ok && payload?.ok && payload?.result?.username) {
+      const { statusCode, payload } =
+        await requestTelegramJson<TelegramGetMeResponse>({
+          apiBase: config.telegram.apiBase,
+          token: config.telegram.botToken,
+          method: "getMe",
+          proxyUrl: config.telegram.proxyUrl
+        });
+      if (
+        statusCode >= 200 &&
+        statusCode < 300 &&
+        payload?.ok &&
+        payload?.result?.username
+      ) {
         checks.push(
           makeCheck(
             "telegram api",
@@ -321,7 +317,7 @@ export async function runHealthcheck(
           makeCheck(
             "telegram api",
             "fail",
-            payload?.description || `HTTP ${response.status}`
+            payload?.description || `HTTP ${statusCode}`
           )
         );
       }
diff --git a/tests/config.test.ts b/tests/config.test.ts
diff --git a/tests/handlers.test.ts b/tests/handlers.test.ts
diff --git a/tests/telegramApi.test.ts b/tests/telegramApi.test.ts
