@mcpher/gas-fakes 2.3.10 → 2.3.13

package/README.md

@@ -35,7 +35,7 @@ Now you can run apps script code directly from your console - for example
 gas-fakes  -s "const files=DriveApp.getRootFolder().searchFiles('title contains \"Untitled\"');while (files.hasNext()) {console.log(files.next().getName())};" 
 ```
 
-For details see [gas fakes cli](gas-fakes-cli.md)
+For details see [gas fakes cli](notes/gas-fakes-cli.md)
 
 ### Configuration
 
@@ -168,7 +168,7 @@ There are a couple of syntactical differences between Node and Apps Script. Not
 // this required on Node but not on Apps Script
 if (ScriptApp.isFake) testFakes()
 ````
-For inspiration on pushing modified files to the IDE, see the togas.sh bash script I use for the test suite. There's also a complete push pull workflow available - see - [push test pull](pull-test-push.md)
+For inspiration on pushing modified files to the IDE, see the togas.sh bash script I use for the test suite. There's also a complete push pull workflow available - see - [push test pull](notes/pull-test-push.md)
 
 
 ## Help
@@ -188,11 +188,11 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [readme](README.md)
 - [Natural Language Automation with Gemini Skills & MCP Server](gemini-skills-mcp.md) - new skills-based agent approach.
 - [gf_agent documentation](../gf_agent/README.md) - instructions for the Gemini CLI automation agent and MCP server.
-- [gas fakes cli](gas-fakes-cli.md)
+- [gas fakes cli](notes/gas-fakes-cli.md)
 - [github actions using adc](https://github.com/brucemcpherson/gas-fakes-actions-adc)
 - [github actions using dwd and wif](https://github.com/brucemcpherson/gas-fakes-actions-dwd)
-- [ksuite as a back end](ksuite_poc.md)
-- [msgraph as a back end](msgraph.md)
+- [ksuite as a back end](notes/ksuite_poc.md)
+- [msgraph as a back end](notes/msgraph.md)
 - [resurrecting scriptDb repo](https://github.com/brucemcpherson/scriptdb-redux)
 - [Resurrecting ScriptDb – nosql database for Apps Script](https://ramblings.mcpher.com/resurrecting-scriptdb-nosql-database-for-apps-script/)
 - [gas-fakes in serverless containers](https://docs.google.com/presentation/d/1JlXF9T--DD4ERHopyP3WyAMhjRCxxHblgCP5ynxaJ3k/edit?usp=sharing)
@@ -203,7 +203,7 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [running gas-fakes on Amazon AWS lambda](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Azure ACA](https://github.com/brucemcpherson/gas-fakes-containers)
 - [running gas-fakes on Github actions](https://github.com/brucemcpherson/gas-fakes-containers)
-- [jdbc notes](jdbc-notes.md)
+- [jdbc notes](notes/jdbc-notes.md)
 - [Yes – you can run native apps script code on Azure ACA as well!](https://ramblings.mcpher.com/yes-you-can-run-native-apps-script-code-on-azure-aca-as-well/)
 - [Yes – you can run native apps script code on AWS Lambda!](https://ramblings.mcpher.com/apps-script-on-aws-lambda/)
 - [initial idea and thoughts](https://ramblings.mcpher.com/a-proof-of-concept-implementation-of-apps-script-environment-on-node/)
@@ -213,16 +213,16 @@ As I mentioned earlier, to take this further, I'm going to need a lot of help to
 - [Turning async into synch on Node using workers](https://ramblings.mcpher.com/turning-async-into-synch-on-node-using-workers/)
 - [All about Apps Script Enums and how to fake them](https://ramblings.mcpher.com/all-about-apps-script-enums-and-how-to-fake-them/)
 - [colaborators](collaborators.md) - additional information for collaborators
-- [oddities](oddities.md) - a collection of oddities uncovered during this project
-- [named colors](named-colors.md)
-- [sandbox](sandbox.md)
-- [senstive scopes](workspace_scopes.md)
-- [using apps script libraries with gas-fakes](libraries.md)
+- [oddities](notes/oddities.md) - a collection of oddities uncovered during this project
+- [named colors](notes/named-colors.md)
+- [sandbox](notes/sandbox.md)
+- [senstive scopes](notes/workspace_scopes.md)
+- [using apps script libraries with gas-fakes](notes/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)
-- [Workspace scopes with local authentication](workspace_scopes.md)
-- [push test pull](pull-test-push.md)
+- [named range identity](notes/named-range-identity.md)
+- [Workspace scopes with local authentication](notes/workspace_scopes.md)
+- [push test pull](notes/pull-test-push.md)
 - [sharing cache and properties between gas-fakes and live apps script](https://ramblings.mcpher.com/sharing-cache-and-properties-between-gas-fakes-and-live-apps-script/)
 - [gas-fakes-cli now has built in mcp server and gemini extension](https://ramblings.mcpher.com/gas-fakes-cli-now-has-built-in-mcp-server-and-gemini-extension/)
 - [gas-fakes CLI: Run apps script code directly from your terminal](https://ramblings.mcpher.com/gas-fakes-cli-run-apps-script-code-directly-from-your-terminal/)

package/gas-fakes.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+process.env.GF_CLI_INTERACTIVE = "true";
 import { main } from "./src/cli/app.js";
 
 main().catch((error) => {

package/gf_agent/scripts/builder.js

@@ -56,7 +56,32 @@ async function build() {
   }
 
   await fs.writeFile(INDEX_FILE, masterIndex);
-  console.log('Build complete! Skills and Index generated.');
+  
+  // Aggregate knowledge files into SKILL.md
+  const TEMPLATE_FILE = './gf_agent/scripts/SKILL.template.md';
+  const KNOWLEDGE_DIR = './gf_agent/knowledge';
+  const SKILL_OUTPUT = './gf_agent/SKILL.md';
+  
+  let skillMarkdown = await fs.readFile(TEMPLATE_FILE, 'utf-8');
+  
+  try {
+    const knowledgeFiles = await fs.readdir(KNOWLEDGE_DIR);
+    // Sort files to ensure deterministic aggregation (e.g., 01-drive.md, 02-syntax.md)
+    knowledgeFiles.sort();
+    
+    for (const kFile of knowledgeFiles) {
+      if (kFile.endsWith('.md')) {
+        const kContent = await fs.readFile(path.join(KNOWLEDGE_DIR, kFile), 'utf-8');
+        skillMarkdown += `\n${kContent}\n`;
+      }
+    }
+  } catch (err) {
+    console.log("No knowledge directory found or error reading it:", err.message);
+  }
+
+  await fs.writeFile(SKILL_OUTPUT, skillMarkdown);
+
+  console.log('Build complete! Skills, Index, and monolithic SKILL.md generated.');
 }
 
 build().catch(console.error);

package/package.json

@@ -40,7 +40,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.3.10",
+  "version": "2.3.13",
   "license": "MIT",
   "main": "main.js",
   "description": "An implementation of the Google Workspace Apps Script runtime: Run native App Script Code on Node and Cloud Run",

package/src/cli/lib-manager.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import { parse } from "acorn";
-import { Auth } from "../support/auth.js"; // Relative to gas-fakes-cli directory
+import { Auth, _identities } from "../support/auth.js"; // Relative to gas-fakes-cli directory
 import { checkForGcloudCli, spawnCommand } from "./utils.js";
 
 async function getAccessToken(pattern) {
@@ -8,12 +8,22 @@ async function getAccessToken(pattern) {
     // Authorization pattern 1
     // We use cloud-platform as it provides sufficient access for Drive API fetching
     // while avoiding the 'well-known client ID' block that targets Workspace scopes like drive.readonly.
-    const auth = await Auth.setAuth(
+    const client = await Auth.setAuth(
       ["https://www.googleapis.com/auth/cloud-platform"],
       true
     );
-    auth.cachedCredential = null;
-    return await auth.getAccessToken();
+    if (client.cachedCredential !== undefined) {
+       client.cachedCredential = null;
+    }
+    const tokenResponse = await client.getAccessToken();
+    const token = tokenResponse.token || tokenResponse; 
+
+    // CRITICAL: We MUST clear the global identities map so that this temporary
+    // library-fetching auth does not trick the downstream executor.js and syncit.js 
+    // into thinking the full environment (and the background worker) has been initialized.
+    _identities.clear();
+
+    return token;
   } else {
     // Authorization pattern 2
     await checkForGcloudCli();

package/src/cli/setup.js

@@ -622,9 +622,22 @@ export async function initializeConfiguration(options = {}) {
 
   if (skillResponse.installSkills) {
     console.log("Installing Gemini CLI skills and MCP server...");
+    let manualSkillCmd;
     try {
-      // 1. Install the agent skill
-      const skillCmd = "gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent";
+      // 1. Install or link the agent skill
+      let skillCmd;
+      const localSkillPath = path.resolve(process.cwd(), "gf_agent", "SKILL.md");
+      const isLocalClone = fs.existsSync(localSkillPath);
+
+      if (isLocalClone) {
+        console.log("Detected local gas-fakes repository. Linking local skill for development...");
+        skillCmd = "gemini skills link ./gf_agent";
+        manualSkillCmd = "1. gemini skills link ./gf_agent";
+      } else {
+        skillCmd = "gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent";
+        manualSkillCmd = "1. gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent";
+      }
+
       console.log(`Executing: ${skillCmd}`);
       execSync(skillCmd, { stdio: "inherit" });
 
@@ -635,11 +648,11 @@ export async function initializeConfiguration(options = {}) {
 
       console.log("\x1b[1;32mInstallation complete!\x1b[0m");
       console.log("\nYou can now use natural language to automate tasks:");
-      console.log("   \x1b[1;33m\"Create a spreadsheet of my recent Drive files\"\x1b[0m");
+      console.log("   \x1b[1;33m\“Create a sheet called ‘Todays drive files' and add any files on Drive modified today to it\"\x1b[0m");
     } catch (err) {
       console.error(`\x1b[1;31mError during Gemini installation: ${err.message}\x1b[0m`);
       console.log("You may need to install them manually:");
-      console.log("1. gemini skills install https://github.com/brucemcpherson/gas-fakes.git --path gf_agent");
+      console.log(manualSkillCmd);
       console.log("2. gemini mcp add --scope project gas-fakes-mcp gas-fakes mcp");
     }
   } else {

package/src/services/chartsapp/fakechartsapp.js

@@ -19,7 +19,12 @@ export const newFakeChartsApp = (...args) => {
 export class FakeChartsApp {
   constructor() {
     const enumProps = [
-      "ChartType", //	ChartType	An enumeration of the possible chart types.
+      "ChartType", //   ChartType       An enumeration of the possible chart types.
+      "ChartHiddenDimensionStrategy",
+      "ChartMergeStrategy",
+      "CurveStyle",
+      "PointStyle",
+      "Position"
     ];
 
     // import all known enums as props of chartsapp

package/src/services/documentapp/elementhelpers.js

@@ -286,3 +286,30 @@ export const updateParagraphStyle = (element, paragraphStyle, fields) => {
   shadow.refresh();
   return element;
 };
+
+/**
+ * Updates the text style for a given element or range within it.
+ * @param {import('./fakeelement.js').FakeElement} element The element whose text style to update.
+ * @param {GoogleAppsScript.Document.TextStyle} textStyle The style object to apply.
+ * @param {string} fields The comma-separated string of field names to update.
+ * @param {object} [range] Optional specific range. Defaults to the element's range.
+ * @returns {import('./fakeelement.js').FakeElement} The element, for chaining.
+ */
+export const updateTextStyle = (element, textStyle, fields, range = null) => {
+  const shadow = element.shadowDocument;
+  const item = element.__elementMapItem;
+  const updateRange = range || {
+    startIndex: item.startIndex,
+    endIndex: item.endIndex,
+    segmentId: shadow.__segmentId,
+    tabId: shadow.__tabId,
+  };
+
+  const requests = [{
+    updateTextStyle: { range: updateRange, textStyle, fields },
+  }];
+
+  Docs.Documents.batchUpdate({ requests }, shadow.getId());
+  shadow.refresh();
+  return element;
+};

package/src/services/documentapp/fakeelement.js

@@ -96,6 +96,14 @@ export class FakeElement {
       });
     }
 
+  /**
+   * Gets the shadow document manager associated with this element's structure.
+   * @type {import('./shadowdocument.js').ShadowDocument | null}
+   */
+  get shadowDocument() {
+    return this.__shadowDocument;
+  }
+
   get __structure() {
     if (this.__isDetached) return null;
     return this.__shadowDocument.structure;

package/src/services/documentapp/fakeparagraph.js

@@ -4,6 +4,7 @@ import { Utils } from '../../support/utils.js';
 import { imageOptions } from './elementoptions.js';
 import { FakeContainerElement } from './fakecontainerelement.js';
 import { registerElement } from './elementRegistry.js';
+import { newFakeText } from './faketext.js';
 import { appendText, addPositionedImage, appendImage, insertImage } from './appenderhelpers.js';
 import { getText as getTextHelper, getAttributes as getAttributesHelper, updateParagraphStyle } from './elementhelpers.js';
 
@@ -32,6 +33,19 @@ export class FakeParagraph extends FakeContainerElement {
     return getTextHelper(this);
   }
 
+  /**
+   * Returns the contents of the paragraph as a Text element.
+   * @returns {GoogleAppsScript.Document.Text} The text element.
+   */
+  editAsText() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.editAsText');
+    if (nargs !== 0) matchThrow();
+    // In gas-fakes, we can return a FakeText that points to the same underlying item.
+    // The getText and updateTextStyle methods will work correctly because they
+    // handle both PARAGRAPH and TEXT items or ranges.
+    return newFakeText(this.__shadowDocument, this.__name);
+  }
+
   appendText(text) {
     const { nargs, matchThrow } = signatureArgs(arguments, 'Paragraph.appendText');
     if (nargs !== 1) matchThrow();

package/src/services/documentapp/faketext.js

@@ -1,9 +1,15 @@
 import { Proxies } from '../../support/proxies.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
 import { FakeElement } from './fakeelement.js';
 import { registerElement } from './elementRegistry.js';
+import { getAttributes as getAttributesHelper, updateTextStyle, getText as getTextHelper } from './elementhelpers.js';
+
+const { is } = Utils;
 
 /**
  * A fake implementation of the Text class for DocumentApp.
+ * @implements {GoogleAppsScript.Document.Text}
  * @see https://developers.google.com/apps-script/reference/document/text
  */
 class FakeText extends FakeElement {
@@ -16,9 +22,173 @@ class FakeText extends FakeElement {
    * @returns {string} The text contents.
    */
   getText() {
-    const item = this.__elementMapItem;
-    // A Text element corresponds to a textRun in the API.
-    return item.textRun?.content || '';
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getText');
+    if (nargs !== 0) matchThrow();
+    return getTextHelper(this);
+  }
+
+  getAttributes() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getAttributes');
+    if (nargs !== 0) matchThrow();
+    return getAttributesHelper(this);
+  }
+
+  setAttributes(attributes) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setAttributes');
+    if (nargs !== 1 || !is.object(attributes)) matchThrow();
+
+    const textStyle = {};
+    const textFields = [];
+    const Attribute = DocumentApp.Attribute;
+
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+
+    for (const key in attributes) {
+      const value = attributes[key];
+      // Note: GAS allows null to clear some attributes, but let's handle the basics first.
+      switch (String(key)) {
+        case String(Attribute.BACKGROUND_COLOR): textStyle.backgroundColor = { color: { rgbColor: colorToRgb(value) } }; textFields.push('backgroundColor'); break;
+        case String(Attribute.BOLD): textStyle.bold = value; textFields.push('bold'); break;
+        case String(Attribute.FONT_FAMILY): textStyle.weightedFontFamily = { fontFamily: value }; textFields.push('weightedFontFamily'); break;
+        case String(Attribute.FONT_SIZE): textStyle.fontSize = { magnitude: value, unit: 'PT' }; textFields.push('fontSize'); break;
+        case String(Attribute.FOREGROUND_COLOR): textStyle.foregroundColor = { color: { rgbColor: colorToRgb(value) } }; textFields.push('foregroundColor'); break;
+        case String(Attribute.ITALIC): textStyle.italic = value; textFields.push('italic'); break;
+        case String(Attribute.LINK_URL): textStyle.link = { url: value }; textFields.push('link'); break;
+        case String(Attribute.STRIKETHROUGH): textStyle.strikethrough = value; textFields.push('strikethrough'); break;
+        case String(Attribute.UNDERLINE): textStyle.underline = value; textFields.push('underline'); break;
+      }
+    }
+
+    if (textFields.length === 0) return this;
+    return updateTextStyle(this, textStyle, textFields.join(','));
+  }
+
+  setBold(bold) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setBold');
+    if (nargs !== 1 || !is.boolean(bold)) matchThrow();
+    return updateTextStyle(this, { bold }, 'bold');
+  }
+
+  isBold() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isBold');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.BOLD];
+  }
+
+  setItalic(italic) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setItalic');
+    if (nargs !== 1 || !is.boolean(italic)) matchThrow();
+    return updateTextStyle(this, { italic }, 'italic');
+  }
+
+  isItalic() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isItalic');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.ITALIC];
+  }
+
+  setUnderline(underline) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setUnderline');
+    if (nargs !== 1 || !is.boolean(underline)) matchThrow();
+    return updateTextStyle(this, { underline }, 'underline');
+  }
+
+  isUnderline() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isUnderline');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.UNDERLINE];
+  }
+
+  setFontFamily(fontFamily) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setFontFamily');
+    if (nargs !== 1 || !is.string(fontFamily)) matchThrow();
+    return updateTextStyle(this, { weightedFontFamily: { fontFamily } }, 'weightedFontFamily');
+  }
+
+  getFontFamily() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getFontFamily');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FONT_FAMILY];
+  }
+
+  setFontSize(fontSize) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setFontSize');
+    if (nargs !== 1 || !is.number(fontSize)) matchThrow();
+    return updateTextStyle(this, { fontSize: { magnitude: fontSize, unit: 'PT' } }, 'fontSize');
+  }
+
+  getFontSize() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getFontSize');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FONT_SIZE];
+  }
+
+  setForegroundColor(color) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setForegroundColor');
+    if (nargs !== 1 || !is.string(color)) matchThrow();
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+    return updateTextStyle(this, { foregroundColor: { color: { rgbColor: colorToRgb(color) } } }, 'foregroundColor');
+  }
+
+  getForegroundColor() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getForegroundColor');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.FOREGROUND_COLOR];
+  }
+
+  setBackgroundColor(color) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setBackgroundColor');
+    if (nargs !== 1 || !is.string(color)) matchThrow();
+    const colorToRgb = (hex) => {
+      if (!hex || !hex.startsWith('#') || hex.length !== 7) return null;
+      const r = parseInt(hex.slice(1, 3), 16) / 255;
+      const g = parseInt(hex.slice(3, 5), 16) / 255;
+      const b = parseInt(hex.slice(5, 7), 16) / 255;
+      return { red: r, green: g, blue: b };
+    };
+    return updateTextStyle(this, { backgroundColor: { color: { rgbColor: colorToRgb(color) } } }, 'backgroundColor');
+  }
+
+  getBackgroundColor() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getBackgroundColor');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.BACKGROUND_COLOR];
+  }
+
+  setLinkUrl(url) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setLinkUrl');
+    if (nargs !== 1 || (!is.string(url) && !is.null(url))) matchThrow();
+    return updateTextStyle(this, { link: { url: url } }, 'link');
+  }
+
+  getLinkUrl() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.getLinkUrl');
+    if (nargs !== 0) matchThrow();
+    return this.getAttributes()[DocumentApp.Attribute.LINK_URL];
+  }
+
+  setStrikethrough(strikethrough) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.setStrikethrough');
+    if (nargs !== 1 || !is.boolean(strikethrough)) matchThrow();
+    return updateTextStyle(this, { strikethrough }, 'strikethrough');
+  }
+
+  isStrikethrough() {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'Text.isStrikethrough');
+    if (nargs !== 0) matchThrow();
+    return !!this.getAttributes()[DocumentApp.Attribute.STRIKETHROUGH];
   }
 
   toString() {
@@ -28,4 +198,4 @@ class FakeText extends FakeElement {
 
 export const newFakeText = (...args) => Proxies.guard(new FakeText(...args));
 
-registerElement('TEXT', newFakeText);
+registerElement('TEXT', newFakeText);

package/src/services/driveapp/driveiterators.js

@@ -14,14 +14,33 @@ export const getFilesIterator = ({
   qob,
   parentId = null,
   folderTypes,
-  fileTypes
+  fileTypes,
+  token
 }) => {
 
 
   // parentId can be null to search everywhere
   if (!is.null(parentId)) assert.nonEmptyString(parentId)
-  assert.boolean(folderTypes)
-  assert.boolean(fileTypes)
+  assert.boolean(folderTypes || !!token)
+  assert.boolean(fileTypes || !!token)
+
+  let state = {
+    qob,
+    parentId,
+    folderTypes,
+    fileTypes,
+    pageToken: null,
+    tank: []
+  }
+
+  if (token) {
+    const saved = JSON.parse(Buffer.from(token, 'base64').toString())
+    state = { ...state, ...saved }
+    qob = state.qob
+    parentId = state.parentId
+    folderTypes = state.folderTypes
+    fileTypes = state.fileTypes
+  }
 
   // DriveApp doesnt give option to specify these so this will be fixed
   const fields = `files(${minFields}),nextPageToken`
@@ -49,9 +68,9 @@ export const getFilesIterator = ({
    */
   function* filesink() {
     // the result tank
-    let tank = []
+    let tank = [...state.tank]
     // the next page token
-    let pageToken = null
+    let pageToken = state.pageToken
 
     do {
       // if nothing in the tank, fill it up
@@ -63,10 +82,14 @@ export const getFilesIterator = ({
         // format the results into the folder or file object
         assert.array(data.files)
         assert.function(DriveApp.__settleClass)
-        tank = data.files.map(DriveApp.__settleClass)
+        
+        // we store raw data in state for continuation
+        state.tank = data.files
+        tank = [...state.tank]
 
         // the presence of a nextPageToken is the signal that there's more to come
         pageToken = data.nextPageToken
+        state.pageToken = pageToken
 
         // if we still have nothing in the tank but there's a page token, keep going
         if (!tank.length && !pageToken) break;
@@ -74,7 +97,12 @@ export const getFilesIterator = ({
 
       // if we've got anything in the tank send back the oldest one
       if (tank.length) {
-        yield tank.splice(0, 1)[0]
+        const raw = tank.splice(0, 1)[0]
+        state.tank.splice(0, 1)
+        yield { 
+          __fakeResolved: DriveApp.__settleClass(raw),
+          __fakeRaw: raw
+        }
       }
 
       // if there's still anything left in the tank, 
@@ -85,9 +113,26 @@ export const getFilesIterator = ({
   // create the iterator
   const fileit = filesink()
 
+  const continuationHandler = (peeked) => {
+    // if we've peeked, we need to make sure the peeked item is included in the tank
+    // because GAS continuation tokens should represent the state AFTER the last next() call.
+    // Peeker already called generator.next(), so the item to be returned by the NEXT next() call
+    // is in peeked.value.
+    const tank = [...state.tank]
+    if (peeked && !peeked.done) {
+      // Put the pre-fetched item back at the start of the tank for the token
+      tank.unshift(peeked.value.__fakeRaw || peeked.value)
+    }
+    const tokenState = {
+      ...state,
+      tank
+    }
+    return Buffer.from(JSON.stringify(tokenState)).toString('base64')
+  }
+
   // a regular iterator doesnt support the same methods 
   // as Apps Script so we'll fake that too
-  return newPeeker(fileit)
+  return newPeeker(fileit, continuationHandler)
 
 }