@bastani/atomic 0.6.6-0 → 0.6.6

package/src/commands/cli/chat/index.ts

@@ -10,7 +10,7 @@
  *   atomic chat -a <agent> [native-args...]
  */
 
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { mkdir, writeFile, rm } from "node:fs/promises";
 import { AGENT_CONFIG, type AgentKey } from "../../../services/config/index.ts";
@@ -19,10 +19,11 @@ import { getCopilotScmDisableFlags } from "../../../services/config/scm-sync.ts"
 import {
   resolveAdditionalInstructionsPath,
 } from "../../../services/config/additional-instructions.ts";
-import { dirname } from "node:path";
 import { ensureProjectSetup } from "../init/index.ts";
 import { COLORS } from "../../../theme/colors.ts";
-import { isCommandInstalled } from "../../../services/system/detect.ts";
+import {
+  getCommandPath,
+} from "../../../services/system/detect.ts";
 import { checkAgentAuth, printAuthError } from "../../../services/system/auth.ts";
 import {
   ensureAtomicGlobalAgentConfigs,
@@ -42,6 +43,24 @@ import {
 } from "../../../sdk/runtime/tmux.ts";
 import { spawnAttachedFooter } from "../../../sdk/runtime/attached-footer.ts";
 import { ensureTmuxInstalled } from "../../../lib/spawn.ts";
+import {
+  buildLauncherEnv,
+  buildSpawnEnv,
+  buildTmuxEnv,
+} from "../../../lib/terminal-env.ts";
+import { atomicTempEnv } from "../../../lib/atomic-temp.ts";
+import {
+  type CommandPathResolver,
+  resolveCopilotCliPath,
+} from "../../../sdk/providers/copilot.ts";
+
+export {
+  buildLauncherEnv,
+  buildSpawnEnv,
+  buildTmuxEnv,
+  TERMINAL_ENV_KEYS,
+  type TerminalEnvKey,
+} from "../../../lib/terminal-env.ts";
 
 // ============================================================================
 // Types
@@ -118,6 +137,18 @@ export function getAdditionalInstructionsDir(
   return path ? dirname(path) : undefined;
 }
 
+export function resolveChatCommand(
+  agentType: AgentType,
+  resolveCommandPath: CommandPathResolver = getCommandPath,
+): string | undefined {
+  if (agentType === "copilot") {
+    return resolveCopilotCliPath(resolveCommandPath);
+  }
+
+  const config = AGENT_CONFIG[agentType];
+  return resolveCommandPath(config.cmd) ?? undefined;
+}
+
 function generateChatId(): string {
   return crypto.randomUUID().slice(0, 8);
 }
@@ -132,6 +163,28 @@ function escPwsh(s: string): string {
   return s.replace(/[`"$]/g, "`$&");
 }
 
+const POSIX_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function assertBashEnvKey(key: string): void {
+  if (!POSIX_ENV_KEY_RE.test(key)) {
+    throw new Error(
+      `Invalid Bash env key "${key}": must match /^[A-Za-z_][A-Za-z0-9_]*$/`,
+    );
+  }
+}
+
+function escPwshEnvKey(key: string): string {
+  return key.replace(/}/g, "`}");
+}
+
+async function removeLauncher(path: string): Promise<void> {
+  try {
+    await rm(path, { force: true });
+  } catch {
+    // Cleanup best effort; attach/fallback result should remain authoritative.
+  }
+}
+
 /**
  * Build a launcher script that preserves cwd and properly quotes args.
  * This avoids shell-injection risks from passthrough args.
@@ -149,7 +202,7 @@ export function buildLauncherScript(
     // PowerShell: use array splatting for safe arg passing
     const argList = args.map((a) => `"${escPwsh(a)}"`).join(", ");
     const envLines = envEntries.map(
-      ([key, value]) => `$env:${key} = "${escPwsh(value)}"`,
+      ([key, value]) => `\${env:${escPwshEnvKey(key)}} = "${escPwsh(value)}"`,
     );
     const script = [
       `Set-Location "${escPwsh(projectRoot)}"`,
@@ -164,18 +217,19 @@ export function buildLauncherScript(
     return { script, ext: "ps1" };
   }
 
-  // Bash: use proper quoting for each arg
-  const quotedArgs = args
-    .map((a) => `"${escBash(a)}"`)
-    .join(" ");
-  const envLines = envEntries.map(
-    ([key, value]) => `export ${key}="${escBash(value)}"`,
-  );
+  const quotedCommand = [
+    `"${escBash(cmd)}"`,
+    ...args.map((arg) => `"${escBash(arg)}"`),
+  ].join(" ");
+  const envLines = envEntries.map(([key, value]) => {
+    assertBashEnvKey(key);
+    return `export ${key}="${escBash(value)}"`;
+  });
   const script = [
     "#!/bin/bash",
     `cd "${escBash(projectRoot)}"`,
     ...envLines,
-    `"${escBash(cmd)}" ${quotedArgs}`,
+    quotedCommand,
     "atomic_exit_code=$?",
     'exit "$atomic_exit_code"',
   ].join("\n");
@@ -206,8 +260,10 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
 
   const config = AGENT_CONFIG[agentType];
 
+  const executable = resolveChatCommand(agentType);
+
   // Check the agent CLI is installed
-  if (!isCommandInstalled(config.cmd)) {
+  if (!executable) {
     console.error(
       `${COLORS.red}Error: '${config.cmd}' is not installed or not in PATH.${COLORS.reset}`
     );
@@ -236,12 +292,14 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
 
   // ── Build argv ──
   const args = await buildAgentArgs(agentType, passthroughArgs, projectRoot);
-  const cmd = [config.cmd, ...args];
+  const cmd = [executable, ...args];
   const overrides = await getProviderOverrides(agentType, projectRoot);
+  const claudeTempEnv = agentType === "claude" ? atomicTempEnv() : {};
   // ATOMIC_AGENT must be baked into the launcher env so the agent CLI
   // and anything it spawns can read it from process start.
   const envVars: Record<string, string> = {
     ...config.env_vars,
+    ...claudeTempEnv,
     ...overrides.envVars,
     ATOMIC_AGENT: agentType,
   };
@@ -267,9 +325,13 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
     }
   }
 
+  const spawnEnv = buildSpawnEnv(envVars);
+  const launcherEnv = buildLauncherEnv(envVars);
+  const tmuxEnv = buildTmuxEnv(envVars);
+
   // ── No TTY: tmux attach requires a real terminal ──
   if (!process.stdin.isTTY) {
-    return spawnDirect(cmd, projectRoot, envVars);
+    return spawnDirect(cmd, projectRoot, spawnEnv);
   }
 
   // ── Ensure tmux is available ──
@@ -283,7 +345,7 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
     }
     if (!isTmuxInstalled()) {
       // No tmux available — fall back to direct spawn
-      return spawnDirect(cmd, projectRoot, envVars);
+      return spawnDirect(cmd, projectRoot, spawnEnv);
     }
   }
 
@@ -294,10 +356,10 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
   const sessionsDir = join(homedir(), ".atomic", "sessions", "chat");
   await mkdir(sessionsDir, { recursive: true });
   const { script, ext } = buildLauncherScript(
-    config.cmd,
+    executable,
     args,
     projectRoot,
-    envVars,
+    launcherEnv,
   );
   const launcherPath = join(sessionsDir, `${windowName}.${ext}`);
   await writeFile(launcherPath, script, { mode: 0o755 });
@@ -308,14 +370,14 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
 
   // ── Create session on the atomic socket and attach ──
   try {
-    const paneId = createSession(windowName, shellCmd, undefined, projectRoot);
+    const paneId = createSession(windowName, shellCmd, undefined, projectRoot, tmuxEnv);
     spawnAttachedFooter(windowName, paneId, agentType);
     killSessionOnPaneExit(windowName, paneId);
 
     if (isInsideAtomicSocket()) {
       // Already on the atomic server — just switch to the new session.
       switchClient(windowName);
-      try { await rm(launcherPath, { force: true }); } catch {}
+      await removeLauncher(launcherPath);
       return 0;
     }
 
@@ -323,30 +385,29 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
       // Inside a different tmux server — detach and replace the client
       // with an attach to the atomic socket (no nesting).
       detachAndAttachAtomic(windowName);
-      try { await rm(launcherPath, { force: true }); } catch {}
+      await removeLauncher(launcherPath);
       return 0;
     }
 
     const attachProc = spawnMuxAttach(windowName);
     const exitCode = await attachProc.exited;
 
-    // Clean up launcher
-    try { await rm(launcherPath, { force: true }); } catch {}
+    await removeLauncher(launcherPath);
 
     // If tmux attach itself failed (e.g. lost TTY), clean up and fall back
     if (exitCode !== 0) {
       try { killSession(windowName); } catch {}
-      return spawnDirect(cmd, projectRoot, envVars);
+      return spawnDirect(cmd, projectRoot, spawnEnv);
     }
 
     return exitCode;
   } catch (error) {
-    try { await rm(launcherPath, { force: true }); } catch {}
+    await removeLauncher(launcherPath);
     const message = error instanceof Error ? error.message : String(error);
     console.error(
       `${COLORS.yellow}Warning: Failed to create tmux session (${message}). Falling back to direct spawn.${COLORS.reset}`
     );
-    return spawnDirect(cmd, projectRoot, envVars);
+    return spawnDirect(cmd, projectRoot, spawnEnv);
   }
 }
 
@@ -357,12 +418,12 @@ export async function chatCommand(options: ChatCommandOptions = {}): Promise<num
 async function spawnDirect(
   cmd: string[],
   projectRoot: string,
-  envVars: Record<string, string> = {},
+  env: Record<string, string> = {},
 ): Promise<number> {
   const proc = Bun.spawn(cmd, {
     stdio: ["inherit", "inherit", "inherit"],
     cwd: projectRoot,
-    env: { ...process.env, ...envVars },
+    env,
   });
 
   return await proc.exited;

package/src/lib/atomic-temp.test.ts

@@ -0,0 +1,86 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  atomicContentTempPath,
+  atomicTempDir,
+  atomicTempEnv,
+  atomicTempPath,
+  ensureAtomicTempDir,
+  withAtomicTempEnv,
+} from "./atomic-temp.ts";
+
+const createdDirs: string[] = [];
+
+function makeTempRoot(): string {
+  const dir = mkdtempSync(join(tmpdir(), "atomic-temp-test-"));
+  createdDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of createdDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("atomic temp helpers", () => {
+  test("uses a per-user directory under ~/.atomic/tmp", () => {
+    expect(atomicTempDir("/home/alice")).toBe("/home/alice/.atomic/tmp");
+  });
+
+  test("creates the temp directory with owner-only permissions", () => {
+    const dir = join(makeTempRoot(), "owned-tmp");
+
+    expect(ensureAtomicTempDir(dir)).toBe(dir);
+    expect(statSync(dir).isDirectory()).toBe(true);
+    if (process.platform !== "win32") {
+      expect(statSync(dir).mode & 0o777).toBe(0o700);
+    }
+  });
+
+  test("builds all Node temp env aliases from the same directory", () => {
+    const dir = join(makeTempRoot(), "env-tmp");
+
+    expect(atomicTempEnv(dir)).toEqual({
+      TMPDIR: dir,
+      TMP: dir,
+      TEMP: dir,
+    });
+  });
+
+  test("builds random and content-addressed paths inside the Atomic temp dir", () => {
+    const dir = join(makeTempRoot(), "paths");
+
+    expect(atomicTempPath("prompt", ".txt", "abc", dir)).toBe(
+      join(dir, "prompt-abc.txt"),
+    );
+    expect(atomicContentTempPath("settings", ".json", "same", dir)).toBe(
+      atomicContentTempPath("settings", ".json", "same", dir),
+    );
+    expect(atomicContentTempPath("settings", ".json", "same", dir)).not.toBe(
+      atomicContentTempPath("settings", ".json", "different", dir),
+    );
+  });
+
+  test("scopes process temp env while an async operation runs", async () => {
+    const dir = join(makeTempRoot(), "scoped");
+    const before = {
+      TMPDIR: process.env.TMPDIR,
+      TMP: process.env.TMP,
+      TEMP: process.env.TEMP,
+    };
+
+    const seen = await withAtomicTempEnv(async () => ({
+      TMPDIR: process.env.TMPDIR,
+      TMP: process.env.TMP,
+      TEMP: process.env.TEMP,
+    }), dir);
+
+    expect(seen).toEqual({ TMPDIR: dir, TMP: dir, TEMP: dir });
+    expect(process.env.TMPDIR).toBe(before.TMPDIR);
+    expect(process.env.TMP).toBe(before.TMP);
+    expect(process.env.TEMP).toBe(before.TEMP);
+  });
+});

package/src/lib/atomic-temp.ts

@@ -0,0 +1,62 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const ATOMIC_TEMP_ENV_KEYS = ["TMPDIR", "TMP", "TEMP"] as const;
+
+export function atomicTempDir(homeDir: string = homedir()): string {
+  return join(homeDir, ".atomic", "tmp");
+}
+
+export function ensureAtomicTempDir(dir: string = atomicTempDir()): string {
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  if (process.platform !== "win32") {
+    chmodSync(dir, 0o700);
+  }
+  return dir;
+}
+
+export function atomicTempEnv(dir: string = ensureAtomicTempDir()): Record<string, string> {
+  return Object.fromEntries(ATOMIC_TEMP_ENV_KEYS.map((key) => [key, dir]));
+}
+
+export function atomicTempPath(
+  prefix: string,
+  extension: string,
+  id: string = randomUUID(),
+  dir: string = ensureAtomicTempDir(),
+): string {
+  return join(dir, `${prefix}-${id}${extension}`);
+}
+
+export function atomicContentTempPath(
+  prefix: string,
+  extension: string,
+  content: string,
+  dir: string = ensureAtomicTempDir(),
+): string {
+  const id = createHash("sha256").update(content).digest("hex").slice(0, 16);
+  return atomicTempPath(prefix, extension, id, dir);
+}
+
+export async function withAtomicTempEnv<T>(
+  fn: () => Promise<T>,
+  dir: string = ensureAtomicTempDir(),
+): Promise<T> {
+  const previous = Object.fromEntries(
+    ATOMIC_TEMP_ENV_KEYS.map((key) => [key, process.env[key]]),
+  );
+  for (const key of ATOMIC_TEMP_ENV_KEYS) {
+    process.env[key] = dir;
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const key of ATOMIC_TEMP_ENV_KEYS) {
+      const value = previous[key];
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+}