@mcpher/gas-fakes 2.0.2 → 2.0.5

package/README.md

@@ -54,7 +54,20 @@ The optional `gasfakes.json` file holds various location and behavior parameters
 | properties | string | /tmp/gas-fakes/properties        | gas-fakes uses a local file to emulate apps script's PropertiesService. This is where it should put the files. You may want to put it somewhere other than /tmp to avoid accidental deletion, but don't put it in a place that'll get commited to public git repo                        |
 | scriptId   | string | from clasp, or some random value | If you have a clasp file, it'll pick up the scriptId from there. If not you can enter your scriptId manually, or just leave it to create a fake one. It's use for the moment is to return something useful from ScriptApp.getScriptId() and to partition the cache and properties stores |
 
+### Troubleshooting: Missing Environment Tags
 
+If you see a warning or error like `Project '...' lacks an 'environment' tag`, it means your Google Cloud Organization has a policy requiring projects to be designated with an environment tag (e.g., `Development`, `Production`).
+
+To resolve this, you need to bind an environment tag to your project. Replace `YOUR_ORG_ID` and `YOUR_PROJECT_ID` with your actual identifiers:
+
+```bash
+# Bind the 'Development' environment tag to your project
+gcloud resource-manager tags bindings create \
+  --tag-value=YOUR_ORG_ID/environment/Development \
+  --parent=//cloudresourcemanager.googleapis.com/projects/YOUR_PROJECT_ID
+```
+
+*Note: The tag key `environment` and the value `Development` must already exist at the organization level. If they don't, you (or your admin) will need to create them first using `gcloud resource-manager tags keys create` and `gcloud resource-manager tags values create`.*
 
 ### Cloud Logging Integration
 

package/package.json

@@ -33,7 +33,7 @@
   },
   "name": "@mcpher/gas-fakes",
   "author": "bruce mcpherson",
-  "version": "2.0.2",
+  "version": "2.0.5",
   "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/setup.js

@@ -153,7 +153,7 @@ export async function initializeConfiguration(options = {}) {
       name: "GOOGLE_CLOUD_PROJECT",
       message: "Enter your GCP Project ID",
       initial:
-        existingConfig.GCP_PROJECT_ID || process.env.GOOGLE_CLOUD_PROJECT,
+        existingConfig.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT || existingConfig.GCP_PROJECT_ID,
     },
     {
       type: "text",
@@ -483,7 +483,14 @@ export async function authenticateUser() {
     scopes += (extraScopes.startsWith(",") ? "" : ",") + extraScopes;
   }
   */
-  const scopes = Array.from(new Set([DEFAULT_SCOPES.split(",").concat(EXTRA_SCOPES.split(","))].filter(d => d))).join(",")
+  const scopes = Array.from(
+    new Set([
+      ...(DEFAULT_SCOPES || "").split(","),
+      ...(EXTRA_SCOPES || "").split(","),
+    ])
+  )
+    .filter((s) => s)
+    .join(",");
   const driveAccessFlag = "--enable-gdrive-access";
 
   console.log(`...requesting scopes ${scopes}`);
@@ -630,7 +637,7 @@ export async function authenticateUser() {
     // Service Account Lifecycle
     let existing_sa = false
     try {
-      execSync(`gcloud iam service-accounts describe "${sa_email}"`, { shell: true });
+      execSync(`gcloud iam service-accounts describe "${sa_email}"`, { stdio: "ignore", shell: true });
       existing_sa = true;
     } catch (error) {
       /* ignore */

package/src/services/formapp/fakecheckboxgriditem.js

@@ -4,6 +4,7 @@ import { registerFormItem } from './formitemregistry.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeCheckboxGridItem = (...args) => {
   return Proxies.guard(new FakeCheckboxGridItem(...args));
@@ -19,6 +20,35 @@ export class FakeCheckboxGridItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this checkbox grid item.
+   * @param {string[][]} responses a two-dimensional array of responses, where each inner array represents the selected columns for a row
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxGridItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.array)) {
+      matchThrow('Invalid arguments: expected a two-dimensional string array.');
+    }
+
+    const questions = this.__resource.questionGroupItem?.questions || [];
+    if (responses.length !== questions.length) {
+      throw new Error(`The number of responses (${responses.length}) must match the number of rows (${questions.length}).`);
+    }
+
+    const answers = responses.map((rowResponses, index) => {
+      const questionId = questions[index].questionId;
+      return {
+        questionId,
+        textAnswers: {
+          answers: rowResponses.map(value => ({ value }))
+        }
+      };
+    });
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the values for every column in the grid.
    * @returns {string[]} an array of column values

package/src/services/formapp/fakecheckboxitem.js

@@ -6,6 +6,7 @@ const { is } = Utils;
 import { registerFormItem } from './formitemregistry.js';
 import { newFakeChoice } from './fakechoice.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeCheckboxItem = (...args) => {
   return Proxies.guard(new FakeCheckboxItem(...args));
@@ -25,6 +26,28 @@ export class FakeCheckboxItem extends FakeChoiceItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this checkbox item.
+   * @param {string[]} responses the selected choices
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'CheckboxItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: responses.map(value => ({ value }))
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
     return 'CheckboxItem';
   }

