timeback 0.0.0-alpha.2 → 0.1.1

package/dist/index.js

@@ -1,17 +1,1379 @@
-// src/index.ts
-function identity(value) {
-  return value;
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/.bun/colorette@2.0.20/node_modules/colorette/index.js
+import * as tty from "tty";
+var {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+var isWindows = platform === "win32";
+var isDumbTerminal = env.TERM === "dumb";
+var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+var isCI = "CI" in env && (("GITHUB_ACTIONS" in env) || ("GITLAB_CI" in env) || ("CIRCLECI" in env));
+var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+var clearBleed = (index, string, open, close, replace) => index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+var filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === "" || string === undefined) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
+var init = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+var colors = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49)
+};
+var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors : Object.keys(colors).reduce((colors2, key) => ({ ...colors2, [key]: String }), {});
+var {
+  reset,
+  bold,
+  dim,
+  italic,
+  underline,
+  inverse,
+  hidden,
+  strikethrough,
+  black,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  gray,
+  bgBlack,
+  bgRed,
+  bgGreen,
+  bgYellow,
+  bgBlue,
+  bgMagenta,
+  bgCyan,
+  bgWhite,
+  blackBright,
+  redBright,
+  greenBright,
+  yellowBright,
+  blueBright,
+  magentaBright,
+  cyanBright,
+  whiteBright,
+  bgBlackBright,
+  bgRedBright,
+  bgGreenBright,
+  bgYellowBright,
+  bgBlueBright,
+  bgMagentaBright,
+  bgCyanBright,
+  bgWhiteBright
+} = createColors();
+
+// ../internal/cli-infra/src/config/timeback.ts
+import { existsSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { createJiti } from "jiti";
+
+// ../types/src/zod/primitives.ts
+import { z } from "zod/v4";
+var TimebackSubject = z.enum([
+  "Reading",
+  "Language",
+  "Vocabulary",
+  "Social Studies",
+  "Writing",
+  "Science",
+  "FastMath",
+  "Math",
+  "None"
+]);
+var TimebackGrade = z.union([
+  z.literal(-1),
+  z.literal(0),
+  z.literal(1),
+  z.literal(2),
+  z.literal(3),
+  z.literal(4),
+  z.literal(5),
+  z.literal(6),
+  z.literal(7),
+  z.literal(8),
+  z.literal(9),
+  z.literal(10),
+  z.literal(11),
+  z.literal(12),
+  z.literal(13)
+]);
+var ScoreStatus = z.enum([
+  "exempt",
+  "fully graded",
+  "not submitted",
+  "partially graded",
+  "submitted"
+]);
+var OrganizationType = z.enum([
+  "department",
+  "school",
+  "district",
+  "local",
+  "state",
+  "national"
+]);
+var OneRosterUserRole = z.enum([
+  "administrator",
+  "aide",
+  "guardian",
+  "parent",
+  "proctor",
+  "relative",
+  "student",
+  "teacher"
+]);
+var EnrollmentRole = z.enum(["administrator", "proctor", "student", "teacher"]);
+var LessonType = z.enum(["powerpath-100", "quiz", "test-out", "placement", "unit-test", "alpha-read-article"]).nullable();
+var IMSErrorResponse = z.object({
+  imsx_codeMajor: z.enum(["failure", "success"]),
+  imsx_severity: z.enum(["error", "warning", "status"]),
+  imsx_description: z.string(),
+  imsx_CodeMinor: z.object({
+    imsx_codeMinorField: z.array(z.object({
+      imsx_codeMinorFieldName: z.string(),
+      imsx_codeMinorFieldValue: z.string()
+    }))
+  }).optional()
+});
+// ../types/src/zod/caliper.ts
+import { z as z2 } from "zod/v4";
+var TimebackUser = z2.object({
+  id: z2.string(),
+  type: z2.literal("TimebackUser"),
+  email: z2.string()
+});
+var TimebackActivityContext = z2.object({
+  id: z2.string(),
+  type: z2.literal("TimebackActivityContext"),
+  subject: TimebackSubject,
+  app: z2.object({ name: z2.string() }).optional(),
+  activity: z2.object({ id: z2.string().optional(), name: z2.string().optional() }).optional(),
+  course: z2.object({ id: z2.string(), name: z2.string() }),
+  process: z2.boolean().optional()
+});
+var CaliperEventBase = z2.object({
+  "@context": z2.literal("http://purl.imsglobal.org/ctx/caliper/v1p2"),
+  id: z2.string(),
+  type: z2.string(),
+  eventTime: z2.string(),
+  profile: z2.literal("TimebackProfile"),
+  actor: TimebackUser,
+  action: z2.string(),
+  object: TimebackActivityContext,
+  edApp: z2.object({ id: z2.string(), name: z2.string().optional() }).optional()
+});
+var TimebackActivityMetric = z2.object({
+  type: z2.enum(["totalQuestions", "correctQuestions", "xpEarned", "masteredUnits"]),
+  value: z2.number()
+});
+var TimebackActivityMetricsCollection = z2.object({
+  id: z2.string(),
+  type: z2.literal("TimebackActivityMetricsCollection"),
+  attempt: z2.number().optional(),
+  items: z2.array(TimebackActivityMetric),
+  extensions: z2.record(z2.string(), z2.unknown()).optional()
+});
+var TimebackActivityEvent = CaliperEventBase.extend({
+  type: z2.literal("ActivityEvent"),
+  action: z2.literal("Completed"),
+  generated: TimebackActivityMetricsCollection
+});
+var TimebackTimeMetric = z2.object({
+  type: z2.enum(["active", "inactive", "waste", "unknown", "anti-pattern"]),
+  value: z2.number(),
+  subType: z2.string().optional()
+});
+var TimebackTimeSpentMetricsCollection = z2.object({
+  id: z2.string(),
+  type: z2.literal("TimebackTimeSpentMetricsCollection"),
+  items: z2.array(TimebackTimeMetric)
+});
+var TimebackTimeSpentEvent = CaliperEventBase.extend({
+  type: z2.literal("TimeSpentEvent"),
+  action: z2.literal("SpentTime"),
+  generated: TimebackTimeSpentMetricsCollection
+});
+var TimebackEvent = z2.union([TimebackActivityEvent, TimebackTimeSpentEvent]);
+var CaliperEnvelope = z2.object({
+  sensor: z2.string(),
+  sendTime: z2.string(),
+  dataVersion: z2.literal("http://purl.imsglobal.org/ctx/caliper/v1p2"),
+  data: z2.array(TimebackEvent)
+});
+// ../types/src/zod/config.ts
+import { z as z3 } from "zod/v4";
+var CourseIds = z3.object({
+  staging: z3.string().optional(),
+  production: z3.string().optional()
+});
+var CourseType = z3.enum(["base", "hole-filling", "optional"]);
+var PublishStatus = z3.enum(["draft", "testing", "published", "deactivated"]);
+var CourseGoals = z3.object({
+  dailyXp: z3.number().int().positive().optional(),
+  dailyLessons: z3.number().int().positive().optional(),
+  dailyActiveMinutes: z3.number().int().positive().optional(),
+  dailyAccuracy: z3.number().int().min(0).max(100).optional(),
+  dailyMasteredUnits: z3.number().int().positive().optional()
+});
+var CourseMetrics = z3.object({
+  totalXp: z3.number().int().positive().optional(),
+  totalLessons: z3.number().int().positive().optional(),
+  totalGrades: z3.number().int().positive().optional()
+});
+var CourseMetadata = z3.object({
+  courseType: CourseType.optional(),
+  isSupplemental: z3.boolean().optional(),
+  isCustom: z3.boolean().optional(),
+  publishStatus: PublishStatus.optional(),
+  contactEmail: z3.email().optional(),
+  primaryApp: z3.string().optional(),
+  goals: CourseGoals.optional(),
+  metrics: CourseMetrics.optional()
+});
+var CourseDefaults = z3.object({
+  courseCode: z3.string().optional(),
+  level: z3.string().optional(),
+  metadata: CourseMetadata.optional()
+});
+var CourseConfig = CourseDefaults.extend({
+  subject: TimebackSubject,
+  grade: TimebackGrade,
+  ids: CourseIds.nullable().optional()
+});
+var TimebackConfig = z3.object({
+  name: z3.string().min(1, "App name is required"),
+  defaults: CourseDefaults.optional(),
+  courses: z3.array(CourseConfig).min(1, "At least one course is required"),
+  sensors: z3.array(z3.string().url()).optional()
+});
+// ../types/src/zod/edubridge.ts
+import { z as z4 } from "zod/v4";
+var EduBridgeEnrollment = z4.object({
+  id: z4.string(),
+  role: z4.string(),
+  beginDate: z4.string().nullable(),
+  endDate: z4.string().nullable(),
+  metadata: z4.object({
+    goals: z4.object({ dailyXp: z4.number().optional() }).optional(),
+    metrics: z4.object({ totalXp: z4.number().optional(), totalLessons: z4.number().optional() }).optional()
+  }).optional(),
+  course: z4.object({
+    id: z4.string(),
+    title: z4.string(),
+    subjects: z4.array(z4.string()).nullable(),
+    grades: z4.array(z4.string()).nullable()
+  }),
+  school: z4.object({
+    id: z4.string(),
+    name: z4.string()
+  })
+});
+var SubjectMetrics = z4.object({
+  activityMetrics: z4.object({
+    xpEarned: z4.number(),
+    totalQuestions: z4.number(),
+    correctQuestions: z4.number(),
+    masteredUnits: z4.number()
+  }),
+  timeSpentMetrics: z4.object({
+    activeSeconds: z4.number(),
+    inactiveSeconds: z4.number(),
+    wasteSeconds: z4.number()
+  }),
+  apps: z4.array(z4.string())
+});
+var EduBridgeAnalyticsFacts = z4.record(z4.string(), z4.record(z4.string(), SubjectMetrics));
+var EduBridgeEnrollmentAnalyticsResponse = z4.object({
+  message: z4.string(),
+  enrollmentId: z4.string(),
+  startDate: z4.string(),
+  endDate: z4.string(),
+  facts: EduBridgeAnalyticsFacts,
+  factsByApp: z4.unknown()
+});
+var SubjectTrackInput = z4.object({
+  subject: z4.string(),
+  gradeLevel: z4.string(),
+  targetCourseId: z4.string(),
+  metadata: z4.record(z4.string(), z4.unknown()).optional()
+});
+// ../types/src/zod/qti.ts
+import { z as z5 } from "zod/v4";
+var QtiAssessmentItemType = z5.enum([
+  "choice",
+  "text-entry",
+  "extended-text",
+  "inline-choice",
+  "match",
+  "order",
+  "associate",
+  "select-point",
+  "graphic-order",
+  "graphic-associate",
+  "graphic-gap-match",
+  "hotspot",
+  "hottext",
+  "slider",
+  "drawing",
+  "media",
+  "upload"
+]);
+var QtiCardinality = z5.enum(["single", "multiple", "ordered", "record"]);
+var QtiBaseType = z5.enum([
+  "identifier",
+  "boolean",
+  "integer",
+  "float",
+  "string",
+  "point",
+  "pair",
+  "directedPair",
+  "duration",
+  "file",
+  "uri"
+]);
+var QtiDifficulty = z5.enum(["easy", "medium", "hard"]);
+var QtiNavigationMode = z5.enum(["linear", "nonlinear"]);
+var QtiSubmissionMode = z5.enum(["individual", "simultaneous"]);
+var QtiShowHide = z5.enum(["show", "hide"]);
+var QtiValidationSchema = z5.enum(["test", "item", "stimulus"]);
+var QtiFeedbackType = z5.enum(["QUESTION", "LESSON"]);
+var QtiCorrectResponse = z5.object({
+  value: z5.array(z5.string())
+}).strict();
+var QtiResponseDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional(),
+  correctResponse: QtiCorrectResponse
+}).strict();
+var QtiOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality,
+  baseType: QtiBaseType.optional()
+}).strict();
+var QtiTestOutcomeDeclaration = z5.object({
+  identifier: z5.string().min(1),
+  cardinality: QtiCardinality.optional(),
+  baseType: QtiBaseType,
+  normalMaximum: z5.number().optional(),
+  normalMinimum: z5.number().optional(),
+  defaultValue: z5.object({
+    value: z5.unknown().optional()
+  }).strict().optional()
+}).strict();
+var QtiInlineFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  variableIdentifier: z5.string().min(1)
+}).strict();
+var QtiResponseProcessing = z5.object({
+  templateType: z5.enum(["match_correct", "map_response"]),
+  responseDeclarationIdentifier: z5.string().min(1),
+  outcomeIdentifier: z5.string().min(1),
+  correctResponseIdentifier: z5.string().min(1),
+  incorrectResponseIdentifier: z5.string().min(1),
+  inlineFeedback: QtiInlineFeedback.optional()
+}).strict();
+var QtiLearningObjectiveSet = z5.object({
+  source: z5.string().min(1),
+  learningObjectiveIds: z5.array(z5.string())
+}).strict();
+var QtiItemMetadata = z5.object({
+  subject: z5.string().optional(),
+  grade: TimebackGrade.optional(),
+  difficulty: QtiDifficulty.optional(),
+  learningObjectiveSet: z5.array(QtiLearningObjectiveSet).optional()
+}).strict();
+var QtiModalFeedback = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  title: z5.string()
+}).strict();
+var QtiFeedbackInline = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiFeedbackBlock = z5.object({
+  outcomeIdentifier: z5.string().min(1),
+  identifier: z5.string().min(1),
+  showHide: QtiShowHide,
+  content: z5.string(),
+  class: z5.array(z5.string())
+}).strict();
+var QtiStylesheet = z5.object({
+  href: z5.string().min(1),
+  type: z5.string().min(1)
+}).strict();
+var QtiCatalogInfo = z5.object({
+  id: z5.string().min(1),
+  support: z5.string(),
+  content: z5.string()
+}).strict();
+var QtiAssessmentItemCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional()
+}).strict();
+var QtiAssessmentItemUpdateInput = z5.object({
+  title: z5.string().min(1),
+  type: QtiAssessmentItemType,
+  qtiVersion: z5.string().optional(),
+  timeDependent: z5.boolean().optional(),
+  adaptive: z5.boolean().optional(),
+  responseDeclarations: z5.array(QtiResponseDeclaration).optional(),
+  outcomeDeclarations: z5.array(QtiOutcomeDeclaration).optional(),
+  responseProcessing: QtiResponseProcessing.optional(),
+  metadata: QtiItemMetadata.optional(),
+  modalFeedback: z5.array(QtiModalFeedback).optional(),
+  feedbackInline: z5.array(QtiFeedbackInline).optional(),
+  feedbackBlock: z5.array(QtiFeedbackBlock).optional(),
+  rawXml: z5.string(),
+  content: z5.record(z5.string(), z5.unknown())
+}).strict();
+var QtiAssessmentItemProcessResponseInput = z5.object({
+  response: z5.union([z5.string(), z5.array(z5.string())])
+}).strict();
+var QtiAssessmentItemRef = z5.object({
+  identifier: z5.string().min(1),
+  href: z5.union([z5.string(), z5.array(z5.string()), z5.array(z5.array(z5.string()))]).optional(),
+  sequence: z5.number().optional()
+}).strict();
+var QtiAssessmentSection = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  visible: z5.boolean(),
+  required: z5.boolean().optional(),
+  fixed: z5.boolean().optional(),
+  sequence: z5.number().optional(),
+  "qti-assessment-item-ref": z5.array(QtiAssessmentItemRef).optional()
+}).strict();
+var QtiTestPart = z5.object({
+  identifier: z5.string().min(1),
+  navigationMode: QtiNavigationMode,
+  submissionMode: QtiSubmissionMode,
+  "qti-assessment-section": z5.union([QtiAssessmentSection, z5.array(QtiAssessmentSection)])
+}).strict();
+var QtiAssessmentTestCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiAssessmentTestUpdateInput = z5.object({
+  title: z5.string().min(1),
+  qtiVersion: z5.string().optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  timeLimit: z5.number().optional(),
+  maxAttempts: z5.number().optional(),
+  toolsEnabled: z5.record(z5.string(), z5.boolean()).optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional(),
+  "qti-test-part": QtiTestPart,
+  "qti-outcome-declaration": z5.array(QtiTestOutcomeDeclaration).optional()
+}).strict();
+var QtiStimulusCreateInput = z5.object({
+  identifier: z5.string().min(1),
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiStimulusUpdateInput = z5.object({
+  title: z5.string().min(1),
+  label: z5.string().optional(),
+  language: z5.string().optional(),
+  stylesheet: QtiStylesheet.optional(),
+  content: z5.string(),
+  catalogInfo: z5.array(QtiCatalogInfo).optional(),
+  toolName: z5.string().optional(),
+  toolVersion: z5.string().optional(),
+  metadata: z5.record(z5.string(), z5.unknown()).optional()
+}).strict();
+var QtiValidateInput = z5.object({
+  xml: z5.string().optional(),
+  schema: QtiValidationSchema,
+  entityId: z5.string().optional()
+}).strict();
+var QtiValidateBatchInput = z5.object({
+  xml: z5.array(z5.string()),
+  schema: QtiValidationSchema,
+  entityIds: z5.array(z5.string())
+}).strict();
+var QtiLessonFeedbackInput = z5.object({
+  questionId: z5.string().optional(),
+  userId: z5.string().min(1),
+  feedback: z5.string().min(1),
+  lessonId: z5.string().min(1),
+  humanApproved: z5.boolean().optional()
+}).strict();
+// ../internal/cli-infra/src/credentials/store.ts
+import { homedir, platform as platform2 } from "node:os";
+import { join } from "node:path";
+
+// ../internal/cli-infra/src/credentials/schema.ts
+import { z as z6 } from "zod";
+var CredentialsSchema = z6.object({
+  clientId: z6.string().min(1, "Client ID is required"),
+  clientSecret: z6.string().min(1, "Client secret is required"),
+  email: z6.email("Valid email is required").optional()
+});
+var ClientIdSchema = z6.string().min(1, "Client ID is required").regex(/^[a-z0-9]+$/, "Client ID must contain only lowercase letters and numbers").length(26, "Client ID must be exactly 26 characters");
+var ClientSecretSchema = z6.string().min(1, "Client secret is required").regex(/^[a-z0-9]+$/, "Client secret must contain only lowercase letters and numbers").max(53, "Client secret must be less than 53 characters");
+
+// ../internal/cli-infra/src/credentials/store.ts
+function getConfigDir() {
+  const home = homedir();
+  switch (platform2()) {
+    case "darwin":
+      return join(home, ".timeback");
+    case "win32":
+      return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "timeback");
+    default:
+      return join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "timeback");
+  }
 }
