tracelet-cli 0.1.0 → 0.1.1

package/dist/bin.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/program.ts
-import { confirm, select } from "@inquirer/prompts";
+import { confirm as confirm2, select as select2 } from "@inquirer/prompts";
+import { readFileSync } from "fs";
 import { Command, Option } from "commander";
 
 // src/agents.ts
@@ -19,16 +20,38 @@ function launchEnv(env = process.env) {
   return { ...env, NO_PROXY: noProxy, no_proxy: noProxy };
 }
 async function hasBin(command) {
-  const paths = process.env.PATH?.split(delimiter) ?? [];
+  const paths = command.includes("/") || command.includes("\\") ? [""] : process.env.PATH?.split(delimiter) ?? [];
+  const names = process.platform === "win32" && !/\.[^\\/]+$/.test(command) ? [command, ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((ext) => `${command}${ext}`)] : [command];
   for (const path of paths) {
-    try {
-      await access(join(path, command), constants.X_OK);
-      return true;
-    } catch {
+    for (const name of names) {
+      try {
+        await access(join(path, name), constants.X_OK);
+        return true;
+      } catch {
+      }
     }
   }
   return false;
 }
+function customAdapter(id, config) {
+  return {
+    id,
+    label: config.label,
+    command: config.command,
+    protocol: config.protocol,
+    detect: () => hasBin(config.command),
+    upstream: async () => config.upstream,
+    launch: (proxyUrl2, args) => {
+      const env = launchEnv();
+      const inject = config.inject.type === "env" ? [] : config.inject.args.map((arg) => arg.replaceAll("{baseUrl}", proxyUrl2));
+      if (config.inject.type === "env") {
+        const name = config.inject.name ?? (config.protocol === "anthropic" ? "ANTHROPIC_BASE_URL" : "OPENAI_BASE_URL");
+        env[name] = proxyUrl2;
+      }
+      return { command: config.command, args: [...inject, ...config.args, ...args], env };
+    }
+  };
+}
 async function usesChatGpt() {
   try {
     const result = await exec("codex", ["login", "status"]);
@@ -138,6 +161,13 @@ async function clearData(root) {
   await mkdir(runs, { recursive: true });
 }
 
+// src/custom-menu.ts
+import { confirm, input, select } from "@inquirer/prompts";
+
+// src/settings.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname } from "path";
+
 // src/paths.ts
 import { existsSync } from "fs";
 import { homedir as homedir3 } from "os";
@@ -155,6 +185,340 @@ function dashboardDir() {
   return existsSync(bundled) ? bundled : workspace;
 }
 
+// src/settings.ts
+function readAgent(value, id) {
+  if (!/^custom-[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id) || !isObject(value)) {
+    throw new Error(`Invalid custom agent: ${id}`);
+  }
+  const { label, command, args, protocol, upstream, inject } = value;
+  if (typeof label !== "string" || !label.trim() || typeof command !== "string" || !command.trim() || !Array.isArray(args) || !args.every((arg) => typeof arg === "string") || protocol !== "anthropic" && protocol !== "openai" || typeof upstream !== "string" || !isObject(inject) || inject.type !== "env" && inject.type !== "args") {
+    throw new Error(`Invalid custom agent: ${id}`);
+  }
+  try {
+    if (!["http:", "https:"].includes(new URL(upstream).protocol)) {
+      throw new Error("Unsupported protocol");
+    }
+  } catch {
+    throw new Error(`Invalid upstream URL for custom agent: ${id}`);
+  }
+  if (inject.type === "env") {
+    if (inject.name !== void 0 && (typeof inject.name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(inject.name))) {
+      throw new Error(`Invalid environment variable for custom agent: ${id}`);
+    }
+    return { label: label.trim(), command: command.trim(), args, protocol, upstream, inject: {
+      type: "env",
+      ...inject.name ? { name: inject.name } : {}
+    } };
+  }
+  if (!Array.isArray(inject.args) || !inject.args.every((arg) => typeof arg === "string") || !inject.args.some((arg) => arg.includes("{baseUrl}"))) {
+    throw new Error(`Invalid Base URL argument template for custom agent: ${id}`);
+  }
+  return {
+    label: label.trim(),
+    command: command.trim(),
+    args,
+    protocol,
+    upstream,
+    inject: { type: "args", args: inject.args }
+  };
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function readRaw(path) {
+  try {
+    const value = JSON.parse(await readFile2(path, "utf8"));
+    if (!isObject(value)) {
+      throw new Error("Settings root must be an object");
+    }
+    return value;
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {};
+    }
+    throw new Error(`Failed to read Tracelet settings: ${path}`, { cause: error });
+  }
+}
+function readProxy(value, name) {
+  if (!isObject(value) || value.mode !== "direct" && value.mode !== "system") {
+    throw new Error(`Invalid proxy mode: ${name}`);
+  }
+  return { mode: value.mode };
+}
+function parseSettings(value, path) {
+  if (value.customAgents !== void 0 && !isObject(value.customAgents)) {
+    throw new Error(`Invalid custom agents: ${path}`);
+  }
+  const customAgents = {};
+  if (isObject(value.customAgents)) {
+    for (const [id, config] of Object.entries(value.customAgents)) {
+      customAgents[id] = readAgent(config, id);
+    }
+  }
+  if (value.proxy !== void 0 && !isObject(value.proxy)) {
+    throw new Error(`Invalid proxy settings: ${path}`);
+  }
+  const proxy = isObject(value.proxy) ? value.proxy : {};
+  const defaultConfig = proxy.default === void 0 ? { mode: "direct" } : readProxy(proxy.default, "default");
+  if (proxy.agents !== void 0 && !isObject(proxy.agents)) {
+    throw new Error(`Invalid agent proxy settings: ${path}`);
+  }
+  const agents2 = {};
+  if (isObject(proxy.agents)) {
+    for (const [agentId, config] of Object.entries(proxy.agents)) {
+      agents2[agentId] = readProxy(config, agentId);
+    }
+  }
+  return { customAgents, proxy: { default: defaultConfig, agents: agents2 } };
+}
+async function writeSettings(path, value) {
+  await mkdir2(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+}
+async function loadSettings(path = settingsFile()) {
+  return parseSettings(await readRaw(path), path);
+}
+function proxyMode(settings, agentId) {
+  return settings.proxy.agents[agentId]?.mode ?? settings.proxy.default.mode;
+}
+async function saveProxy(target, mode, path = settingsFile()) {
+  const value = await readRaw(path);
+  const current = parseSettings(value, path);
+  const agents2 = { ...current.proxy.agents };
+  let defaultConfig = current.proxy.default;
+  if (target === "all") {
+    defaultConfig = { mode };
+    for (const agentId of Object.keys(agents2)) {
+      delete agents2[agentId];
+    }
+  } else if (mode === defaultConfig.mode) {
+    delete agents2[target];
+  } else {
+    agents2[target] = { mode };
+  }
+  const next = { ...value, proxy: { default: defaultConfig, agents: agents2 } };
+  await writeSettings(path, next);
+}
+async function saveAgent(id, agent, path = settingsFile()) {
+  const value = await readRaw(path);
+  const current = parseSettings(value, path);
+  const customAgents = { ...current.customAgents, [id]: readAgent(agent, id) };
+  await writeSettings(path, { ...value, customAgents });
+}
+async function removeAgent(id, path = settingsFile()) {
+  const value = await readRaw(path);
+  const current = parseSettings(value, path);
+  const customAgents = { ...current.customAgents };
+  const proxyAgents = { ...current.proxy.agents };
+  delete customAgents[id];
+  delete proxyAgents[id];
+  await writeSettings(path, {
+    ...value,
+    customAgents,
+    proxy: { default: current.proxy.default, agents: proxyAgents }
+  });
+}
+
+// src/custom-menu.ts
+function baseEnv(protocol) {
+  return protocol === "anthropic" ? "ANTHROPIC_BASE_URL" : "OPENAI_BASE_URL";
+}
+function required(value) {
+  return value.trim() ? true : "This field is required.";
+}
+function parseArgs(value) {
+  const args = JSON.parse(value);
+  if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string")) {
+    throw new Error("Enter a JSON array of strings.");
+  }
+  return args;
+}
+async function askArgs(message, args, needsUrl = false) {
+  const value = await input({
+    message,
+    default: JSON.stringify(args),
+    validate: (text) => {
+      try {
+        const parsed = parseArgs(text);
+        if (needsUrl && !parsed.some((arg) => arg.includes("{baseUrl}"))) {
+          return "Include {baseUrl} in one argument.";
+        }
+        return true;
+      } catch {
+        return 'Enter a JSON array of strings, for example ["--profile","work"].';
+      }
+    }
+  });
+  return parseArgs(value);
+}
+function validUrl(value) {
+  try {
+    return ["http:", "https:"].includes(new URL(value).protocol) ? true : "Use an http:// or https:// URL.";
+  } catch {
+    return "Enter a valid upstream URL.";
+  }
+}
+async function askProtocol(current) {
+  return select({
+    message: "Protocol",
+    choices: [
+      { name: "Anthropic Messages", value: "anthropic" },
+      { name: "OpenAI Responses", value: "openai" }
+    ],
+    default: current
+  });
+}
+async function askInject(protocol, current) {
+  const type = await select({
+    message: "How should Tracelet pass its local Base URL?",
+    choices: [
+      { name: "Environment variable (recommended)", value: "env" },
+      { name: "Command arguments", value: "args" }
+    ],
+    default: current?.type ?? "env"
+  });
+  if (type === "env") {
+    const fallback = baseEnv(protocol);
+    const name = await input({
+      message: `Environment variable (blank uses ${fallback})`,
+      default: current?.type === "env" ? current.name ?? "" : "",
+      validate: (value) => !value || /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) ? true : "Enter a valid environment variable name."
+    });
+    return { type: "env", ...name ? { name } : {} };
+  }
+  const args = await askArgs(
+    "Base URL arguments (JSON array containing {baseUrl})",
+    current?.type === "args" ? current.args : ["--base-url", "{baseUrl}"],
+    true
+  );
+  return { type: "args", args };
+}
+function nextId(label, used) {
+  const slug = label.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "agent";
+  const base = `custom-${slug}`;
+  let id = base;
+  let count = 2;
+  while (used[id]) {
+    id = `${base}-${count++}`;
+  }
+  return id;
+}
+function showAgent(id, agent) {
+  console.log(`
+${agent.label} (${id})`);
+  console.log(`  Command: ${JSON.stringify([agent.command, ...agent.args])}`);
+  console.log(`  Protocol: ${agent.protocol}`);
+  console.log(`  Upstream: ${agent.upstream}`);
+  console.log(`  Base URL: ${agent.inject.type === "env" ? `env ${agent.inject.name ?? baseEnv(agent.protocol)}` : `args ${JSON.stringify(agent.inject.args)}`}
+`);
+}
+async function addAgent() {
+  const settings = await loadSettings();
+  const label = await input({ message: "Agent name", validate: required });
+  const id = nextId(label, settings.customAgents);
+  const command = await input({ message: "Executable command", validate: required });
+  const args = await askArgs("Default arguments (JSON array)", []);
+  const protocol = await askProtocol();
+  const inject = await askInject(protocol);
+  const envName = inject.type === "env" ? inject.name ?? baseEnv(protocol) : baseEnv(protocol);
+  const upstream = await input({
+    message: "Original upstream URL",
+    default: process.env[envName] ?? (protocol === "anthropic" ? "https://api.anthropic.com" : "https://api.openai.com/v1"),
+    validate: validUrl
+  });
+  const agent = { label, command, args, protocol, upstream, inject };
+  showAgent(id, agent);
+  if (!await confirm({ message: "Save this agent?", default: true })) {
+    return void 0;
+  }
+  await saveAgent(id, agent);
+  console.log(`Agent saved: ${id}`);
+  return await confirm({ message: "Launch it now?", default: false }) ? id : void 0;
+}
+async function chooseAgent(message) {
+  const entries = Object.entries((await loadSettings()).customAgents);
+  if (entries.length === 0) {
+    console.log("No custom agents configured.");
+    return void 0;
+  }
+  return select({
+    message,
+    choices: [
+      ...entries.map(([id, agent]) => ({ name: `${agent.label} (${id})`, value: id })),
+      { name: "Back", value: "back" }
+    ]
+  });
+}
+async function editAgent() {
+  const id = await chooseAgent("Select an agent to edit");
+  if (!id || id === "back") return;
+  const draft = structuredClone((await loadSettings()).customAgents[id]);
+  showAgent(id, draft);
+  for (; ; ) {
+    const field = await select({
+      message: "Select a field to edit",
+      // 一次展示全部字段，并在首尾停止方向键导航。
+      pageSize: 8,
+      loop: false,
+      choices: [
+        { name: `Name: ${draft.label}`, value: "label" },
+        { name: `Command: ${draft.command}`, value: "command" },
+        { name: `Default arguments: ${JSON.stringify(draft.args)}`, value: "args" },
+        { name: `Protocol: ${draft.protocol}`, value: "protocol" },
+        { name: `Upstream: ${draft.upstream}`, value: "upstream" },
+        { name: "Base URL injection", value: "inject" },
+        { name: "Save changes", value: "save" },
+        { name: "Cancel", value: "cancel" }
+      ]
+    });
+    if (field === "cancel") return;
+    if (field === "save") {
+      await saveAgent(id, draft);
+      console.log(`Agent updated: ${id}`);
+      return;
+    }
+    if (field === "label") draft.label = await input({ message: "Agent name", default: draft.label, validate: required });
+    if (field === "command") draft.command = await input({ message: "Executable command", default: draft.command, validate: required });
+    if (field === "args") draft.args = await askArgs("Default arguments (JSON array)", draft.args);
+    if (field === "protocol") draft.protocol = await askProtocol(draft.protocol);
+    if (field === "upstream") draft.upstream = await input({ message: "Original upstream URL", default: draft.upstream, validate: validUrl });
+    if (field === "inject") draft.inject = await askInject(draft.protocol, draft.inject);
+  }
+}
+async function deleteAgent() {
+  const id = await chooseAgent("Select an agent to delete");
+  if (!id || id === "back") return;
+  const agent = (await loadSettings()).customAgents[id];
+  if (!await confirm({ message: `Delete ${agent.label} (${id})? Recorded history will be kept.`, default: false })) {
+    console.log("Delete cancelled.");
+    return;
+  }
+  await removeAgent(id);
+  console.log(`Agent deleted: ${id}. Recorded history was kept.`);
+}
+async function manageAgents() {
+  if (!process.stdin.isTTY) throw new Error("The agent command requires an interactive terminal.");
+  for (; ; ) {
+    const action = await select({
+      message: "Manage custom agents",
+      choices: [
+        { name: "Add agent", value: "add" },
+        { name: "Edit agent", value: "edit" },
+        { name: "Delete agent", value: "delete" },
+        { name: "Back", value: "back" }
+      ]
+    });
+    if (action === "back") return void 0;
+    if (action === "add") {
+      const id = await addAgent();
+      if (id) return id;
+    }
+    if (action === "edit") await editAgent();
+    if (action === "delete") await deleteAgent();
+  }
+}
+
 // ../../packages/shared/src/headers.ts
 var secrets = /* @__PURE__ */ new Set([
   "authorization",
@@ -229,8 +593,8 @@ function responseHeaders(headers) {
 }
 
 // ../../packages/proxy/src/target.ts
-function targetUrl(route, input) {
-  const local = new URL(input, "http://127.0.0.1");
+function targetUrl(route, input2) {
+  const local = new URL(input2, "http://127.0.0.1");
   const target = new URL(route.upstream);
   const suffix = local.pathname.slice(route.prefix.length).replace(/^\//, "");
   const basePath = target.pathname.replace(/\/$/, "");
@@ -1685,11 +2049,11 @@ function parseOutputFormat(params, content) {
 }
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.125.0/node_modules/@anthropic-ai/sdk/_vendor/partial-json-parser/parser.mjs
-var tokenize = (input) => {
+var tokenize = (input2) => {
   let current = 0;
   let tokens = [];
-  while (current < input.length) {
-    let char = input[current];
+  while (current < input2.length) {
+    let char = input2[current];
     if (char === "\\") {
       current++;
       continue;
@@ -1745,26 +2109,26 @@ var tokenize = (input) => {
     if (char === '"') {
       let value = "";
       let danglingQuote = false;
-      char = input[++current];
+      char = input2[++current];
       while (char !== '"') {
-        if (current === input.length) {
+        if (current === input2.length) {
           danglingQuote = true;
           break;
         }
         if (char === "\\") {
           current++;
-          if (current === input.length) {
+          if (current === input2.length) {
             danglingQuote = true;
             break;
           }
-          value += char + input[current];
-          char = input[++current];
+          value += char + input2[current];
+          char = input2[++current];
         } else {
           value += char;
-          char = input[++current];
+          char = input2[++current];
         }
       }
-      char = input[++current];
+      char = input2[++current];
       if (!danglingQuote) {
         tokens.push({
           type: "string",
@@ -1783,13 +2147,13 @@ var tokenize = (input) => {
       let value = "";
       if (char === "-") {
         value += char;
-        char = input[++current];
+        char = input2[++current];
       }
       while (char && (NUMBERS.test(char) || char === "." || // exponent marker, e.g. `1e10` or `1.5E-9`
       char === "e" || char === "E" || // exponent sign, only valid immediately after the exponent marker
       (char === "-" || char === "+") && (value[value.length - 1] === "e" || value[value.length - 1] === "E"))) {
         value += char;
-        char = input[++current];
+        char = input2[++current];
       }
       tokens.push({
         type: "number",
@@ -1801,11 +2165,11 @@ var tokenize = (input) => {
     if (char && LETTERS.test(char)) {
       let value = "";
       while (char && LETTERS.test(char)) {
-        if (current === input.length) {
+        if (current === input2.length) {
           break;
         }
         value += char;
-        char = input[++current];
+        char = input2[++current];
       }
       if (value == "true" || value == "false" || value === "null") {
         tokens.push({
@@ -1904,7 +2268,7 @@ var generate = (tokens) => {
   });
   return output;
 };
-var partialParse = (input) => JSON.parse(generate(unstrip(strip(tokenize(input)))));
+var partialParse = (input2) => JSON.parse(generate(unstrip(strip(tokenize(input2)))));
 
 // ../../node_modules/.pnpm/@anthropic-ai+sdk@0.125.0/node_modules/@anthropic-ai/sdk/internal/message-stream-utils.mjs
 var JSON_BUF_PROPERTY = "__json_buf";
@@ -1915,17 +2279,17 @@ function withLazyInput(prev, jsonBuf) {
       next[key] = prev[key];
   }
   Object.defineProperty(next, JSON_BUF_PROPERTY, { value: jsonBuf, enumerable: false, writable: true });
-  let input;
+  let input2;
   let parsed = false;
   Object.defineProperty(next, "input", {
     enumerable: true,
     configurable: true,
     get() {
       if (!parsed) {
-        input = jsonBuf ? partialParse(jsonBuf) : {};
+        input2 = jsonBuf ? partialParse(jsonBuf) : {};
         parsed = true;
       }
-      return input;
+      return input2;
     }
   });
   return next;
@@ -6716,17 +7080,17 @@ var Recorder = class {
     this.onChange = onChange;
   }
   /** 开始捕获一次模型 HTTP 请求。 */
-  async start(input) {
+  async start(input2) {
     const meta = {
       id: makeId("ex"),
-      runId: input.runId,
-      sessionId: `run:${input.runId}`,
+      runId: input2.runId,
+      sessionId: `run:${input2.runId}`,
       sessionSource: "run",
-      protocol: input.protocol,
-      method: input.method,
-      path: input.path,
+      protocol: input2.protocol,
+      method: input2.method,
+      path: input2.path,
       stream: false,
-      requestHeaders: redactHeaders(input.headers),
+      requestHeaders: redactHeaders(input2.headers),
       startedAt: nowIso(),
       requestBytes: 0,
       responseBytes: 0,
@@ -6748,12 +7112,12 @@ var Recorder = class {
 };
 
 // ../../packages/storage/src/reader.ts
-import { readFile as readFile3, readdir } from "fs/promises";
+import { readFile as readFile4, readdir } from "fs/promises";
 import { join as join4 } from "path";
 
 // ../../packages/storage/src/files.ts
-import { mkdir as mkdir2, readFile as readFile2, rename, writeFile } from "fs/promises";
-import { dirname, join as join3 } from "path";
+import { mkdir as mkdir3, readFile as readFile3, rename, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
 function dateKey(iso) {
   return iso.slice(0, 10);
 }
@@ -6762,18 +7126,18 @@ function getRunDir(root, iso, runId) {
 }
 async function writeJson(path, value) {
   const temp = `${path}.tmp`;
-  await mkdir2(dirname(path), { recursive: true });
-  await writeFile(temp, `${JSON.stringify(value, null, 2)}
+  await mkdir3(dirname2(path), { recursive: true });
+  await writeFile2(temp, `${JSON.stringify(value, null, 2)}
 `, "utf8");
   await rename(temp, path);
 }
 async function readJson(path) {
-  return JSON.parse(await readFile2(path, "utf8"));
+  return JSON.parse(await readFile3(path, "utf8"));
 }
 async function readJsonl(path) {
   let text = "";
   try {
-    text = await readFile2(path, "utf8");
+    text = await readFile3(path, "utf8");
   } catch {
     return [];
   }
@@ -6835,6 +7199,28 @@ function contentText(value) {
   const parts = array(value).map((item) => record(item)).filter((item) => item?.type === "text" || item?.type === "input_text" || item?.type === "output_text").map((item) => string(item?.text)).filter((text) => typeof text === "string" && !isContext(text));
   return string(parts.join("\n\n"));
 }
+function promptText(value) {
+  if (typeof value === "string") {
+    return string(value);
+  }
+  const parts = array(value).map((item) => record(item)).filter((item) => item?.type === "text" || item?.type === "input_text" || item?.type === "output_text").map((item) => string(item?.text)).filter((text) => Boolean(text));
+  return string(parts.join("\n\n"));
+}
+function systemText(exchange) {
+  const body = record(exchange?.request);
+  const parts = [promptText(body?.system), promptText(body?.instructions)].filter((text) => Boolean(text));
+  for (const raw of array(body?.input)) {
+    const item = record(raw);
+    if (item?.type !== "message" || item?.role !== "system" && item?.role !== "developer") {
+      continue;
+    }
+    const text = promptText(item?.content);
+    if (text) {
+      parts.push(text);
+    }
+  }
+  return string(parts.join("\n\n"));
+}
 function reasoningText(value) {
   const summary = array(value?.summary).map((item) => string(record(item)?.text)).filter((text) => Boolean(text));
   return string(summary.join("\n\n")) ?? string(value?.thinking) ?? contentText(value?.content);
@@ -6931,13 +7317,13 @@ function codexItem(value) {
   }
   if (type.endsWith("_call")) {
     const callId = string(item?.call_id) ?? string(item?.id);
-    const input = item?.arguments ?? item?.input ?? item?.action;
+    const input2 = item?.arguments ?? item?.input ?? item?.action;
     return [{
       ...callId ? { sourceId: callId, callId } : {},
       kind: "tool",
       role: "assistant",
       name: string(item?.name) ?? type.replace(/_call$/, ""),
-      input: json(input),
+      input: json(input2),
       status: "pending"
     }];
   }
@@ -6964,10 +7350,10 @@ function turnMeta(exchange) {
   const metadata = record(json(encoded));
   const source = string(client?.thread_source) ?? string(metadata?.thread_source);
   const id = string(client?.turn_id) ?? string(metadata?.turn_id);
-  const texts = requestItems(exchange).filter((item) => item?.kind === "message").map((item) => item?.text ?? "").join("\n");
+  const claudeInternal = exchange?.meta?.protocol === "anthropic" && isInternalText(requestItems(exchange).filter((item) => item?.kind === "message").map((item) => item?.text ?? "").join("\n"));
   return {
     ...id ? { id } : {},
-    internal: source === "system" || isInternalText(texts)
+    internal: source === "system" || claudeInternal
   };
 }
 function fingerprint(item) {
@@ -7007,6 +7393,7 @@ var Builder = class {
   ids = /* @__PURE__ */ new Set();
   seen = /* @__PURE__ */ new Set();
   max = /* @__PURE__ */ new Map();
+  systemPrompt;
   current;
   turnSeq = 0;
   itemSeq = 0;
@@ -7016,10 +7403,16 @@ var Builder = class {
   }
   /** 将一次 Exchange 合并到当前会话。 */
   add(exchange) {
+    const prompt = systemText(exchange);
+    if (prompt && !this.systemPrompt) {
+      this.systemPrompt = { text: prompt, exchangeIds: [exchange.meta.id] };
+    } else if (prompt && this.systemPrompt?.text === prompt) {
+      this.link(this.systemPrompt.exchangeIds, exchange.meta.id);
+    }
     const meta = turnMeta(exchange);
-    const input = this.snapshot(requestItems(exchange));
-    const userIndex = lastUser(input);
-    input.forEach((item, index) => {
+    const input2 = this.snapshot(requestItems(exchange));
+    const userIndex = lastUser(input2);
+    input2.forEach((item, index) => {
       const newTurn = item?.kind === "message" && item?.role === "user";
       const explicit = newTurn && index === userIndex ? meta.id : void 0;
       const turn = newTurn ? this.turn(explicit, meta.internal, exchange, true) : this.turn(meta.id, meta.internal, exchange, false);
@@ -7040,6 +7433,7 @@ var Builder = class {
       sessionId: this.session.id,
       protocol: this.session.protocol,
       ...model ? { model } : {},
+      ...this.systemPrompt ? { systemPrompt: this.systemPrompt } : {},
       startedAt: this.session.startedAt,
       ...this.session.endedAt ? { endedAt: this.session.endedAt } : {},
       exchangeIds: this.session.exchanges.map((item) => item.id),
@@ -7219,12 +7613,19 @@ async function scan(root) {
   for (const date of await readDirs(runsRoot)) {
     const dateDir = join4(runsRoot, date);
     for (const run of await readDirs(dateDir)) {
+      const runDir = join4(dateDir, run);
+      let agentLabel;
+      try {
+        const info = await readJson(join4(runDir, "run.json"));
+        agentLabel = info.agentLabel ?? (info.agent === "claude" ? "Claude Code" : info.agent === "codex" ? "Codex" : info.agent);
+      } catch {
+      }
       const exchangesDir = join4(dateDir, run, "exchanges");
       for (const exchange of await readDirs(exchangesDir)) {
         const dir = join4(exchangesDir, exchange);
         try {
           const meta = await readJson(join4(dir, "meta.json"));
-          result.push({ dir, meta: normalizeMeta(meta) });
+          result.push({ dir, meta: normalizeMeta(meta), ...agentLabel ? { agentLabel } : {} });
         } catch {
         }
       }
@@ -7266,6 +7667,7 @@ async function listSessions(root) {
     groups.set(item.meta.sessionId, {
       id: item.meta.sessionId,
       protocol: item.meta.protocol,
+      ...item.agentLabel ? { agentLabel: item.agentLabel } : {},
       startedAt: item.meta.startedAt,
       ...item.meta.completedAt ? { endedAt: item.meta.completedAt } : {},
       ...isInternal(item.meta) ? { internal: true } : {},
@@ -7276,8 +7678,8 @@ async function listSessions(root) {
 }
 async function readExchange(stored) {
   const [requestBody, responseBody, chunkRows, events] = await Promise.all([
-    readFile3(join4(stored.dir, "request.bin")),
-    readFile3(join4(stored.dir, "response.bin")),
+    readFile4(join4(stored.dir, "request.bin")),
+    readFile4(join4(stored.dir, "response.bin")),
     readJsonl(join4(stored.dir, "response-chunks.jsonl")),
     readJsonl(join4(stored.dir, "sse-events.jsonl"))
   ]);
@@ -7343,11 +7745,11 @@ async function getConversation(root, sessionId) {
 }
 
 // ../../packages/storage/src/store.ts
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import { join as join6 } from "path";
 
 // ../../packages/storage/src/writer.ts
-import { mkdir as mkdir3, open } from "fs/promises";
+import { mkdir as mkdir4, open } from "fs/promises";
 import { join as join5 } from "path";
 var ExchangeWriter = class {
   dir;
@@ -7370,7 +7772,7 @@ var ExchangeWriter = class {
   }
   /** 创建目录并打开全部追加文件。 */
   async init() {
-    await mkdir3(this.dir, { recursive: true });
+    await mkdir4(this.dir, { recursive: true });
     [this.req, this.reqIndex, this.res, this.resIndex, this.eventFile] = await Promise.all([
       open(join5(this.dir, "request.bin"), "a"),
       open(join5(this.dir, "request-chunks.jsonl"), "a"),
@@ -7463,7 +7865,7 @@ var FileStore = class {
   }
   /** 初始化存储根目录。 */
   async init() {
-    await mkdir4(join6(this.root, "runs"), { recursive: true });
+    await mkdir5(join6(this.root, "runs"), { recursive: true });
   }
   /** 创建一次运行记录并返回其目录。 */
   async startRun(run) {
@@ -7559,7 +7961,7 @@ data: ${JSON.stringify(data)}
 };
 
 // ../../packages/server/src/static.ts
-import { readFile as readFile4, stat } from "fs/promises";
+import { readFile as readFile5, stat } from "fs/promises";
 import { extname, resolve as resolve3, sep } from "path";
 var contentTypes = {
   ".css": "text/css; charset=utf-8",
@@ -7588,7 +7990,7 @@ async function serveStatic(root, pathname, res) {
     target = resolve3(base, "index.html");
   }
   try {
-    const body = await readFile4(target);
+    const body = await readFile5(target);
     res.writeHead(200, {
       "content-type": contentTypes?.[extname(target)] ?? "application/octet-stream",
       "cache-control": target.endsWith("index.html") ? "no-cache" : "public, max-age=31536000, immutable"
@@ -7702,53 +8104,12 @@ var TraceletServer = class {
   }
 };
 
-// src/settings.ts
-import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-async function readRaw(path) {
-  try {
-    const value = JSON.parse(await readFile5(path, "utf8"));
-    if (!isObject(value)) {
-      throw new Error("Settings root must be an object");
-    }
-    return value;
-  } catch (error) {
-    if (error?.code === "ENOENT") {
-      return {};
-    }
-    throw new Error(`Failed to read Tracelet settings: ${path}`, { cause: error });
-  }
-}
-async function loadSettings(path = settingsFile()) {
-  const value = await readRaw(path);
-  const proxy = value.proxy;
-  if (proxy !== void 0 && !isObject(proxy)) {
-    throw new Error(`Invalid proxy settings: ${path}`);
-  }
-  const mode = isObject(proxy) ? proxy.mode : void 0;
-  if (mode !== void 0 && mode !== "direct" && mode !== "system") {
-    throw new Error(`Invalid proxy mode: ${String(mode)}`);
-  }
-  return { proxy: { mode: mode ?? "direct" } };
-}
-async function saveProxy(mode, path = settingsFile()) {
-  const value = await readRaw(path);
-  const proxy = isObject(value.proxy) ? value.proxy : {};
-  const next = { ...value, proxy: { ...proxy, mode } };
-  await mkdir5(dirname2(path), { recursive: true });
-  await writeFile2(path, `${JSON.stringify(next, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-}
-
 // src/spawn.ts
 import { spawn } from "child_process";
-async function spawnAgent(input) {
+async function spawnAgent(input2) {
   return new Promise((resolve4, reject) => {
-    const child = spawn(input.command, input.args, {
-      env: input.env,
+    const child = spawn(input2.command, input2.args, {
+      env: input2.env,
       stdio: "inherit"
     });
     function onSigint() {
@@ -7783,12 +8144,12 @@ function lineValue(output, key) {
   return output.match(new RegExp(`^\\s*${key}\\s*:\\s*(.+?)\\s*$`, "m"))?.[1];
 }
 function proxyUrl(value) {
-  const input = value?.trim();
-  if (!input) {
+  const input2 = value?.trim();
+  if (!input2) {
     return void 0;
   }
   try {
-    const url = new URL(/^[a-z]+:\/\//i.test(input) ? input : `http://${input}`);
+    const url = new URL(/^[a-z]+:\/\//i.test(input2) ? input2 : `http://${input2}`);
     return url.protocol === "http:" || url.protocol === "https:" ? url.toString().replace(/\/$/, "") : void 0;
   } catch {
     return void 0;
@@ -7844,13 +8205,17 @@ async function systemProxy(platform = process.platform) {
 
 // src/run.ts
 async function runAgent(agentId, args, options) {
-  const adapter = agents[agentId];
+  const settings = await loadSettings();
+  const adapter = agentId === "claude" || agentId === "codex" ? agents[agentId] : settings.customAgents[agentId] ? customAdapter(agentId, settings.customAgents[agentId]) : void 0;
+  if (!adapter) {
+    throw new Error(`Unknown agent: ${agentId}`);
+  }
   if (!await adapter.detect()) {
     throw new Error(`${adapter.label} command not found: ${adapter.command}`);
   }
-  const settings = await loadSettings();
-  const proxy = settings.proxy.mode === "system" ? await systemProxy() : void 0;
-  if (settings.proxy.mode === "system" && !proxy) {
+  const mode = proxyMode(settings, agentId);
+  const proxy = mode === "system" ? await systemProxy() : void 0;
+  if (mode === "system" && !proxy) {
     console.warn("System proxy not found. Using a direct connection.");
   }
   const server = new TraceletServer({
@@ -7861,6 +8226,7 @@ async function runAgent(agentId, args, options) {
   const run = {
     id: makeId("run"),
     agent: adapter.id,
+    agentLabel: adapter.label,
     cwd: process.cwd(),
     command: adapter.command,
     startedAt: nowIso()
@@ -7895,6 +8261,9 @@ async function runDashboard(options) {
 }
 
 // src/program.ts
+var { version } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
 function parsePort(value) {
   const port = Number.parseInt(value, 10);
   if (!Number.isInteger(port) || port < 0 || port > 65535) {
@@ -7911,28 +8280,47 @@ function getOptions(program) {
 }
 async function interactive(program) {
   if (!process.stdin.isTTY) {
-    throw new Error("Use tracelet claude or tracelet codex in a non-interactive environment.");
+    throw new Error("Use tracelet claude, tracelet codex, or tracelet run <id> in a non-interactive environment.");
   }
-  const [claudeReady, codexReady] = await Promise.all([
-    agents.claude.detect(),
-    agents.codex.detect()
-  ]);
-  const agent = await select({
-    message: "Select an agent to trace",
-    choices: [
-      {
-        name: "Claude Code",
-        value: "claude",
-        ...!claudeReady ? { disabled: "claude command not found" } : {}
-      },
-      {
-        name: "Codex",
-        value: "codex",
-        ...!codexReady ? { disabled: "codex command not found" } : {}
+  for (; ; ) {
+    const settings = await loadSettings();
+    const [claudeReady, codexReady] = await Promise.all([
+      agents.claude.detect(),
+      agents.codex.detect()
+    ]);
+    const custom = await Promise.all(Object.entries(settings.customAgents).map(async ([id, config]) => ({
+      name: config.label,
+      value: id,
+      ...!await customAdapter(id, config).detect() ? { disabled: `${config.command} command not found` } : {}
+    })));
+    const agent = await select2({
+      message: "Select an agent to trace",
+      choices: [
+        {
+          name: "Claude Code",
+          value: "claude",
+          ...!claudeReady ? { disabled: "claude command not found" } : {}
+        },
+        {
+          name: "Codex",
+          value: "codex",
+          ...!codexReady ? { disabled: "codex command not found" } : {}
+        },
+        ...custom,
+        { name: "Manage custom agents...", value: "manage" }
+      ]
+    });
+    if (agent === "manage") {
+      const launch = await manageAgents();
+      if (launch) {
+        process.exitCode = await runAgent(launch, [], getOptions(program));
+        return;
       }
-    ]
-  });
-  process.exitCode = await runAgent(agent, [], getOptions(program));
+      continue;
+    }
+    process.exitCode = await runAgent(agent, [], getOptions(program));
+    return;
+  }
 }
 async function clearRecords(program, yes) {
   const root = dataDir(getOptions(program).dataDir);
@@ -7940,7 +8328,7 @@ async function clearRecords(program, yes) {
     if (!process.stdin.isTTY) {
       throw new Error("Use tracelet clear --yes in a non-interactive environment.");
     }
-    const accepted = await confirm({
+    const accepted = await confirm2({
       message: `This will permanently delete all Tracelet records in ${root}. Continue?`,
       default: false
     });
@@ -7956,8 +8344,27 @@ async function configureProxy() {
   if (!process.stdin.isTTY) {
     throw new Error("The proxy command requires an interactive terminal.");
   }
-  const current = (await loadSettings()).proxy.mode;
-  const mode = await select({
+  const settings = await loadSettings();
+  const target = await select2({
+    message: "Select an agent to configure",
+    choices: [
+      {
+        name: `Claude Code (${proxyMode(settings, "claude") === "system" ? "On" : "Off"})`,
+        value: "claude"
+      },
+      {
+        name: `Codex (${proxyMode(settings, "codex") === "system" ? "On" : "Off"})`,
+        value: "codex"
+      },
+      { name: "All agents", value: "all" },
+      ...Object.entries(settings.customAgents).map(([id, agent]) => ({
+        name: `${agent.label} (${proxyMode(settings, id) === "system" ? "On" : "Off"})`,
+        value: id
+      }))
+    ]
+  });
+  const current = target === "all" ? settings.proxy.default.mode : proxyMode(settings, target);
+  const mode = await select2({
     message: "Use the system proxy for upstream requests?",
     choices: [
       { name: "On", value: "system" },
@@ -7965,17 +8372,25 @@ async function configureProxy() {
     ],
     default: current
   });
-  await saveProxy(mode);
-  console.log(mode === "system" ? "System proxy enabled." : "System proxy disabled.");
+  await saveProxy(target, mode);
+  const label = target === "all" ? "all agents" : target === "claude" || target === "codex" ? agents[target].label : settings.customAgents[target]?.label ?? target;
+  console.log(`System proxy ${mode === "system" ? "enabled" : "disabled"} for ${label}.`);
 }
 function createProgram() {
   const program = new Command();
-  program.name("tracelet").description("Record LLM requests and streaming responses from Claude Code and Codex").version("0.1.0").enablePositionalOptions().addOption(new Option("-p, --port <port>", "Local server port").default(4318).argParser(parsePort)).option("--data-dir <path>", "Local trace directory").action(() => interactive(program));
+  program.name("tracelet").description("Record LLM requests and streaming responses from built-in and custom agents").version(version).enablePositionalOptions().addOption(new Option("-p, --port <port>", "Local server port").default(4318).argParser(parsePort)).option("--data-dir <path>", "Local trace directory").action(() => interactive(program));
   for (const agentId of ["claude", "codex"]) {
     program.command(`${agentId} [args...]`).description(`Start and trace ${agents[agentId].label}`).allowUnknownOption().passThroughOptions().action(async (args) => {
       process.exitCode = await runAgent(agentId, args, getOptions(program));
     });
   }
+  program.command("agent").description("Add, edit, or delete custom agents").action(async () => {
+    const launch = await manageAgents();
+    if (launch) process.exitCode = await runAgent(launch, [], getOptions(program));
+  });
+  program.command("run <id> [args...]").description("Start and trace a custom agent by ID").allowUnknownOption().passThroughOptions().action(async (id, args) => {
+    process.exitCode = await runAgent(id, args, getOptions(program));
+  });
   program.command("dashboard").description("View local Tracelet history").action(() => runDashboard(getOptions(program)));
   program.command("proxy").description("Configure system proxy usage").action(configureProxy);
   const clear = program.command("clear").description("Clear all local Tracelet history").option("-y, --yes", "Skip confirmation");