package/src/services/formapp/fakedateitem.js

@@ -0,0 +1,67 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeDateItem = (...args) => {
+  return Proxies.guard(new FakeDateItem(...args));
+};
+
+/**
+ * @class FakeDateItem
+ * @see https://developers.google.com/apps-script/reference/forms/date-item
+ */
+export class FakeDateItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this date item.
+   * @param {Date} date the date
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(date) {
+    const typeName = this.getType() === ItemType.DATETIME ? 'DateTimeItem' : 'DateItem';
+    const { nargs, matchThrow } = signatureArgs(arguments, `${typeName}.createResponse`);
+    if (nargs !== 1 || !is.date(date)) {
+      matchThrow('Invalid arguments: expected a Date object.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    
+    // Format date as YYYY-MM-DD or YYYY-MM-DDTHH:mm:ssZ for API?
+    // Actually, the Forms API expects text answers. 
+    // For DATE, it's "YYYY-MM-DD". For DATETIME, it's "YYYY-MM-DD HH:mm".
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    let value = `${year}-${month}-${day}`;
+    
+    if (this.getType() === ItemType.DATETIME) {
+      const hours = String(date.getHours()).padStart(2, '0');
+      const minutes = String(date.getMinutes()).padStart(2, '0');
+      value += ` ${hours}:${minutes}`;
+    }
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return this.getType() === ItemType.DATETIME ? 'DateTimeItem' : 'DateItem';
+  }
+}
+
+registerFormItem(ItemType.DATE, newFakeDateItem);
+registerFormItem(ItemType.DATETIME, newFakeDateItem);

package/src/services/formapp/fakedurationitem.js

@@ -0,0 +1,54 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeDurationItem = (...args) => {
+  return Proxies.guard(new FakeDurationItem(...args));
+};
+
+/**
+ * @class FakeDurationItem
+ * @see https://developers.google.com/apps-script/reference/forms/duration-item
+ */
+export class FakeDurationItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this duration item.
+   * @param {number} hours the hours
+   * @param {number} minutes the minutes
+   * @param {number} seconds the seconds
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(hours, minutes, seconds) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'DurationItem.createResponse');
+    if (nargs !== 3 || !is.number(hours) || !is.number(minutes) || !is.number(seconds)) {
+      matchThrow('Invalid arguments: expected three numbers.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const value = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return 'DurationItem';
+  }
+}
+
+registerFormItem(ItemType.DURATION, newFakeDurationItem);

package/src/services/formapp/fakeform.js

@@ -12,6 +12,9 @@ import { newFakeCheckboxItem } from './fakecheckboxitem.js';
 import { newFakeListItem } from './fakelistitem.js';
 import { newFakePageBreakItem } from './fakepagebreakitem.js';
 import { newFakeTextItem } from './faketextitem.js';
+import { newFakeDateItem } from './fakedateitem.js';
+import { newFakeTimeItem } from './faketimeitem.js';
+import { newFakeDurationItem } from './fakedurationitem.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils
@@ -261,6 +264,93 @@ export class FakeForm {
     return this.__addItem(itemResource, newFakeTextItem);
   }
 