-function noop() {}
-function yes() {
-  return true;
+var CREDENTIALS_DIR = getConfigDir();
+var CREDENTIALS_FILE = join(CREDENTIALS_DIR, "credentials.json");
+
+// ../internal/cli-infra/src/config/timeback.ts
+var FILE_PATTERNS = ["timeback.config.ts", "timeback.config.js", "timeback.config.mjs"];
+var jiti = createJiti(import.meta.url, { fsCache: false });
+async function importModule(fullPath) {
+  const module = await jiti.import(fullPath);
+  return module.default ?? module;
 }
-function no() {
+async function loadConfig(opts = {}) {
+  const cwd = process.cwd();
+  let rawConfig = null;
+  let foundPath = null;
+  let loadError = null;
+  if (opts.configPath) {
+    const fullPath = resolve(cwd, opts.configPath);
+    if (!existsSync(fullPath)) {
+      return {
+        success: false,
+        error: `Config file not found: ${opts.configPath}`
+      };
+    }
+    try {
+      rawConfig = await importModule(fullPath);
+      foundPath = fullPath;
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to load ${opts.configPath}:
+${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  } else {
+    for (const filename of FILE_PATTERNS) {
+      const fullPath = resolve(cwd, filename);
+      if (!existsSync(fullPath))
+        continue;
+      try {
+        rawConfig = await importModule(fullPath);
+        foundPath = fullPath;
+        break;
+      } catch (err) {
+        loadError = err instanceof Error ? err : new Error(String(err));
+        foundPath = fullPath;
+        break;
+      }
+    }
+  }
+  if (loadError && foundPath) {
+    return {
+      success: false,
+      error: `Failed to load ${basename(foundPath)}:
+${loadError.message}`
+    };
+  }
+  if (!rawConfig || !foundPath) {
+    return {
+      success: false,
+      error: `No timeback config found. Run ${greenBright("timeback init")} to create one.`
+    };
+  }
+  const result = TimebackConfig.safeParse(rawConfig);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join(`
+`);
+    return {
+      success: false,
+      error: `Invalid config in ${basename(foundPath)}:
+${issues}`
+    };
+  }
+  return {
+    success: true,
+    config: result.data,
+    configPath: foundPath
+  };
+}
+// src/shared/constants.ts
+var ROUTES = {
+  ACTIVITY: "/activity",
+  IDENTITY: {
+    SIGNIN: "/identity/signin",
+    SIGNOUT: "/identity/signout",
+    CALLBACK: "/identity/callback"
+  },
+  USER: {
+    ME: "/user/me"
+  }
+};
+
+// ../internal/logger/src/debug.ts
+var patterns = null;
+var debugAll = false;
+var debugEnvSet = false;
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${regexStr}$`);
+}
+function parseDebugEnv() {
+  if (patterns !== null)
+    return;
+  patterns = [];
+  if (typeof process === "undefined" || !process.env?.DEBUG) {
+    debugEnvSet = false;
+    return;
+  }
+  debugEnvSet = true;
+  const debugValue = process.env.DEBUG.trim();
+  if (debugValue === "1" || debugValue === "true" || debugValue === "*") {
+    debugAll = true;
+    return;
+  }
+  const parts = debugValue.split(",").map((p) => p.trim()).filter(Boolean);
+  for (const part of parts) {
+    if (part.startsWith("-")) {
+      patterns.push({
+        regex: patternToRegex(part.slice(1)),
+        exclude: true
+      });
+    } else {
+      patterns.push({
+        regex: patternToRegex(part),
+        exclude: false
+      });
+    }
+  }
+  const hasInclude = patterns.some((p) => !p.exclude);
+  if (!hasInclude && patterns.length > 0) {
+    debugAll = true;
+  }
+}
+function shouldShowDebug(scope) {
+  parseDebugEnv();
+  if (!debugEnvSet) {
+    return true;
+  }
+  if (debugAll) {
+    if (scope) {
+      for (const pattern of patterns) {
+        if (pattern.exclude && pattern.regex.test(scope)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  if (!scope) {
+    return false;
+  }
+  for (const pattern of patterns) {
+    if (pattern.exclude && pattern.regex.test(scope)) {
+      return false;
+    }
+  }
+  for (const pattern of patterns) {
+    if (!pattern.exclude && pattern.regex.test(scope)) {
+      return true;
+    }
+  }
   return false;
 }
+
+// ../internal/logger/src/env.ts
+function isBrowser() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+function detectEnvironment() {
+  if (isBrowser()) {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.env) {
+    if (process.env["NODE_ENV"] === "test" || process.env["BUN_ENV"] === "test") {
+      return "test";
+    }
+    if (false) {}
+    if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE) {
+      return "ci";
+    }
+  }
+  return "terminal";
+}
+
+// ../internal/logger/src/formatters/terminal.ts
+var nodeInspect;
+if (!isBrowser()) {
+  try {
+    const util = await import("node:util");
+    nodeInspect = util.inspect;
+  } catch {}
+}
+var colors2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m"
+};
+function getLevelColor(level) {
+  switch (level) {
+    case "debug":
+      return colors2.blue;
+    case "info":
+      return colors2.cyan;
+    case "warn":
+      return colors2.yellow;
+    case "error":
+      return colors2.red;
+  }
+}
+function getConsoleMethod(level) {
+  switch (level) {
+    case "debug":
+      return console.debug;
+    case "info":
+      return console.info;
+    case "warn":
+      return console.warn;
+    case "error":
+      return console.error;
+  }
+}
+function formatContext(context) {
+  if (nodeInspect) {
+    return nodeInspect(context, {
+      depth: null,
+      colors: true,
+      breakLength: 80,
+      compact: false
+    });
+  }
+  return JSON.stringify(context, null, 2);
+}
+var terminalFormatter = (entry) => {
+  const levelColor = getLevelColor(entry.level);
+  const consoleMethod = getConsoleMethod(entry.level);
+  const levelUpper = entry.level.toUpperCase().padEnd(5);
+  const isoString = entry.timestamp.toISOString().replace(/\.\d{3}Z$/, "");
+  const timestamp = `${colors2.dim}[${isoString}]${colors2.reset}`;
+  const level = `${levelColor}${levelUpper}${colors2.reset}`;
+  const scope = entry.scope ? `${colors2.bold}[${entry.scope}]${colors2.reset} ` : "";
+  const prefix = `${timestamp} ${level} ${scope}${entry.message}`;
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    consoleMethod(prefix, formatContext(entry.context));
+  } else {
+    consoleMethod(prefix);
+  }
+};
+// ../internal/logger/src/formatters/ci.ts
+var LEVEL_PREFIX = {
+  debug: "[DEBUG]",
+  info: "[INFO]",
+  warn: "[WARN]",
+  error: "[ERROR]"
+};
+function formatContext2(context) {
+  return Object.entries(context).map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  if (value === undefined)
+    return "undefined";
+  return JSON.stringify(value);
+}
+var ciFormatter = (entry) => {
+  const parts = [];
+  parts.push(entry.timestamp.toISOString());
+  parts.push(LEVEL_PREFIX[entry.level]);
+  if (entry.scope) {
+    parts.push(`[${entry.scope}]`);
+  }
+  parts.push(entry.message);
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    parts.push(formatContext2(entry.context));
+  }
+  console.log(parts.join(" "));
+};
+// ../internal/logger/src/formatters/production.ts
+var productionFormatter = (entry) => {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    ...entry.scope && { scope: entry.scope },
+    msg: entry.message
+  };
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    Object.assign(output, entry.context);
+  }
+  console.log(JSON.stringify(output));
+};
+// ../internal/logger/src/formatters/browser.ts
+var LEVEL_STYLES = {
+  debug: "color: gray",
+  info: "color: #0ea5e9",
+  warn: "color: #f59e0b",
+  error: "color: #ef4444; font-weight: bold"
+};
+var LEVEL_METHODS = {
+  debug: "log",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var browserFormatter = (entry) => {
+  const method = LEVEL_METHODS[entry.level];
+  const style = LEVEL_STYLES[entry.level];
+  const prefix = entry.scope ? `[${entry.scope}]` : "";
+  const label = `%c${prefix} ${entry.message}`;
+  if (entry.context && Object.keys(entry.context).length > 0) {
+    console[method](label, style, entry.context);
+  } else {
+    console[method](label, style);
+  }
+};
+// ../internal/logger/src/logger.ts
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+function getFormatter(env2) {
+  switch (env2) {
+    case "terminal":
+      return terminalFormatter;
+    case "ci":
+      return ciFormatter;
+    case "production":
+      return productionFormatter;
+    case "browser":
+      return browserFormatter;
+    case "test":
+      return () => {};
+  }
+}
+function getDefaultMinLevel() {
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    return "debug";
+  }
+  return "info";
+}
+function shouldLog(level, minLevel) {
+  return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(minLevel);
+}
+
+class Logger {
+  scope;
+  minLevel;
+  environment;
+  formatter;
+  defaultContext;
+  constructor(options = {}) {
+    this.scope = options.scope;
+    this.minLevel = options.minLevel ?? getDefaultMinLevel();
+    this.defaultContext = options.defaultContext ?? {};
+    this.environment = options.environment ?? detectEnvironment();
+    this.formatter = getFormatter(this.environment);
+  }
+  child(scope) {
+    const childScope = this.scope ? `${this.scope}:${scope}` : scope;
+    return new Logger({
+      scope: childScope,
+      minLevel: this.minLevel,
+      environment: this.environment,
+      defaultContext: { ...this.defaultContext }
+    });
+  }
+  withContext(context) {
+    return new Logger({
+      scope: this.scope,
+      minLevel: this.minLevel,
+      environment: this.environment,
+      defaultContext: { ...this.defaultContext, ...context }
+    });
+  }
+  debug(message, context) {
+    this.log("debug", message, context);
+  }
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  log(level, message, context) {
+    if (level === "debug" && !shouldShowDebug(this.scope)) {
+      return;
+    }
+    if (!shouldLog(level, this.minLevel)) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      scope: this.scope,
+      context: context || Object.keys(this.defaultContext).length > 0 ? { ...this.defaultContext, ...context } : undefined,
+      timestamp: new Date
+    };
+    this.formatter(entry);
+  }
+}
+function createLogger(options = {}) {
+  return new Logger(options);
+}
+// src/server/lib/logger.ts
+function isDebug() {
+  try {
+    const debug = typeof process === "undefined" ? undefined : process.env.DEBUG;
+    return debug === "1" || debug === "true";
+  } catch {
+    return false;
+  }
+}
+function createScopedLogger(scope) {
+  return createLogger({
+    scope: `timeback:${scope}`,
+    minLevel: isDebug() ? "debug" : "warn"
+  });
+}
+var ssoLog = createScopedLogger("sso");
+var oidcLog = createScopedLogger("oidc");
+
+// src/server/lib/oidc.ts
+var discoveryCache = new Map;
+async function fetchDiscoveryDocument(issuer) {
+  const cached = discoveryCache.get(issuer);
+  if (cached) {
+    return cached;
+  }
+  const url = `${issuer}/.well-known/openid-configuration`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    oidcLog.error("Discovery fetch failed", { status: response.status });
+    throw new Error(`Failed to fetch OIDC discovery: ${response.statusText}`);
+  }
+  const doc = await response.json();
+  oidcLog.debug("Fetched OIDC discovery document", {
+    authEndpoint: doc.authorization_endpoint,
+    tokenEndpoint: doc.token_endpoint
+  });
+  discoveryCache.set(issuer, doc);
+  return doc;
+}
+function getIssuer(env2) {
+  switch (env2) {
+    case "production":
+      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_3uhuoRM3R";
+    case "staging":
+      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_5EUwTP9XD";
+    case "local":
+      throw new Error("Local environment is not yet supported for OIDC");
+  }
+}
+async function buildAuthorizationUrl(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const url = new URL(discovery.authorization_endpoint);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", params.clientId);
+  url.searchParams.set("redirect_uri", params.redirectUri);
+  url.searchParams.set("scope", "openid profile email");
+  url.searchParams.set("state", params.state);
+  return url.toString();
+}
+async function exchangeCodeForTokens(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const response = await fetch(discovery.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: params.clientId,
+      client_secret: params.clientSecret,
+      code: params.code,
+      redirect_uri: params.redirectUri
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    oidcLog.error("Token exchange failed", { status: response.status, body: text });
+    throw new Error(`Token exchange failed: ${response.status} ${text}`);
+  }
+  const tokens = await response.json();
+  oidcLog.debug("Received tokens from IdP", { expiresIn: tokens.expires_in });
+  return tokens;
+}
+async function getUserInfo(params) {
+  const discovery = await fetchDiscoveryDocument(params.issuer);
+  const response = await fetch(discovery.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${params.accessToken}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`UserInfo request failed: ${response.statusText}`);
+  }
+  return response.json();
+}
+// src/server/lib/utils.ts
+function jsonResponse(data, status = 200, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(data), { status, headers: responseHeaders });
+}
+function redirectResponse(url, headers) {
+  const responseHeaders = new Headers(headers);
+  responseHeaders.set("Location", url);
+  return new Response(null, { status: 302, headers: responseHeaders });
+}
+function encodeBase64Url(data) {
+  const json = JSON.stringify(data);
+  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(encoded) {
+  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const json = atob(padded);
+  return JSON.parse(json);
+}
+// src/server/handlers/identity.ts
+function buildErrorContext(error, errorCode, state, req) {
+  return {
+    error,
+    errorCode,
+    state,
+    req,
+    redirect: redirectResponse,
+    json: jsonResponse
+  };
+}
+async function handleSignIn(req, env2, identity) {
+  if (identity.mode !== "sso") {
+    ssoLog.warn("SSO not configured");
+    return jsonResponse({ error: "SSO not configured" }, 400);
+  }
+  const issuer = identity.issuer ?? getIssuer(env2);
+  const url = new URL(req.url);
+  let redirectUri = identity.redirectUri;
+  if (!redirectUri) {
+    const basePath = url.pathname.replace(ROUTES.IDENTITY.SIGNIN, "");
+    redirectUri = `${url.origin}${basePath}${ROUTES.IDENTITY.CALLBACK}`;
+  }
+  ssoLog.debug("SSO sign-in initiated", { env: env2, issuer, clientId: identity.clientId, redirectUri });
+  const stateData = identity.buildState ? identity.buildState({ req, url }) : {};
+  const state = encodeBase64Url(stateData);
+  const authUrl = await buildAuthorizationUrl({
+    issuer,
+    clientId: identity.clientId,
+    redirectUri,
+    state
+  });
+  ssoLog.debug("Redirecting to IdP", { url: authUrl });
+  return redirectResponse(authUrl);
+}
+async function handleCallback(req, env2, identity) {
+  if (identity.mode !== "sso") {
+    ssoLog.warn("SSO not configured");
+    return jsonResponse({ error: "SSO not configured" }, 400);
+  }
+  const url = new URL(req.url);
+  const code = url.searchParams.get("code");
+  const errorParam = url.searchParams.get("error");
+  const stateParam = url.searchParams.get("state");
+  ssoLog.debug("Received callback from IdP", { hasCode: !!code, error: errorParam });
+  const state = stateParam ? tryDecodeState(stateParam) : undefined;
+  if (errorParam) {
+    return await handleCallbackError(errorParam, url, state, req, identity);
+  }
+  if (!code) {
+    return await handleMissingCode(state, req, identity);
+  }
+  return await exchangeAndComplete(code, url, state, req, env2, identity);
+}
+function tryDecodeState(stateParam) {
+  try {
+    return decodeBase64Url(stateParam);
+  } catch {
+    ssoLog.warn("Failed to decode state");
+    return;
+  }
+}
+function handleCallbackError(errorParam, url, state, req, identity) {
+  const errorDesc = url.searchParams.get("error_description");
+  ssoLog.error("IdP returned error", { error: errorParam, description: errorDesc });
+  const error = new Error(errorDesc ?? errorParam);
+  if (identity.onCallbackError) {
+    return identity.onCallbackError(buildErrorContext(error, errorParam, state, req));
+  }
+  return jsonResponse({ error: errorParam }, 400);
+}
+function handleMissingCode(state, req, identity) {
+  ssoLog.error("Missing authorization code in callback");
+  const error = new Error("Missing authorization code");
+  if (identity.onCallbackError) {
+    return identity.onCallbackError(buildErrorContext(error, "missing_code", state, req));
+  }
+  return jsonResponse({ error: "Missing authorization code" }, 400);
+}
+async function exchangeAndComplete(code, url, state, req, env2, identity) {
+  try {
+    const issuer = identity.issuer ?? getIssuer(env2);
+    let redirectUri = identity.redirectUri;
+    if (!redirectUri) {
+      const basePath = url.pathname.replace(ROUTES.IDENTITY.CALLBACK, "");
+      redirectUri = `${url.origin}${basePath}${ROUTES.IDENTITY.CALLBACK}`;
+    }
+    ssoLog.debug("Exchanging auth code for tokens", { issuer, clientId: identity.clientId });
+    const tokens = await exchangeCodeForTokens({
+      issuer,
+      clientId: identity.clientId,
+      clientSecret: identity.clientSecret,
+      code,
+      redirectUri
+    });
+    const userInfo = await getUserInfo({ issuer, accessToken: tokens.access_token });
+    const identities = typeof userInfo.identities === "string" ? JSON.parse(userInfo.identities) : userInfo.identities;
+    ssoLog.debug("SSO completed", { user: { ...userInfo, identities } });
+    const ctx = {
+      tokens,
+      user: userInfo,
+      state,
+      req,
+      redirect: redirectResponse,
+      json: jsonResponse
+    };
+    return identity.onCallbackSuccess(ctx);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error("Unknown error");
+    ssoLog.error("Token exchange failed", { error: error.message });
+    if (identity.onCallbackError) {
+      return identity.onCallbackError(buildErrorContext(error, undefined, state, req));
+    }
+    return jsonResponse({ error: error.message }, 500);
+  }
+}
+function createIdentityHandlers(params) {
+  const { env: env2, identity } = params;
+  return {
+    signIn: (req) => handleSignIn(req, env2, identity),
+    callback: (req) => handleCallback(req, env2, identity),
+    signOut: () => redirectResponse("/")
+  };
+}
+// src/server/handlers/activity.ts
+import * as z7 from "zod";
+var activityMetricsSchema = z7.object({
+  totalQuestions: z7.number().int().nonnegative().optional(),
+  correctQuestions: z7.number().int().nonnegative().optional(),
+  xpEarned: z7.number().int().nonnegative().optional(),
+  masteredUnits: z7.number().int().nonnegative().optional()
+});
+var activityEndPayloadSchema = z7.object({
+  id: z7.string().min(1),
+  name: z7.string().min(1),
+  courseCode: z7.string().min(1),
+  startedAt: z7.iso.datetime(),
+  endedAt: z7.iso.datetime(),
+  elapsedMs: z7.number().int().nonnegative(),
+  pausedMs: z7.number().int().nonnegative(),
+  metrics: activityMetricsSchema
+});
+function createActivityHandler(config2) {
+  return async (req) => {
+    try {
+      const user = await config2.identity.getUser(req);
+      if (!user) {
+        return jsonResponse({ success: false, error: "Unauthorized" }, 401);
+      }
+      const body = await req.json();
+      const parseResult = activityEndPayloadSchema.safeParse(body);
+      if (!parseResult.success) {
+        return jsonResponse({
+          success: false,
+          error: "Invalid payload",
+          details: parseResult.error.flatten()
+        }, 400);
+      }
+      const payload = parseResult.data;
+      console.log("Activity received:", {
+        user,
+        payload,
+        app: config2.appConfig
+      });
+      return jsonResponse({ success: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return jsonResponse({ success: false, error: message }, 500);
+    }
+  };
+}
+// src/server/handlers/user.ts
+function createUserHandler(config2) {
+  return async (req) => {
+    try {
+      const user = await config2.identity.getUser(req);
+      if (!user) {
+        return jsonResponse({ error: "Unauthorized" }, 401);
+      }
+      const profile = {
+        id: user.id,
+        email: user.email,
+        name: user.name
+      };
+      return jsonResponse(profile);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return jsonResponse({ error: message }, 500);
+    }
+  };
+}
+// src/server/timeback.ts
+async function createServer(config2) {
+  const configResult = await loadConfig({ configPath: config2.configPath });
+  if (!configResult.success) {
+    throw new Error(`Failed to load timeback config: ${configResult.error}`);
+  }
+  const appConfig = configResult.config;
+  const activity = createActivityHandler({
+    env: config2.env,
+    identity: config2.identity,
+    appConfig: {
+      name: appConfig.name,
+      sensors: appConfig.sensors ?? []
+    },
+    apiCredentials: config2.api
+  });
+  const identity = createIdentityHandlers({
+    env: config2.env,
+    identity: config2.identity
+  });
+  const user = createUserHandler({
+    env: config2.env,
+    identity: config2.identity,
+    apiCredentials: config2.api
+  });
+  return {
+    config: config2,
+    handle: {
+      activity,
+      identity,
+      user: {
+        me: user
+      }
+    }
+  };
+}
 export {
-  yes,
-  noop,
-  no,
-  identity
+  createServer
 };