@cryer/star-cli 0.3.8 → 0.3.9

package/README.md

@@ -116,6 +116,11 @@ model = "gpt-4o"                  # model id sent to the API
                                   # provider (low/medium/high are common; some add minimal/max...).
                                   # Unset = server default. Ignored for anthropic. The /model
                                   # picker also offers these levels after a model pick.
+# vision = false                  # mark a text-only model: read_image/screenshot then decline with
+                                  # a text error instead of attaching images the endpoint would
+                                  # reject. Unset = images allowed. (Without it, a 4xx rejecting
+                                  # images outright still self-heals: the images are stripped from
+                                  # the history and the request retried once.)
 # streamIdleTimeoutSec = 60       # per-model overrides of the global stream watchdog timeouts
 # streamFirstChunkTimeoutSec = 600
 # optional per-model pricing in USD per 1M tokens — enables the $ estimate in /cost and /usage.

package/README.zh-CN.md

@@ -114,6 +114,10 @@ model = "gpt-4o"                  # 发送给 API 的模型 id
                                   # minimal/max 等），因此接受任意字符串，由服务端校验。
                                   # 不设置 = 服务端默认。anthropic 协议下忽略。
                                   # /model 选完模型后也会接着让你选择推理强度。
+# vision = false                  # 标记纯语言模型：read_image/screenshot 会直接返回文本错误，
+                                  # 不再把图片塞进历史导致端点报 4xx。不设置 = 允许图片。（即使
+                                  # 不设置，端点明确拒绝图片的 4xx 也会自愈：剥掉历史中的图片后
+                                  # 自动重试一次。）
 # streamIdleTimeoutSec = 60       # 按模型覆盖全局的流看门狗超时
 # streamFirstChunkTimeoutSec = 600
 # 可选的按模型定价（美元/1M token）——启用 /cost 和 /usage 中的美元估算。

package/dist/chunk-4IRY44TG.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+// src/llm/registry.ts
+function listModels(config) {
+  return config.models;
+}
+function resolveModelConfig(config, modelName) {
+  const name = modelName ?? config.defaultModel;
+  const model = config.models.find((m) => m.name === name);
+  if (!model) {
+    const available = config.models.map((m) => m.name).join(", ") || "(none)";
+    throw new Error(`Model "${name}" not found. Available models: ${available}`);
+  }
+  return model;
+}
+function resolveStartupModel(config, sessionModel) {
+  if (sessionModel) {
+    if (config.models.some((m) => m.name === sessionModel)) {
+      return { name: sessionModel, notice: null };
+    }
+    return {
+      name: config.defaultModel,
+      notice: `Session model "${sessionModel}" not found in config \u2014 using default model.`
+    };
+  }
+  return { name: config.defaultModel, notice: null };
+}
+
+export {
+  listModels,
+  resolveModelConfig,
+  resolveStartupModel
+};
+//# sourceMappingURL=chunk-4IRY44TG.js.map

package/dist/chunk-4IRY44TG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/llm/registry.ts"],"sourcesContent":["import type { ModelConfig, StarConfig } from \"../config/schema\";\n\nexport function listModels(config: StarConfig): ModelConfig[] {\n  return config.models;\n}\n\nexport function resolveModelConfig(config: StarConfig, modelName?: string): ModelConfig {\n  const name = modelName ?? config.defaultModel;\n  const model = config.models.find((m) => m.name === name);\n  if (!model) {\n    const available = config.models.map((m) => m.name).join(\", \") || \"(none)\";\n    throw new Error(`Model \"${name}\" not found. Available models: ${available}`);\n  }\n  return model;\n}\n\n// Pick the model at startup. An explicit --model already sits in\n// config.defaultModel (loader override), so it wins naturally; otherwise a\n// resumed session's recorded model is restored when it still exists in the\n// config. A stale recorded model falls back to the default with a notice.\nexport function resolveStartupModel(\n  config: StarConfig,\n  sessionModel?: string | null,\n): { name: string | undefined; notice: string | null } {\n  if (sessionModel) {\n    if (config.models.some((m) => m.name === sessionModel)) {\n      return { name: sessionModel, notice: null };\n    }\n    return {\n      name: config.defaultModel,\n      notice: `Session model \"${sessionModel}\" not found in config — using default model.`,\n    };\n  }\n  return { name: config.defaultModel, notice: null };\n}\n"],"mappings":";;;AAEO,SAAS,WAAW,QAAmC;AAC5D,SAAO,OAAO;AAChB;AAEO,SAAS,mBAAmB,QAAoB,WAAiC;AACtF,QAAM,OAAO,aAAa,OAAO;AACjC,QAAM,QAAQ,OAAO,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,IAAI;AACvD,MAAI,CAAC,OAAO;AACV,UAAM,YAAY,OAAO,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,IAAI,KAAK;AACjE,UAAM,IAAI,MAAM,UAAU,IAAI,kCAAkC,SAAS,EAAE;AAAA,EAC7E;AACA,SAAO;AACT;AAMO,SAAS,oBACd,QACA,cACqD;AACrD,MAAI,cAAc;AAChB,QAAI,OAAO,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,YAAY,GAAG;AACtD,aAAO,EAAE,MAAM,cAAc,QAAQ,KAAK;AAAA,IAC5C;AACA,WAAO;AAAA,MACL,MAAM,OAAO;AAAA,MACb,QAAQ,kBAAkB,YAAY;AAAA,IACxC;AAAA,EACF;AACA,SAAO,EAAE,MAAM,OAAO,cAAc,QAAQ,KAAK;AACnD;","names":[]}