+  /**
+   * Appends a new question item that allows the respondent to enter a paragraph of text.
+   * @returns {import('./faketextitem.js').FakeTextItem} The new paragraph text item.
+   */
+  addParagraphTextItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          textQuestion: {
+            paragraph: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeTextItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a date.
+   * @returns {import('./fakedateitem.js').FakeDateItem} The new date item.
+   */
+  addDateItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          dateQuestion: {
+            includeYear: true,
+            includeTime: false,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDateItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a date and time.
+   * @returns {import('./fakedateitem.js').FakeDateItem} The new date-time item.
+   */
+  addDateTimeItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          dateQuestion: {
+            includeYear: true,
+            includeTime: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDateItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a time.
+   * @returns {import('./faketimeitem.js').FakeTimeItem} The new time item.
+   */
+  addTimeItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          timeQuestion: {
+            duration: false,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeTimeItem);
+  }
+
+  /**
+   * Appends a new question item that allows the respondent to choose a duration.
+   * @returns {import('./fakedurationitem.js').FakeDurationItem} The new duration item.
+   */
+  addDurationItem() {
+    const itemResource = {
+      questionItem: {
+        question: {
+          timeQuestion: {
+            duration: true,
+          },
+        },
+      },
+    };
+    return this.__addItem(itemResource, newFakeDurationItem);
+  }
+
   /**
    * Gets the ID of the form's response destination.
    * @returns {string | null} The destination ID, or null if no destination is set.

package/src/services/formapp/fakegriditem.js

@@ -4,6 +4,7 @@ import { registerFormItem } from './formitemregistry.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 import { ItemType } from '../enums/formsenums.js';
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeGridItem = (...args) => {
   return Proxies.guard(new FakeGridItem(...args));
@@ -19,6 +20,35 @@ export class FakeGridItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this grid item.
+   * @param {string[]} responses an array of responses, where each element represents the selected column for a row
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(responses) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'GridItem.createResponse');
+    if (nargs !== 1 || !Utils.is.array(responses) || !responses.every(Utils.is.string)) {
+      matchThrow('Invalid arguments: expected a string array.');
+    }
+
+    const questions = this.__resource.questionGroupItem?.questions || [];
+    if (responses.length !== questions.length) {
+      throw new Error(`The number of responses (${responses.length}) must match the number of rows (${questions.length}).`);
+    }
+
+    const answers = responses.map((rowResponse, index) => {
+      const questionId = questions[index].questionId;
+      return {
+        questionId,
+        textAnswers: {
+          answers: [{ value: rowResponse }]
+        }
+      };
+    });
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the values for every column in the grid.
    * @returns {string[]} an array of column values
@@ -40,7 +70,7 @@ export class FakeGridItem extends FakeFormItem {
     if (!questions) {
       return [];
     }
-    return questions.map(question => question.rowQuestion?.title || null).filter(f=>f);
+    return questions.map(question => question.rowQuestion?.title || null).filter(f => f);
   }
 
   /**

package/src/services/formapp/fakeitemresponse.js

@@ -78,7 +78,11 @@ export class FakeItemResponse {
     );
 
     if (allTextAnswers.length === 0) {
-      return '';
+      return itemType === 'CHECKBOX' ? [] : '';
+    }
+
+    if (itemType === 'CHECKBOX') {
+      return allTextAnswers.map(a => a.value);
     }
 
     // For items like grids, there can be multiple answer values. The live script joins them with a comma.

package/src/services/formapp/fakelistitem.js

@@ -4,6 +4,9 @@ import { newFakeChoice } from './fakechoice.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
 import { Utils } from '../../support/utils.js';
+import { signatureArgs } from '../../support/helpers.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeListItem = (...args) => {
   return Proxies.guard(new FakeListItem(...args));
@@ -18,6 +21,28 @@ export class FakeListItem extends FakeFormItem {
     super(...args);
   }
 
+  /**
+   * Creates a new ItemResponse for this list item.
+   * @param {string} response the selected choice
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ListItem.createResponse');
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Creates a new choice for this item.
    * @param {string} value The value for the new choice.

package/src/services/formapp/fakemultiplechoiceitem.js

@@ -2,6 +2,10 @@ import { Proxies } from '../../support/proxies.js';
 import { FakeChoiceItem } from './fakechoiceitem.js';
 import { registerFormItem } from './formitemregistry.js';
 import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeMultipleChoiceItem = (form, itemId) => {
   return Proxies.guard(new FakeMultipleChoiceItem(form, itemId));
@@ -16,6 +20,29 @@ export class FakeMultipleChoiceItem extends FakeChoiceItem {
   constructor(form, itemId) {
     super(form, itemId);
   }
+
+  /**
+   * Creates a new ItemResponse for this multiple choice item.
+   * @param {string} response the selected choice
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'MultipleChoiceItem.createResponse');
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
     return 'MultipleChoiceItem';
   }

package/src/services/formapp/fakescaleitem.js

@@ -5,6 +5,7 @@ import { ItemType } from '../enums/formsenums.js';
 import { signatureArgs } from '../../support/helpers.js';
 import { Utils } from '../../support/utils.js';
 const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeScaleItem = (...args) => {
   return Proxies.guard(new FakeScaleItem(...args));
@@ -20,6 +21,28 @@ export class FakeScaleItem extends FakeFormItem {
     super(form, itemId);
   }
 
+  /**
+   * Creates a new ItemResponse for this scale item.
+   * @param {number} response the selected value
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'ScaleItem.createResponse');
+    if (nargs !== 1 || !is.number(response)) {
+      matchThrow('Invalid arguments: expected a number.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response.toString() }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   /**
    * Gets the lower bound of the scale.
    * @returns {Integer} the lower bound

package/src/services/formapp/faketextitem.js

@@ -1,5 +1,11 @@
 import { Proxies } from '../../support/proxies.js';
 import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
 
 export const newFakeTextItem = (...args) => {
   return Proxies.guard(new FakeTextItem(...args));
@@ -14,7 +20,34 @@ export class FakeTextItem extends FakeFormItem {
     super(...args);
   }
 
+  /**
+   * Creates a new ItemResponse for this text item.
+   * @param {string} response the response text
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(response) {
+    // Both TextItem and ParagraphTextItem have the same createResponse signature.
+    const typeName = this.getType() === ItemType.PARAGRAPH_TEXT ? 'ParagraphTextItem' : 'TextItem';
+    const { nargs, matchThrow } = signatureArgs(arguments, `${typeName}.createResponse`);
+    if (nargs !== 1 || !is.string(response)) {
+      matchThrow('Invalid arguments: expected a string.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value: response }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
   toString() {
-    return 'TextItem';
+    return this.getType() === ItemType.PARAGRAPH_TEXT ? 'ParagraphTextItem' : 'TextItem';
   }
-}
+}
+
+registerFormItem(ItemType.TEXT, newFakeTextItem);
+registerFormItem(ItemType.PARAGRAPH_TEXT, newFakeTextItem);

package/src/services/formapp/faketimeitem.js

@@ -0,0 +1,53 @@
+import { Proxies } from '../../support/proxies.js';
+import { FakeFormItem } from './fakeformitem.js';
+import { registerFormItem } from './formitemregistry.js';
+import { ItemType } from '../enums/formsenums.js';
+import { signatureArgs } from '../../support/helpers.js';
+import { Utils } from '../../support/utils.js';
+const { is } = Utils;
+import { newFakeItemResponse } from './fakeitemresponse.js';
+
+export const newFakeTimeItem = (...args) => {
+  return Proxies.guard(new FakeTimeItem(...args));
+};
+
+/**
+ * @class FakeTimeItem
+ * @see https://developers.google.com/apps-script/reference/forms/time-item
+ */
+export class FakeTimeItem extends FakeFormItem {
+  constructor(...args) {
+    super(...args);
+  }
+
+  /**
+   * Creates a new ItemResponse for this time item.
+   * @param {number} hour the hour
+   * @param {number} minute the minute
+   * @returns {import('./fakeitemresponse.js').FakeItemResponse} the item response
+   */
+  createResponse(hour, minute) {
+    const { nargs, matchThrow } = signatureArgs(arguments, 'TimeItem.createResponse');
+    if (nargs !== 2 || !is.number(hour) || !is.number(minute)) {
+      matchThrow('Invalid arguments: expected two numbers.');
+    }
+
+    const questionId = this.__resource.questionItem?.question?.questionId;
+    const value = `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+
+    const answers = [{
+      questionId,
+      textAnswers: {
+        answers: [{ value }]
+      }
+    }];
+
+    return newFakeItemResponse(this, answers);
+  }
+
+  toString() {
+    return 'TimeItem';
+  }
+}
+
+registerFormItem(ItemType.TIME, newFakeTimeItem);

package/src/services/formapp/formitems.js

@@ -8,4 +8,8 @@ import './fakecheckboxgriditem.js';
 import './fakescaleitem.js';
 import './fakepagebreakitem.js';
 import './fakelistitem.js';
+import './faketextitem.js';
+import './fakedateitem.js';
+import './faketimeitem.js';
+import './fakedurationitem.js';
 // Add other item types here as they are implemented (e.g., './faketextitem.js')

package/src/support/auth.js

@@ -117,7 +117,7 @@ const setAuth = async (scopes = [], mcpLoading = false) => {
     // 2. if AUTH_TYPE is ADC, use ADC
     // 3. if AUTH_TYPE is not set, use DWD if saName is present, else ADC
     const saName = process.env.GOOGLE_SERVICE_ACCOUNT_NAME
-    const authType = process.env.AUTH_TYPE?.toLowerCase() || 'dwd'
+    const authType = process.env.AUTH_TYPE?.toLowerCase()
     const useDwd = authType === 'dwd' || (authType !== 'adc' && saName)
 
     if (!useDwd) {
@@ -127,6 +127,9 @@ const setAuth = async (scopes = [], mcpLoading = false) => {
       })
       _sourceClient = _authClient
     } else {
+      if (!saName) {
+        throw new Error("Domain-Wide Delegation (DWD) requested or inferred, but GOOGLE_SERVICE_ACCOUNT_NAME is not set in environment.");
+      }
       mayLog(`...using service account: ${saName}`)
       const targetPrincipal = `${saName}@${_projectId}.iam.gserviceaccount.com`
       mayLog(`...attempting to use service account: ${targetPrincipal}`)

package/src/support/sxauth.js

@@ -7,7 +7,7 @@
  */
 import got from 'got';
 import { Auth } from './auth.js';
-import { syncError, syncLog } from './workersync/synclogger.js';
+import { syncError, syncLog, syncWarn } from './workersync/synclogger.js';
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import path from 'path'
 
@@ -85,8 +85,22 @@ export const sxInit = async ({ manifestPath, claspPath, settingsPath, cachePath,
   // get the required scopes and set them
   const scopes = manifest.oauthScopes || []
 
+  // Force mandatory scopes for DWD if not already present
+  // These are required to get user identity information when using Domain-Wide Delegation
+  const mandatoryScopes = [
+    "openid",
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/cloud-platform"
+  ]
+
+  const scopeSet = new Set(scopes)
+  mandatoryScopes.forEach(scope => scopeSet.add(scope))
+  const finalScopes = Array.from(scopeSet)
+
+  syncLog(`...using scopes: ${finalScopes.join(', ')}`)
+
   // Initialize auth. 
-  const auth = await Auth.setAuth(scopes);
+  const auth = await Auth.setAuth(finalScopes);
 
   // static things we need to get into the main thread we can do now
   const projectId = Auth.getProjectId();
@@ -126,7 +140,7 @@ export const sxInit = async ({ manifestPath, claspPath, settingsPath, cachePath,
   const allowedScopes = new Set(effectiveScopes)
   const missingScopes = scopes.filter(scope => !allowedScopes.has(scope))
   if (missingScopes.length > 0) {
-    syncError(`...these scopes were asked for but not granted: ${missingScopes.join(', ')}`)
+    syncWarn(`...these scopes were asked for but not granted: ${missingScopes.join(', ')}. Note: Operations may still succeed if the 'https://www.googleapis.com/auth/cloud-platform' scope was granted.`)
   }
   return {
     // these will be the scopes we're allowed to get