@slashfi/agents-sdk 0.69.12 → 0.70.1

package/src/adk-check.ts

@@ -13,10 +13,16 @@
  *   adk run --no-check -e "code"  Execute inline without type-checking
  */
 
-import { join, dirname, basename, resolve } from "node:path";
-import { homedir } from "node:os";
-import { existsSync, writeFileSync, readFileSync, unlinkSync, copyFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import {
+  copyFileSync,
+  existsSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
 
 export interface CheckOptions {
   file?: string;
@@ -26,62 +32,94 @@ export interface CheckOptions {
   configDir?: string;
 }
 
-const INLINE_PREAMBLE_CHECK = (
-  `import "./.adk_types";\n` +
-  `import { createAdk, createLocalFsStore } from "@slashfi/agents-sdk";\n` +
-  `import { join } from "node:path";\n` +
-  `import { homedir } from "node:os";\n` +
-  `const adk = createAdk(\n` +
-  `  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n` +
-  `  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n` +
-  `);\n`
-);
-
-const INLINE_PREAMBLE_RUN = (
-  `import { createAdk, createLocalFsStore } from "@slashfi/agents-sdk";\n` +
-  `import { join } from "node:path";\n` +
-  `import { homedir } from "node:os";\n` +
-  `const adk = createAdk(\n` +
-  `  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n` +
-  `  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n` +
-  `);\n`
-);
-
-export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitCode: number }> {
-  const configDir = opts.configDir ?? process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk");
+/**
+ * Resolve the absolute path to the @slashfi/agents-sdk package.
+ * This ensures the preamble works regardless of the script's working directory,
+ * since bare specifiers like "@slashfi/agents-sdk" may not resolve from arbitrary cwds.
+ */
+function resolveAgentsSdkPath(): string {
+  try {
+    // require.resolve gives us the main entry point, e.g.
+    // /root/.bun/install/global/node_modules/@slashfi/agents-sdk/dist/index.js
+    const resolved = require.resolve("@slashfi/agents-sdk");
+    // Extract package root path
+    const marker = "@slashfi/agents-sdk";
+    const idx = resolved.indexOf(marker);
+    if (idx !== -1) {
+      return resolved.substring(0, idx + marker.length);
+    }
+    return "@slashfi/agents-sdk";
+  } catch {
+    return "@slashfi/agents-sdk";
+  }
+}
+
+function makePreambleCheck(sdkPath: string): string {
+  return `import "./.adk_types";\nimport { createAdk, createLocalFsStore } from "${sdkPath}";\nimport { join } from "node:path";\nimport { homedir } from "node:os";\nconst adk = createAdk(\n  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n);\n`;
+}
+
+function makePreambleRun(sdkPath: string): string {
+  return `import { createAdk, createLocalFsStore } from "${sdkPath}";\nimport { join } from "node:path";\nimport { homedir } from "node:os";\nconst adk = createAdk(\n  createLocalFsStore(process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk")),\n  { token: process.env.ATLAS_TOKEN ?? process.env.ADK_TOKEN ?? "" },\n);\n`;
+}
+
+/**
+ * Create a run wrapper file that injects the adk preamble before the user's code.
+ * Works for both inline (-e) and file mode.
+ */
+function writeRunWrapper(
+  tmpFile: string,
+  preamble: string,
+  userCode: string,
+): void {
+  writeFileSync(tmpFile, preamble + userCode);
+}
+
+export async function adkCheck(
+  opts: CheckOptions,
+): Promise<{ ok: boolean; exitCode: number }> {
+  const configDir =
+    opts.configDir ?? process.env.ADK_CONFIG_DIR ?? join(homedir(), ".adk");
   const adkTypes = join(configDir, "adk.d.ts");
   const hasTypes = existsSync(adkTypes);
   const isInline = !!opts.code;
+  const sdkPath = resolveAgentsSdkPath();
+  const PREAMBLE_RUN = makePreambleRun(sdkPath);
 
   // --no-check: skip typecheck, just run
   if (opts.noCheck && opts.run) {
-    if (isInline) {
-      const tmpFile = join(process.cwd(), ".adk_run.ts");
-      writeFileSync(tmpFile, INLINE_PREAMBLE_RUN + opts.code);
-      const r = spawnSync("bun", ["run", tmpFile], { cwd: process.cwd(), stdio: "inherit", env: process.env });
-      try { unlinkSync(tmpFile); } catch {}
-      return { ok: r.status === 0, exitCode: r.status ?? 1 };
-    } else {
-      const r = spawnSync("bun", ["run", resolve(opts.file!)], {
-        cwd: dirname(resolve(opts.file!)), stdio: "inherit", env: process.env,
-      });
-      return { ok: r.status === 0, exitCode: r.status ?? 1 };
-    }
+    const cwd = isInline ? process.cwd() : dirname(resolve(opts.file!));
+    const userCode = isInline
+      ? opts.code!
+      : readFileSync(resolve(opts.file!), "utf-8");
+    const tmpFile = join(cwd, ".adk_run.ts");
+    writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+    const r = spawnSync("bun", ["run", tmpFile], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    try {
+      unlinkSync(tmpFile);
+    } catch {}
+    return { ok: r.status === 0, exitCode: r.status ?? 1 };
   }
 
   if (!hasTypes) {
-    console.error("\x1b[33m\u26a0\x1b[0m No adk.d.ts found. Run `adk sync` first to generate agent types.");
+    console.error(
+      "\x1b[33m\u26a0\x1b[0m No adk.d.ts found. Run `adk sync` first to generate agent types.",
+    );
   }
 
   let cwd: string;
   let checkFile: string;
   let originalFile: string | undefined;
   const cleanup: string[] = [];
+  const PREAMBLE_CHECK = makePreambleCheck("@slashfi/agents-sdk");
 
   if (isInline) {
     cwd = process.cwd();
     checkFile = join(cwd, ".adk_check.ts");
-    writeFileSync(checkFile, INLINE_PREAMBLE_CHECK + opts.code);
+    writeFileSync(checkFile, PREAMBLE_CHECK + opts.code);
     cleanup.push(checkFile);
   } else if (opts.file) {
     originalFile = resolve(opts.file);
@@ -91,8 +129,16 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
     }
     cwd = dirname(originalFile);
     checkFile = join(cwd, `.adk_check_${basename(originalFile)}`);
+    // File mode: inject preamble so `adk` is typed and available
     const typesImport = hasTypes ? `import "./.adk_types";\n` : "";
-    writeFileSync(checkFile, typesImport + readFileSync(originalFile, "utf-8"));
+    const preambleNoTypes = PREAMBLE_CHECK.replace(
+      `import "./.adk_types";\n`,
+      "",
+    );
+    writeFileSync(
+      checkFile,
+      typesImport + preambleNoTypes + readFileSync(originalFile, "utf-8"),
+    );
     cleanup.push(checkFile);
   } else {
     console.error('Usage: adk check <file> | adk check -e "<code>"');
@@ -108,31 +154,74 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
 
   // Write minimal tsconfig
   const tsconfigFile = join(cwd, ".adk_tsconfig.json");
-  writeFileSync(tsconfigFile, JSON.stringify({
-    compilerOptions: {
-      target: "ES2022",
-      module: "ESNext",
-      moduleResolution: "bundler",
-      esModuleInterop: true,
-      strict: true,
-      noEmit: true,
-      skipLibCheck: true,
-      types: ["node"],
-    },
-    include: [basename(checkFile)],
-  }));
+  writeFileSync(
+    tsconfigFile,
+    JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        noEmit: true,
+        skipLibCheck: true,
+        types: ["node"],
+      },
+      include: [basename(checkFile)],
+    }),
+  );
   cleanup.push(tsconfigFile);
 
   // Find type checker
   const checker = findTypeChecker();
 
+  if (!checker) {
+    console.error(
+      "\x1b[33m\u26a0\x1b[0m No TypeScript type checker found (tsgo or tsc). Skipping type check.",
+    );
+    for (const f of cleanup) {
+      try {
+        unlinkSync(f);
+      } catch {}
+    }
+
+    // Still run if requested
+    if (opts.run) {
+      const userCode = isInline
+        ? opts.code!
+        : readFileSync(originalFile!, "utf-8");
+      const tmpFile = join(cwd, ".adk_run.ts");
+      writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+      const r = spawnSync("bun", ["run", tmpFile], {
+        cwd,
+        stdio: "inherit",
+        env: process.env,
+      });
+      try {
+        unlinkSync(tmpFile);
+      } catch {}
+      return { ok: r.status === 0, exitCode: r.status ?? 1 };
+    }
+    return { ok: true, exitCode: 0 };
+  }
+
   // Type-check
-  const result = spawnSync(checker.cmd, [...checker.args, "--project", tsconfigFile], {
-    cwd, stdio: "inherit", env: process.env,
-  });
+  const result = spawnSync(
+    checker.cmd,
+    [...checker.args, "--project", tsconfigFile],
+    {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    },
+  );
 
   // Clean up
-  for (const f of cleanup) { try { unlinkSync(f); } catch {} }
+  for (const f of cleanup) {
+    try {
+      unlinkSync(f);
+    } catch {}
+  }
 
   if (result.status !== 0) {
     return { ok: false, exitCode: result.status ?? 1 };
@@ -142,25 +231,73 @@ export async function adkCheck(opts: CheckOptions): Promise<{ ok: boolean; exitC
 
   // Run
   if (opts.run) {
-    let runResult;
-    if (isInline) {
-      const tmpFile = join(cwd, ".adk_run.ts");
-      writeFileSync(tmpFile, INLINE_PREAMBLE_RUN + opts.code);
-      runResult = spawnSync("bun", ["run", tmpFile], { cwd, stdio: "inherit", env: process.env });
-      try { unlinkSync(tmpFile); } catch {}
-    } else {
-      runResult = spawnSync("bun", ["run", originalFile!], { cwd, stdio: "inherit", env: process.env });
-    }
+    const userCode = isInline
+      ? opts.code!
+      : readFileSync(originalFile!, "utf-8");
+    const tmpFile = join(cwd, ".adk_run.ts");
+    writeRunWrapper(tmpFile, PREAMBLE_RUN, userCode);
+    const runResult = spawnSync("bun", ["run", tmpFile], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    try {
+      unlinkSync(tmpFile);
+    } catch {}
     return { ok: runResult.status === 0, exitCode: runResult.status ?? 1 };
   }
 
   return { ok: true, exitCode: 0 };
 }
 
-function findTypeChecker(): { cmd: string; args: string[] } {
+/**
+ * Find a working TypeScript type checker.
+ * Returns null if none found — callers should skip type checking gracefully.
+ *
+ * Checks:
+ * 1. tsgo binary (fastest — native TypeScript compiler)
+ * 2. npx tsgo (if installed as a package)
+ * 3. tsc binary (standard TypeScript compiler, verified via --version)
+ * 4. npx tsc — but ONLY if it's the real TypeScript compiler, not the
+ *    unrelated `tsc` npm package that prints "This is not the tsc command
+ *    you are looking for"
+ */
+function findTypeChecker(): { cmd: string; args: string[] } | null {
+  // 1. tsgo binary
   const tsgo = spawnSync("which", ["tsgo"], { stdio: "pipe" });
   if (tsgo.status === 0) return { cmd: "tsgo", args: [] };
-  const npxTsgo = spawnSync("npx", ["tsgo", "--version"], { stdio: "pipe", timeout: 5000 });
+
+  // 2. npx tsgo
+  const npxTsgo = spawnSync("npx", ["tsgo", "--version"], {
+    stdio: "pipe",
+    timeout: 5000,
+  });
   if (npxTsgo.status === 0) return { cmd: "npx", args: ["tsgo"] };
-  return { cmd: "npx", args: ["tsc"] };
+
+  // 3. tsc binary (e.g. from `npm install -g typescript`)
+  const tscWhich = spawnSync("which", ["tsc"], { stdio: "pipe" });
+  if (tscWhich.status === 0) {
+    // Verify it's the real TypeScript compiler, not the bogus `tsc` npm package
+    const tscVersion = spawnSync("tsc", ["--version"], {
+      stdio: "pipe",
+      timeout: 5000,
+    });
+    const output = tscVersion.stdout?.toString() ?? "";
+    if (tscVersion.status === 0 && output.includes("Version")) {
+      return { cmd: "tsc", args: [] };
+    }
+  }
+
+  // 4. npx tsc — validate it's actually TypeScript
+  const npxTsc = spawnSync("npx", ["--no-install", "tsc", "--version"], {
+    stdio: "pipe",
+    timeout: 10000,
+  });
+  const npxOutput = npxTsc.stdout?.toString() ?? "";
+  if (npxTsc.status === 0 && npxOutput.includes("Version")) {
+    return { cmd: "npx", args: ["tsc"] };
+  }
+
+  // No type checker found
+  return null;
 }

package/src/registry-consumer.ts

@@ -128,9 +128,21 @@ async function resolveTemplates<T>(
 // Registry Auth Headers
 // ============================================
 
+/**
+ * Expand `$VAR` and `${VAR}` references in a string using process.env.
+ * Unresolved variables are left as-is (no silent empty-string replacement).
+ */
+function expandEnvVars(value: string): string {
+  return value.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, braced, bare) => {
+    const varName = braced ?? bare;
+    return process.env[varName] ?? match;
+  });
+}
+
 /**
  * Build auth headers for a registry based on its auth config and custom headers.
  * Merges typed auth (bearer, api-key) with arbitrary custom headers.
+ * Environment variable references ($VAR or ${VAR}) in header values are expanded.
  */
 function buildRegistryAuthHeaders(
   registry: ResolvedRegistry,
@@ -171,8 +183,11 @@ function buildRegistryAuthHeaders(
   }
 
   // Merge custom headers (these override auth-generated headers)
+  // Expand $VAR / ${VAR} env references in header values
   if (registry.headers) {
-    Object.assign(headers, registry.headers);
+    for (const [key, value] of Object.entries(registry.headers)) {
+      headers[key] = expandEnvVars(value);
+    }
   }
 
   return headers;