package/dist/chunk-56ZIA57D.js

@@ -0,0 +1,493 @@
+#!/usr/bin/env node
+import {
+  gitTreesDir,
+  isSensitivePath
+} from "./chunk-A5PXPWHB.js";
+
+// src/core/messages.ts
+function toStarMessage(message) {
+  return "role" in message ? { message } : message;
+}
+function toCoreMessages(messages) {
+  return messages.map((star) => star.message);
+}
+function isSyntheticUserMessage(star) {
+  return star.message.role === "user" && star.meta?.synthetic !== void 0;
+}
+function coreMessageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((part) => part.type === "text").map((part) => "text" in part ? part.text : "").join(" ");
+  }
+  return "";
+}
+var MISSING_TOOL_RESULT_TEXT = "tool result missing (session was interrupted)";
+var INTERRUPTED_TOOL_RESULT_TEXT = "Tool execution interrupted by user.";
+var UNFINISHED_TOOL_RESULT_TEXT = "Tool execution interrupted before a result was produced.";
+function reconcileStarMessages(messages) {
+  const result = [];
+  let pending = [];
+  const flushPending = () => {
+    for (const call of pending) {
+      result.push({
+        message: {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              result: MISSING_TOOL_RESULT_TEXT
+            }
+          ]
+        }
+      });
+    }
+    pending = [];
+  };
+  for (const star of messages) {
+    const message = star.message;
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      flushPending();
+      pending = message.content.filter((part) => part.type === "tool-call").map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName }));
+    } else if (message.role === "tool" && Array.isArray(message.content) && pending.length > 0) {
+      const answered = new Set(message.content.map((part) => part.toolCallId));
+      pending = pending.filter((call) => !answered.has(call.toolCallId));
+    } else {
+      flushPending();
+    }
+    result.push(star);
+  }
+  flushPending();
+  return result;
+}
+function retractLastTurn(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const star = messages[i];
+    if (star && star.message.role === "user" && !isSyntheticUserMessage(star)) {
+      return { messages: messages.slice(0, i), removed: messages.length - i };
+    }
+  }
+  return { messages, removed: 0 };
+}
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderConfigSchema = z.object({
+  name: z.string(),
+  // openai-responses talks to the Responses API (/responses) instead of chat
+  // completions — the wire format codex uses, and the native API of
+  // reasoning-model relays that otherwise hide reasoning behind empty chat
+  // completions. streamChat sends strictSchemas:false + store:false with it.
+  protocol: z.enum(["openai-compatible", "anthropic", "openai-responses"]).default("openai-compatible"),
+  baseURL: z.string(),
+  apiKeyEnv: z.string().optional(),
+  apiKey: z.string().optional(),
+  headers: z.record(z.string()).optional()
+});
+var ModelConfigSchema = z.object({
+  name: z.string(),
+  provider: z.string(),
+  model: z.string(),
+  maxTokens: z.number().int().positive().optional(),
+  // Per-model context window; overrides the top-level contextMaxTokens for
+  // compaction and the status bar when set.
+  contextMaxTokens: z.number().int().positive().optional(),
+  // Reasoning intensity for thinking models, forwarded verbatim as
+  // OpenAI-style reasoning_effort on every request (llm/provider.ts
+  // reasoningEffortMetadata) — level naming varies by model/provider
+  // (low|medium|high are common; some add minimal/max/xhigh/none), so any
+  // non-empty string is accepted and the server validates it. Unset = the
+  // request carries no effort field and the server-side default applies.
+  // Anthropic maps effort to a thinking budget instead — ignored there.
+  reasoningEffort: z.string().min(1).optional(),
+  // Sampling temperature forwarded on every request. Unset = the AI SDK's
+  // own default applies (ai@4 sends 0 — it does NOT omit the field). Some
+  // endpoints reject anything but one explicit value (e.g. kimi-for-coding:
+  // "invalid temperature: only 1 is allowed") — set it here. No upper
+  // bound: ranges vary by provider and the server validates.
+  temperature: z.number().min(0).optional(),
+  // Per-model overrides of the top-level stream watchdog timeouts (unset =
+  // the global values apply). Raise streamIdleTimeoutSec for relays that
+  // buffer long generations and stall mid-stream between flushes.
+  streamIdleTimeoutSec: z.number().positive().optional(),
+  streamFirstChunkTimeoutSec: z.number().positive().optional(),
+  // Text-only models: set false so image-producing tools (read_image,
+  // screenshot) decline with a text error instead of attaching images the
+  // endpoint would reject with an unrecoverable 4xx. Unset = images allowed.
+  vision: z.boolean().optional(),
+  // Cost estimation needs BOTH prices (USD per 1M tokens); with only one set
+  // the model is treated as unpriced.
+  promptPrice: z.number().nonnegative().optional(),
+  completionPrice: z.number().nonnegative().optional(),
+  // Optional price (USD per 1M tokens) for cache-read prompt tokens. When
+  // unset, OpenAI-style cached tokens bill at promptPrice and Anthropic-style
+  // cache reads are not billed — set this for accurate cache pricing.
+  cacheReadPrice: z.number().nonnegative().optional()
+});
+var PermissionsConfigSchema = z.object({
+  allow: z.array(z.string()).default([]),
+  deny: z.array(z.string()).default([]),
+  // Rules that force a confirmation prompt in auto mode (same tool(glob)
+  // syntax as allow/deny) — e.g. ask = ["bash(git push *)"]. Priority:
+  // deny > ask > allow > mode default. Only meaningful in auto mode (ask
+  // mode already prompts; readonly/plan are unaffected; yolo bypasses all).
+  ask: z.array(z.string()).default([]),
+  // Extra likely-secret file globs extending core/sensitive.ts's hardcoded
+  // list (same single-* glob semantics as rules, matched case-insensitively
+  // against the basename and the full normalized path). Global config only —
+  // the project-config sandbox drops the whole [permissions] table.
+  sensitive: z.array(z.string()).default([])
+});
+var HookConfigSchema = z.object({
+  event: z.enum(["PreToolUse", "PostToolUse", "Stop"]),
+  matcher: z.string().refine(
+    (pattern) => {
+      try {
+        new RegExp(pattern);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { message: "invalid regular expression" }
+  ).optional(),
+  command: z.string().min(1),
+  timeoutSec: z.number().positive().default(30)
+});
+var ConfigSchema = z.object({
+  defaultModel: z.string().default(""),
+  // Optional [[models]] name for cheap auxiliary LLM calls (compaction
+  // summaries, session titles, turn completion checks) — Claude Code routes
+  // these to a Haiku-class model. Unset = the active main model does them.
+  smallModel: z.string().optional(),
+  permissionMode: z.enum(["auto", "ask", "readonly", "yolo", "plan"]).default("ask"),
+  providers: z.array(ProviderConfigSchema).default([]),
+  models: z.array(ModelConfigSchema).default([]),
+  // Cap on model round-trips ("steps") per turn between progress checkpoints.
+  // One step is a streamed reply plus every tool call it asked for — stream
+  // retries and auto-continue nudges do not consume steps. Reaching the cap
+  // while tools still execute resets the budget with a notice; the turn stops
+  // only when no tool ran since the last checkpoint (the doom-loop
+  // signature). 0 disables the cap entirely (opencode/codex have none).
+  maxSteps: z.number().int().min(0).default(100),
+  contextMaxTokens: z.number().int().positive().default(1e5),
+  // Token threshold at which the agent loop auto-compacts the history.
+  // Defaults to the effective context window (compact only when full); set a
+  // lower value to compact earlier and keep headroom. Manual /compact ignores
+  // this — it always compacts.
+  compactThresholdTokens: z.number().int().positive().optional(),
+  // Seconds without any stream part before a stalled response is ended
+  // gracefully (some relays never send the terminal chunks). Applies once
+  // content has started streaming; the wait for the first content part gets
+  // a longer allowance (control/metadata parts don't count as content).
+  streamIdleTimeoutSec: z.number().positive().default(20),
+  // Seconds to wait for the very first content part before giving up; slow
+  // thinking-model endpoints can stay silent for minutes after accepting
+  // the request.
+  streamFirstChunkTimeoutSec: z.number().positive().default(300),
+  // Extra attempts per model request when a stream fails transiently
+  // (network error, 429/5xx, idle watchdog cutoff) or comes back empty, so a
+  // relay hiccup does not silently end a half-finished turn. 0 disables.
+  // The wait between attempts honors Retry-After headers and otherwise backs
+  // off exponentially with jitter (llm/retry.ts); retries after a
+  // timeout/empty failure also scale both stream timeouts up (attempt number
+  // ×, capped at 3x) since the relay is likely overloaded. Default 5 matches
+  // opencode/Codex retry budgets and rides out flaky relays (中转站) better
+  // than a minimal budget.
+  streamMaxRetries: z.number().int().min(0).default(5),
+  // How many consecutive unproductive replies may be nudged before the turn
+  // is handed back: a text-only reply that announces pending work ("我将…",
+  // "I will…") or answers a nudge with more words, or an empty reply that
+  // survived the stream retry budget (steered with a nudge — a changed
+  // request — since identical resends already failed). Tool calls reset the
+  // count, so a productive task keeps going; exhaustion surfaces a notice
+  // instead of stopping silently. Never fires in plan mode. 0 disables.
+  maxAutoContinues: z.number().int().min(0).default(2),
+  contextCompaction: z.enum(["summary", "truncate"]).default("summary"),
+  // Optional per-session dollar budget; when set, the REPL stops the session
+  // once the estimated cost for the session reaches this amount.
+  sessionBudgetUsd: z.number().positive().optional(),
+  // Terminal bell (REPL only): ring when a turn takes longer than
+  // notifyBellThresholdSec, and when a background task finishes.
+  // STAR_NO_NOTIFY=1 disables without touching the config.
+  notifyBell: z.boolean().default(true),
+  notifyBellThresholdSec: z.number().positive().default(10),
+  permissions: PermissionsConfigSchema.default({ allow: [], deny: [] }),
+  hooks: z.array(HookConfigSchema).default([]),
+  // Consecutive identical tool calls (same tool + same arguments) allowed
+  // before the loop refuses to execute the repeat and tells the model to
+  // change approach — a guard against agents stuck retrying a failing call
+  // (opencode's doom_loop). 0 disables.
+  doomLoopThreshold: z.number().int().min(0).default(3),
+  // Track the whole working tree with an internal git repo (outside the
+  // user's .git) at every turn boundary, so /undo and /redo can restore
+  // changes made by ANY tool (bash included), not just write_file/edit_file.
+  // Falls back silently to per-file snapshots when git is unavailable.
+  gitSnapshots: z.boolean().default(true),
+  // web_fetch SSRF guard escape hatch: by default target hosts are resolved
+  // before connecting and private/reserved ranges are refused (loopback,
+  // RFC1918, link-local incl. the cloud metadata address 169.254.169.254,
+  // ULA, and localhost/.local/.internal names; redirect hops re-checked).
+  // true disables the guard for intranet use. Global config only — not in
+  // the project-config sandbox whitelist.
+  webFetchAllowPrivateHosts: z.boolean().default(false)
+});
+function contextWindowTokens(config, modelName) {
+  return config.models.find((m) => m.name === modelName)?.contextMaxTokens ?? config.contextMaxTokens;
+}
+function resolveCompactThreshold(config, windowTokens) {
+  return Math.min(config.compactThresholdTokens ?? windowTokens, windowTokens);
+}
+
+// src/snapshot/git-tree.ts
+import { execFile } from "child_process";
+import { randomBytes } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readdir, rm, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+var GC_TIMEOUT_MS = 6e4;
+var GIT_MAX_BUFFER = 8 * 1024 * 1024;
+var GC_INTERVAL = 50;
+var TRACK_FAILURE_TTL_MS = 5 * 60 * 1e3;
+var MAX_PINNED_REFS = 50;
+var PINNED_REF_PREFIX = "refs/star/";
+var SENSITIVE_EXCLUDE_PATTERNS = [
+  ".env",
+  ".env.*",
+  "!.env.example",
+  "!.env.sample",
+  "!.env.template",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519",
+  ".npmrc",
+  ".netrc",
+  ".pgpass",
+  "*.pem",
+  "*.key",
+  "*.p12",
+  "*.pfx",
+  "**/.aws/credentials",
+  "**/.kube/config"
+];
+var GIT_CONFIG_ARGS = [
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.eol=native",
+  "-c",
+  "filter.lfs.process=",
+  "-c",
+  "filter.lfs.smudge=",
+  "-c",
+  "filter.lfs.clean="
+];
+function gitEnv() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && !key.toUpperCase().startsWith("GIT_")) env[key] = value;
+  }
+  return env;
+}
+function runGit(args, timeoutMs = GIT_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    execFile(
+      "git",
+      [...GIT_CONFIG_ARGS, ...args],
+      { timeout: timeoutMs, maxBuffer: GIT_MAX_BUFFER, encoding: "utf8", env: gitEnv() },
+      (error, stdout) => {
+        resolve(error ? null : stdout.trim());
+      }
+    );
+  });
+}
+var gitAvailable = null;
+var trackFailureUntil = /* @__PURE__ */ new Map();
+var trackCounts = /* @__PURE__ */ new Map();
+var scrubbedRepos = /* @__PURE__ */ new Set();
+async function isGitAvailable() {
+  if (gitAvailable === null) {
+    gitAvailable = await runGit(["--version"]) !== null;
+  }
+  return gitAvailable;
+}
+function treeRepoDir(cwd) {
+  const key = Buffer.from(path.resolve(cwd), "utf8").toString("base64url");
+  return path.join(gitTreesDir(), key);
+}
+async function removeTreeRepo(cwd) {
+  const dir = treeRepoDir(cwd);
+  trackFailureUntil.delete(path.resolve(cwd));
+  trackCounts.delete(dir);
+  scrubbedRepos.delete(dir);
+  await rm(dir, { recursive: true, force: true }).catch(() => {
+  });
+}
+async function pruneTreeReposExcept(remainingCwds) {
+  let entries;
+  try {
+    entries = await readdir(gitTreesDir());
+  } catch {
+    return;
+  }
+  const keep = /* @__PURE__ */ new Set();
+  for (const cwd of remainingCwds) keep.add(path.basename(treeRepoDir(cwd)));
+  await Promise.all(
+    entries.filter((entry) => !keep.has(entry)).map(
+      (entry) => rm(path.join(gitTreesDir(), entry), { recursive: true, force: true }).catch(() => {
+      })
+    )
+  );
+}
+function isGuardedDir(cwd) {
+  const resolved = path.resolve(cwd);
+  const home = path.resolve(os.homedir());
+  const same = (a, b) => process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  return same(resolved, home) || same(resolved, path.parse(resolved).root);
+}
+async function ensureTreeRepo(cwd) {
+  const dir = treeRepoDir(cwd);
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    if (!existsSync(path.join(dir, "HEAD"))) {
+      const out = await runGit(["init", "--bare", dir]);
+      if (out === null) return null;
+      await runGit([`--git-dir=${dir}`, "config", "core.autocrlf", "false"]);
+    }
+    await mkdir(path.join(dir, "info"), { recursive: true });
+    await writeFile(
+      path.join(dir, "info", "exclude"),
+      `${SENSITIVE_EXCLUDE_PATTERNS.join("\n")}
+`,
+      "utf8"
+    );
+  } catch {
+    return null;
+  }
+  return dir;
+}
+function repoArgs(dir, cwd) {
+  return [`--git-dir=${dir}`, `--work-tree=${cwd}`];
+}
+async function untrackExcluded(dir, cwd) {
+  const base = repoArgs(dir, cwd);
+  const listed = await runGit([...base, "ls-files", "-z", "-c", "-i", "--exclude-standard"]);
+  if (listed === null) return false;
+  const files = listed.split("\0").filter(Boolean);
+  if (files.length === 0) return true;
+  const removed = await runGit([
+    ...base,
+    "rm",
+    "--cached",
+    "--ignore-unmatch",
+    "-q",
+    "--",
+    ...files.map((file) => `:(literal)${file}`)
+  ]);
+  return removed !== null;
+}
+function trackTree(cwd) {
+  const key = path.resolve(cwd);
+  const next = (trackChains.get(key) ?? Promise.resolve(null)).then(() => trackTreeGuarded(cwd));
+  trackChains.set(key, next);
+  return next;
+}
+var trackChains = /* @__PURE__ */ new Map();
+async function trackTreeGuarded(cwd) {
+  if (isGuardedDir(cwd)) return null;
+  const key = path.resolve(cwd);
+  const failedUntil = trackFailureUntil.get(key);
+  if (failedUntil !== void 0 && Date.now() < failedUntil) return null;
+  const tree = await trackTreeUncached(cwd);
+  if (tree === null) {
+    trackFailureUntil.set(key, Date.now() + TRACK_FAILURE_TTL_MS);
+    return null;
+  }
+  trackFailureUntil.delete(key);
+  return tree;
+}
+async function pinTree(base, tree) {
+  const ref = `${PINNED_REF_PREFIX}${Date.now()}-${randomBytes(4).toString("hex")}`;
+  if (await runGit([...base, "update-ref", ref, tree]) === null) return;
+  const listed = await runGit([...base, "for-each-ref", "--format=%(refname)", PINNED_REF_PREFIX]);
+  if (listed === null) return;
+  const refs = listed.split("\n").filter(Boolean);
+  const stale = refs.slice(0, Math.max(0, refs.length - MAX_PINNED_REFS));
+  await Promise.all(stale.map((name) => runGit([...base, "update-ref", "-d", name])));
+}
+async function trackTreeUncached(cwd) {
+  if (!await isGitAvailable()) return null;
+  const dir = await ensureTreeRepo(cwd);
+  if (!dir) return null;
+  const base = repoArgs(dir, cwd);
+  if (!scrubbedRepos.has(dir)) {
+    if (!await untrackExcluded(dir, cwd)) return null;
+    scrubbedRepos.add(dir);
+  }
+  if (await runGit([...base, "add", "-A"]) === null) return null;
+  const tree = await runGit([...base, "write-tree"]);
+  if (tree === null) return null;
+  await pinTree(base, tree);
+  const count = (trackCounts.get(dir) ?? 0) + 1;
+  trackCounts.set(dir, count);
+  if (count % GC_INTERVAL === 0) {
+    await runGit([`--git-dir=${dir}`, "gc", "--auto"], GC_TIMEOUT_MS);
+  }
+  return tree;
+}
+async function restoreTree(cwd, hash) {
+  if (isGuardedDir(cwd)) return false;
+  if (!await isGitAvailable()) return false;
+  const dir = await ensureTreeRepo(cwd);
+  if (!dir) return false;
+  const base = repoArgs(dir, cwd);
+  if (await runGit([...base, "read-tree", hash]) === null) return false;
+  if (!await untrackExcluded(dir, cwd)) return false;
+  if (await runGit([...base, "checkout-index", "-f", "-a"]) === null) return false;
+  if (await runGit([...base, "clean", "-fd"]) === null) return false;
+  return true;
+}
+async function diffTreeNames(cwd, hash) {
+  if (!await isGitAvailable()) return null;
+  const dir = treeRepoDir(cwd);
+  if (!existsSync(path.join(dir, "HEAD"))) return null;
+  const base = repoArgs(dir, cwd);
+  const changed = await runGit([...base, "diff", "--name-only", hash]);
+  const untracked = await runGit([...base, "ls-files", "--others", "--exclude-standard"]);
+  if (changed === null || untracked === null) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const line of [...changed.split("\n"), ...untracked.split("\n")]) {
+    if (line !== "" && !isSensitivePath(line)) names.add(line);
+  }
+  return [...names];
+}
+
+export {
+  toStarMessage,
+  toCoreMessages,
+  isSyntheticUserMessage,
+  coreMessageText,
+  INTERRUPTED_TOOL_RESULT_TEXT,
+  UNFINISHED_TOOL_RESULT_TEXT,
+  reconcileStarMessages,
+  retractLastTurn,
+  ProviderConfigSchema,
+  ModelConfigSchema,
+  PermissionsConfigSchema,
+  HookConfigSchema,
+  ConfigSchema,
+  contextWindowTokens,
+  resolveCompactThreshold,
+  removeTreeRepo,
+  pruneTreeReposExcept,
+  trackTree,
+  restoreTree,
+  diffTreeNames
+};
+//# sourceMappingURL=chunk-56ZIA57D.js.map