@letta-ai/letta-code 0.21.12 → 0.21.14

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.21.12",
+    version: "0.21.14",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -40508,7 +40508,7 @@ import {
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync7,
   renameSync as renameSync2,
-  rmdirSync,
+  rmSync as rmSync2,
   statSync as statSync2,
   writeFileSync as writeFileSync6
 } from "node:fs";
@@ -40586,7 +40586,7 @@ function isLockStale(lockDir) {
 }
 function stealLock(lockDir) {
   try {
-    rmdirSync(lockDir, { recursive: true });
+    rmSync2(lockDir, { recursive: true, force: true });
   } catch {}
 }
 function acquireLock() {
@@ -40607,7 +40607,7 @@ function acquireLock() {
           try {
             const current = readLockOwner(lockDir);
             if (current && current.token === token) {
-              rmdirSync(lockDir, { recursive: true });
+              rmSync2(lockDir, { recursive: true, force: true });
             }
           } catch {}
         }
@@ -65411,7 +65411,7 @@ async function runProcess(context3) {
 }
 async function shell(args) {
   validateRequiredParams(args, ["command"], "shell");
-  const { command, workdir, timeout_ms, signal, onOutput } = args;
+  const { command, workdir, timeout_ms, env_overrides, signal, onOutput } = args;
   if (!Array.isArray(command) || command.length === 0) {
     throw new Error("command must be a non-empty array of strings");
   }
@@ -65422,7 +65422,10 @@ async function shell(args) {
   const context3 = {
     command,
     cwd: cwd2,
-    env: getShellEnv(),
+    env: {
+      ...getShellEnv(),
+      ...env_overrides ?? {}
+    },
     timeout,
     signal,
     onOutput
@@ -65543,6 +65546,7 @@ async function shell_command(args) {
     signal,
     onOutput
   } = args;
+  const envOverrides = getMemoryGitIdentityEnvOverrides(command, workdir);
   const launchers = buildShellLaunchers(command, { login });
   if (launchers.length === 0) {
     throw new Error("Command must be a non-empty string");
@@ -65554,6 +65558,7 @@ async function shell_command(args) {
       return await shell({
         command: launcher,
         workdir,
+        env_overrides: envOverrides,
         timeout_ms,
         justification,
         signal,
@@ -65572,7 +65577,96 @@ async function shell_command(args) {
   const reason = lastError?.message || "Shell unavailable";
   throw new Error(suffix ? `${reason} (tried: ${suffix})` : reason);
 }
+function getMemoryGitIdentityEnvOverrides(command, workdir) {
+  const agentId = getCurrentAgentIdOrEnv();
+  if (!agentId) {
+    return;
+  }
+  if (!containsGitCommitInvocation(command)) {
+    return;
+  }
+  const scopedToMemoryDir = isMemoryDirCommand(command, agentId) || (workdir ? isMemoryDirCommand(`cd ${shellQuote(workdir)} && ${command}`, agentId) : false);
+  if (!scopedToMemoryDir) {
+    return;
+  }
+  const agentName = (process.env.AGENT_NAME || "").trim() || agentId;
+  const agentEmail = `${agentId}@letta.com`;
+  return {
+    GIT_AUTHOR_NAME: agentName,
+    GIT_AUTHOR_EMAIL: agentEmail,
+    GIT_COMMITTER_NAME: agentName,
+    GIT_COMMITTER_EMAIL: agentEmail
+  };
+}
+function getCurrentAgentIdOrEnv() {
+  const envAgentId = (process.env.AGENT_ID || process.env.LETTA_AGENT_ID || "").trim();
+  if (envAgentId) {
+    return envAgentId;
+  }
+  try {
+    const agentId = getCurrentAgentId().trim();
+    if (agentId) {
+      return agentId;
+    }
+  } catch {}
+  return "";
+}
+function containsGitCommitInvocation(command) {
+  const segments = command.split(/&&|\|\||;|\|/).map((segment) => segment.trim()).filter(Boolean);
+  for (const segment of segments) {
+    const tokens = tokenizeSegment(segment);
+    if (tokens.length === 0) {
+      continue;
+    }
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=.*/.test(tokens[index] ?? "")) {
+      index += 1;
+    }
+    if (tokens[index] !== "git") {
+      continue;
+    }
+    index += 1;
+    while (index < tokens.length) {
+      const token = tokens[index];
+      if (!token) {
+        index += 1;
+        continue;
+      }
+      if (token === "-c" || token === "-C") {
+        index += 2;
+        continue;
+      }
+      if (token.startsWith("-")) {
+        index += 1;
+        continue;
+      }
+      if (token === "commit") {
+        return true;
+      }
+      break;
+    }
+  }
+  return false;
+}
+function tokenizeSegment(segment) {
+  const matches = segment.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+  if (!matches) {
+    return [];
+  }
+  return matches.map(stripWrappingQuotes);
+}
+function stripWrappingQuotes(token) {
+  if (token.startsWith('"') && token.endsWith('"') || token.startsWith("'") && token.endsWith("'")) {
+    return token.slice(1, -1);
+  }
+  return token;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
 var init_ShellCommand2 = __esm(async () => {
+  init_context();
+  init_readOnlyShell();
   init_shellRunner();
   await init_Shell2();
 });
@@ -65827,6 +65921,17 @@ var init_skillContentRegistry = __esm(() => {
 import { readdirSync as readdirSync7 } from "node:fs";
 import { readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname10, join as join20 } from "node:path";
+function getMemorySkillsDirs(agentId) {
+  const dirs = new Set;
+  const memoryDir = process.env.MEMORY_DIR || process.env.LETTA_MEMORY_DIR;
+  if (memoryDir && memoryDir.trim().length > 0) {
+    dirs.add(join20(memoryDir.trim(), "skills"));
+  }
+  if (agentId) {
+    dirs.add(join20(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents", agentId, "memory", "skills"));
+  }
+  return Array.from(dirs);
+}
 function hasAdditionalFiles(skillMdPath) {
   try {
     const skillDir = dirname10(skillMdPath);
@@ -65849,6 +65954,13 @@ async function readSkillContent(skillId, skillsDir, agentId) {
       return { content, path: agentSkillPath };
     } catch {}
   }
+  for (const memorySkillsDir of getMemorySkillsDirs(agentId)) {
+    const memorySkillPath = join20(memorySkillsDir, skillId, "SKILL.md");
+    try {
+      const content = await readFile6(memorySkillPath, "utf-8");
+      return { content, path: memorySkillPath };
+    } catch {}
+  }
   const globalSkillPath = join20(GLOBAL_SKILLS_DIR, skillId, "SKILL.md");
   try {
     const content = await readFile6(globalSkillPath, "utf-8");
@@ -74226,6 +74338,84 @@ var init_check_approval = __esm(() => {
   ];
 });
 
+// src/utils/createRelayedAbortController.ts
+function createRelayedAbortController(parentSignal) {
+  const controller = new AbortController;
+  if (!parentSignal) {
+    return {
+      controller,
+      signal: controller.signal,
+      cleanup: () => {}
+    };
+  }
+  if (parentSignal.aborted) {
+    controller.abort(parentSignal.reason);
+    return {
+      controller,
+      signal: controller.signal,
+      cleanup: () => {}
+    };
+  }
+  const relayAbort = () => {
+    controller.abort(parentSignal.reason);
+  };
+  parentSignal.addEventListener("abort", relayAbort, { once: true });
+  return {
+    controller,
+    signal: controller.signal,
+    cleanup: () => {
+      parentSignal.removeEventListener("abort", relayAbort);
+    }
+  };
+}
+
+// src/utils/streamAbortRelay.ts
+function composeCleanups(first, second) {
+  let cleaned = false;
+  return () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    first();
+    second();
+  };
+}
+function createStreamAbortRelay(parentSignal) {
+  if (!parentSignal) {
+    return null;
+  }
+  const requestAbort = createRelayedAbortController(parentSignal);
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    requestAbort.cleanup();
+  };
+  return {
+    signal: requestAbort.signal,
+    attach(stream2) {
+      const existingCleanup = streamAbortRelayCleanupByStream.get(stream2);
+      streamAbortRelayCleanupByStream.set(stream2, existingCleanup ? composeCleanups(existingCleanup, cleanup) : cleanup);
+    },
+    cleanup
+  };
+}
+function cleanupStreamAbortRelay(stream2) {
+  const cleanup = streamAbortRelayCleanupByStream.get(stream2);
+  if (!cleanup) {
+    return;
+  }
+  streamAbortRelayCleanupByStream.delete(stream2);
+  cleanup();
+}
+var streamAbortRelayCleanupByStream;
+var init_streamAbortRelay = __esm(() => {
+  streamAbortRelayCleanupByStream = new WeakMap;
+});
+
 // src/agent/approval-result-normalization.ts
 function normalizeToolReturnText(value) {
   if (typeof value === "string")
@@ -74470,19 +74660,23 @@ async function sendMessageStream(conversationId, messages, opts = { streamTokens
   const firstOtid = messages[0]?.otid;
   debugLog("send-message-stream", "request_start conversation_id=%s agent_id=%s messages=%s otid=%s stream_tokens=%s background=%s max_retries=%s", resolvedConversationId, opts.agentId ?? "none", messageSummary || "(empty)", firstOtid ?? "none", opts.streamTokens ?? true, opts.background ?? true, requestOptions.maxRetries ?? "default");
   let stream2;
+  const abortRelay = createStreamAbortRelay(requestOptions.signal);
   try {
     stream2 = await client.conversations.messages.create(resolvedConversationId, requestBody, {
       ...requestOptions,
+      ...abortRelay ? { signal: abortRelay.signal } : {},
       headers: {
         ...requestOptions.headers ?? {},
         ...extraHeaders
       }
     });
   } catch (error) {
+    abortRelay?.cleanup();
     debugWarn("send-message-stream", "request_error conversation_id=%s otid=%s status=%s error=%s", resolvedConversationId, firstOtid ?? "none", error?.status ?? "none", error instanceof Error ? error.message : String(error));
     throw error;
   }
   debugLog("send-message-stream", "request_ok conversation_id=%s otid=%s", resolvedConversationId, firstOtid ?? "none");
+  abortRelay?.attach(stream2);
   if (requestStartTime !== undefined) {
     streamRequestStartTimes.set(stream2, requestStartTime);
   }
@@ -74499,6 +74693,7 @@ async function sendMessageStream(conversationId, messages, opts = { streamTokens
 var streamRequestStartTimes, streamToolContextIds, streamRequestContexts;
 var init_message = __esm(async () => {
   init_debug();
+  init_streamAbortRelay();
   init_timing();
   init_approval_result_normalization();
   init_clientSkills();
@@ -76589,6 +76784,7 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
     if (abortSignal) {
       abortSignal.removeEventListener("abort", abortHandler);
     }
+    cleanupStreamAbortRelay(stream2);
     clearLastSDKDiagnostic();
   }
   if (!stopReason && streamProcessor.stopReason) {
@@ -76680,15 +76876,23 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
       const client = await lazyClient();
       buffers.commitGeneration = (buffers.commitGeneration || 0) + 1;
       buffers.interrupted = false;
-      const resumeStream = runIdSource === "otid" && streamOtid && streamRequestContext ? await client.conversations.messages.stream(streamRequestContext.resolvedConversationId, {
-        agent_id: streamRequestContext.conversationId === "default" ? streamRequestContext.agentId ?? undefined : undefined,
-        otid: streamOtid,
-        starting_after: result.lastSeqId ?? 0,
-        batch_size: 1000
-      }) : await client.runs.messages.stream(runIdToResume, {
-        starting_after: result.lastSeqId ?? 0,
-        batch_size: 1000
-      });
+      const resumeAbortRelay = createStreamAbortRelay(abortSignal);
+      let resumeStream;
+      try {
+        resumeStream = runIdSource === "otid" && streamOtid && streamRequestContext ? await client.conversations.messages.stream(streamRequestContext.resolvedConversationId, {
+          agent_id: streamRequestContext.conversationId === "default" ? streamRequestContext.agentId ?? undefined : undefined,
+          otid: streamOtid,
+          starting_after: result.lastSeqId ?? 0,
+          batch_size: 1000
+        }, resumeAbortRelay ? { signal: resumeAbortRelay.signal } : undefined) : await client.runs.messages.stream(runIdToResume, {
+          starting_after: result.lastSeqId ?? 0,
+          batch_size: 1000
+        }, resumeAbortRelay ? { signal: resumeAbortRelay.signal } : undefined);
+      } catch (resumeError) {
+        resumeAbortRelay?.cleanup();
+        throw resumeError;
+      }
+      resumeAbortRelay?.attach(resumeStream);
       const resumeResult = await drainStream(resumeStream, buffers, refresh, abortSignal, undefined, onChunkProcessed, contextTracker, seenSeqIdThreshold, true);
       if (resumeResult.stopReason !== "error") {
         debugWarn("stream", "[MID-STREAM RESUME] ✅ Success (runId=%s, stopReason=%s)", runIdToResume, resumeResult.stopReason);
@@ -76753,6 +76957,7 @@ var FALLBACK_RUN_DISCOVERY_TIMEOUT_MS = 5000;
 var init_stream = __esm(async () => {
   init_error();
   init_debug();
+  init_streamAbortRelay();
   init_timing();
   init_chunkLog();
   await __promiseAll([
@@ -80692,15 +80897,23 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
         try {
           const client = await getClient();
           const messageOtid = messages.map((item) => item.otid).find((value) => typeof value === "string");
+          const resumeAbortRelay = createStreamAbortRelay(abortSignal);
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
           }
-          return await client.conversations.messages.stream(conversationId, {
-            agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
-            otid: messageOtid ?? undefined,
-            starting_after: 0,
-            batch_size: 1000
-          });
+          try {
+            const resumeStream = await client.conversations.messages.stream(conversationId, {
+              agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
+              otid: messageOtid ?? undefined,
+              starting_after: 0,
+              batch_size: 1000
+            }, resumeAbortRelay ? { signal: resumeAbortRelay.signal } : undefined);
+            resumeAbortRelay?.attach(resumeStream);
+            return resumeStream;
+          } catch (resumeError) {
+            resumeAbortRelay?.cleanup();
+            throw resumeError;
+          }
         } catch (resumeError) {
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
@@ -80815,15 +81028,23 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
         try {
           const client = await getClient();
           const messageOtid = messages.map((item) => item.otid).find((value) => typeof value === "string");
+          const resumeAbortRelay = createStreamAbortRelay(abortSignal);
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
           }
-          return await client.conversations.messages.stream(conversationId, {
-            agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
-            otid: messageOtid ?? undefined,
-            starting_after: 0,
-            batch_size: 1000
-          });
+          try {
+            const resumeStream = await client.conversations.messages.stream(conversationId, {
+              agent_id: conversationId === "default" ? runtime.agentId ?? undefined : undefined,
+              otid: messageOtid ?? undefined,
+              starting_after: 0,
+              batch_size: 1000
+            }, resumeAbortRelay ? { signal: resumeAbortRelay.signal } : undefined);
+            resumeAbortRelay?.attach(resumeStream);
+            return resumeStream;
+          } catch (resumeError) {
+            resumeAbortRelay?.cleanup();
+            throw resumeError;
+          }
         } catch (resumeError) {
           if (abortSignal?.aborted) {
             throw new Error("Cancelled by user");
@@ -80853,6 +81074,7 @@ var init_send = __esm(async () => {
   init_errorFormatter();
   init_diffPreview();
   init_interactivePolicy();
+  init_streamAbortRelay();
   init_constants2();
   init_cwd();
   init_permissionMode();
@@ -83697,6 +83919,19 @@ function runDetachedListenerTask(commandName, task2) {
     }
   });
 }
+async function replaySyncStateForRuntime(listenerRuntime, socket, scope, opts) {
+  const syncScopedRuntime = getOrCreateScopedRuntime(listenerRuntime, scope.agent_id, scope.conversation_id);
+  const recoverFn = opts?.recoverApprovalStateForSync ?? recoverApprovalStateForSync;
+  try {
+    await recoverFn(syncScopedRuntime, scope);
+  } catch (error) {
+    trackListenerError("listener_sync_recovery_failed", error, "listener_sync_recovery");
+    if (isDebugEnabled()) {
+      console.warn("[Listen] Sync approval recovery failed:", error);
+    }
+  }
+  emitStateSync(socket, listenerRuntime, scope);
+}
 function getParsedRuntimeScope(parsed) {
   if (!parsed || typeof parsed !== "object" || !("runtime" in parsed)) {
     return null;
@@ -83727,7 +83962,7 @@ function handleModeChange(msg, socket, runtime, scope) {
       current.modeBeforePlan = null;
     }
     persistPermissionModeMapForRuntime(runtime);
-    emitDeviceStatusUpdate(socket, runtime, scope);
+    emitRuntimeStateUpdates(runtime, scope);
     if (isDebugEnabled()) {
       console.log(`[Listen] Mode changed to: ${msg.mode}`);
     }
@@ -84089,7 +84324,7 @@ async function handleSkillCommand(parsed, socket) {
     existsSync: existsSync22,
     lstatSync: lstatSync2,
     mkdirSync: mkdirSync15,
-    rmdirSync: rmdirSync2,
+    rmdirSync,
     symlinkSync,
     unlinkSync: unlinkSync8
   } = await import("node:fs");
@@ -84124,7 +84359,7 @@ async function handleSkillCommand(parsed, socket) {
         const stat6 = lstatSync2(linkPath);
         if (stat6.isSymbolicLink()) {
           if (process.platform === "win32") {
-            rmdirSync2(linkPath);
+            rmdirSync(linkPath);
           } else {
             unlinkSync8(linkPath);
           }
@@ -84182,7 +84417,7 @@ async function handleSkillCommand(parsed, socket) {
         return true;
       }
       if (process.platform === "win32") {
-        rmdirSync2(linkPath);
+        rmdirSync(linkPath);
       } else {
         unlinkSync8(linkPath);
       }
@@ -84832,9 +85067,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           console.log(`[Listen V2] Dropping sync: runtime mismatch or closed`);
           return;
         }
-        const syncScopedRuntime = getOrCreateScopedRuntime(runtime, parsed.runtime.agent_id, parsed.runtime.conversation_id);
-        await recoverApprovalStateForSync(syncScopedRuntime, parsed.runtime);
-        emitStateSync(socket, runtime, parsed.runtime);
+        await replaySyncStateForRuntime(runtime, socket, parsed.runtime);
         return;
       }
       if (parsed.type === "input") {
@@ -85749,6 +85982,7 @@ var init_client4 = __esm(async () => {
   __listenClientTestUtils = {
     createRuntime: createLegacyTestRuntime,
     createListenerRuntime: createRuntime,
+    handleModeChange,
     getOrCreateScopedRuntime,
     buildListModelsEntries,
     buildListModelsResponse,
@@ -85798,6 +86032,7 @@ var init_client4 = __esm(async () => {
     handleCreateAgentCommand,
     handleReflectionSettingsCommand,
     scheduleQueuePump,
+    replaySyncStateForRuntime,
     recoverApprovalStateForSync,
     clearRecoveredApprovalStateForScope: (runtime, scope) => clearRecoveredApprovalStateForScope(asListenerRuntimeForTests(runtime), scope),
     emitStateSync
@@ -119988,7 +120223,7 @@ import {
   mkdirSync as mkdirSync22,
   mkdtempSync,
   readFileSync as readFileSync18,
-  rmSync as rmSync3,
+  rmSync as rmSync4,
   writeFileSync as writeFileSync16
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
@@ -120371,7 +120606,7 @@ async function installGithubApp(options) {
       agentUrl: resolvedAgentId ? buildChatUrl(resolvedAgentId) : null
     };
   } finally {
-    rmSync3(tempDir, { recursive: true, force: true });
+    rmSync4(tempDir, { recursive: true, force: true });
   }
 }
 var DEFAULT_WORKFLOW_PATH = ".github/workflows/letta.yml", ALTERNATE_WORKFLOW_PATH = ".github/workflows/letta-code.yml";
@@ -149303,7 +149538,7 @@ async function runListenSubcommand(argv) {
 
 // src/cli/subcommands/memfs.ts
 await init_memoryGit();
-import { cpSync, existsSync as existsSync22, mkdirSync as mkdirSync15, rmSync as rmSync2, statSync as statSync8 } from "node:fs";
+import { cpSync, existsSync as existsSync22, mkdirSync as mkdirSync15, rmSync as rmSync3, statSync as statSync8 } from "node:fs";
 import { readdir as readdir6 } from "node:fs/promises";
 import { homedir as homedir23 } from "node:os";
 import { join as join28 } from "node:path";
@@ -149496,7 +149731,7 @@ async function runMemfsSubcommand(argv) {
         return 1;
       }
       const root = getMemoryRoot(agentId);
-      rmSync2(root, { recursive: true, force: true });
+      rmSync3(root, { recursive: true, force: true });
       cpSync(backupPath, root, { recursive: true });
       console.log(JSON.stringify({ restoredFrom: backupPath }, null, 2));
       return 0;
@@ -153311,4 +153546,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=1C3BE0588811294864756E2164756E21
+//# debugId=DEDBAA251791817164756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.21.12",
+  "version": "0.21.14",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {