@mod-computer/cli 0.1.0 → 0.1.1

package/dist/cli.bundle.js

@@ -837,41 +837,41 @@ var init_types = __esm({
       get description() {
         return this._def.description;
       }
-      _getType(input) {
-        return getParsedType(input.data);
+      _getType(input2) {
+        return getParsedType(input2.data);
       }
-      _getOrReturnCtx(input, ctx) {
+      _getOrReturnCtx(input2, ctx) {
         return ctx || {
-          common: input.parent.common,
-          data: input.data,
-          parsedType: getParsedType(input.data),
+          common: input2.parent.common,
+          data: input2.data,
+          parsedType: getParsedType(input2.data),
           schemaErrorMap: this._def.errorMap,
-          path: input.path,
-          parent: input.parent
+          path: input2.path,
+          parent: input2.parent
         };
       }
-      _processInputParams(input) {
+      _processInputParams(input2) {
         return {
           status: new ParseStatus(),
           ctx: {
-            common: input.parent.common,
-            data: input.data,
-            parsedType: getParsedType(input.data),
+            common: input2.parent.common,
+            data: input2.data,
+            parsedType: getParsedType(input2.data),
             schemaErrorMap: this._def.errorMap,
-            path: input.path,
-            parent: input.parent
+            path: input2.path,
+            parent: input2.parent
           }
         };
       }
-      _parseSync(input) {
-        const result = this._parse(input);
+      _parseSync(input2) {
+        const result = this._parse(input2);
         if (isAsync(result)) {
           throw new Error("Synchronous parse encountered promise.");
         }
         return result;
       }
-      _parseAsync(input) {
-        const result = this._parse(input);
+      _parseAsync(input2) {
+        const result = this._parse(input2);
         return Promise.resolve(result);
       }
       parse(data, params) {
@@ -1135,13 +1135,13 @@ var init_types = __esm({
     dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
     dateRegex = new RegExp(`^${dateRegexSource}$`);
     ZodString = class _ZodString extends ZodType {
-      _parse(input) {
+      _parse(input2) {
         if (this._def.coerce) {
-          input.data = String(input.data);
+          input2.data = String(input2.data);
         }
-        const parsedType = this._getType(input);
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.string) {
-          const ctx2 = this._getOrReturnCtx(input);
+          const ctx2 = this._getOrReturnCtx(input2);
           addIssueToContext(ctx2, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.string,
@@ -1153,8 +1153,8 @@ var init_types = __esm({
         let ctx = void 0;
         for (const check of this._def.checks) {
           if (check.kind === "min") {
-            if (input.data.length < check.value) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (input2.data.length < check.value) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_small,
                 minimum: check.value,
@@ -1166,8 +1166,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "max") {
-            if (input.data.length > check.value) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (input2.data.length > check.value) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_big,
                 maximum: check.value,
@@ -1179,10 +1179,10 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "length") {
-            const tooBig = input.data.length > check.value;
-            const tooSmall = input.data.length < check.value;
+            const tooBig = input2.data.length > check.value;
+            const tooSmall = input2.data.length < check.value;
             if (tooBig || tooSmall) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               if (tooBig) {
                 addIssueToContext(ctx, {
                   code: ZodIssueCode.too_big,
@@ -1205,8 +1205,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "email") {
-            if (!emailRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!emailRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "email",
                 code: ZodIssueCode.invalid_string,
@@ -1218,8 +1218,8 @@ var init_types = __esm({
             if (!emojiRegex) {
               emojiRegex = new RegExp(_emojiRegex, "u");
             }
-            if (!emojiRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!emojiRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "emoji",
                 code: ZodIssueCode.invalid_string,
@@ -1228,8 +1228,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "uuid") {
-            if (!uuidRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!uuidRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "uuid",
                 code: ZodIssueCode.invalid_string,
@@ -1238,8 +1238,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "nanoid") {
-            if (!nanoidRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!nanoidRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "nanoid",
                 code: ZodIssueCode.invalid_string,
@@ -1248,8 +1248,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "cuid") {
-            if (!cuidRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!cuidRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "cuid",
                 code: ZodIssueCode.invalid_string,
@@ -1258,8 +1258,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "cuid2") {
-            if (!cuid2Regex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!cuid2Regex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "cuid2",
                 code: ZodIssueCode.invalid_string,
@@ -1268,8 +1268,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "ulid") {
-            if (!ulidRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!ulidRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "ulid",
                 code: ZodIssueCode.invalid_string,
@@ -1279,9 +1279,9 @@ var init_types = __esm({
             }
           } else if (check.kind === "url") {
             try {
-              new URL(input.data);
+              new URL(input2.data);
             } catch {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "url",
                 code: ZodIssueCode.invalid_string,
@@ -1291,9 +1291,9 @@ var init_types = __esm({
             }
           } else if (check.kind === "regex") {
             check.regex.lastIndex = 0;
-            const testResult = check.regex.test(input.data);
+            const testResult = check.regex.test(input2.data);
             if (!testResult) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "regex",
                 code: ZodIssueCode.invalid_string,
@@ -1302,10 +1302,10 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "trim") {
-            input.data = input.data.trim();
+            input2.data = input2.data.trim();
           } else if (check.kind === "includes") {
-            if (!input.data.includes(check.value, check.position)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!input2.data.includes(check.value, check.position)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: { includes: check.value, position: check.position },
@@ -1314,12 +1314,12 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "toLowerCase") {
-            input.data = input.data.toLowerCase();
+            input2.data = input2.data.toLowerCase();
           } else if (check.kind === "toUpperCase") {
-            input.data = input.data.toUpperCase();
+            input2.data = input2.data.toUpperCase();
           } else if (check.kind === "startsWith") {
-            if (!input.data.startsWith(check.value)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!input2.data.startsWith(check.value)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: { startsWith: check.value },
@@ -1328,8 +1328,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "endsWith") {
-            if (!input.data.endsWith(check.value)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!input2.data.endsWith(check.value)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: { endsWith: check.value },
@@ -1339,8 +1339,8 @@ var init_types = __esm({
             }
           } else if (check.kind === "datetime") {
             const regex = datetimeRegex(check);
-            if (!regex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!regex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: "datetime",
@@ -1350,8 +1350,8 @@ var init_types = __esm({
             }
           } else if (check.kind === "date") {
             const regex = dateRegex;
-            if (!regex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!regex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: "date",
@@ -1361,8 +1361,8 @@ var init_types = __esm({
             }
           } else if (check.kind === "time") {
             const regex = timeRegex(check);
-            if (!regex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!regex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_string,
                 validation: "time",
@@ -1371,8 +1371,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "duration") {
-            if (!durationRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!durationRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "duration",
                 code: ZodIssueCode.invalid_string,
@@ -1381,8 +1381,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "ip") {
-            if (!isValidIP(input.data, check.version)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!isValidIP(input2.data, check.version)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "ip",
                 code: ZodIssueCode.invalid_string,
@@ -1391,8 +1391,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "jwt") {
-            if (!isValidJWT(input.data, check.alg)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!isValidJWT(input2.data, check.alg)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "jwt",
                 code: ZodIssueCode.invalid_string,
@@ -1401,8 +1401,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "cidr") {
-            if (!isValidCidr(input.data, check.version)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!isValidCidr(input2.data, check.version)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "cidr",
                 code: ZodIssueCode.invalid_string,
@@ -1411,8 +1411,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "base64") {
-            if (!base64Regex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!base64Regex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "base64",
                 code: ZodIssueCode.invalid_string,
@@ -1421,8 +1421,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "base64url") {
-            if (!base64urlRegex.test(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!base64urlRegex.test(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 validation: "base64url",
                 code: ZodIssueCode.invalid_string,
@@ -1434,7 +1434,7 @@ var init_types = __esm({
             util.assertNever(check);
           }
         }
-        return { status: status.value, value: input.data };
+        return { status: status.value, value: input2.data };
       }
       _regex(regex, validation, message) {
         return this.refinement((data) => regex.test(data), {
@@ -1687,13 +1687,13 @@ var init_types = __esm({
         this.max = this.lte;
         this.step = this.multipleOf;
       }
-      _parse(input) {
+      _parse(input2) {
         if (this._def.coerce) {
-          input.data = Number(input.data);
+          input2.data = Number(input2.data);
         }
-        const parsedType = this._getType(input);
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.number) {
-          const ctx2 = this._getOrReturnCtx(input);
+          const ctx2 = this._getOrReturnCtx(input2);
           addIssueToContext(ctx2, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.number,
@@ -1705,8 +1705,8 @@ var init_types = __esm({
         const status = new ParseStatus();
         for (const check of this._def.checks) {
           if (check.kind === "int") {
-            if (!util.isInteger(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!util.isInteger(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.invalid_type,
                 expected: "integer",
@@ -1716,9 +1716,9 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "min") {
-            const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+            const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
             if (tooSmall) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_small,
                 minimum: check.value,
@@ -1730,9 +1730,9 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "max") {
-            const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+            const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
             if (tooBig) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_big,
                 maximum: check.value,
@@ -1744,8 +1744,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "multipleOf") {
-            if (floatSafeRemainder(input.data, check.value) !== 0) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (floatSafeRemainder(input2.data, check.value) !== 0) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.not_multiple_of,
                 multipleOf: check.value,
@@ -1754,8 +1754,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "finite") {
-            if (!Number.isFinite(input.data)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (!Number.isFinite(input2.data)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.not_finite,
                 message: check.message
@@ -1766,7 +1766,7 @@ var init_types = __esm({
             util.assertNever(check);
           }
         }
-        return { status: status.value, value: input.data };
+        return { status: status.value, value: input2.data };
       }
       gte(value, message) {
         return this.setLimit("min", value, true, errorUtil.toString(message));
@@ -1918,25 +1918,25 @@ var init_types = __esm({
         this.min = this.gte;
         this.max = this.lte;
       }
-      _parse(input) {
+      _parse(input2) {
         if (this._def.coerce) {
           try {
-            input.data = BigInt(input.data);
+            input2.data = BigInt(input2.data);
           } catch {
-            return this._getInvalidInput(input);
+            return this._getInvalidInput(input2);
           }
         }
-        const parsedType = this._getType(input);
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.bigint) {
-          return this._getInvalidInput(input);
+          return this._getInvalidInput(input2);
         }
         let ctx = void 0;
         const status = new ParseStatus();
         for (const check of this._def.checks) {
           if (check.kind === "min") {
-            const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
+            const tooSmall = check.inclusive ? input2.data < check.value : input2.data <= check.value;
             if (tooSmall) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_small,
                 type: "bigint",
@@ -1947,9 +1947,9 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "max") {
-            const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
+            const tooBig = check.inclusive ? input2.data > check.value : input2.data >= check.value;
             if (tooBig) {
-              ctx = this._getOrReturnCtx(input, ctx);
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_big,
                 type: "bigint",
@@ -1960,8 +1960,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "multipleOf") {
-            if (input.data % check.value !== BigInt(0)) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (input2.data % check.value !== BigInt(0)) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.not_multiple_of,
                 multipleOf: check.value,
@@ -1973,10 +1973,10 @@ var init_types = __esm({
             util.assertNever(check);
           }
         }
-        return { status: status.value, value: input.data };
+        return { status: status.value, value: input2.data };
       }
-      _getInvalidInput(input) {
-        const ctx = this._getOrReturnCtx(input);
+      _getInvalidInput(input2) {
+        const ctx = this._getOrReturnCtx(input2);
         addIssueToContext(ctx, {
           code: ZodIssueCode.invalid_type,
           expected: ZodParsedType.bigint,
@@ -2085,13 +2085,13 @@ var init_types = __esm({
       });
     };
     ZodBoolean = class extends ZodType {
-      _parse(input) {
+      _parse(input2) {
         if (this._def.coerce) {
-          input.data = Boolean(input.data);
+          input2.data = Boolean(input2.data);
         }
-        const parsedType = this._getType(input);
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.boolean) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.boolean,
@@ -2099,7 +2099,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
     };
     ZodBoolean.create = (params) => {
@@ -2110,13 +2110,13 @@ var init_types = __esm({
       });
     };
     ZodDate = class _ZodDate extends ZodType {
-      _parse(input) {
+      _parse(input2) {
         if (this._def.coerce) {
-          input.data = new Date(input.data);
+          input2.data = new Date(input2.data);
         }
-        const parsedType = this._getType(input);
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.date) {
-          const ctx2 = this._getOrReturnCtx(input);
+          const ctx2 = this._getOrReturnCtx(input2);
           addIssueToContext(ctx2, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.date,
@@ -2124,8 +2124,8 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        if (Number.isNaN(input.data.getTime())) {
-          const ctx2 = this._getOrReturnCtx(input);
+        if (Number.isNaN(input2.data.getTime())) {
+          const ctx2 = this._getOrReturnCtx(input2);
           addIssueToContext(ctx2, {
             code: ZodIssueCode.invalid_date
           });
@@ -2135,8 +2135,8 @@ var init_types = __esm({
         let ctx = void 0;
         for (const check of this._def.checks) {
           if (check.kind === "min") {
-            if (input.data.getTime() < check.value) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (input2.data.getTime() < check.value) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_small,
                 message: check.message,
@@ -2148,8 +2148,8 @@ var init_types = __esm({
               status.dirty();
             }
           } else if (check.kind === "max") {
-            if (input.data.getTime() > check.value) {
-              ctx = this._getOrReturnCtx(input, ctx);
+            if (input2.data.getTime() > check.value) {
+              ctx = this._getOrReturnCtx(input2, ctx);
               addIssueToContext(ctx, {
                 code: ZodIssueCode.too_big,
                 message: check.message,
@@ -2166,7 +2166,7 @@ var init_types = __esm({
         }
         return {
           status: status.value,
-          value: new Date(input.data.getTime())
+          value: new Date(input2.data.getTime())
         };
       }
       _addCheck(check) {
@@ -2219,10 +2219,10 @@ var init_types = __esm({
       });
     };
     ZodSymbol = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.symbol) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.symbol,
@@ -2230,7 +2230,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
     };
     ZodSymbol.create = (params) => {
@@ -2240,10 +2240,10 @@ var init_types = __esm({
       });
     };
     ZodUndefined = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.undefined) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.undefined,
@@ -2251,7 +2251,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
     };
     ZodUndefined.create = (params) => {
@@ -2261,10 +2261,10 @@ var init_types = __esm({
       });
     };
     ZodNull = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.null) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.null,
@@ -2272,7 +2272,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
     };
     ZodNull.create = (params) => {
@@ -2286,8 +2286,8 @@ var init_types = __esm({
         super(...arguments);
         this._any = true;
       }
-      _parse(input) {
-        return OK(input.data);
+      _parse(input2) {
+        return OK(input2.data);
       }
     };
     ZodAny.create = (params) => {
@@ -2301,8 +2301,8 @@ var init_types = __esm({
         super(...arguments);
         this._unknown = true;
       }
-      _parse(input) {
-        return OK(input.data);
+      _parse(input2) {
+        return OK(input2.data);
       }
     };
     ZodUnknown.create = (params) => {
@@ -2312,8 +2312,8 @@ var init_types = __esm({
       });
     };
     ZodNever = class extends ZodType {
-      _parse(input) {
-        const ctx = this._getOrReturnCtx(input);
+      _parse(input2) {
+        const ctx = this._getOrReturnCtx(input2);
         addIssueToContext(ctx, {
           code: ZodIssueCode.invalid_type,
           expected: ZodParsedType.never,
@@ -2329,10 +2329,10 @@ var init_types = __esm({
       });
     };
     ZodVoid = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.undefined) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.void,
@@ -2340,7 +2340,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
     };
     ZodVoid.create = (params) => {
@@ -2350,8 +2350,8 @@ var init_types = __esm({
       });
     };
     ZodArray = class _ZodArray extends ZodType {
-      _parse(input) {
-        const { ctx, status } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx, status } = this._processInputParams(input2);
         const def = this._def;
         if (ctx.parsedType !== ZodParsedType.array) {
           addIssueToContext(ctx, {
@@ -2465,10 +2465,10 @@ var init_types = __esm({
         this._cached = { shape, keys };
         return this._cached;
       }
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.object) {
-          const ctx2 = this._getOrReturnCtx(input);
+          const ctx2 = this._getOrReturnCtx(input2);
           addIssueToContext(ctx2, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.object,
@@ -2476,7 +2476,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        const { status, ctx } = this._processInputParams(input);
+        const { status, ctx } = this._processInputParams(input2);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
         if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
@@ -2790,8 +2790,8 @@ var init_types = __esm({
       });
     };
     ZodUnion = class extends ZodType {
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         const options = this._def.options;
         function handleResults(results) {
           for (const result of results) {
@@ -2912,8 +2912,8 @@ var init_types = __esm({
       }
     };
     ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.object) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -2988,8 +2988,8 @@ var init_types = __esm({
       }
     };
     ZodIntersection = class extends ZodType {
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         const handleParsed = (parsedLeft, parsedRight) => {
           if (isAborted(parsedLeft) || isAborted(parsedRight)) {
             return INVALID;
@@ -3041,8 +3041,8 @@ var init_types = __esm({
       });
     };
     ZodTuple = class _ZodTuple extends ZodType {
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.array) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3114,8 +3114,8 @@ var init_types = __esm({
       get valueSchema() {
         return this._def.valueType;
       }
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.object) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3167,8 +3167,8 @@ var init_types = __esm({
       get valueSchema() {
         return this._def.valueType;
       }
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.map) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3227,8 +3227,8 @@ var init_types = __esm({
       });
     };
     ZodSet = class _ZodSet extends ZodType {
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.set) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3316,8 +3316,8 @@ var init_types = __esm({
         super(...arguments);
         this.validate = this.implement;
       }
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.function) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3420,8 +3420,8 @@ var init_types = __esm({
       get schema() {
         return this._def.getter();
       }
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         const lazySchema = this._def.getter();
         return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
       }
@@ -3434,9 +3434,9 @@ var init_types = __esm({
       });
     };
     ZodLiteral = class extends ZodType {
-      _parse(input) {
-        if (input.data !== this._def.value) {
-          const ctx = this._getOrReturnCtx(input);
+      _parse(input2) {
+        if (input2.data !== this._def.value) {
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             received: ctx.data,
             code: ZodIssueCode.invalid_literal,
@@ -3444,7 +3444,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return { status: "valid", value: input.data };
+        return { status: "valid", value: input2.data };
       }
       get value() {
         return this._def.value;
@@ -3458,9 +3458,9 @@ var init_types = __esm({
       });
     };
     ZodEnum = class _ZodEnum extends ZodType {
-      _parse(input) {
-        if (typeof input.data !== "string") {
-          const ctx = this._getOrReturnCtx(input);
+      _parse(input2) {
+        if (typeof input2.data !== "string") {
+          const ctx = this._getOrReturnCtx(input2);
           const expectedValues = this._def.values;
           addIssueToContext(ctx, {
             expected: util.joinValues(expectedValues),
@@ -3472,8 +3472,8 @@ var init_types = __esm({
         if (!this._cache) {
           this._cache = new Set(this._def.values);
         }
-        if (!this._cache.has(input.data)) {
-          const ctx = this._getOrReturnCtx(input);
+        if (!this._cache.has(input2.data)) {
+          const ctx = this._getOrReturnCtx(input2);
           const expectedValues = this._def.values;
           addIssueToContext(ctx, {
             received: ctx.data,
@@ -3482,7 +3482,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
       get options() {
         return this._def.values;
@@ -3523,9 +3523,9 @@ var init_types = __esm({
     };
     ZodEnum.create = createZodEnum;
     ZodNativeEnum = class extends ZodType {
-      _parse(input) {
+      _parse(input2) {
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
-        const ctx = this._getOrReturnCtx(input);
+        const ctx = this._getOrReturnCtx(input2);
         if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
           const expectedValues = util.objectValues(nativeEnumValues);
           addIssueToContext(ctx, {
@@ -3538,7 +3538,7 @@ var init_types = __esm({
         if (!this._cache) {
           this._cache = new Set(util.getValidEnumValues(this._def.values));
         }
-        if (!this._cache.has(input.data)) {
+        if (!this._cache.has(input2.data)) {
           const expectedValues = util.objectValues(nativeEnumValues);
           addIssueToContext(ctx, {
             received: ctx.data,
@@ -3547,7 +3547,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return OK(input.data);
+        return OK(input2.data);
       }
       get enum() {
         return this._def.values;
@@ -3564,8 +3564,8 @@ var init_types = __esm({
       unwrap() {
         return this._def.type;
       }
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
@@ -3597,8 +3597,8 @@ var init_types = __esm({
       sourceType() {
         return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
       }
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         const effect = this._def.effect || null;
         const checkCtx = {
           addIssue: (arg) => {
@@ -3730,12 +3730,12 @@ var init_types = __esm({
       });
     };
     ZodOptional = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType === ZodParsedType.undefined) {
           return OK(void 0);
         }
-        return this._def.innerType._parse(input);
+        return this._def.innerType._parse(input2);
       }
       unwrap() {
         return this._def.innerType;
@@ -3749,12 +3749,12 @@ var init_types = __esm({
       });
     };
     ZodNullable = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType === ZodParsedType.null) {
           return OK(null);
         }
-        return this._def.innerType._parse(input);
+        return this._def.innerType._parse(input2);
       }
       unwrap() {
         return this._def.innerType;
@@ -3768,8 +3768,8 @@ var init_types = __esm({
       });
     };
     ZodDefault = class extends ZodType {
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         let data = ctx.data;
         if (ctx.parsedType === ZodParsedType.undefined) {
           data = this._def.defaultValue();
@@ -3793,8 +3793,8 @@ var init_types = __esm({
       });
     };
     ZodCatch = class extends ZodType {
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         const newCtx = {
           ...ctx,
           common: {
@@ -3846,10 +3846,10 @@ var init_types = __esm({
       });
     };
     ZodNaN = class extends ZodType {
-      _parse(input) {
-        const parsedType = this._getType(input);
+      _parse(input2) {
+        const parsedType = this._getType(input2);
         if (parsedType !== ZodParsedType.nan) {
-          const ctx = this._getOrReturnCtx(input);
+          const ctx = this._getOrReturnCtx(input2);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_type,
             expected: ZodParsedType.nan,
@@ -3857,7 +3857,7 @@ var init_types = __esm({
           });
           return INVALID;
         }
-        return { status: "valid", value: input.data };
+        return { status: "valid", value: input2.data };
       }
     };
     ZodNaN.create = (params) => {
@@ -3868,8 +3868,8 @@ var init_types = __esm({
     };
     BRAND = Symbol("zod_brand");
     ZodBranded = class extends ZodType {
-      _parse(input) {
-        const { ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { ctx } = this._processInputParams(input2);
         const data = ctx.data;
         return this._def.type._parse({
           data,
@@ -3882,8 +3882,8 @@ var init_types = __esm({
       }
     };
     ZodPipeline = class _ZodPipeline extends ZodType {
-      _parse(input) {
-        const { status, ctx } = this._processInputParams(input);
+      _parse(input2) {
+        const { status, ctx } = this._processInputParams(input2);
         if (ctx.common.async) {
           const handleAsync = async () => {
             const inResult = await this._def.in._parseAsync({
@@ -3937,8 +3937,8 @@ var init_types = __esm({
       }
     };
     ZodReadonly = class extends ZodType {
-      _parse(input) {
-        const result = this._def.innerType._parse(input);
+      _parse(input2) {
+        const result = this._def.innerType._parse(input2);
         const freeze = (data) => {
           if (isValid(data)) {
             data.value = Object.freeze(data.value);
@@ -5876,32 +5876,32 @@ var init_branch_service = __esm({
           doc: branchDoc
         };
       }
-      buildSpecificationData(input, context) {
-        if (!input) {
+      buildSpecificationData(input2, context) {
+        if (!input2) {
           return void 0;
         }
-        const specDocId = input.specDocId ?? context.specDocId;
+        const specDocId = input2.specDocId ?? context.specDocId;
         if (!specDocId) {
           console.warn("[BranchService] Unable to build specification metadata without specDocId");
           return void 0;
         }
-        const createdAt = input.createdAt ?? context.createdAt;
+        const createdAt = input2.createdAt ?? context.createdAt;
         const data = {
           specDocId,
-          specFilePath: input.specFilePath,
-          title: input.title,
-          branchName: input.branchName ?? context.branchName,
-          branchDescription: input.branchDescription ?? context.branchDescription ?? void 0,
+          specFilePath: input2.specFilePath,
+          title: input2.title,
+          branchName: input2.branchName ?? context.branchName,
+          branchDescription: input2.branchDescription ?? context.branchDescription ?? void 0,
           createdAt,
-          updatedAt: input.updatedAt ?? createdAt,
-          workspaceId: input.workspaceId ?? context.workspaceId,
-          lifecycleStatus: input.lifecycleStatus ?? "active",
-          activeTrackingEnabled: input.activeTrackingEnabled ?? true,
-          baseline: input.baseline ?? this.buildBaselineSnapshot(createdAt, context.workspaceId, context.initialFileHeads),
-          changeSummary: input.changeSummary,
-          coverage: input.coverage,
-          git: input.git,
-          lastSetActiveAt: input.activeTrackingEnabled === false ? void 0 : createdAt
+          updatedAt: input2.updatedAt ?? createdAt,
+          workspaceId: input2.workspaceId ?? context.workspaceId,
+          lifecycleStatus: input2.lifecycleStatus ?? "active",
+          activeTrackingEnabled: input2.activeTrackingEnabled ?? true,
+          baseline: input2.baseline ?? this.buildBaselineSnapshot(createdAt, context.workspaceId, context.initialFileHeads),
+          changeSummary: input2.changeSummary,
+          coverage: input2.coverage,
+          git: input2.git,
+          lastSetActiveAt: input2.activeTrackingEnabled === false ? void 0 : createdAt
         };
         if (!data.branchDescription) {
           delete data.branchDescription;
@@ -5915,8 +5915,8 @@ var init_branch_service = __esm({
         if (!data.git) {
           delete data.git;
         }
-        if (input.abstract) {
-          data.abstract = input.abstract;
+        if (input2.abstract) {
+          data.abstract = input2.abstract;
         }
         return data;
       }
@@ -5990,8 +5990,8 @@ var init_branch_service = __esm({
         const safeTimestamp = timestamp ? timestamp.replace(/[:\sT]/g, "-").split(".")[0] : (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         return `spec-${slug}-${safeTimestamp}`;
       }
-      slugifyBranchName(input) {
-        const slug = input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      slugifyBranchName(input2) {
+        const slug = input2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
         return slug || "branch";
       }
       detectConflicts(sourceBranch, targetBranch) {
@@ -18340,7 +18340,7 @@ function DirectoryPageContainer({ repo: repo2, selectedWorkspace, selectedThread
       cancelled = true;
     };
   }, [repo2, selectedWorkspace, selectedThread, loadRootDirectory]);
-  useInput((input, key) => {
+  useInput((input2, key) => {
     if (key.downArrow) {
       setSelectedIndex((i) => Math.min(i + 1, rootIds.length - 1));
     } else if (key.upArrow) {
@@ -18499,7 +18499,7 @@ function BranchesContainer({ repo: repo2, workspace, onSelect }) {
       ;
     };
   }, [repo2, workspace]);
-  useInput2((input, key) => {
+  useInput2((input2, key) => {
     if (key.downArrow)
       setIdx((i) => Math.min(i + 1, Math.max(0, threads.length - 1)));
     else if (key.upArrow)
@@ -18718,7 +18718,7 @@ function App({ repo: repo2, featureFlags: providedFeatureFlags }) {
   const [inputValue, setInputValue] = useState4("");
   const [pendingChatInput, setPendingChatInput] = useState4("");
   const initialUploadDoneRef = useRef2(false);
-  useInput3((input, key) => {
+  useInput3((input2, key) => {
     if (key.escape) {
       setRoute("workspaces");
       setSelectedWorkspace(null);
@@ -18857,7 +18857,7 @@ import { NodeFSStorageAdapter } from "@automerge/automerge-repo-storage-nodefs";
 import { WebSocketClientAdapter } from "@automerge/automerge-repo-network-websocket";
 
 // ../mod-core/dist/utils/resolveAutomergeWsUrl.js
-var DEFAULT_AUTOMERGE_WS_URL = "ws://localhost:3031";
+var DEFAULT_AUTOMERGE_WS_URL = "wss://mod-monorepo.onrender.com";
 var LOCAL_AUTOMERGE_WS_URL = "ws://localhost:3031";
 var ENV_KEYS = [
   "AUTOMERGE_WS_URL",
@@ -19047,6 +19047,7 @@ async function agentsRunCommand(args, repo2) {
 // dist/lib/storage.js
 import fs6 from "fs";
 import path6 from "path";
+import crypto2 from "crypto";
 import os from "os";
 
 // dist/types/config.js
@@ -19107,6 +19108,29 @@ function writeConfig(config) {
   const configPath = getConfigPath2();
   atomicWrite(configPath, JSON.stringify(config, null, 2), 384);
 }
+function getWorkspaceConnectionPath(directoryPath) {
+  const absolutePath = path6.resolve(directoryPath);
+  const hash = crypto2.createHash("sha256").update(absolutePath).digest("hex").slice(0, 16);
+  return path6.join(getModDir(), "workspaces", hash);
+}
+function readWorkspaceConnection(directoryPath) {
+  const connectionPath = getWorkspaceConnectionPath(directoryPath);
+  if (!fs6.existsSync(connectionPath)) {
+    return null;
+  }
+  try {
+    const content = fs6.readFileSync(connectionPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Warning: Could not read workspace connection for ${directoryPath}`);
+    return null;
+  }
+}
+function writeWorkspaceConnection(directoryPath, connection) {
+  ensureModDir2();
+  const connectionPath = getWorkspaceConnectionPath(directoryPath);
+  atomicWrite(connectionPath, JSON.stringify(connection, null, 2), 384);
+}
 function atomicWrite(filePath, content, mode) {
   const tempPath = `${filePath}.tmp.${process.pid}`;
   fs6.writeFileSync(tempPath, content, { mode });
@@ -21752,8 +21776,8 @@ var SpecificationParserService = class {
       return `${filePath || "inline"}:${content.length}-${content.slice(0, 10)}`;
     }
     try {
-      const crypto4 = __require("crypto");
-      const key = `${filePath || "inline"}:${crypto4.createHash("md5").update(content).digest("hex")}`;
+      const crypto5 = __require("crypto");
+      const key = `${filePath || "inline"}:${crypto5.createHash("md5").update(content).digest("hex")}`;
       return key;
     } catch (error) {
       return `${filePath || "inline"}:${content.length}-${content.slice(0, 10)}`;
@@ -22133,7 +22157,7 @@ Thumbs.db
 };
 
 // dist/services/automatic-file-tracker.js
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 var AutomaticFileTracker = class {
   constructor(repo2) {
     this.debounceTimers = /* @__PURE__ */ new Map();
@@ -22375,7 +22399,7 @@ var AutomaticFileTracker = class {
     return detectMimeType(fileName);
   }
   getContentHash(content) {
-    return crypto2.createHash("sha256").update(content, "utf8").digest("hex");
+    return crypto3.createHash("sha256").update(content, "utf8").digest("hex");
   }
   async disableAutoTracking() {
     if (!this.isTracking)
@@ -24714,7 +24738,7 @@ Examples:
 // dist/services/file-import-service.js
 import fs14 from "fs";
 import path16 from "path";
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 var FileImportService = class {
   constructor(repo2) {
     this.folderCache = /* @__PURE__ */ new Map();
@@ -24915,7 +24939,7 @@ var FileImportService = class {
     try {
       const content = await fs14.promises.readFile(filePath, "utf-8");
       const relativePath = path16.relative(workingDir, filePath);
-      const contentHash = crypto3.createHash("sha256").update(content).digest("hex");
+      const contentHash = crypto4.createHash("sha256").update(content).digest("hex");
       const pathParts = relativePath.split(path16.sep);
       const fileName = pathParts.pop();
       const dirPath = pathParts.join("/");
@@ -25096,36 +25120,211 @@ async function syncCommand(args, repo2) {
 import fs15 from "fs";
 import path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
+
+// dist/lib/prompts.js
+import readline from "readline";
+async function select(question, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve5) => {
+    console.log(`
+${question}`);
+    options.forEach((option, index) => {
+      const number = `${index + 1}.`.padEnd(3);
+      if (option.description) {
+        console.log(`  ${number} ${option.label}`);
+        console.log(`      ${option.description}`);
+      } else {
+        console.log(`  ${number} ${option.label}`);
+      }
+    });
+    console.log();
+    const prompt = () => {
+      rl.question("Select [1-" + options.length + "]: ", (answer) => {
+        const num = parseInt(answer.trim(), 10);
+        if (num >= 1 && num <= options.length) {
+          rl.close();
+          resolve5(options[num - 1].value);
+        } else {
+          console.log(`Please enter a number between 1 and ${options.length}`);
+          prompt();
+        }
+      });
+    };
+    prompt();
+  });
+}
+async function input(question, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve5) => {
+    const defaultSuffix = (options == null ? void 0 : options.default) ? ` (${options.default})` : "";
+    const promptText = `${question}${defaultSuffix}: `;
+    const prompt = () => {
+      rl.question(promptText, (answer) => {
+        const value = answer.trim() || (options == null ? void 0 : options.default) || "";
+        if (options == null ? void 0 : options.validate) {
+          const error = options.validate(value);
+          if (error) {
+            console.log(`  ${error}`);
+            prompt();
+            return;
+          }
+        }
+        rl.close();
+        resolve5(value);
+      });
+    };
+    prompt();
+  });
+}
+function validateWorkspaceName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Workspace name cannot be empty";
+  }
+  if (name.length > 100) {
+    return "Workspace name must be 100 characters or less";
+  }
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9-_ ]*[a-zA-Z0-9]$|^[a-zA-Z0-9]$/.test(name.trim())) {
+    return "Workspace name must start and end with alphanumeric characters";
+  }
+  return null;
+}
+
+// dist/commands/init.js
 var __filename3 = fileURLToPath3(import.meta.url);
 var __dirname3 = path17.dirname(__filename3);
 async function initCommand(args, repo2) {
   const subcommand = args[0];
+  const isForce = args.includes("--force");
   if (subcommand === "list" || args.includes("--list")) {
     await listAvailableCommands();
     process.exit(0);
   }
   try {
-    const workspaceStatus = await checkWorkspaceStatus(repo2);
+    ensureModDir2();
+    const currentDir = process.cwd();
+    const existingConnection = readWorkspaceConnection(currentDir);
+    if (existingConnection && !isForce) {
+      console.log("Already initialized");
+      console.log(`Workspace: ${existingConnection.workspaceName}`);
+      console.log("");
+      console.log("Run `mod sync start` to begin syncing");
+      console.log("");
+      console.log("To connect to a different workspace, run `mod init --force`");
+      process.exit(0);
+    }
     await ensureClaudeCommandsDirectory();
     const availableCommands = await discoverAvailableCommands();
     const installedCommands = await getInstalledCommands();
-    const commandsToInstall = await determineCommandsToInstall(availableCommands, installedCommands, args.includes("--force"));
+    const commandsToInstall = await determineCommandsToInstall(availableCommands, installedCommands, isForce);
     if (commandsToInstall.length > 0) {
-      displayInstallationPlan(commandsToInstall);
-      const shouldProceed = args.includes("--force") || await confirmInstallation(commandsToInstall);
-      if (!shouldProceed) {
-        console.log("Installation cancelled");
-        process.exit(0);
-      }
       await installCommands(commandsToInstall);
     }
-    const finalWorkspaceStatus = await handleWorkspaceInitialization(workspaceStatus, repo2);
-    displayInitializationSuccess(commandsToInstall, finalWorkspaceStatus);
+    const config = readConfig();
+    const isAuthenticated = !!config.auth;
+    let workspaceConnection;
+    if (isAuthenticated) {
+      workspaceConnection = await handleAuthenticatedInit(repo2, config.auth.email);
+    } else {
+      workspaceConnection = await handleUnauthenticatedInit(repo2);
+    }
+    writeWorkspaceConnection(currentDir, workspaceConnection);
+    displayInitializationSuccess(commandsToInstall, workspaceConnection, isAuthenticated);
     process.exit(0);
   } catch (error) {
     handleInstallationError(error);
   }
 }
+async function handleAuthenticatedInit(repo2, email) {
+  console.log(`Signed in as ${email}`);
+  const modWorkspace = createModWorkspace(repo2);
+  let workspaces = [];
+  try {
+    const handles = await modWorkspace.listWorkspaces();
+    workspaces = handles.map((h) => ({ id: h.id, name: h.name }));
+  } catch (error) {
+    console.warn("Could not load cloud workspaces. Creating local workspace.");
+  }
+  const options = [
+    ...workspaces.map((w) => ({
+      label: w.name,
+      value: { type: "existing", id: w.id, name: w.name }
+    })),
+    {
+      label: "+ Create new workspace",
+      value: { type: "create", id: "", name: "" }
+    }
+  ];
+  const choice = await select("Select workspace:", options);
+  if (choice.type === "create") {
+    return await createNewWorkspace(repo2);
+  }
+  return {
+    path: process.cwd(),
+    workspaceId: choice.id,
+    workspaceName: choice.name,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function handleUnauthenticatedInit(repo2) {
+  const choice = await select("Select option:", [
+    {
+      label: "Create local workspace",
+      value: "create",
+      description: "Work offline, sync later"
+    },
+    {
+      label: "Sign in to sync with team",
+      value: "signin",
+      description: "Access cloud workspaces"
+    }
+  ]);
+  if (choice === "signin") {
+    console.log("");
+    console.log("Please run `mod auth login` to sign in, then run `mod init` again.");
+    process.exit(0);
+  }
+  return await createNewWorkspace(repo2);
+}
+async function createNewWorkspace(repo2) {
+  const currentDirName = path17.basename(process.cwd());
+  const defaultName = currentDirName.charAt(0).toUpperCase() + currentDirName.slice(1);
+  const name = await input("Workspace name", {
+    default: defaultName,
+    validate: validateWorkspaceName
+  });
+  console.log("Creating workspace...");
+  const modWorkspace = createModWorkspace(repo2);
+  const workspace = await modWorkspace.createWorkspace({ name });
+  return {
+    path: process.cwd(),
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function displayInitializationSuccess(commands, connection, isAuthenticated) {
+  console.log("");
+  console.log("Initialized Mod in " + connection.path);
+  console.log(`Workspace: ${connection.workspaceName}`);
+  if (commands.length > 0) {
+    console.log("");
+    console.log(`Installed ${commands.length} Claude command(s)`);
+  }
+  console.log("");
+  if (isAuthenticated) {
+    console.log("Run `mod sync start` to begin syncing");
+  } else {
+    console.log("Run `mod auth login` to enable sync with collaborators");
+  }
+}
 async function ensureClaudeCommandsDirectory() {
   const claudeDir = path17.join(process.cwd(), ".claude");
   const commandsDir = path17.join(claudeDir, "commands");
@@ -25144,7 +25343,6 @@ async function discoverAvailableCommands() {
   const packageRoot = path17.resolve(__dirname3, "../..");
   const commandsSourceDir = path17.join(packageRoot, "commands");
   if (!fs15.existsSync(commandsSourceDir)) {
-    console.warn("\u26A0\uFE0F  No commands directory found in CLI package");
     return [];
   }
   const commands = [];
@@ -25176,7 +25374,7 @@ async function getInstalledCommands() {
       const metadata = parseFrontmatter(content);
       installed.set(filename, metadata);
     } catch (error) {
-      console.warn(`\u26A0\uFE0F  Could not read metadata from ${filename}: ${error.message}`);
+      console.warn(`Could not read metadata from ${filename}: ${error.message}`);
     }
   }
   return installed;
@@ -25186,7 +25384,6 @@ function parseFrontmatter(content) {
   if (!frontmatterMatch) {
     return {
       version: "0.0.0",
-      // Old version to trigger update
       updated: "1970-01-01",
       checksum: "",
       description: void 0
@@ -25236,45 +25433,12 @@ function compareVersions(v1, v2) {
   }
   return 0;
 }
-async function listAvailableCommands() {
-  console.log("\u{1F4CB} Available Claude Commands:\n");
-  try {
-    const commands = await discoverAvailableCommands();
-    if (commands.length === 0) {
-      console.log("   No commands available");
-      return;
-    }
-    for (const command of commands) {
-      console.log(`   ${command.filename.replace(".md", "")}`);
-      console.log(`   \u251C\u2500\u2500 Version: ${command.metadata.version}`);
-      if (command.metadata.description) {
-        console.log(`   \u2514\u2500\u2500 Description: ${command.metadata.description}`);
-      } else {
-        console.log(`   \u2514\u2500\u2500 Updated: ${command.metadata.updated}`);
-      }
-      console.log();
-    }
-  } catch (error) {
-    console.error("\u274C Error listing commands:", error.message);
-  }
-}
-function displayInstallationPlan(commands) {
-  console.log("\u{1F4E6} Installing Claude Commands:\n");
-  for (const command of commands) {
-    console.log(`   ${command.filename.replace(".md", "")} (v${command.metadata.version})`);
-  }
-  console.log();
-}
-async function confirmInstallation(commands) {
-  return true;
-}
 async function installCommands(commands) {
   const commandsDir = path17.join(process.cwd(), ".claude", "commands");
   const tempFiles = [];
   try {
     for (const command of commands) {
       const tempPath = path17.join(commandsDir, `${command.filename}.tmp`);
-      const finalPath = path17.join(commandsDir, command.filename);
       const contentWithChecksum = await updateChecksumInContent(command.content);
       fs15.writeFileSync(tempPath, contentWithChecksum, "utf8");
       tempFiles.push(tempPath);
@@ -25290,8 +25454,8 @@ async function installCommands(commands) {
   }
 }
 async function updateChecksumInContent(content) {
-  const crypto4 = await import("crypto");
-  const contentHash = crypto4.createHash("sha256").update(content).digest("hex").substring(0, 16);
+  const crypto5 = await import("crypto");
+  const contentHash = crypto5.createHash("sha256").update(content).digest("hex").substring(0, 16);
   const withoutChecksum = content.replace(/^(\s*)checksum:\s*\S*$/gm, "");
   return withoutChecksum.replace(/^(---\n)([\s\S]*?)(---)/, `$1$2checksum: ${contentHash}
 $3`);
@@ -25303,130 +25467,43 @@ function cleanup(tempFiles) {
         fs15.unlinkSync(file);
       }
     } catch (error) {
-      console.warn(`\u26A0\uFE0F  Could not clean up temporary file ${file}: ${error.message}`);
+      console.warn(`Could not clean up temporary file ${file}: ${error.message}`);
     }
   }
 }
-function displayInitializationSuccess(commands, workspaceStatus) {
-  console.log("\u2705 Initialization Complete!\n");
-  if (commands.length > 0) {
-    console.log(`\u{1F4E6} Installed ${commands.length} Claude command(s):
-`);
-    for (const command of commands) {
-      const commandName = command.filename.replace(".md", "");
-      console.log(`   /${commandName} - ${command.metadata.description || "Mod workflow command"}`);
-    }
-    console.log();
-  } else {
-    console.log("\u2705 All Claude commands are up to date\n");
-  }
-  if (workspaceStatus.created) {
-    console.log(`\u{1F680} Created new workspace: "${workspaceStatus.workspaceName}"`);
-  } else {
-    console.log(`\u{1F4C1} Using existing workspace: "${workspaceStatus.workspaceName}"`);
-  }
-  console.log("\n\u{1F4A1} Usage:");
-  console.log('   Open Claude Code and type "/" to see available commands');
-  console.log('   Use "mod workspace list" to see all workspaces');
-  console.log("   Commands are available in your .claude/commands directory\n");
-}
-async function checkWorkspaceStatus(repo2) {
+async function listAvailableCommands() {
+  console.log("Available Claude Commands:\n");
   try {
-    const config = await readModConfig();
-    if (config && config.workspaceId) {
-      let workspaceName = "Existing Workspace";
-      if (repo2) {
-        try {
-          const modWorkspace = createModWorkspace(repo2);
-          const workspaces = await modWorkspace.listWorkspaces();
-          const currentWorkspace = workspaces.find((w) => w.id === config.workspaceId);
-          if (currentWorkspace) {
-            workspaceName = currentWorkspace.name;
-          }
-        } catch (error) {
-          console.warn("\u26A0\uFE0F  Could not fetch workspace name, using generic name");
-        }
+    const commands = await discoverAvailableCommands();
+    if (commands.length === 0) {
+      console.log("   No commands available");
+      return;
+    }
+    for (const command of commands) {
+      console.log(`   ${command.filename.replace(".md", "")}`);
+      console.log(`   Version: ${command.metadata.version}`);
+      if (command.metadata.description) {
+        console.log(`   Description: ${command.metadata.description}`);
       }
-      return {
-        exists: true,
-        created: false,
-        workspaceName,
-        workspaceId: config.workspaceId
-      };
+      console.log();
     }
-    return {
-      exists: false,
-      created: false,
-      workspaceName: "New Workspace",
-      workspaceId: void 0
-    };
-  } catch (error) {
-    return {
-      exists: false,
-      created: false,
-      workspaceName: "New Workspace",
-      workspaceId: void 0
-    };
-  }
-}
-async function handleWorkspaceInitialization(workspaceStatus, repo2) {
-  if (workspaceStatus.exists) {
-    return workspaceStatus;
-  }
-  try {
-    const modWorkspace = createModWorkspace(repo2);
-    const workspaceName = generateWorkspaceName();
-    console.log(`\u{1F680} Creating new workspace: "${workspaceName}"...`);
-    const workspace = await modWorkspace.createWorkspace({
-      name: workspaceName
-    });
-    const config = {
-      workspaceId: workspace.id,
-      activeBranchId: void 0
-    };
-    await writeModConfig(config);
-    return {
-      exists: false,
-      created: true,
-      workspaceName: workspace.name,
-      workspaceId: workspace.id
-    };
   } catch (error) {
-    console.warn(`\u26A0\uFE0F  Failed to create workspace: ${error.message}`);
-    console.log("   Continuing with command installation only.");
-    return {
-      exists: false,
-      created: false,
-      workspaceName: "Failed to create",
-      workspaceId: void 0
-    };
-  }
-}
-function generateWorkspaceName() {
-  const currentDir = path17.basename(process.cwd());
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  if (currentDir && currentDir !== "." && currentDir !== "/" && currentDir.length > 1) {
-    return currentDir.charAt(0).toUpperCase() + currentDir.slice(1);
+    console.error("Error listing commands:", error.message);
   }
-  return `Workspace-${timestamp}`;
 }
 function handleInstallationError(error) {
-  console.error("\u274C Initialization failed:");
+  console.error("Initialization failed:");
   if (error.code === "EACCES" || error.code === "EPERM") {
-    console.error("   Permission denied. Try running with appropriate permissions.");
-    console.error("   Make sure you have write access to the .claude/commands directory.");
+    console.error("   Permission denied.");
   } else if (error.code === "ENOSPC") {
     console.error("   Insufficient disk space.");
-  } else if (error.code === "ENOTDIR") {
-    console.error("   Invalid directory structure. Ensure .claude is a directory, not a file.");
   } else {
     console.error(`   ${error.message}`);
   }
-  console.error("\n\u{1F527} Troubleshooting:");
-  console.error("   - Ensure you have write permissions in the current directory");
-  console.error('   - Try running "mod init --force" to overwrite existing files');
-  console.error("   - Check that .claude is not a file (should be a directory)");
-  console.error('   - For workspace issues, try "mod workspace create <name>" separately');
+  console.error("");
+  console.error("Troubleshooting:");
+  console.error("   - Ensure you have write permissions");
+  console.error('   - Try running "mod init --force" to overwrite');
   process.exit(1);
 }