timeback-studio 0.1.6 → 0.1.8

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);
@@ -22727,6 +22937,7 @@ function createLogger(options = {}) {
 }
 // src/server/services/bootstrap.ts
 var log = createLogger({ scope: "studio:service:bootstrap" });
+var hasLoggedInitialLoad = false;
 
 class BootstrapService {
   client;
@@ -22757,8 +22968,11 @@ class BootstrapService {
       stats,
       errors: errors3.length
     });
-    const message = `Loaded ${underline(stats.totalCourses)} ${pluralize(stats.totalCourses, "course")}, ${underline(stats.totalStudents)} ${pluralize(stats.totalStudents, "student")}`;
-    M2.success(message);
+    if (!hasLoggedInitialLoad) {
+      const message = `Loaded ${underline(stats.totalCourses)} ${pluralize(stats.totalCourses, "course")}, ${underline(stats.totalStudents)} ${pluralize(stats.totalStudents, "student")}`;
+      M2.success(message);
+      hasLoggedInitialLoad = true;
+    }
     return {
       user,
       courses,
@@ -23238,48 +23452,107 @@ class EventsService {
     return result;
   }
 }
-// src/server/services/live.ts
-var log4 = createLogger({ scope: "studio:service:live" });
+// src/server/services/live-poller.ts
+var log4 = createLogger({ scope: "studio:service:live-poller" });
+var pollers = new Map;
+function getOrCreatePoller(environment, statusService, eventsService) {
+  let poller = pollers.get(environment);
+  if (!poller) {
+    poller = new LivePoller({ environment, statusService, eventsService });
+    pollers.set(environment, poller);
+  }
+  return poller;
+}
 
