timeback-studio 0.1.6 → 0.1.7

package/dist/bin.js

@@ -16854,13 +16854,14 @@ async function validateEmailWithTimeback(environment, clientId, clientSecret, em
     if (page.data.length === 0) {
       return {
         valid: false,
+        reason: "not_found",
         error: `No user found with email "${email3}" in ${environment}`
       };
     }
     return { valid: true };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : "Unknown error";
-    return { valid: false, error: `Failed to validate email: ${message}` };
+    return { valid: false, reason: "api_error", error: `Failed to validate email: ${message}` };
   }
 }
 
@@ -17162,6 +17163,8 @@ var ActivityCompletedInput = exports_external.object({
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
   extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
   attempt: exports_external.number().int().min(1).optional(),
   generatedExtensions: exports_external.object({
     pctCompleteApp: exports_external.number().optional()
@@ -17174,7 +17177,9 @@ var TimeSpentInput = exports_external.object({
   eventTime: IsoDateTimeString.optional(),
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
-  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional()
 }).strict();
 var TimebackEvent = exports_external.union([TimebackActivityEvent, TimebackTimeSpentEvent]);
 var CaliperEnvelope = exports_external.object({
@@ -17364,7 +17369,7 @@ var TimebackConfig = exports_external.object({
   path: ["courses"]
 });
 // ../types/src/zod/edubridge.ts
-var EdubridgeDateString = IsoDateTimeString;
+var EdubridgeDateString = exports_external.union([IsoDateTimeString, IsoDateString]);
 var EduBridgeEnrollment = exports_external.object({
   id: exports_external.string(),
   role: exports_external.string(),
@@ -19465,6 +19470,184 @@ async function addCredentials(options = {}) {
   if (exitOnComplete)
     process.exit(0);
 }
+// src/cli/commands/credentials/create-account.ts
+import { randomUUID } from "node:crypto";
+import { TimebackClient as TimebackClient2 } from "@timeback/core";
+async function promptName(label) {
+  const value = await he({
+    message: label,
+    placeholder: "Enter name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return `${label} is required`;
+    }
+  });
+  if (isCancelled(value))
+    return null;
+  return value.trim();
+}
+async function searchOrganizations(client, query) {
+  const allOrgs = await client.oneroster.orgs.listAll({
+    where: { status: "active" },
+    max: 100
+  });
+  if (!query.trim())
+    return allOrgs;
+  const lowerQuery = query.toLowerCase().trim();
+  return allOrgs.filter((org) => org.name?.toLowerCase().includes(lowerQuery));
+}
+async function searchForOrganization(client) {
+  const query = await he({
+    message: "Search for organization",
+    placeholder: "Enter organization name to search"
+  });
+  if (isCancelled(query))
+    return null;
+  const s = Y2();
+  s.start("Searching organizations...");
+  let results;
+  try {
+    results = await searchOrganizations(client, query);
+    s.stop(green(`Found ${results.length} result${results.length === 1 ? "" : "s"}`));
+  } catch (error48) {
+    s.stop(red("Failed to search organizations"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+  if (results.length === 0) {
+    M2.warn("No organizations found matching your search");
+    return promptOrganization(client);
+  }
+  const validResults = results.filter((org) => org.sourcedId);
+  if (validResults.length === 0) {
+    M2.warn("No valid organizations found (missing IDs)");
+    return promptOrganization(client);
+  }
+  const options = validResults.map((org) => ({
+    value: org.sourcedId,
+    label: org.name ?? "Unnamed Organization"
+  }));
+  options.push({ value: "__back__", label: `${dim("←")} Back to options` });
+  const selection = await ve({
+    message: "Select an organization",
+    options
+  });
+  if (isCancelled(selection))
+    return null;
+  if (selection === "__back__") {
+    return promptOrganization(client);
+  }
+  return validResults.find((org) => org.sourcedId === selection) ?? null;
+}
+async function promptOrganization(client) {
+  const action = await ve({
+    message: "Organization",
+    options: [
+      { value: "search", label: "Search for existing organization" },
+      { value: "create", label: "Create new organization" }
+    ]
+  });
+  if (isCancelled(action))
+    return null;
+  if (action === "create") {
+    return createNewOrganization(client);
+  }
+  return searchForOrganization(client);
+}
+async function createNewOrganization(client) {
+  const name = await he({
+    message: "Organization name",
+    placeholder: "Enter organization name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return "Organization name is required";
+    }
+  });
+  if (isCancelled(name))
+    return null;
+  const s = Y2();
+  s.start("Creating organization...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.orgs.create({
+      sourcedId,
+      name: name.trim(),
+      type: "school",
+      status: "active"
+    });
+    const organization = await client.oneroster.orgs.get(sourcedId);
+    s.stop(green(`Organization "${name}" created`));
+    return organization;
+  } catch (error48) {
+    s.stop(red("Failed to create organization"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createUser(client, email3, givenName, familyName, organizationId) {
+  const s = Y2();
+  s.start("Creating account...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.users.create({
+      sourcedId,
+      givenName,
+      familyName,
+      email: email3.toLowerCase(),
+      enabledUser: true,
+      status: "active",
+      roles: [
+        {
+          roleType: "primary",
+          role: "administrator",
+          org: { sourcedId: organizationId }
+        }
+      ]
+    });
+    const user = await client.oneroster.users.get(sourcedId);
+    s.stop(green("Account created successfully"));
+    return user;
+  } catch (error48) {
+    s.stop(red("Failed to create account"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createAccountFlow(options) {
+  const { environment, clientId, clientSecret, email: email3 } = options;
+  M2.info("");
+  M2.info(`No account found for ${dim(email3)} in ${environment}`);
+  const shouldCreate = await ye({
+    message: "Would you like to create a new account?",
+    initialValue: true
+  });
+  if (isCancelled(shouldCreate)) {
+    return { success: false };
+  }
+  if (!shouldCreate) {
+    return { success: false, declined: true };
+  }
+  const client = new TimebackClient2({
+    env: environment,
+    auth: { clientId, clientSecret }
+  });
+  const givenName = await promptName("First name");
+  if (!givenName)
+    return { success: false };
+  const familyName = await promptName("Last name");
+  if (!familyName)
+    return { success: false };
+  const organization = await promptOrganization(client);
+  if (!organization?.sourcedId)
+    return { success: false };
+  const user = await createUser(client, email3, givenName, familyName, organization.sourcedId);
+  if (!user) {
+    return { success: false };
+  }
+  M2.success(`Account created for ${user.givenName} ${user.familyName}`);
+  return { success: true };
+}
+
 // src/cli/commands/credentials/email.ts
 async function updateEmail(options = {}) {
   const { exitOnComplete = true, inline = false } = options;
@@ -19533,32 +19716,58 @@ async function updateEmail(options = {}) {
     return;
   }
   const emailUnchanged = email3 === (currentEmail ?? "");
-  if (emailUnchanged) {
-    if (!inline)
-      outro.info("Email unchanged");
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
   if (email3) {
     const s = Y2();
-    s.start("Validating email...");
+    s.start("Checking account...");
     const result = await validateEmailWithTimeback(targetEnv, currentCreds.clientId, currentCreds.clientSecret, email3);
     if (!result.valid) {
-      s.stop(red("Email validation failed"));
-      M2.error(result.error ?? "Unknown error");
-      M2.info("Please contact a Timeback admin to set up your account.");
+      if (result.reason !== "not_found") {
+        s.stop(red("Account check failed"));
+        M2.error(result.error ?? "Unknown error");
+        if (!inline)
+          outro.error("Account check failed");
+        if (exitOnComplete)
+          process.exit(1);
+        return;
+      }
+      s.stop(red("No account found"));
+      const { success: accountCreated, declined } = await createAccountFlow({
+        environment: targetEnv,
+        clientId: currentCreds.clientId,
+        clientSecret: currentCreds.clientSecret,
+        email: email3
+      });
+      if (!emailUnchanged) {
+        await saveCredentials(targetEnv, {
+          ...currentCreds,
+          email: email3
+        });
+        M2.success(`Email saved for ${targetEnv}`);
+      }
+      if (!inline) {
+        if (accountCreated || declined) {
+          outro.success();
+        } else {
+          outro.info("Setup incomplete - run this command again to finish");
+        }
+      }
+      if (exitOnComplete)
+        process.exit(0);
+      return;
+    }
+    s.stop(green("Account verified"));
+    if (emailUnchanged) {
       if (!inline)
-        outro.error("Email validation failed");
+        outro.info("Email unchanged");
       if (exitOnComplete)
-        process.exit(1);
+        process.exit(0);
       return;
     }
     await saveCredentials(targetEnv, {
       ...currentCreds,
       email: email3
     });
-    s.stop(green(`Email updated for ${targetEnv}`));
+    M2.success(`Email updated for ${targetEnv}`);
     if (!inline)
       outro.success();
     if (exitOnComplete)
@@ -19874,7 +20083,7 @@ function printError3(error48, opts = {}) {
   parser.printError(error48);
 }
 // src/cli/lib/courses.ts
-import { TimebackClient as TimebackClient2 } from "@timeback/core";
+import { TimebackClient as TimebackClient3 } from "@timeback/core";
 async function fetchCoursesByIds(client, ids) {
   const courses = [];
   for (const id of ids) {
@@ -19886,7 +20095,7 @@ async function fetchCoursesByIds(client, ids) {
   return courses;
 }
 async function fetchCourses(creds, env2, ids) {
-  const client = new TimebackClient2({
+  const client = new TimebackClient3({
     env: env2,
     auth: { clientId: creds.clientId, clientSecret: creds.clientSecret }
   });
@@ -19908,7 +20117,7 @@ async function checkCoursesManaged(creds, env2, ids) {
   if (ids.length === 0) {
     return { allManaged: true, unmanagedCourses: [] };
   }
-  const client = new TimebackClient2({
+  const client = new TimebackClient3({
     env: env2,
     auth: { clientId: creds.clientId, clientSecret: creds.clientSecret }
   });
@@ -19956,7 +20165,7 @@ async function handleCredentialSetup(options = {}) {
   };
 }
 // src/cli/lib/onboarding/import.ts
-import { TimebackClient as TimebackClient3 } from "@timeback/core";
+import { TimebackClient as TimebackClient4 } from "@timeback/core";
 async function promptImportApp(credentials, configuredEnvs) {
   let env2;
   if (configuredEnvs.length === 1 && configuredEnvs[0]) {
@@ -19969,7 +20178,7 @@ async function promptImportApp(credentials, configuredEnvs) {
     env2 = selectedEnv;
   }
   const creds = credentials[env2];
-  const client = new TimebackClient3({
+  const client = new TimebackClient4({
     env: env2,
     auth: { clientId: creds.clientId, clientSecret: creds.clientSecret }
   });
@@ -22399,7 +22608,8 @@ var cors = (options) => {
 async function handleBootstrap(c, ctx) {
   const { bootstrap } = c.get("services");
   const env2 = c.get("env");
-  const email3 = ctx.credentials[env2]?.email;
+  const freshCredentials = await getSavedCredentials(env2);
+  const email3 = freshCredentials?.email;
   const courseIds = ctx.userConfig.courseIds[env2];
   const result = await bootstrap.getBootstrap({ email: email3, courseIds });
   return c.json(result);
@@ -23331,11 +23541,15 @@ class StatusService {
   }
   async getStatus() {
     const configuredEnvironments = await getConfiguredEnvironments();
+    const [stagingCreds, productionCreds] = await Promise.all([
+      getSavedCredentials("staging"),
+      getSavedCredentials("production")
+    ]);
     return {
       config: this.ctx.userConfig,
       environment: this.ctx.defaultEnvironment,
       configuredEnvironments,
-      hasEmail: !!this.ctx.credentials.staging?.email || !!this.ctx.credentials.production?.email
+      hasEmail: !!stagingCreds?.email || !!productionCreds?.email
     };
   }
 }

package/dist/cli/commands/credentials/create-account.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Account Creation
+ *
+ * Interactive CLI flow for creating a new Timeback user account
+ * when no matching account exists for the provided email.
+ */
+import type { CredentialEnvironment } from '@timeback/internal-cli-infra';
+/**
+ * Options for creating a new account.
+ */
+interface CreateAccountOptions {
+    environment: CredentialEnvironment;
+    clientId: string;
+    clientSecret: string;
+    email: string;
+}
+/**
+ * Result of the account creation flow.
+ */
+interface CreateAccountResult {
+    success: boolean;
+    /** User explicitly declined to create an account (vs cancelled or failed) */
+    declined?: boolean;
+}
+/**
+ * Interactive flow to create a new Timeback account.
+ *
+ * Called when no matching user is found for the provided email.
+ * Guides the user through entering their name and selecting/creating
+ * an organization.
+ *
+ * @param options - Account creation options
+ * @returns Result indicating success and the created user
+ */
+export declare function createAccountFlow(options: CreateAccountOptions): Promise<CreateAccountResult>;
+export {};
+//# sourceMappingURL=create-account.d.ts.map

package/dist/cli/commands/credentials/create-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-account.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/credentials/create-account.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAA;AAGzE;;GAEG;AACH,UAAU,oBAAoB;IAC7B,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,UAAU,mBAAmB;IAC5B,OAAO,EAAE,OAAO,CAAA;IAChB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,OAAO,CAAA;CAClB;AA2ND;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA0CnG"}

package/dist/cli/commands/credentials/email.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/credentials/email.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqH7E"}
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/credentials/email.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAE3C;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAqJ7E"}

package/dist/index.js

@@ -14744,13 +14744,14 @@ async function validateEmailWithTimeback(environment, clientId, clientSecret, em
     if (page.data.length === 0) {
       return {
         valid: false,
+        reason: "not_found",
         error: `No user found with email "${email3}" in ${environment}`
       };
     }
     return { valid: true };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : "Unknown error";
-    return { valid: false, error: `Failed to validate email: ${message}` };
+    return { valid: false, reason: "api_error", error: `Failed to validate email: ${message}` };
   }
 }
 
@@ -15052,6 +15053,8 @@ var ActivityCompletedInput = exports_external.object({
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
   extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
   attempt: exports_external.number().int().min(1).optional(),
   generatedExtensions: exports_external.object({
     pctCompleteApp: exports_external.number().optional()
@@ -15064,7 +15067,9 @@ var TimeSpentInput = exports_external.object({
   eventTime: IsoDateTimeString.optional(),
   metricsId: exports_external.string().optional(),
   id: exports_external.string().optional(),
-  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  extensions: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  edApp: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional(),
+  session: exports_external.union([exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())]).optional()
 }).strict();
 var TimebackEvent = exports_external.union([TimebackActivityEvent, TimebackTimeSpentEvent]);
 var CaliperEnvelope = exports_external.object({
@@ -15254,7 +15259,7 @@ var TimebackConfig = exports_external.object({
   path: ["courses"]
 });
 // ../types/src/zod/edubridge.ts
-var EdubridgeDateString = IsoDateTimeString;
+var EdubridgeDateString = exports_external.union([IsoDateTimeString, IsoDateString]);
 var EduBridgeEnrollment = exports_external.object({
   id: exports_external.string(),
   role: exports_external.string(),
@@ -17540,6 +17545,184 @@ async function addCredentials(options = {}) {
   if (exitOnComplete)
     process.exit(0);
 }
+// src/cli/commands/credentials/create-account.ts
+import { randomUUID } from "node:crypto";
+import { TimebackClient as TimebackClient3 } from "@timeback/core";
+async function promptName(label) {
+  const value = await he({
+    message: label,
+    placeholder: "Enter name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return `${label} is required`;
+    }
+  });
+  if (isCancelled(value))
+    return null;
+  return value.trim();
+}
+async function searchOrganizations(client, query) {
+  const allOrgs = await client.oneroster.orgs.listAll({
+    where: { status: "active" },
+    max: 100
+  });
+  if (!query.trim())
+    return allOrgs;
+  const lowerQuery = query.toLowerCase().trim();
+  return allOrgs.filter((org) => org.name?.toLowerCase().includes(lowerQuery));
+}
+async function searchForOrganization(client) {
+  const query = await he({
+    message: "Search for organization",
+    placeholder: "Enter organization name to search"
+  });
+  if (isCancelled(query))
+    return null;
+  const s = Y2();
+  s.start("Searching organizations...");
+  let results;
+  try {
+    results = await searchOrganizations(client, query);
+    s.stop(green(`Found ${results.length} result${results.length === 1 ? "" : "s"}`));
+  } catch (error48) {
+    s.stop(red("Failed to search organizations"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+  if (results.length === 0) {
+    M2.warn("No organizations found matching your search");
+    return promptOrganization(client);
+  }
+  const validResults = results.filter((org) => org.sourcedId);
+  if (validResults.length === 0) {
+    M2.warn("No valid organizations found (missing IDs)");
+    return promptOrganization(client);
+  }
+  const options = validResults.map((org) => ({
+    value: org.sourcedId,
+    label: org.name ?? "Unnamed Organization"
+  }));
+  options.push({ value: "__back__", label: `${dim("←")} Back to options` });
+  const selection = await ve({
+    message: "Select an organization",
+    options
+  });
+  if (isCancelled(selection))
+    return null;
+  if (selection === "__back__") {
+    return promptOrganization(client);
+  }
+  return validResults.find((org) => org.sourcedId === selection) ?? null;
+}
+async function promptOrganization(client) {
+  const action = await ve({
+    message: "Organization",
+    options: [
+      { value: "search", label: "Search for existing organization" },
+      { value: "create", label: "Create new organization" }
+    ]
+  });
+  if (isCancelled(action))
+    return null;
+  if (action === "create") {
+    return createNewOrganization(client);
+  }
+  return searchForOrganization(client);
+}
+async function createNewOrganization(client) {
+  const name = await he({
+    message: "Organization name",
+    placeholder: "Enter organization name",
+    validate: (v2) => {
+      if (!v2?.trim())
+        return "Organization name is required";
+    }
+  });
+  if (isCancelled(name))
+    return null;
+  const s = Y2();
+  s.start("Creating organization...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.orgs.create({
+      sourcedId,
+      name: name.trim(),
+      type: "school",
+      status: "active"
+    });
+    const organization = await client.oneroster.orgs.get(sourcedId);
+    s.stop(green(`Organization "${name}" created`));
+    return organization;
+  } catch (error48) {
+    s.stop(red("Failed to create organization"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createUser(client, email3, givenName, familyName, organizationId) {
+  const s = Y2();
+  s.start("Creating account...");
+  const sourcedId = randomUUID();
+  try {
+    await client.oneroster.users.create({
+      sourcedId,
+      givenName,
+      familyName,
+      email: email3.toLowerCase(),
+      enabledUser: true,
+      status: "active",
+      roles: [
+        {
+          roleType: "primary",
+          role: "administrator",
+          org: { sourcedId: organizationId }
+        }
+      ]
+    });
+    const user = await client.oneroster.users.get(sourcedId);
+    s.stop(green("Account created successfully"));
+    return user;
+  } catch (error48) {
+    s.stop(red("Failed to create account"));
+    M2.error(error48 instanceof Error ? error48.message : "Unknown error");
+    return null;
+  }
+}
+async function createAccountFlow(options) {
+  const { environment, clientId, clientSecret, email: email3 } = options;
+  M2.info("");
+  M2.info(`No account found for ${dim(email3)} in ${environment}`);
+  const shouldCreate = await ye({
+    message: "Would you like to create a new account?",
+    initialValue: true
+  });
+  if (isCancelled(shouldCreate)) {
+    return { success: false };
+  }
+  if (!shouldCreate) {
+    return { success: false, declined: true };
+  }
+  const client = new TimebackClient3({
+    env: environment,
+    auth: { clientId, clientSecret }
+  });
+  const givenName = await promptName("First name");
+  if (!givenName)
+    return { success: false };
+  const familyName = await promptName("Last name");
+  if (!familyName)
+    return { success: false };
+  const organization = await promptOrganization(client);
+  if (!organization?.sourcedId)
+    return { success: false };
+  const user = await createUser(client, email3, givenName, familyName, organization.sourcedId);
+  if (!user) {
+    return { success: false };
+  }
+  M2.success(`Account created for ${user.givenName} ${user.familyName}`);
+  return { success: true };
+}
+
 // src/cli/commands/credentials/email.ts
 async function updateEmail(options = {}) {
   const { exitOnComplete = true, inline = false } = options;
@@ -17608,32 +17791,58 @@ async function updateEmail(options = {}) {
     return;
   }
   const emailUnchanged = email3 === (currentEmail ?? "");
-  if (emailUnchanged) {
-    if (!inline)
-      outro.info("Email unchanged");
-    if (exitOnComplete)
-      process.exit(0);
-    return;
-  }
   if (email3) {
     const s = Y2();
-    s.start("Validating email...");
+    s.start("Checking account...");
     const result = await validateEmailWithTimeback(targetEnv, currentCreds.clientId, currentCreds.clientSecret, email3);
     if (!result.valid) {
-      s.stop(red("Email validation failed"));
-      M2.error(result.error ?? "Unknown error");
-      M2.info("Please contact a Timeback admin to set up your account.");
+      if (result.reason !== "not_found") {
+        s.stop(red("Account check failed"));
+        M2.error(result.error ?? "Unknown error");
+        if (!inline)
+          outro.error("Account check failed");
+        if (exitOnComplete)
+          process.exit(1);
+        return;
+      }
+      s.stop(red("No account found"));
+      const { success: accountCreated, declined } = await createAccountFlow({
+        environment: targetEnv,
+        clientId: currentCreds.clientId,
+        clientSecret: currentCreds.clientSecret,
+        email: email3
+      });
+      if (!emailUnchanged) {
+        await saveCredentials(targetEnv, {
+          ...currentCreds,
+          email: email3
+        });
+        M2.success(`Email saved for ${targetEnv}`);
+      }
+      if (!inline) {
+        if (accountCreated || declined) {
+          outro.success();
+        } else {
+          outro.info("Setup incomplete - run this command again to finish");
+        }
+      }
+      if (exitOnComplete)
+        process.exit(0);
+      return;
+    }
+    s.stop(green("Account verified"));
+    if (emailUnchanged) {
       if (!inline)
-        outro.error("Email validation failed");
+        outro.info("Email unchanged");
       if (exitOnComplete)
-        process.exit(1);
+        process.exit(0);
       return;
     }
     await saveCredentials(targetEnv, {
       ...currentCreds,
       email: email3
     });
-    s.stop(green(`Email updated for ${targetEnv}`));
+    M2.success(`Email updated for ${targetEnv}`);
     if (!inline)
       outro.success();
     if (exitOnComplete)
@@ -17846,7 +18055,7 @@ async function handleCredentialSetup(options = {}) {
   };
 }
 // src/cli/lib/onboarding/import.ts
-import { TimebackClient as TimebackClient3 } from "@timeback/core";
+import { TimebackClient as TimebackClient4 } from "@timeback/core";
 async function promptImportApp(credentials, configuredEnvs) {
   let env2;
   if (configuredEnvs.length === 1 && configuredEnvs[0]) {
@@ -17859,7 +18068,7 @@ async function promptImportApp(credentials, configuredEnvs) {
     env2 = selectedEnv;
   }
   const creds = credentials[env2];
-  const client = new TimebackClient3({
+  const client = new TimebackClient4({
     env: env2,
     auth: { clientId: creds.clientId, clientSecret: creds.clientSecret }
   });
@@ -20289,7 +20498,8 @@ var cors = (options) => {
 async function handleBootstrap(c, ctx) {
   const { bootstrap } = c.get("services");
   const env2 = c.get("env");
-  const email3 = ctx.credentials[env2]?.email;
+  const freshCredentials = await getSavedCredentials(env2);
+  const email3 = freshCredentials?.email;
   const courseIds = ctx.userConfig.courseIds[env2];
   const result = await bootstrap.getBootstrap({ email: email3, courseIds });
   return c.json(result);
@@ -21221,11 +21431,15 @@ class StatusService {
   }
   async getStatus() {
     const configuredEnvironments = await getConfiguredEnvironments();
+    const [stagingCreds, productionCreds] = await Promise.all([
+      getSavedCredentials("staging"),
+      getSavedCredentials("production")
+    ]);
     return {
       config: this.ctx.userConfig,
       environment: this.ctx.defaultEnvironment,
       configuredEnvironments,
-      hasEmail: !!this.ctx.credentials.staging?.email || !!this.ctx.credentials.production?.email
+      hasEmail: !!stagingCreds?.email || !!productionCreds?.email
     };
   }
 }

package/dist/server/controllers/bootstrap.d.ts

@@ -11,6 +11,9 @@ import type { EnvVariables } from '../lib';
  *
  * Requires env middleware to set `env` and `client` context variables.
  *
+ * NOTE: We read credentials fresh from disk to pick up changes made via CLI
+ * (e.g., email updates, account creation) without requiring a server restart.
+ *
  * @param c - Hono context with env variables
  * @param ctx - App context
  * @returns JSON response with user and courses

package/dist/server/controllers/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAU7F"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/server/controllers/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC;IAAE,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,GAAG,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAW7F"}

package/dist/server/services/status.d.ts

@@ -15,10 +15,13 @@ export declare class StatusService {
     private readonly ctx;
     constructor(ctx: AppContext);
     /**
- * Build the status payload.
- *
- * @returns Status payload object
- */
+     * Build the status payload.
+     *
+     * NOTE: We read credentials fresh from disk to pick up changes made via CLI
+     * (e.g., email updates, account creation) without requiring a server restart.
+     *
+     * @returns Status payload object
+     */
     getStatus(): Promise<StatusEventPayload>;
 }
 //# sourceMappingURL=status.d.ts.map

package/dist/server/services/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/server/services/status.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD;;;;;GAKG;AACH,qBAAa,aAAa;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAY;IAEhC,YAAY,GAAG,EAAE,UAAU,EAE1B;IAED;;;;GAIE;IACI,SAAS,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAU7C;CACD"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/server/services/status.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErD;;;;;GAKG;AACH,qBAAa,aAAa;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAY;IAEhC,YAAY,GAAG,EAAE,UAAU,EAE1B;IAED;;;;;;;OAOG;IACG,SAAS,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAc7C;CACD"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "timeback-studio",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"type": "module",
 	"exports": {
 		".": {