@mcpher/gas-fakes 1.2.25 → 1.2.26

package/README.RU.md

@@ -348,6 +348,9 @@ const getParentsIterator = ({
 - [gemini](gemini-observations.md) - some reflections and experiences on using gemini to help code large projects
 - [named colors](named-colors.md)
 - [sandbox](sandbox.md)
+- [using apps script libraries with gas-fakes](libraries.md)
+- [how libhandler works](libhandler.md)
+- [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)
 - [named range identity](named-range-identity.md)
 - [adc and restricted scopes](https://ramblings.mcpher.com/how-to-allow-access-to-sensitive-scopes-with-application-default-credentials/)
 - [push test pull](pull-test-push.md)

package/README.md

@@ -167,6 +167,9 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [gemini](gemini-observations.md) - some reflections and experiences on using gemini to help code large projects
 - [named colors](named-colors.md)
 - [sandbox](sandbox.md)
+- [using apps script libraries with gas-fakes](libraries.md)
+- [how libhandler works](libhandler.md)
+- [article:using apps script libraries with gas-fakes](https://ramblings.mcpher.com/how-to-use-apps-script-libraries-directly-from-node/)
 - [named range identity](named-range-identity.md)
 - [adc and restricted scopes](https://ramblings.mcpher.com/how-to-allow-access-to-sensitive-scopes-with-application-default-credentials/)
 - [push test pull](pull-test-push.md)

package/package.json

@@ -34,7 +34,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "1.2.25",
+  "version": "1.2.26",
   "license": "MIT",
   "main": "main.js",
   "description": "A proof of concept implementation of Apps Script Environment on Node",

package/src/cli/app.js

@@ -138,9 +138,24 @@ export async function main() {
     .command("enableAPIs")
     .description("Enables or disables required Google Cloud APIs.")
     .option("--all", "Enable all default APIs.")
+    // Drive
     .option("--edrive", "Enable drive.googleapis.com")
     .option("--ddrive", "Disable drive.googleapis.com")
-    // ... (other flags implied by setup.js logic)
+    // Sheets
+    .option("--esheets", "Enable sheets.googleapis.com")
+    .option("--dsheets", "Disable sheets.googleapis.com")
+    // Forms
+    .option("--eforms", "Enable forms.googleapis.com")
+    .option("--dforms", "Disable forms.googleapis.com")
+    // Docs
+    .option("--edocs", "Enable docs.googleapis.com")
+    .option("--ddocs", "Disable docs.googleapis.com")
+    // Gmail
+    .option("--egmail", "Enable gmail.googleapis.com")
+    .option("--dgmail", "Disable gmail.googleapis.com")
+    // Logging
+    .option("--elogging", "Enable logging.googleapis.com")
+    .option("--dlogging", "Disable logging.googleapis.com")
     .action(enableGoogleAPIs);
 
   // --- MCP Command ---

package/src/cli/executor.js

@@ -43,6 +43,29 @@ function generateItemWhitelistScript(items) {
   return `behavior.setIdWhitelist([${whitelistItemsString}]);`;
 }
 
+function generateGmailSandbox(gmailSandbox) {
+  if (!gmailSandbox) return [];
+  const { emailWhitelist, usageLimit, labelWhitelist, cleanup } = gmailSandbox;
+  const temp = ["const gmailSettings = behavior.sandboxService.GmailApp;"];
+  if (emailWhitelist && emailWhitelist.length > 0) {
+    temp.push(
+      `gmailSettings.emailWhitelist = ${JSON.stringify(emailWhitelist)};`
+    );
+  }
+  if (gmailSandbox.hasOwnProperty("cleanup")) {
+    temp.push(`gmailSettings.cleanup = ${cleanup};`);
+  }
+  if (usageLimit) {
+    temp.push(`gmailSettings.usageLimit = ${usageLimit};`);
+  }
+  if (labelWhitelist && labelWhitelist.length > 0) {
+    temp.push(
+      `gmailSettings.labelWhitelist = ${JSON.stringify(labelWhitelist)};`
+    );
+  }
+  return temp;
+}
+
 function generateSandboxSetupScript(sandboxConfig) {
   const script = [
     "const behavior = ScriptApp.__behavior;",
@@ -50,11 +73,12 @@ function generateSandboxSetupScript(sandboxConfig) {
     "behavior.strictSandbox = true;",
   ];
 
-  const { whitelistServices, blacklistServices, whitelistItems } =
+  const { whitelistServices, blacklistServices, whitelistItems, gmailSandbox } =
     sandboxConfig;
 
   script.push(...generateServiceWhitelistScript(whitelistServices));
   script.push(...generateServiceBlacklistScript(blacklistServices));
+  script.push(...generateGmailSandbox(gmailSandbox));
 
   const itemWhitelist = generateItemWhitelistScript(whitelistItems);
   if (itemWhitelist) {

package/src/cli/mcp.js

@@ -157,7 +157,10 @@ function registerDefaultTool(server) {
     if (!args.filename || !args.tools) {
       return {
         content: [
-          { type: "text", text: "Error: `filename` and `tools` are required." },
+          {
+            type: "text",
+            text: "Error: `filename` and `tools` are required.",
+          },
         ],
         isError: true,
       };
@@ -166,11 +169,9 @@ function registerDefaultTool(server) {
     const tool_ar = [];
     for (let i = 0; i < args.tools.length; i++) {
       const { name, schema, gas_script, libraries } = args.tools[i];
-      // Note: This generation logic is complex; assuming gas_library is empty for generation context,
-      // or simply rendering the array strings.
       tool_ar.push(
         `{ name: "${name}", schema: ${schema}, func: (object = {}) => { \n\n${gas_script} }, libraries: ${JSON.stringify(
-          libraries
+          libraries || []
         )} }`
       );
     }

package/src/cli/setup.js

@@ -2,17 +2,26 @@ import prompts from "prompts";
 import dotenv from "dotenv";
 import fs from "fs";
 import path from "path";
+import os from "os";
 import { execSync } from "child_process";
 import { checkForGcloudCli, runCommandSync } from "./utils.js";
 
-// --- Utility: Search .env ---
+// --- Utility Functions ---
+
+/**
+ * Recursively searches for .env files starting from a directory.
+ * @param {string} dir - Start directory
+ * @returns {Promise<string[]>} List of found .env file paths
+ */
 async function findEnvFiles(dir) {
   try {
     const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     const promises = entries.map((entry) => {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        if (entry.name === "node_modules") return Promise.resolve([]);
+        if (entry.name === "node_modules") {
+          return Promise.resolve([]);
+        }
         return findEnvFiles(fullPath);
       } else if (entry.isFile() && entry.name === ".env") {
         return Promise.resolve(fullPath);
@@ -27,7 +36,7 @@ async function findEnvFiles(dir) {
   }
 }
 
-// --- Commands ---
+// --- Exported Command Implementations ---
 
 export async function initializeConfiguration(options = {}) {
   let envPath;
@@ -38,7 +47,10 @@ export async function initializeConfiguration(options = {}) {
   } else {
     const foundFiles = await findEnvFiles(process.cwd());
     if (foundFiles.length > 0) {
-      const choices = foundFiles.map((file) => ({ title: file, value: file }));
+      const choices = foundFiles.map((file) => ({
+        title: file,
+        value: file,
+      }));
       choices.push({
         title: "Create a new .env file in the current directory",
         value: "new",
@@ -56,10 +68,11 @@ export async function initializeConfiguration(options = {}) {
         return;
       }
 
-      envPath =
-        response.envPathSelection === "new"
-          ? path.join(process.cwd(), ".env")
-          : response.envPathSelection;
+      if (response.envPathSelection === "new") {
+        envPath = path.join(process.cwd(), ".env");
+      } else {
+        envPath = response.envPathSelection;
+      }
     } else {
       console.log(
         "No .env file found. A new one will be created in the current directory."
@@ -79,15 +92,18 @@ export async function initializeConfiguration(options = {}) {
 
   console.log("--------------------------------------------------");
   console.log("Configuring .env for gas-fakes");
+  console.log("Press Enter to accept the default value in brackets.");
+  console.log("Use Space to select/deselect scopes.");
   console.log("--------------------------------------------------");
 
   const existingExtraScopes = existingConfig.EXTRA_SCOPES
     ? existingConfig.EXTRA_SCOPES.split(",").filter((s) => s)
     : [];
+
   const responses = {};
 
-  // Stage 1: Basic Info
-  const basicInfoResponses = await prompts([
+  // --- Stage 1: Basic Info ---
+  const basicInfoQuestions = [
     {
       type: "text",
       name: "GCP_PROJECT_ID",
@@ -102,17 +118,26 @@ export async function initializeConfiguration(options = {}) {
         "Enter a test Drive file ID for authentication checks (optional)",
       initial: existingConfig.DRIVE_TEST_FILE_ID || "",
     },
-  ]);
+  ];
 
-  if (typeof basicInfoResponses.GCP_PROJECT_ID === "undefined") return;
+  const basicInfoResponses = await prompts(basicInfoQuestions);
+  if (typeof basicInfoResponses.GCP_PROJECT_ID === "undefined") {
+    console.log("Initialization cancelled.");
+    return;
+  }
   Object.assign(responses, basicInfoResponses);
 
-  // Stage 2: Scopes
+  // --- Stage 2: Scopes ---
+
   const DEFAULT_SCOPES_VALUES = [
     "https://www.googleapis.com/auth/userinfo.email",
     "openid",
     "https://www.googleapis.com/auth/cloud-platform",
   ];
+  console.log(
+    "\nThe following default scopes are required for basic operations and will be enabled automatically:"
+  );
+  DEFAULT_SCOPES_VALUES.forEach((scope) => console.log(`  - ${scope}`));
   responses.DEFAULT_SCOPES = DEFAULT_SCOPES_VALUES;
 
   const extraScopeQuestion = {
@@ -124,7 +149,30 @@ export async function initializeConfiguration(options = {}) {
         title: "Workspace resources",
         value: "https://www.googleapis.com/auth/drive",
       },
+      /*
+      {
+        title: "Sheets (full access)",
+        value: "https://www.googleapis.com/auth/spreadsheets",
+      },
+      {
+        title: "Docs (full access)",
+        value: "https://www.googleapis.com/auth/documents",
+      },
+      {
+        title: "Forms (full access)",
+        value: "https://www.googleapis.com/auth/forms",
+      },
+      {
+        title: "Gmail (send mail)",
+        value: "https://www.googleapis.com/auth/gmail.send",
+      },
+      {
+        title: "Gmail (full access)",
+        value: "https://www.googleapis.com/auth/gmail.modify",
+      },
+      */
       {
+        // actually labels are not sensitive
         title: "Gmail labels",
         value: "https://www.googleapis.com/auth/gmail.labels",
       },
@@ -133,49 +181,130 @@ export async function initializeConfiguration(options = {}) {
         title: "Gmail compose",
         value: "https://www.googleapis.com/auth/gmail.compose",
       },
+      {
+        sensitivity: "sensitive",
+        title: "Gmail modify",
+        value: "https://www.googleapis.com/auth/gmail.modify",
+      },
+      {
+        sensitivity: "sensitive",
+        title: "Gmail send",
+        value: "https://www.googleapis.com/auth/gmail.send",
+      },
     ].map((scope) => ({
       ...scope,
       title: scope.sensitivity
         ? `[${scope.sensitivity}] ${scope.title}`
         : scope.title,
+      // because we always need drive for ant extra scopes
       selected:
         existingExtraScopes.length > 0
           ? existingExtraScopes.includes(scope.value)
           : scope.value === "https://www.googleapis.com/auth/drive",
     })),
+    hint: "- Use space to select/deselect. Press Enter to submit.",
   };
 
+  // Check for any kind of sensitivity
+  const sensitiveScopesList = extraScopeQuestion.choices.filter(
+    (scope) => scope.sensitivity
+  );
+
   const extraScopeResponses = await prompts(extraScopeQuestion);
-  if (typeof extraScopeResponses.EXTRA_SCOPES === "undefined") return;
+
+  if (typeof extraScopeResponses.EXTRA_SCOPES === "undefined") {
+    console.log("Initialization cancelled.");
+    return;
+  }
   Object.assign(responses, extraScopeResponses);
 
-  const clientCredentialResponse = await prompts({
+  const selectedExtraScopes = responses.EXTRA_SCOPES || [];
+
+  const usesSensitiveScopes = sensitiveScopesList.some((s) =>
+    selectedExtraScopes.includes(s.value)
+  );
+
+  if (usesSensitiveScopes) {
+    console.log("\n--------------------------------------------------");
+    console.log(
+      "You have selected sensitive or restricted scopes. Google requires an OAuth client credential file for these."
+    );
+    console.log(
+      "See the getting started guide https://github.com/brucemcpherson/gas-fakes/blob/main/GETTING_STARTED.md for how."
+    );
+    console.log("--------------------------------------------------");
+  }
+
+  const clientCredentialQuestion = {
     type: "text",
     name: "CLIENT_CREDENTIAL_FILE",
-    message: "Enter path to OAuth client credentials JSON (optional)",
+    message: usesSensitiveScopes
+      ? "Enter the path and filename for your OAuth client credentials JSON"
+      : "Enter path to OAuth client credentials JSON (optional)",
     initial: existingConfig.CLIENT_CREDENTIAL_FILE || "",
-  });
+    validate: (input) => {
+      const trimmedInput = input.trim();
+
+      if (usesSensitiveScopes) {
+        if (trimmedInput === "") {
+          return "This field is required for the selected sensitive scopes.";
+        }
+      } else {
+        if (trimmedInput === "") {
+          return true;
+        }
+      }
+
+      const resolvedPath = path.resolve(process.cwd(), trimmedInput);
+      if (!fs.existsSync(resolvedPath)) {
+        return `File not found at '${resolvedPath}'. Please check the path and try again.`;
+      }
+
+      return true;
+    },
+  };
+
+  const clientCredentialResponse = await prompts(clientCredentialQuestion);
+  if (typeof clientCredentialResponse.CLIENT_CREDENTIAL_FILE === "undefined") {
+    console.log("Initialization cancelled.");
+    return;
+  }
   Object.assign(responses, clientCredentialResponse);
 
-  // Stage 3: Remaining Config
-  const remainingResponses = await prompts([
+  // --- Stage 3: Remaining Config ---
+  const defaultScopesDisplay = `\n  - Default: [${responses.DEFAULT_SCOPES.join(
+    ", "
+  )}]`;
+  const extraScopesDisplay =
+    responses.EXTRA_SCOPES && responses.EXTRA_SCOPES.length > 0
+      ? `\n  - Extra:   [${responses.EXTRA_SCOPES.join(", ")}]`
+      : "\n  - Extra:   [None]";
+
+  const remainingQuestions = [
     {
       type: "toggle",
       name: "QUIET",
       message: "Run gas-fakes package in quiet mode",
-      initial: existingConfig.QUIET === "true",
+      initial: existingConfig.QUIET === "true" ? true : false,
     },
     {
       type: "select",
       name: "LOG_DESTINATION",
-      message: "Enter logging destination",
+      message: `Selected Scopes:${defaultScopesDisplay}${extraScopesDisplay}\n\nEnter logging destination`,
       choices: [
         { title: "CONSOLE", value: "CONSOLE" },
         { title: "CLOUD", value: "CLOUD" },
         { title: "BOTH", value: "BOTH" },
         { title: "NONE", value: "NONE" },
       ],
-      initial: 0,
+      initial:
+        ["CONSOLE", "CLOUD", "BOTH", "NONE"].indexOf(
+          existingConfig.LOG_DESTINATION
+        ) > -1
+          ? ["CONSOLE", "CLOUD", "BOTH", "NONE"].indexOf(
+              existingConfig.LOG_DESTINATION
+            )
+          : 0,
     },
     {
       type: "select",
@@ -185,18 +314,31 @@ export async function initializeConfiguration(options = {}) {
         { title: "FILE", value: "FILE" },
         { title: "UPSTASH", value: "UPSTASH" },
       ],
-      initial: 0,
+      initial:
+        ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE?.toUpperCase()) >
+        -1
+          ? ["FILE", "UPSTASH"].indexOf(existingConfig.STORE_TYPE.toUpperCase())
+          : 0,
     },
-  ]);
+  ];
+
+  const remainingResponses = await prompts(remainingQuestions);
+  if (typeof remainingResponses.LOG_DESTINATION === "undefined") {
+    console.log("Initialization cancelled.");
+    return;
+  }
   Object.assign(responses, remainingResponses);
 
-  if (Array.isArray(responses.DEFAULT_SCOPES))
+  // Convert scope arrays to comma-separated strings for saving
+  if (Array.isArray(responses.DEFAULT_SCOPES)) {
     responses.DEFAULT_SCOPES = responses.DEFAULT_SCOPES.join(",");
-  if (Array.isArray(responses.EXTRA_SCOPES))
+  }
+  if (Array.isArray(responses.EXTRA_SCOPES)) {
     responses.EXTRA_SCOPES = responses.EXTRA_SCOPES.join(",");
+  }
 
   if (responses.STORE_TYPE === "UPSTASH") {
-    const upstashResponses = await prompts([
+    const upstashQuestions = [
       {
         type: "text",
         name: "UPSTASH_REDIS_REST_URL",
@@ -209,10 +351,23 @@ export async function initializeConfiguration(options = {}) {
         message: "Enter your Upstash Redis REST Token",
         initial: existingConfig.UPSTASH_REDIS_REST_TOKEN || "",
       },
-    ]);
+    ];
+    const upstashResponses = await prompts(upstashQuestions);
+
+    if (typeof upstashResponses.UPSTASH_REDIS_REST_URL === "undefined") {
+      console.log("Initialization cancelled during Upstash configuration.");
+      return;
+    }
     Object.assign(responses, upstashResponses);
   }
 
+  // --- Confirmation Step ---
+  console.log("\n------------------ Summary ------------------");
+  Object.entries(responses).forEach(([key, value]) => {
+    if (value !== undefined) console.log(`${key}: ${value}`);
+  });
+  console.log("-------------------------------------------");
+
   const confirmSave = await prompts({
     type: "confirm",
     name: "save",
@@ -221,33 +376,51 @@ export async function initializeConfiguration(options = {}) {
   });
 
   if (!confirmSave.save) {
-    console.log("Configuration discarded.");
+    console.log("Configuration discarded. No changes were made.");
     return;
   }
 
+  // --- File Writing Logic ---
+  console.log(`Writing configuration to "${envPath}"...`);
   const inits =
     responses.STORE_TYPE !== "UPSTASH"
       ? { UPSTASH_REDIS_REST_TOKEN: "", UPSTASH_REDIS_REST_URL: "" }
       : {};
   const finalConfig = { ...existingConfig, ...responses, ...inits };
 
+  console.log("\n------------------ Final output ------------------");
   const envContent = Reflect.ownKeys(finalConfig)
-    .map((key) => `${key}="${(finalConfig[key] || "").toString().trim()}"`)
+    .map((key) => {
+      const item = finalConfig[key];
+      const res = `${key}="${(item.toString() || "").trim()}"`;
+      console.log(res);
+      return res;
+    })
     .join("\n");
 
   fs.writeFileSync(envPath, envContent + "\n", "utf8");
+
+  console.log("--------------------------------------------------");
   console.log("Setup complete. Your .env file has been updated.");
+  console.log("--------------------------------------------------");
 }
 
+/**
+ * Handles the 'auth' command to authenticate with Google Cloud.
+ */
 export function authenticateUser() {
+  // First, check if gcloud CLI is available.
   checkForGcloudCli();
-  const envPath = path.join(process.cwd(), ".env");
+
+  const rootDirectory = process.cwd();
+  const envPath = path.join(rootDirectory, ".env");
 
   if (!fs.existsSync(envPath)) {
     console.error(`Error: .env file not found at '${envPath}'`);
     console.error("Please run './gas-fakes.js init' first.");
     process.exit(1);
   }
+
   dotenv.config({ path: envPath, quiet: true });
 
   const {
@@ -263,42 +436,149 @@ export function authenticateUser() {
     process.exit(1);
   }
 
-  let scopes =
+  const defaultScopes =
     DEFAULT_SCOPES ||
     "https://www.googleapis.com/auth/userinfo.email,openid,https://www.googleapis.com/auth/cloud-platform";
-  if (EXTRA_SCOPES && EXTRA_SCOPES.length > 0) {
-    scopes += "," + EXTRA_SCOPES;
+  const extraScopes =
+    EXTRA_SCOPES ||
+    "https://www.googleapis.com/auth/drive,https://www.googleapis.com/auth/spreadsheets";
+
+  let scopes = defaultScopes;
+  if (extraScopes && extraScopes.length > 0) {
+    scopes += (extraScopes.startsWith(",") ? "" : ",") + extraScopes;
   }
 
+  const driveAccessFlag = "--enable-gdrive-access";
+
+  console.log(`...requesting scopes ${scopes}`);
+
   let clientFlag = "";
-  if (CLIENT_CREDENTIAL_FILE && fs.existsSync(CLIENT_CREDENTIAL_FILE)) {
-    clientFlag = `--client-id-file="${CLIENT_CREDENTIAL_FILE}"`;
+  if (CLIENT_CREDENTIAL_FILE) {
+    console.log("...attempting to use enhanced client credentials");
+
+    let clientPath = CLIENT_CREDENTIAL_FILE;
+    if (!path.isAbsolute(clientPath)) {
+      clientPath = path.join(rootDirectory, clientPath);
+    }
+
+    if (fs.existsSync(clientPath)) {
+      clientFlag = `--client-id-file="${clientPath}"`;
+    } else {
+      console.error(
+        `Error: Client credential file specified in .env not found at '${clientPath}'`
+      );
+      process.exit(1);
+    }
+  } else {
+    console.log(
+      "\n...CLIENT_CREDENTIAL_FILE is not set. Using default Application Default Credentials (ADC)."
+    );
+    console.log(
+      "...if you have requested any sensitive scopes, you'll see 'This app is blocked message.'"
+    );
+    console.log(
+      "...To allow them see - https://github.com/brucemcpherson/gas-fakes/blob/main/GETTING_STARTED.md\n"
+    );
   }
 
+  const projectId = GCP_PROJECT_ID;
   const activeConfig = AC || "default";
 
+  console.log("Revoking previous credentials...");
   try {
     execSync("gcloud auth revoke --quiet", { stdio: "ignore" });
-  } catch (e) {}
-
+  } catch (e) {
+    /* ignore */
+  }
   try {
-    runCommandSync(`gcloud config configurations activate "${activeConfig}"`);
+    execSync("gcloud auth application-default revoke --quiet", {
+      stdio: "ignore",
+    });
   } catch (e) {
+    /* ignore */
+  }
+
+  console.log(`Ensuring gcloud configuration '${activeConfig}' exists...`);
+  try {
+    execSync(`gcloud config configurations describe "${activeConfig}"`, {
+      stdio: "ignore",
+    });
+    console.log(`Configuration '${activeConfig}' already exists.`);
+  } catch (error) {
+    console.log(`Configuration '${activeConfig}' not found. Creating it...`);
     runCommandSync(`gcloud config configurations create "${activeConfig}"`);
-    runCommandSync(`gcloud config configurations activate "${activeConfig}"`);
   }
 
-  runCommandSync(`gcloud config set project ${GCP_PROJECT_ID}`);
-  runCommandSync(`gcloud auth login --enable-gdrive-access`);
+  console.log(`Activating gcloud configuration: ${activeConfig}`);
+  runCommandSync(`gcloud config configurations activate "${activeConfig}"`);
+
+  console.log(`Setting project to: ${projectId}`);
+  runCommandSync(`gcloud config set project ${projectId}`);
+  runCommandSync(`gcloud config set billing/quota_project ${projectId}`);
+
+  console.log("Initiating user login...");
+  runCommandSync(`gcloud auth login ${driveAccessFlag}`);
+
+  console.log("Initiating Application Default Credentials (ADC) login...");
   runCommandSync(
     `gcloud auth application-default login --scopes="${scopes}" ${clientFlag}`
   );
+  runCommandSync(
+    `gcloud auth application-default set-quota-project ${projectId}`
+  );
+
+  // --- Verification ---
+  console.log("\nVerifying configuration...");
 
+  const gcloudConfigDir =
+    process.env.CLOUDSDK_CONFIG || path.join(os.homedir(), ".config", "gcloud");
+  const activeConfigPath = path.join(gcloudConfigDir, "active_config");
+
+  let currentConfig = "unknown";
+  if (fs.existsSync(activeConfigPath)) {
+    currentConfig = fs.readFileSync(activeConfigPath, "utf8").trim();
+  } else {
+    console.warn(
+      `Warning: Could not find active_config file at ${activeConfigPath}`
+    );
+  }
+
+  const currentProject = execSync("gcloud config get project")
+    .toString()
+    .trim();
+  console.log(
+    `Active config is ${currentConfig} - project is ${currentProject}`
+  );
+
+  console.log("\nFetching token information...");
+  const userToken = execSync("gcloud auth print-access-token")
+    .toString()
+    .trim();
+  const appDefaultToken = execSync(
+    "gcloud auth application-default print-access-token"
+  )
+    .toString()
+    .trim();
+
+  console.log("\n...user token scopes");
+  runCommandSync(
+    `curl https://www.googleapis.com/oauth2/v3/tokeninfo?access_token=${userToken}`
+  );
+
+  console.log("\n...application default token scopes");
+  runCommandSync(
+    `curl https://www.googleapis.com/oauth2/v3/tokeninfo?access_token=${appDefaultToken}`
+  );
   console.log("\nAuthentication process finished.");
 }
 
+/**
+ * Handles the 'enableAPIs' command to enable or disable necessary Google Cloud services based on options.
+ * @param {object} options Options object provided by commander.js.
+ */
 export function enableGoogleAPIs(options) {
   checkForGcloudCli();
+
   const API_SERVICES = {
     drive: "drive.googleapis.com",
     sheets: "sheets.googleapis.com",
@@ -308,22 +588,45 @@ export function enableGoogleAPIs(options) {
     logging: "logging.googleapis.com",
   };
 
-  const enable = [];
-  const disable = [];
-
+  const servicesToEnable = new Set();
+  const servicesToDisable = new Set();
   if (options.all || Object.keys(options).length === 0) {
-    enable.push(...Object.values(API_SERVICES));
+    Object.values(API_SERVICES).forEach((service) =>
+      servicesToEnable.add(service)
+    );
   } else {
     for (const key in API_SERVICES) {
-      if (options[`e${key}`]) enable.push(API_SERVICES[key]);
-      if (options[`d${key}`]) disable.push(API_SERVICES[key]);
+      if (options[`e${key}`]) {
+        servicesToEnable.add(API_SERVICES[key]);
+      }
+      if (options[`d${key}`]) {
+        servicesToDisable.add(API_SERVICES[key]);
+      }
     }
   }
-
-  if (enable.length > 0) {
-    runCommandSync(`gcloud services enable ${enable.join(" ")}`);
+  if (servicesToEnable.size > 0) {
+    const enableList = Array.from(servicesToEnable);
+    console.log(`Enabling Google Cloud services: ${enableList.join(", ")}...`);
+    runCommandSync(`gcloud services enable ${enableList.join(" ")}`);
+    console.log("Services enabled successfully.");
   }
-  if (disable.length > 0) {
-    runCommandSync(`gcloud services disable ${disable.join(" ")}`);
+  if (servicesToDisable.size > 0) {
+    const disableList = Array.from(servicesToDisable);
+    console.log(
+      `Disabling Google Cloud services: ${disableList.join(", ")}...`
+    );
+    runCommandSync(`gcloud services disable ${disableList.join(" ")}`);
+    console.log("Services disabled successfully.");
+  }
+  if (
+    servicesToEnable.size === 0 &&
+    servicesToDisable.size === 0 &&
+    Object.keys(options).length > 0 &&
+    !options.all
+  ) {
+    console.log("No specific APIs were selected to enable or disable.");
+    console.log(
+      "Use '--all' to enable all default APIs, or specify flags like '--edrive' or '--ddrive'."
+    );
   }
 }

package/src/cli/utils.js

@@ -5,8 +5,8 @@ const require = createRequire(import.meta.url);
 const pjson = require("../../package.json");
 
 export const VERSION = pjson.version;
-export const CLI_VERSION = "0.0.16"; // Kept from original logic
-export const MCP_VERSION = "0.0.6";
+export const CLI_VERSION = "0.0.18"; // Kept from original logic
+export const MCP_VERSION = "0.0.7";
 
 /**
  * Replaces escaped newline characters ('\\n') with actual newlines,

package/src/index.js

@@ -24,5 +24,6 @@ import './services/formapp/app.js'
 import './services/slidesapp/app.js'
 import './services/mimetype/app.js'
 import './services/lock/app.js'
+import './services/libhandlerapp/app.js'
 // should be last
 import './services/stores/app.js'

package/src/services/advdrive/fakeadvdrivefiles.js

@@ -64,6 +64,7 @@ class FakeAdvDriveFiles {
   }
 
   /**
+   * TODO implement the correct download method
    * this is fairly pointless in apps script as it returns an operation, and Drive.Operations are not supported
    * TODO - look into what actually happens to the operation - it may be possible to do something with it using the operations ap directly
    * for the moment we'll just return a fake operation that looks like adv returns
@@ -193,48 +194,24 @@ class FakeAdvDriveFiles {
 
   }
 
-  export() {
-    return notYetImplemented()
-  }
-
-}
+  export(fileId, mimeType) {
 
+    if (!is.nonEmptyString(fileId)) {
+      throw new Error(`API call to drive.files.export failed with error: Required`)
+    }
+    ScriptApp.__behavior.isAccessible(fileId, 'Drive', 'read');
+    const params = {
+      id: fileId,
+      mimeType,
+    }
 
-/**
- * tidy up a fields parameter
- * @param {object} p
- * @param {string} [p.fields=minFields] which fields to get
- * @return {string[]} an array of the fields required merged with the minimum fields required to support caching
- */
-const tidyFieldsFar = ({ fields = "" } = {}, mf = minFields) => {
-  if (!is.string(fields)) {
-    throw new Error(`invalid fields definition`, fields)
+    const { response, data } = Syncit.fxDriveExport(params)
+    return data
+    
   }
 
-  return Array.from(
-    new Set((mf.split(",").concat(fields.split(","))
-      .map(f => f.replace(/\s/g, ""))
-      .filter(f => f)))
-      .keys()
-  )
-}
-
-
-/**
- * enhance the array of required fields by adding any propertyies already in cache
- * @param {object} p
- * @param {File} p.cachedFile meta data
- * @returns {string} an enhanced fields as a string with the dedupped fields already in cache
- */
-const enhanceFar = ({ cachedFile, far }) => {
-  // we'll enhance the cache with the current value of any already fetched key by fetching it again
-  far = cachedFile ? Array.from(new Set(far.concat(Reflect.ownKeys(cachedFile))).keys()) : far
-
-  // now construct an appropriate fields arg
-  return far.join(",")
 }
 
-
   /**
    * ceate/patch a file and optionally upload some data
    * update and copy are virtually the same payload

package/src/services/libhandlerapp/app.js

@@ -0,0 +1,9 @@
+/**
+ * the idea here is to create an empty global entry for the singleton
+ * but only load it when it is actually used.
+ */
+import { newFakeLibHandlerApp as maker} from './fakelibhandlerapp.js';
+import { lazyLoaderApp } from '../common/lazyloader.js'
+
+let _app = null;
+_app = lazyLoaderApp(_app, 'LibHandlerApp', maker)

package/src/services/libhandlerapp/fakelibhandler.js

@@ -0,0 +1,39 @@
+import { Proxies } from '../../support/proxies.js';
+import { Auth } from '../../support/auth.js';
+import { newFakeLibrary } from './fakelibrary.js';
+export const newFakeLibHandler = (...args) => {
+  return Proxies.guard(new FakeLibHandler(...args));
+};
+
+// to keep the same pattern as other apps script services, we'll use the worker to async/sync
+// the starting point is the current manifest (or another manifest if specified)
+class FakeLibHandler {
+  constructor(manifest) {
+    this.__manifest = manifest
+    if (!this.__manifest) {
+      console.warn ('...manifest not found in auth and not provided - no libraries will be loaded');
+    }
+  }
+
+  get manifest() {
+    return this.__manifest;
+  }
+  get dependencies() {
+    return this.__manifest.dependencies;
+  }
+  get libraries() {
+    return this.dependencies?.libraries;
+  }
+  get enabledAdvancedServices() {
+    return this.dependencies?.enabledAdvancedServices;
+  }
+
+  fetchLibraries() {
+    const libs =  this.dependencies?.libraries.map(newFakeLibrary);
+    return libs
+  }
+
+  toString() {
+    return 'LibHandler';
+  }
+}

package/src/services/libhandlerapp/fakelibhandlerapp.js

@@ -0,0 +1,54 @@
+import { Proxies } from '../../support/proxies.js';
+import { Auth } from '../../support/auth.js';
+import { newFakeLibHandler } from './fakelibhandler.js';
+
+export const newFakeLibHandlerApp = (...args) => {
+  return Proxies.guard(new FakeLibHandlerApp(...args));
+};
+
+// we ned to be able to handle multiple recursive libraries
+// the default source will be the current manifest
+// for now we only sipport the HEAD version of libraries
+class FakeLibHandlerApp {
+  constructor() {
+    this.__libMap = new Map()
+  }
+
+  get libMap() {
+    return this.__libMap
+  }
+
+
+  load(manifest) {
+    manifest = manifest || Auth.getManifest();
+    if (!manifest) {
+      throw new Error('manifest not found in auth and not provided');
+    }
+    this.__libMap = new Map()
+
+    const recurseManifests = (manifest) => {
+      const libs = newFakeLibHandler(manifest).fetchLibraries();
+      libs.forEach((lib) => {
+        if (!this.libMap.has(lib.libraryId)) {
+          this.libMap.set(lib.libraryId, lib);
+          console.log(`...loading ${lib.libraryId} - ${lib.userSymbol}`)
+          if (lib.libraries) {
+            recurseManifests(lib.manifest)
+          }
+        }
+      })
+    }
+    recurseManifests(manifest)
+    
+    this.libMap.forEach((lib) => {
+      lib.inject()
+    })
+    return this
+  }
+
+
+  toString() {
+    return 'LibHandlerApp';
+  }
+
+}

package/src/services/libhandlerapp/fakelibrary.js

@@ -0,0 +1,117 @@
+import { Proxies } from '../../support/proxies.js';
+import { parse } from 'acorn';
+
+export const newFakeLibrary = (...args) => {
+  return Proxies.guard(new FakeLibrary(...args));
+};
+
+// to keep the same pattern as other apps script services, we'll use the worker to async/sync
+// the starting point is the current manifest (or another manifest if specified)
+class FakeLibrary {
+  constructor(libraryOb) {
+    this.__libraryOb = libraryOb;
+    if (!this.__libraryOb) {
+      throw new Error('library not provided');
+    }
+    this.__content = null;
+    this.__libContent = null;
+    this.__manifest = null;
+  }
+  get libraryOb() {
+    return this.__libraryOb;
+  }
+  get version() {
+    return this.__libraryOb.version;
+  }
+  get userSymbol() {
+    return this.__libraryOb.userSymbol;
+  }
+  get libraryId() {
+    if (!this.__libraryOb.libraryId) {
+      throw new Error(`libraryId not found in library ${JSON.stringify(this.__libraryOb)}`);
+    }
+    return this.__libraryOb.libraryId;
+  }
+  get libContent() {
+    if (!this.__libContent) {
+      this.__allowSandboxAccess();
+      const data = Drive.Files.export(
+        this.libraryId,
+        'application/vnd.google-apps.script+json',
+      );
+      if (!data) {
+        throw new Error(`Library ${this.libraryId} not found`);
+      }
+      this.__libContent = JSON.parse(Utilities.newBlob(data).getDataAsString())
+    }
+    return this.__libContent
+  }
+  __allowSandboxAccess() {
+    if (ScriptApp.__behavior?.sandboxMode) {
+      ScriptApp.__behavior.addWhitelistedFile(this.libraryId);
+    }
+  }
+
+  get combinedJs() {
+    return this.libContent.files.filter((f) => f.type === 'server_js').map((f) => `////-- ${f.name} --\n${f.source}`).join(`\n\n`)
+  }
+
+  get content() {
+    if (!this.__content) {
+      const libContent = this.libContent;
+      this.__content = {
+        ...this.__libraryOb,
+        ...libContent,
+        serverJs: this.serverJs,
+        manifest: this.manifest,
+        libraries: this.libraries,
+        combinedJs: this.combinedJs
+      }
+    }
+    return this.__content
+  }
+  get wrapper() {
+    const ast = parse(this.combinedJs, {
+      ecmaVersion: 'latest',
+      sourceType: 'script',
+      allowReserved: true
+    });
+    const getBody = (ast, type) => {
+      return (ast.type === 'Program' ? ast.body.filter(f => f.type === type) : [])
+    }
+    const makeExports = (ast, type, accessor) => getBody(ast, type).map((f) => accessor(f))
+    const functions = makeExports(ast, 'FunctionDeclaration', (f) => f.id.name)
+    const variables = makeExports(ast, 'VariableDeclaration', (f) => f.declarations[0].id.name)
+    const classes = makeExports(ast, 'ClassDeclaration', (f) => f.id.name)
+    const exports = [...functions, ...variables, ...classes];
+    return `${this.combinedJs};\nreturn { ${exports.join(', ')} };`;
+  }
+
+  inject() {
+    if (!this.wrapper) {
+      throw new Error('wrapper not loaded');
+    }
+    globalThis[this.userSymbol] = (new Function(this.wrapper))()
+    return this
+  }
+
+  get manifest() {
+    if (!this.__manifest) {
+      const t = this.libContent?.files?.find((f) => f.type === 'json' && f.name === 'appsscript')
+      if (!t) {
+        throw new Error(`manifest not found in library ${this.libraryId}`)
+      }
+      this.__manifest = JSON.parse(t.source)
+    }
+    return this.__manifest
+  }
+  get serverJs() {
+    return this.libContent?.files?.filter((f) => f.type === 'server_js')
+  }
+  get libraries() {
+    return this.manifest?.dependencies?.libraries || null;
+  }
+  toString() {
+    return 'Library';
+  }
+}

package/src/services/scriptapp/behavior.js

@@ -348,7 +348,7 @@ class FakeBehavior {
     return id
   }
   isAccessible(id, serviceName, accessType = 'read') {
-    if (!is.nonEmptyString(id)) {
+    if (this.sandboxMode && !is.nonEmptyString(id)) {
       throw new Error(`Invalid sandbox id parameter (${id}) - must be a non-empty string`);
     }
 

package/src/support/sxdrive.js

@@ -139,25 +139,17 @@ export const sxStreamUpMedia = async (Auth, { resource, bytes, fields, method, m
   }
 
 }
-
-/**
- * sync a call to download data from drive
- * @param {object} p pargs
- * @param {string} p.id file id
- * @return {SxResult} from the api
- */
-export const sxDriveMedia = async (Auth, { id }) => {
-
+const sxStreamer = async ({
+  params,
+  options = {},
+  method = 'get' }) => {
   // this is the node drive service
   const drive = getDriveApiClient();
-  const streamed = await drive.files.get({
-    fileId: id,
-    alt: 'media'
-  }, {
-    responseType: 'stream'
+  const streamed = await drive.files[method](params, {
+    responseType: 'stream',
+    ...options
   })
   const response = responseSyncify(streamed)
-
   if (response.status === 200) {
     const buf = await getStreamAsBuffer(streamed.data)
     const data = Array.from(buf)
@@ -172,9 +164,37 @@ export const sxDriveMedia = async (Auth, { id }) => {
       response
     }
   }
+}
+/**
+ * sync a call to export data from drive
+ * @param {object} p pargs
+ * @param {string} p.id file id
+ * @return {SxResult} from the api
+ */
+export const sxDriveExport = async (_, { id: fileId, mimeType }) => {
+
+  return sxStreamer({ params: {
+    fileId,
+    mimeType
+  }, method: 'export' })
+
+}
+/**
+ * sync a call to download data from drive
+ * @param {object} p pargs
+ * @param {string} p.id file id
+ * @return {SxResult} from the api
+ */
+export const sxDriveMedia = async (_, { id: fileId }) => {
+
+  return sxStreamer({params: {
+    fileId,
+    alt: 'media'
+  }, method: 'get' })
 
 }
 
+
 export const sxDriveGet = (Auth, { id, params, options }) => {
   return sxDrive(Auth, {
     prop: "files",

package/src/support/syncit.js

@@ -333,6 +333,23 @@ const fxDriveMedia = ({ id }) => {
     id,
   });
 };
+/**
+ * sync a call to Drive api to stream a download
+ * @param {object} p pargs
+ * @param {string} p.prop the prop of drive eg 'files' for drive.files
+ * @param {string} p.method the method of drive eg 'list' for drive.files.list
+ * @param {object} p.params the params to add to the request
+ * @return {DriveResponse} from the drive api
+ */
+const fxDriveExport = ({ id, mimeType , options ={alt: 'media'}}) => {
+  // see issue https://issuetracker.google.com/issues/468534237
+  // live apps script failes without this alt option
+  return callSync("sxDriveExport", {
+    id,
+    mimeType,
+    options
+  });
+};
 
 /**
  * a sync version of fetching
@@ -399,5 +416,5 @@ export const Syncit = {
   fxDocs,
   fxForms,
   fxGmail,
-  // fxGetImagesFromXlsx
-};
+  fxDriveExport
+}

package/testlib.sh

@@ -1 +1,2 @@
-node gas-fakes -l bmFiddler@13EWG4-lPrEf34itxQhAQ7b9JEbmCBfO8uE4Mhr99CHi3Pw65oxXtq-rU -s "const sheet=SpreadsheetApp.openById('1h9IGIShgVBVUrUjjawk5MaCEQte_7t32XeEP1Z5jXKQ').getSheets()[0];const fiddler = new bmFiddler.Fiddler(sheet);console.log (fiddler.getData().slice(0, 5));"
+gas-fakes -l bmFiddler@13EWG4-lPrEf34itxQhAQ7b9JEbmCBfO8uE4Mhr99CHi3Pw65oxXtq-rU \
+-s "const sheet=SpreadsheetApp.openById('1h9IGIShgVBVUrUjjawk5MaCEQte_7t32XeEP1Z5jXKQ').getSheets()[0];const fiddler = new bmFiddler.Fiddler(sheet);console.log (fiddler.getData().slice(0, 5));"