-class LiveService {
+class LivePoller {
+  environment;
   statusService;
   eventsService;
+  subscribers = new Set;
+  interval = null;
+  state;
+  lastBroadcast;
+  initialTickPromise = null;
+  ticking = false;
   constructor(options) {
+    this.environment = options.environment;
     this.statusService = options.statusService;
     this.eventsService = options.eventsService;
-  }
-  static createInitialState() {
     const now = Date.now();
-    return {
+    this.state = {
       lastStatusHash: "",
       lastEventTime: new Date().toISOString(),
       lastStatusTick: now,
       lastEventsTick: now
     };
   }
-  async tick(state) {
-    const updates = [];
-    const now = Date.now();
-    const newState = { ...state };
-    const statusUpdate = await this.fetchStatusIfChanged(state.lastStatusHash);
-    if (statusUpdate) {
-      updates.push(statusUpdate.update);
-      newState.lastStatusHash = statusUpdate.hash;
+  subscribe(callback) {
+    this.subscribers.add(callback);
+    if (this.subscribers.size === 1) {
+      this.start();
     }
-    newState.lastStatusTick = now;
-    const shouldCheckEvents = this.hasIntervalElapsed(state.lastEventsTick, now, constants.events.polling.tickIntervalMs);
-    if (shouldCheckEvents) {
-      const eventsUpdate = await this.fetchEventsIfNew(state.lastEventTime);
-      if (eventsUpdate) {
-        updates.push(eventsUpdate.update);
-        newState.lastEventTime = eventsUpdate.newEventTime;
+    return () => {
+      this.subscribers.delete(callback);
+      if (this.subscribers.size === 0) {
+        this.stop();
+        pollers.delete(this.environment);
       }
-      newState.lastEventsTick = now;
+    };
+  }
+  async getLastBroadcastAfterInitialTick() {
+    if (this.initialTickPromise) {
+      await this.initialTickPromise;
+    }
+    return this.lastBroadcast;
+  }
+  start() {
+    log4.debug("Poller started", { environment: this.environment });
+    this.initialTickPromise = this.tick();
+    this.interval = setInterval(() => this.tick(), constants.sse.defaultTickIntervalMs);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
     }
-    return { updates, newState };
+    this.lastBroadcast = undefined;
+    this.initialTickPromise = null;
+    log4.debug("Poller stopped", { environment: this.environment });
   }
-  hasIntervalElapsed(lastTick, now, intervalMs) {
-    return now - lastTick >= intervalMs;
+  async tick() {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      const updates = [];
+      const now = Date.now();
+      const statusUpdate = await this.fetchStatusIfChanged(this.state.lastStatusHash);
+      if (statusUpdate) {
+        updates.push(statusUpdate.update);
+        this.state.lastStatusHash = statusUpdate.hash;
+      }
+      this.state.lastStatusTick = now;
+      const shouldCheckEvents = now - this.state.lastEventsTick >= constants.events.polling.tickIntervalMs;
+      if (shouldCheckEvents) {
+        const eventsUpdate = await this.fetchEventsIfNew(this.state.lastEventTime);
+        if (eventsUpdate) {
+          updates.push(eventsUpdate.update);
+          this.state.lastEventTime = eventsUpdate.newEventTime;
+        }
+        this.state.lastEventsTick = now;
+      }
+      if (updates.length > 0) {
+        const data = JSON.stringify(updates);
+        this.lastBroadcast = data;
+        for (const callback of this.subscribers) {
+          callback(data);
+        }
+      }
+    } catch (error48) {
+      log4.error("Tick failed", { environment: this.environment, error: error48 });
+    } finally {
+      this.ticking = false;
+    }
   }
   async fetchStatusIfChanged(lastHash) {
     try {
@@ -23306,7 +23579,8 @@ class LiveService {
       }
       const message = `${underline(newEvents.length)} new ${pluralize(newEvents.length, "event")}`;
       M2.message(message, { symbol: magenta("◆") });
-      const mostRecentTime = newEvents.map((e2) => e2.eventTime).sort().pop();
+      const mostRecentTime = newEvents.map((e2) => new Date(e2.eventTime).getTime()).sort((a, b3) => a - b3).pop();
+      const newEventTime = mostRecentTime === undefined ? lastEventTime : new Date(mostRecentTime + 1).toISOString();
       return {
         update: {
           type: "events",
@@ -23315,7 +23589,7 @@ class LiveService {
             timestamp: new Date().toISOString()
           }
         },
-        newEventTime: mostRecentTime ?? lastEventTime
+        newEventTime
       };
     } catch (error48) {
       log4.error("Failed to fetch events", { error: error48 });
@@ -23331,11 +23605,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
     };
   }
 }
@@ -23716,6 +23994,7 @@ function runSSE(c, options) {
     } catch {
       abort("write error");
     }
+    options.onClose?.();
     unregisterConnection(key, () => abort("superseded"));
     log8.debug("SSE connection closed", { ...meta3, reason: closeReason });
   });
@@ -23818,20 +24097,41 @@ function handleEventsStream(c) {
 }
 // src/server/controllers/live.ts
 function handleLive(c) {
+  const env2 = c.get("env");
   const { status: statusService, events: eventsService } = c.get("services");
-  const liveService = new LiveService({ statusService, eventsService });
-  let state = LiveService.createInitialState();
+  const poller = getOrCreatePoller(env2, statusService, eventsService);
+  let pending;
+  let isFirstTick = true;
+  const takePending = () => {
+    const data = pending;
+    pending = undefined;
+    return data;
+  };
+  const unsubscribe = poller.subscribe((data) => {
+    pending = data;
+  });
   return runSSE(c, {
     event: "live",
     intervalMs: constants.sse.defaultTickIntervalMs,
     sendInitial: true,
+    onClose: unsubscribe,
     tick: async () => {
-      const result = await liveService.tick(state);
-      state = result.newState;
-      if (result.updates.length === 0) {
-        return;
+      if (isFirstTick) {
+        isFirstTick = false;
+        const immediate = takePending();
+        if (immediate !== undefined) {
+          return immediate;
+        }
+        const initial = await poller.getLastBroadcastAfterInitialTick();
+        if (pending !== undefined && pending === initial) {
+          pending = undefined;
+        }
+        if (initial !== undefined) {
+          return initial;
+        }
+        return takePending();
       }
-      return JSON.stringify(result.updates);
+      return takePending();
     }
   });
 }

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"}